@buildonspark/spark-sdk 0.2.2 → 0.2.4

package/dist/native/index.js

@@ -14336,14 +14336,6 @@ var SparkServiceDefinition = {
       responseStream: false,
       options: {}
     },
-    create_tree_v2: {
-      name: "create_tree_v2",
-      requestType: CreateTreeRequest,
-      requestStream: false,
-      responseType: CreateTreeResponse,
-      responseStream: false,
-      options: {}
-    },
     get_signing_operator_list: {
       name: "get_signing_operator_list",
       requestType: Empty,
@@ -14510,6 +14502,90 @@ var SparkServiceDefinition = {
       responseType: ExitSingleNodeTreesResponse,
       responseStream: false,
       options: {}
+    },
+    /**
+     * The following endpoints enforce inclusion of Direct Transactions used
+     * for unilateral exits
+     */
+    create_tree_v2: {
+      name: "create_tree_v2",
+      requestType: CreateTreeRequest,
+      requestStream: false,
+      responseType: CreateTreeResponse,
+      responseStream: false,
+      options: {}
+    },
+    cooperative_exit_v2: {
+      name: "cooperative_exit_v2",
+      requestType: CooperativeExitRequest,
+      requestStream: false,
+      responseType: CooperativeExitResponse,
+      responseStream: false,
+      options: {}
+    },
+    extend_leaf_v2: {
+      name: "extend_leaf_v2",
+      requestType: ExtendLeafRequest,
+      requestStream: false,
+      responseType: ExtendLeafResponse,
+      responseStream: false,
+      options: {}
+    },
+    claim_transfer_sign_refunds_v2: {
+      name: "claim_transfer_sign_refunds_v2",
+      requestType: ClaimTransferSignRefundsRequest,
+      requestStream: false,
+      responseType: ClaimTransferSignRefundsResponse,
+      responseStream: false,
+      options: {}
+    },
+    finalize_node_signatures_v2: {
+      name: "finalize_node_signatures_v2",
+      requestType: FinalizeNodeSignaturesRequest,
+      requestStream: false,
+      responseType: FinalizeNodeSignaturesResponse,
+      responseStream: false,
+      options: {}
+    },
+    initiate_preimage_swap_v2: {
+      name: "initiate_preimage_swap_v2",
+      requestType: InitiatePreimageSwapRequest,
+      requestStream: false,
+      responseType: InitiatePreimageSwapResponse,
+      responseStream: false,
+      options: {}
+    },
+    start_leaf_swap_v2: {
+      name: "start_leaf_swap_v2",
+      requestType: StartTransferRequest,
+      requestStream: false,
+      responseType: StartTransferResponse,
+      responseStream: false,
+      options: {}
+    },
+    counter_leaf_swap_v2: {
+      name: "counter_leaf_swap_v2",
+      requestType: CounterLeafSwapRequest,
+      requestStream: false,
+      responseType: CounterLeafSwapResponse,
+      responseStream: false,
+      options: {}
+    },
+    start_transfer_v2: {
+      name: "start_transfer_v2",
+      requestType: StartTransferRequest,
+      requestStream: false,
+      responseType: StartTransferResponse,
+      responseStream: false,
+      options: {}
+    },
+    refresh_timelock_v2: {
+      name: "refresh_timelock_v2",
+      requestType: RefreshTimelockRequest,
+      requestStream: false,
+      responseType: RefreshTimelockResponse,
+      responseStream: false,
+      options: {}
     }
   }
 };
@@ -14732,13 +14808,24 @@ function applyAdaptorToSignature(pubkey, hash, signature, adaptorPrivateKeyBytes
   const adaptorPrivateKey = bytesToNumberBE2(adaptorPrivateKeyBytes);
   const newS = mod(sBigInt + adaptorPrivateKey, secp256k12.CURVE.n);
   const newSig = new Uint8Array([...r, ...numberToBytesBE(newS, 32)]);
-  if (schnorr.verify(newSig, hash, pubkey)) {
-    return newSig;
+  try {
+    if (schnorr.verify(newSig, hash, pubkey)) {
+      return newSig;
+    }
+  } catch (e) {
+    console.error("[applyAdaptorToSignature] Addition verification failed:", e);
   }
   const altS = mod(sBigInt - adaptorPrivateKey, secp256k12.CURVE.n);
   const altSig = new Uint8Array([...r, ...numberToBytesBE(altS, 32)]);
-  if (schnorr.verify(altSig, hash, pubkey)) {
-    return altSig;
+  try {
+    if (schnorr.verify(altSig, hash, pubkey)) {
+      return altSig;
+    }
+  } catch (e) {
+    console.error(
+      "[applyAdaptorToSignature] Subtraction verification failed:",
+      e
+    );
   }
   throw new Error("Cannot apply adaptor to signature");
 }
@@ -15605,7 +15692,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"]
   };
 };
 
@@ -15851,6 +15942,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
     }
 }`;
 
@@ -16180,6 +16275,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 {
@@ -16304,18 +16403,39 @@ function mapTransferToWalletTransfer(proto, identityPublicKey) {
   };
 }
 
+// src/utils/fetch.ts
+var fetchImpl = typeof window !== "undefined" && window.fetch ? window.fetch.bind(window) : globalThis.fetch ? globalThis.fetch : null;
+var Headers = globalThis.Headers ?? null;
+var getFetch = () => {
+  if (!fetchImpl) {
+    throw new Error(
+      "Fetch implementation is not set. Please set it using setFetch()."
+    );
+  }
+  if (!Headers) {
+    throw new Error(
+      "Headers implementation is not set. Please set it using setFetch()."
+    );
+  }
+  return {
+    fetch: fetchImpl,
+    Headers
+  };
+};
+
 // src/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();
@@ -16332,14 +16452,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();
@@ -16802,7 +16923,14 @@ function getTransferPackageSigningPayload(transferID, transferPackage) {
 
 // src/utils/transaction.ts
 import { Transaction as Transaction2 } from "@scure/btc-signer";
+var INITIAL_TIMELOCK = 2e3;
+var TEST_UNILATERAL_TIMELOCK = 100;
 var TIME_LOCK_INTERVAL = 100;
+var DIRECT_TIMELOCK_OFFSET = 50;
+var INITIAL_SEQUENCE = 1 << 30 | INITIAL_TIMELOCK;
+var INITIAL_DIRECT_SEQUENCE = 1 << 30 | INITIAL_TIMELOCK + DIRECT_TIMELOCK_OFFSET;
+var TEST_UNILATERAL_SEQUENCE = 1 << 30 | TEST_UNILATERAL_TIMELOCK;
+var TEST_UNILATERAL_DIRECT_SEQUENCE = 1 << 30 | TEST_UNILATERAL_TIMELOCK + DIRECT_TIMELOCK_OFFSET;
 var ESTIMATED_TX_SIZE = 191;
 var DEFAULT_SATS_PER_VBYTE = 5;
 var DEFAULT_FEE_SATS = ESTIMATED_TX_SIZE * DEFAULT_SATS_PER_VBYTE;
@@ -16812,29 +16940,270 @@ function maybeApplyFee(amount) {
   }
   return amount;
 }
-function createRefundTx(sequence, nodeOutPoint, amountSats, receivingPubkey, network) {
-  const newRefundTx = new Transaction2({
+function createRootTx(depositOutPoint, depositTxOut) {
+  const cpfpRootTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  cpfpRootTx.addInput(depositOutPoint);
+  cpfpRootTx.addOutput(depositTxOut);
+  cpfpRootTx.addOutput(getEphemeralAnchorOutput());
+  const directRootTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  directRootTx.addInput(depositOutPoint);
+  directRootTx.addOutput({
+    script: depositTxOut.script,
+    amount: maybeApplyFee(depositTxOut.amount ?? 0n)
+  });
+  return [cpfpRootTx, directRootTx];
+}
+function createSplitTx(parentOutPoint, childTxOuts) {
+  const cpfpSplitTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  cpfpSplitTx.addInput(parentOutPoint);
+  for (const txOut of childTxOuts) {
+    cpfpSplitTx.addOutput(txOut);
+  }
+  cpfpSplitTx.addOutput(getEphemeralAnchorOutput());
+  const directSplitTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  directSplitTx.addInput(parentOutPoint);
+  let totalOutputAmount = 0n;
+  for (const txOut of childTxOuts) {
+    totalOutputAmount += txOut.amount ?? 0n;
+  }
+  if (totalOutputAmount > BigInt(DEFAULT_FEE_SATS)) {
+    const feeRatio = Number(DEFAULT_FEE_SATS) / Number(totalOutputAmount);
+    for (const txOut of childTxOuts) {
+      const adjustedAmount = BigInt(
+        Math.floor(Number(txOut.amount ?? 0n) * (1 - feeRatio))
+      );
+      directSplitTx.addOutput({
+        script: txOut.script,
+        amount: adjustedAmount
+      });
+    }
+  } else {
+    for (const txOut of childTxOuts) {
+      directSplitTx.addOutput(txOut);
+    }
+  }
+  return [cpfpSplitTx, directSplitTx];
+}
+function createNodeTx({
+  txOut,
+  parentOutPoint,
+  applyFee,
+  includeAnchor
+}) {
+  const nodeTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  nodeTx.addInput(parentOutPoint);
+  if (applyFee) {
+    nodeTx.addOutput({
+      script: txOut.script,
+      amount: maybeApplyFee(txOut.amount ?? 0n)
+    });
+  } else {
+    nodeTx.addOutput(txOut);
+  }
+  if (includeAnchor) {
+    nodeTx.addOutput(getEphemeralAnchorOutput());
+  }
+  return nodeTx;
+}
+function createNodeTxs(txOut, txIn, directTxIn) {
+  const cpfpNodeTx = createNodeTx({
+    txOut,
+    parentOutPoint: txIn,
+    includeAnchor: true
+  });
+  let directNodeTx;
+  if (directTxIn) {
+    directNodeTx = createNodeTx({
+      txOut,
+      parentOutPoint: directTxIn,
+      includeAnchor: false,
+      applyFee: true
+    });
+  }
+  return { cpfpNodeTx, directNodeTx };
+}
+function createLeafNodeTx(sequence, directSequence, parentOutPoint, txOut, shouldCalculateFee) {
+  const cpfpLeafTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  cpfpLeafTx.addInput({
+    ...parentOutPoint,
+    sequence
+  });
+  cpfpLeafTx.addOutput(txOut);
+  cpfpLeafTx.addOutput(getEphemeralAnchorOutput());
+  const directLeafTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  directLeafTx.addInput({
+    ...parentOutPoint,
+    sequence: directSequence
+  });
+  const amountSats = txOut.amount ?? 0n;
+  let outputAmount = amountSats;
+  if (shouldCalculateFee) {
+    outputAmount = maybeApplyFee(amountSats);
+  }
+  directLeafTx.addOutput({
+    script: txOut.script,
+    amount: outputAmount
+  });
+  return [cpfpLeafTx, directLeafTx];
+}
+function createRefundTx({
+  sequence,
+  input,
+  amountSats,
+  receivingPubkey,
+  network,
+  shouldCalculateFee,
+  includeAnchor
+}) {
+  const refundTx = new Transaction2({
     version: 3,
     allowUnknownOutputs: true
   });
-  newRefundTx.addInput({
-    ...nodeOutPoint,
+  refundTx.addInput({
+    ...input,
     sequence
   });
   const refundPkScript = getP2TRScriptFromPublicKey(receivingPubkey, network);
-  newRefundTx.addOutput({
+  let outputAmount = amountSats;
+  if (shouldCalculateFee) {
+    outputAmount = maybeApplyFee(amountSats);
+  }
+  refundTx.addOutput({
     script: refundPkScript,
+    amount: outputAmount
+  });
+  if (includeAnchor) {
+    refundTx.addOutput(getEphemeralAnchorOutput());
+  }
+  return refundTx;
+}
+function createRefundTxs({
+  sequence,
+  directSequence,
+  input,
+  directInput,
+  amountSats,
+  receivingPubkey,
+  network
+}) {
+  const cpfpRefundTx = createRefundTx({
+    sequence,
+    input,
+    amountSats,
+    receivingPubkey,
+    network,
+    shouldCalculateFee: false,
+    includeAnchor: true
+  });
+  let directRefundTx;
+  let directFromCpfpRefundTx;
+  if (directSequence && directInput) {
+    directRefundTx = createRefundTx({
+      sequence: directSequence,
+      input: directInput,
+      amountSats,
+      receivingPubkey,
+      network,
+      shouldCalculateFee: true,
+      includeAnchor: false
+    });
+    directFromCpfpRefundTx = createRefundTx({
+      sequence: directSequence,
+      input,
+      amountSats,
+      receivingPubkey,
+      network,
+      shouldCalculateFee: true,
+      includeAnchor: false
+    });
+  } else if (directInput && !directSequence) {
+    throw new ValidationError(
+      "directSequence must be provided if directInput is",
+      {
+        field: "directSequence",
+        value: directSequence
+      }
+    );
+  }
+  return { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx };
+}
+function createConnectorRefundTransactions(sequence, cpfpNodeOutPoint, directNodeOutPoint, connectorOutput, amountSats, receiverPubKey, network, shouldCalculateFee) {
+  const cpfpRefundTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  cpfpRefundTx.addInput({
+    ...cpfpNodeOutPoint,
+    sequence
+  });
+  cpfpRefundTx.addInput(connectorOutput);
+  const receiverScript = getP2TRScriptFromPublicKey(receiverPubKey, network);
+  cpfpRefundTx.addOutput({
+    script: receiverScript,
     amount: amountSats
   });
-  newRefundTx.addOutput(getEphemeralAnchorOutput());
-  return newRefundTx;
+  const directRefundTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  directRefundTx.addInput({
+    ...directNodeOutPoint,
+    sequence
+  });
+  directRefundTx.addInput(connectorOutput);
+  let outputAmount = amountSats;
+  if (shouldCalculateFee) {
+    outputAmount = maybeApplyFee(amountSats);
+  }
+  directRefundTx.addOutput({
+    script: receiverScript,
+    amount: outputAmount
+  });
+  const directFromCpfpTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  directFromCpfpTx.addInput({
+    ...cpfpNodeOutPoint,
+    sequence
+  });
+  directFromCpfpTx.addInput(connectorOutput);
+  directFromCpfpTx.addOutput({
+    script: receiverScript,
+    amount: outputAmount
+  });
+  return [cpfpRefundTx, directRefundTx, directFromCpfpTx];
 }
 function getCurrentTimelock(currSequence) {
   return (currSequence || 0) & 65535;
 }
 function getTransactionSequence(currSequence) {
   const timelock = getCurrentTimelock(currSequence);
-  return 1 << 30 | timelock;
+  return {
+    nextSequence: 1 << 30 | timelock,
+    nextDirectSequence: 1 << 30 | timelock + DIRECT_TIMELOCK_OFFSET
+  };
 }
 function checkIfValidSequence(currSequence) {
   const TIME_LOCK_ACTIVE = (currSequence || 0) & 2147483648;
@@ -16852,24 +17221,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() {
@@ -17528,7 +17905,7 @@ import * as ecies from "eciesjs";
 import { isNode } from "@lightsparkdev/core";
 var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
 var isBun = globalThis.Bun !== void 0;
-var packageVersion = true ? "0.2.2" : "unknown";
+var packageVersion = true ? "0.2.4" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -18021,7 +18398,7 @@ import {
 import { secp256k1 as secp256k114 } from "@noble/curves/secp256k1";
 import { validateMnemonic } from "@scure/bip39";
 import { wordlist as wordlist2 } from "@scure/bip39/wordlists/english";
-import { Address as Address7, OutScript as OutScript5, Transaction as Transaction9 } from "@scure/btc-signer";
+import { Address as Address6, OutScript as OutScript4, Transaction as Transaction9 } from "@scure/btc-signer";
 import { Mutex } from "async-mutex";
 import { uuidv7 as uuidv75, uuidv7obj } from "uuidv7";
 
@@ -18172,10 +18549,18 @@ var CompleteCoopExit = `
 var CompleteLeavesSwap = `
   mutation CompleteLeavesSwap(
     $adaptor_secret_key: String!
+    $direct_adaptor_secret_key: String!
+    $direct_from_cpfp_adaptor_secret_key: String!
     $user_outbound_transfer_external_id: UUID!
     $leaves_swap_request_id: ID!
   ) {
-    complete_leaves_swap(input: { adaptor_secret_key: $adaptor_secret_key, user_outbound_transfer_external_id: $user_outbound_transfer_external_id, leaves_swap_request_id: $leaves_swap_request_id }) {
+    complete_leaves_swap(input: { 
+      adaptor_secret_key: $adaptor_secret_key, 
+      direct_adaptor_secret_key: $direct_adaptor_secret_key,
+      direct_from_cpfp_adaptor_secret_key: $direct_from_cpfp_adaptor_secret_key,
+      user_outbound_transfer_external_id: $user_outbound_transfer_external_id, 
+      leaves_swap_request_id: $leaves_swap_request_id 
+    }) {
       request {
         ...LeavesSwapRequestFragment
       }
@@ -18298,6 +18683,8 @@ var RequestLightningSend = `
 var RequestSwapLeaves = `
   mutation RequestSwapLeaves(
     $adaptor_pubkey: PublicKey!
+    $direct_adaptor_pubkey: PublicKey
+    $direct_from_cpfp_adaptor_pubkey: PublicKey
     $total_amount_sats: Long!
     $target_amount_sats: Long!
     $fee_sats: Long!
@@ -18307,6 +18694,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
@@ -18797,6 +19186,8 @@ var SspClient = class {
   }
   async requestLeaveSwap({
     adaptorPubkey,
+    directAdaptorPubkey,
+    directFromCpfpAdaptorPubkey,
     totalAmountSats,
     targetAmountSats,
     feeSats,
@@ -18808,6 +19199,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,
@@ -18826,6 +19219,8 @@ var SspClient = class {
   }
   async completeLeaveSwap({
     adaptorSecretKey,
+    directAdaptorSecretKey,
+    directFromCpfpAdaptorSecretKey,
     userOutboundTransferExternalId,
     leavesSwapRequestId
   }) {
@@ -18833,6 +19228,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
       },
@@ -22193,72 +22590,367 @@ var TokenTransactionWithStatus2 = {
     return message;
   }
 };
-var SparkTokenServiceDefinition = {
-  name: "SparkTokenService",
-  fullName: "spark_token.SparkTokenService",
-  methods: {
-    /**
-     * Start process to create final token transaction with all inputs required
-     * from user and SOs (including revocation secret commitment)
-     */
-    start_transaction: {
-      name: "start_transaction",
-      requestType: StartTransactionRequest,
-      requestStream: false,
-      responseType: StartTransactionResponse,
-      responseStream: false,
-      options: {}
-    },
-    /**
-     * Complete the transaction and commit it with all SOs. This will be
-     * coordinated by one SO.
-     */
-    commit_transaction: {
-      name: "commit_transaction",
-      requestType: CommitTransactionRequest,
-      requestStream: false,
-      responseType: CommitTransactionResponse,
-      responseStream: false,
-      options: {}
-    },
-    query_token_metadata: {
-      name: "query_token_metadata",
-      requestType: QueryTokenMetadataRequest,
-      requestStream: false,
-      responseType: QueryTokenMetadataResponse,
-      responseStream: false,
-      options: {}
-    },
-    query_token_transactions: {
-      name: "query_token_transactions",
-      requestType: QueryTokenTransactionsRequest2,
-      requestStream: false,
-      responseType: QueryTokenTransactionsResponse2,
-      responseStream: false,
-      options: {}
-    },
-    query_token_outputs: {
-      name: "query_token_outputs",
-      requestType: QueryTokenOutputsRequest2,
-      requestStream: false,
-      responseType: QueryTokenOutputsResponse2,
-      responseStream: false,
-      options: {}
+function createBaseFreezeTokensPayload2() {
+  return {
+    version: 0,
+    ownerPublicKey: new Uint8Array(0),
+    tokenPublicKey: void 0,
+    tokenIdentifier: void 0,
+    issuerProvidedTimestamp: 0,
+    operatorIdentityPublicKey: new Uint8Array(0),
+    shouldUnfreeze: false
+  };
+}
+var FreezeTokensPayload2 = {
+  encode(message, writer = new BinaryWriter7()) {
+    if (message.version !== 0) {
+      writer.uint32(8).uint32(message.version);
     }
-  }
-};
-function bytesFromBase645(b64) {
-  if (globalThis.Buffer) {
-    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
-  } else {
-    const bin = globalThis.atob(b64);
-    const arr = new Uint8Array(bin.length);
-    for (let i = 0; i < bin.length; ++i) {
-      arr[i] = bin.charCodeAt(i);
+    if (message.ownerPublicKey.length !== 0) {
+      writer.uint32(18).bytes(message.ownerPublicKey);
     }
-    return arr;
-  }
-}
+    if (message.tokenPublicKey !== void 0) {
+      writer.uint32(26).bytes(message.tokenPublicKey);
+    }
+    if (message.tokenIdentifier !== void 0) {
+      writer.uint32(34).bytes(message.tokenIdentifier);
+    }
+    if (message.issuerProvidedTimestamp !== 0) {
+      writer.uint32(40).uint64(message.issuerProvidedTimestamp);
+    }
+    if (message.operatorIdentityPublicKey.length !== 0) {
+      writer.uint32(50).bytes(message.operatorIdentityPublicKey);
+    }
+    if (message.shouldUnfreeze !== false) {
+      writer.uint32(56).bool(message.shouldUnfreeze);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader7 ? input : new BinaryReader7(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseFreezeTokensPayload2();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.version = reader.uint32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.ownerPublicKey = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.tokenPublicKey = reader.bytes();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.tokenIdentifier = reader.bytes();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.issuerProvidedTimestamp = longToNumber4(reader.uint64());
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.operatorIdentityPublicKey = reader.bytes();
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+          message.shouldUnfreeze = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      version: isSet6(object.version) ? globalThis.Number(object.version) : 0,
+      ownerPublicKey: isSet6(object.ownerPublicKey) ? bytesFromBase645(object.ownerPublicKey) : new Uint8Array(0),
+      tokenPublicKey: isSet6(object.tokenPublicKey) ? bytesFromBase645(object.tokenPublicKey) : void 0,
+      tokenIdentifier: isSet6(object.tokenIdentifier) ? bytesFromBase645(object.tokenIdentifier) : void 0,
+      issuerProvidedTimestamp: isSet6(object.issuerProvidedTimestamp) ? globalThis.Number(object.issuerProvidedTimestamp) : 0,
+      operatorIdentityPublicKey: isSet6(object.operatorIdentityPublicKey) ? bytesFromBase645(object.operatorIdentityPublicKey) : new Uint8Array(0),
+      shouldUnfreeze: isSet6(object.shouldUnfreeze) ? globalThis.Boolean(object.shouldUnfreeze) : false
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.version !== 0) {
+      obj.version = Math.round(message.version);
+    }
+    if (message.ownerPublicKey.length !== 0) {
+      obj.ownerPublicKey = base64FromBytes5(message.ownerPublicKey);
+    }
+    if (message.tokenPublicKey !== void 0) {
+      obj.tokenPublicKey = base64FromBytes5(message.tokenPublicKey);
+    }
+    if (message.tokenIdentifier !== void 0) {
+      obj.tokenIdentifier = base64FromBytes5(message.tokenIdentifier);
+    }
+    if (message.issuerProvidedTimestamp !== 0) {
+      obj.issuerProvidedTimestamp = Math.round(message.issuerProvidedTimestamp);
+    }
+    if (message.operatorIdentityPublicKey.length !== 0) {
+      obj.operatorIdentityPublicKey = base64FromBytes5(message.operatorIdentityPublicKey);
+    }
+    if (message.shouldUnfreeze !== false) {
+      obj.shouldUnfreeze = message.shouldUnfreeze;
+    }
+    return obj;
+  },
+  create(base) {
+    return FreezeTokensPayload2.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseFreezeTokensPayload2();
+    message.version = object.version ?? 0;
+    message.ownerPublicKey = object.ownerPublicKey ?? new Uint8Array(0);
+    message.tokenPublicKey = object.tokenPublicKey ?? void 0;
+    message.tokenIdentifier = object.tokenIdentifier ?? void 0;
+    message.issuerProvidedTimestamp = object.issuerProvidedTimestamp ?? 0;
+    message.operatorIdentityPublicKey = object.operatorIdentityPublicKey ?? new Uint8Array(0);
+    message.shouldUnfreeze = object.shouldUnfreeze ?? false;
+    return message;
+  }
+};
+function createBaseFreezeTokensRequest2() {
+  return { freezeTokensPayload: void 0, issuerSignature: new Uint8Array(0) };
+}
+var FreezeTokensRequest2 = {
+  encode(message, writer = new BinaryWriter7()) {
+    if (message.freezeTokensPayload !== void 0) {
+      FreezeTokensPayload2.encode(message.freezeTokensPayload, writer.uint32(10).fork()).join();
+    }
+    if (message.issuerSignature.length !== 0) {
+      writer.uint32(18).bytes(message.issuerSignature);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader7 ? input : new BinaryReader7(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseFreezeTokensRequest2();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.freezeTokensPayload = FreezeTokensPayload2.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.issuerSignature = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      freezeTokensPayload: isSet6(object.freezeTokensPayload) ? FreezeTokensPayload2.fromJSON(object.freezeTokensPayload) : void 0,
+      issuerSignature: isSet6(object.issuerSignature) ? bytesFromBase645(object.issuerSignature) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.freezeTokensPayload !== void 0) {
+      obj.freezeTokensPayload = FreezeTokensPayload2.toJSON(message.freezeTokensPayload);
+    }
+    if (message.issuerSignature.length !== 0) {
+      obj.issuerSignature = base64FromBytes5(message.issuerSignature);
+    }
+    return obj;
+  },
+  create(base) {
+    return FreezeTokensRequest2.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseFreezeTokensRequest2();
+    message.freezeTokensPayload = object.freezeTokensPayload !== void 0 && object.freezeTokensPayload !== null ? FreezeTokensPayload2.fromPartial(object.freezeTokensPayload) : void 0;
+    message.issuerSignature = object.issuerSignature ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseFreezeTokensResponse2() {
+  return { impactedOutputIds: [], impactedTokenAmount: new Uint8Array(0) };
+}
+var FreezeTokensResponse2 = {
+  encode(message, writer = new BinaryWriter7()) {
+    for (const v of message.impactedOutputIds) {
+      writer.uint32(10).string(v);
+    }
+    if (message.impactedTokenAmount.length !== 0) {
+      writer.uint32(18).bytes(message.impactedTokenAmount);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader7 ? input : new BinaryReader7(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseFreezeTokensResponse2();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.impactedOutputIds.push(reader.string());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.impactedTokenAmount = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      impactedOutputIds: globalThis.Array.isArray(object?.impactedOutputIds) ? object.impactedOutputIds.map((e) => globalThis.String(e)) : [],
+      impactedTokenAmount: isSet6(object.impactedTokenAmount) ? bytesFromBase645(object.impactedTokenAmount) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.impactedOutputIds?.length) {
+      obj.impactedOutputIds = message.impactedOutputIds;
+    }
+    if (message.impactedTokenAmount.length !== 0) {
+      obj.impactedTokenAmount = base64FromBytes5(message.impactedTokenAmount);
+    }
+    return obj;
+  },
+  create(base) {
+    return FreezeTokensResponse2.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseFreezeTokensResponse2();
+    message.impactedOutputIds = object.impactedOutputIds?.map((e) => e) || [];
+    message.impactedTokenAmount = object.impactedTokenAmount ?? new Uint8Array(0);
+    return message;
+  }
+};
+var SparkTokenServiceDefinition = {
+  name: "SparkTokenService",
+  fullName: "spark_token.SparkTokenService",
+  methods: {
+    /**
+     * Start process to create final token transaction with all inputs required
+     * from user and SOs (including revocation secret commitment)
+     */
+    start_transaction: {
+      name: "start_transaction",
+      requestType: StartTransactionRequest,
+      requestStream: false,
+      responseType: StartTransactionResponse,
+      responseStream: false,
+      options: {}
+    },
+    /**
+     * Complete the transaction and commit it with all SOs. This will be
+     * coordinated by one SO.
+     */
+    commit_transaction: {
+      name: "commit_transaction",
+      requestType: CommitTransactionRequest,
+      requestStream: false,
+      responseType: CommitTransactionResponse,
+      responseStream: false,
+      options: {}
+    },
+    query_token_metadata: {
+      name: "query_token_metadata",
+      requestType: QueryTokenMetadataRequest,
+      requestStream: false,
+      responseType: QueryTokenMetadataResponse,
+      responseStream: false,
+      options: {}
+    },
+    query_token_transactions: {
+      name: "query_token_transactions",
+      requestType: QueryTokenTransactionsRequest2,
+      requestStream: false,
+      responseType: QueryTokenTransactionsResponse2,
+      responseStream: false,
+      options: {}
+    },
+    query_token_outputs: {
+      name: "query_token_outputs",
+      requestType: QueryTokenOutputsRequest2,
+      requestStream: false,
+      responseType: QueryTokenOutputsResponse2,
+      responseStream: false,
+      options: {}
+    },
+    freeze_tokens: {
+      name: "freeze_tokens",
+      requestType: FreezeTokensRequest2,
+      requestStream: false,
+      responseType: FreezeTokensResponse2,
+      responseStream: false,
+      options: {}
+    }
+  }
+};
+function bytesFromBase645(b64) {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
 function base64FromBytes5(arr) {
   if (globalThis.Buffer) {
     return globalThis.Buffer.from(arr).toString("base64");
@@ -22700,11 +23392,7 @@ import { sha256 as sha2568 } from "@noble/hashes/sha2";
 import { Transaction as Transaction4 } from "@scure/btc-signer";
 import * as ecies2 from "eciesjs";
 import { uuidv7 as uuidv72 } from "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,
@@ -22721,12 +23409,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()];
@@ -22764,13 +23454,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,
@@ -22796,6 +23499,8 @@ var BaseTransferService = class {
       transferID,
       receiverIdentityPubkey,
       leaves,
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map(),
       /* @__PURE__ */ new Map()
     );
     const transferPackage = await this.prepareTransferPackage(
@@ -22809,7 +23514,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,
@@ -22838,12 +23543,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) {
@@ -22863,12 +23578,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,
@@ -22928,7 +23642,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);
@@ -22943,54 +23657,120 @@ var BaseTransferService = class {
           `Output not found for leaf ${operatorSigningResult.leafId}`
         );
       }
-      const refundTxSighash = getSigHashFromTx(leafData.refundTx, 0, txOutput);
+      const cpfpRefundTxSighash = getSigHashFromTx(
+        leafData.refundTx,
+        0,
+        txOutput
+      );
       const publicKey = await this.config.signer.getPublicKeyFromDerivation(
         leafData.keyDerivation
       );
-      const userSignature = await this.config.signer.signFrost({
-        message: refundTxSighash,
+      const cpfpUserSignature = await this.config.signer.signFrost({
+        message: cpfpRefundTxSighash,
         publicKey,
         keyDerivation: leafData.keyDerivation,
         selfCommitment: leafData.signingNonceCommitment,
         statechainCommitments: operatorSigningResult.refundTxSigningResult?.signingNonceCommitments,
-        adaptorPubKey,
+        adaptorPubKey: cpfpAdaptorPubKey,
         verifyingKey: operatorSigningResult.verifyingKey
       });
-      const refundAggregate = await this.config.signer.aggregateFrost({
-        message: refundTxSighash,
+      const cpfpRefundAggregate = await this.config.signer.aggregateFrost({
+        message: cpfpRefundTxSighash,
         statechainSignatures: operatorSigningResult.refundTxSigningResult?.signatureShares,
         statechainPublicKeys: operatorSigningResult.refundTxSigningResult?.publicKeys,
         verifyingKey: operatorSigningResult.verifyingKey,
         statechainCommitments: operatorSigningResult.refundTxSigningResult?.signingNonceCommitments,
         selfCommitment: leafData.signingNonceCommitment,
         publicKey,
-        selfSignature: userSignature,
-        adaptorPubKey
+        selfSignature: cpfpUserSignature,
+        adaptorPubKey: cpfpAdaptorPubKey
       });
+      let directRefundAggregate;
+      let directFromCpfpRefundAggregate;
+      if (leafData.directTx) {
+        const directTxOutput = leafData.directTx.getOutput(0);
+        if (leafData.directRefundTx) {
+          const directRefundTxSighash = getSigHashFromTx(
+            leafData.directRefundTx,
+            0,
+            directTxOutput
+          );
+          const directUserSignature = await this.config.signer.signFrost({
+            message: directRefundTxSighash,
+            publicKey,
+            keyDerivation: leafData.keyDerivation,
+            selfCommitment: leafData.directSigningNonceCommitment,
+            statechainCommitments: operatorSigningResult.directRefundTxSigningResult?.signingNonceCommitments,
+            adaptorPubKey: directAdaptorPubKey,
+            verifyingKey: operatorSigningResult.verifyingKey
+          });
+          directRefundAggregate = await this.config.signer.aggregateFrost({
+            message: directRefundTxSighash,
+            statechainSignatures: operatorSigningResult.directRefundTxSigningResult?.signatureShares,
+            statechainPublicKeys: operatorSigningResult.directRefundTxSigningResult?.publicKeys,
+            verifyingKey: operatorSigningResult.verifyingKey,
+            statechainCommitments: operatorSigningResult.directRefundTxSigningResult?.signingNonceCommitments,
+            selfCommitment: leafData.directSigningNonceCommitment,
+            publicKey,
+            selfSignature: directUserSignature,
+            adaptorPubKey: directAdaptorPubKey
+          });
+        }
+        if (leafData.directFromCpfpRefundTx) {
+          const directFromCpfpRefundTxSighash = getSigHashFromTx(
+            leafData.directFromCpfpRefundTx,
+            0,
+            txOutput
+          );
+          const directFromCpfpUserSignature = await this.config.signer.signFrost({
+            message: directFromCpfpRefundTxSighash,
+            publicKey,
+            keyDerivation: leafData.keyDerivation,
+            selfCommitment: leafData.directFromCpfpRefundSigningNonceCommitment,
+            statechainCommitments: operatorSigningResult.directFromCpfpRefundTxSigningResult?.signingNonceCommitments,
+            adaptorPubKey: directFromCpfpAdaptorPubKey,
+            verifyingKey: operatorSigningResult.verifyingKey
+          });
+          directFromCpfpRefundAggregate = await this.config.signer.aggregateFrost({
+            message: directFromCpfpRefundTxSighash,
+            statechainSignatures: operatorSigningResult.directFromCpfpRefundTxSigningResult?.signatureShares,
+            statechainPublicKeys: operatorSigningResult.directFromCpfpRefundTxSigningResult?.publicKeys,
+            verifyingKey: operatorSigningResult.verifyingKey,
+            statechainCommitments: operatorSigningResult.directFromCpfpRefundTxSigningResult?.signingNonceCommitments,
+            selfCommitment: leafData.directFromCpfpRefundSigningNonceCommitment,
+            publicKey,
+            selfSignature: directFromCpfpUserSignature,
+            adaptorPubKey: directFromCpfpAdaptorPubKey
+          });
+        }
+      }
       nodeSignatures.push({
         nodeId: operatorSigningResult.leafId,
-        refundTxSignature: refundAggregate,
         nodeTxSignature: new Uint8Array(),
-        // TODO: Add direct refund signature
         directNodeTxSignature: new Uint8Array(),
-        directRefundTxSignature: new Uint8Array(),
-        directFromCpfpRefundTxSignature: new Uint8Array()
+        refundTxSignature: cpfpRefundAggregate,
+        directRefundTxSignature: directRefundAggregate ?? new Uint8Array(),
+        directFromCpfpRefundTxSignature: directFromCpfpRefundAggregate ?? new Uint8Array()
       });
     }
     return nodeSignatures;
   }
-  async prepareSendTransferKeyTweaks(transferID, receiverIdentityPubkey, leaves, refundSignatureMap) {
+  async prepareSendTransferKeyTweaks(transferID, receiverIdentityPubkey, leaves, cpfpRefundSignatureMap, directRefundSignatureMap, directFromCpfpRefundSignatureMap) {
     const receiverEciesPubKey = ecies2.PublicKey.fromHex(
       bytesToHex10(receiverIdentityPubkey)
     );
     const leavesTweaksMap = /* @__PURE__ */ new Map();
     for (const leaf of leaves) {
-      const refundSignature = refundSignatureMap.get(leaf.leaf.id);
+      const cpfpRefundSignature = cpfpRefundSignatureMap.get(leaf.leaf.id);
+      const directRefundSignature = directRefundSignatureMap.get(leaf.leaf.id);
+      const directFromCpfpRefundSignature = directFromCpfpRefundSignatureMap.get(leaf.leaf.id);
       const leafTweaksMap = await this.prepareSingleSendTransferKeyTweak(
         transferID,
         leaf,
         receiverEciesPubKey,
-        refundSignature
+        cpfpRefundSignature,
+        directRefundSignature,
+        directFromCpfpRefundSignature
       );
       for (const [identifier, leafTweak] of leafTweaksMap) {
         leavesTweaksMap.set(identifier, [
@@ -23001,7 +23781,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,
@@ -23049,10 +23829,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;
@@ -23082,7 +23861,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)
@@ -23090,7 +23874,9 @@ var TransferService = class extends BaseTransferService {
     const transferWithTweakedKeys = await this.sendTransferTweakKey(
       transfer,
       leaves,
-      signatureMap
+      signatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap
     );
     return transferWithTweakedKeys;
   }
@@ -23194,7 +23980,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,
@@ -23203,11 +23995,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,
@@ -23216,31 +24016,45 @@ var TransferService = class extends BaseTransferService {
     return {
       transfer,
       signatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap,
       leafDataMap
     };
   }
-  async counterSwapSignRefund(leaves, receiverIdentityPubkey, expiryTime, adaptorPubKey) {
+  async counterSwapSignRefund(leaves, receiverIdentityPubkey, expiryTime, cpfpAdaptorPubKey, directAdaptorPubKey, directFromCpfpAdaptorPubKey) {
     return this.sendTransferSignRefundInternal(
       leaves,
       receiverIdentityPubkey,
       expiryTime,
       true,
-      adaptorPubKey
+      cpfpAdaptorPubKey,
+      directAdaptorPubKey,
+      directFromCpfpAdaptorPubKey
     );
   }
-  async sendTransferSignRefundInternal(leaves, receiverIdentityPubkey, expiryTime, forSwap, adaptorPubKey) {
+  async sendTransferSignRefundInternal(leaves, receiverIdentityPubkey, expiryTime, forSwap, cpfpAdaptorPubKey, directAdaptorPubKey, directFromCpfpAdaptorPubKey) {
     const transferId = uuidv72();
     const leafDataMap = /* @__PURE__ */ new Map();
     for (const leaf of leaves) {
       const signingNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+      const directSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+      const directFromCpfpRefundSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
       const tx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
       const refundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
+      const directTx = leaf.leaf.directTx.length > 0 ? getTxFromRawTxBytes(leaf.leaf.directTx) : void 0;
+      const directRefundTx = leaf.leaf.directRefundTx.length > 0 ? getTxFromRawTxBytes(leaf.leaf.directRefundTx) : void 0;
+      const directFromCpfpRefundTx = leaf.leaf.directFromCpfpRefundTx.length > 0 ? getTxFromRawTxBytes(leaf.leaf.directFromCpfpRefundTx) : void 0;
       leafDataMap.set(leaf.leaf.id, {
         keyDerivation: leaf.keyDerivation,
         receivingPubkey: receiverIdentityPubkey,
         signingNonceCommitment,
+        directSigningNonceCommitment,
         tx,
+        directTx,
         refundTx,
+        directRefundTx,
+        directFromCpfpRefundTx,
+        directFromCpfpRefundSigningNonceCommitment,
         vout: leaf.leaf.vout
       });
     }
@@ -23253,8 +24067,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,
@@ -23263,10 +24077,12 @@ var TransferService = class extends BaseTransferService {
             expiryTime
           },
           swapId: uuidv72(),
-          adaptorPublicKey: adaptorPubKey || new Uint8Array()
+          adaptorPublicKey: cpfpAdaptorPubKey,
+          directAdaptorPublicKey: directAdaptorPubKey,
+          directFromCpfpAdaptorPublicKey: directFromCpfpAdaptorPubKey
         });
       } else if (forSwap) {
-        response = await sparkClient.start_leaf_swap({
+        response = await sparkClient.start_leaf_swap_v2({
           transferId,
           leavesToSend: signingJobs,
           ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
@@ -23274,7 +24090,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(),
@@ -23291,15 +24107,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
     };
@@ -23312,38 +24142,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: hexToBytes6(getTxId(nodeTx)),
         index: 0
       };
+      let directNodeTx;
+      let directNodeOutPoint;
+      if (leaf.leaf.directTx.length > 0) {
+        directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
+        directNodeOutPoint = {
+          txid: hexToBytes6(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;
@@ -23464,13 +24324,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
       });
     }
@@ -23492,7 +24356,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
@@ -23507,7 +24371,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
       });
@@ -23546,109 +24410,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 Transaction4({ 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
+    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"
       });
-      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
-        });
-      }
+    }
+    let { nextSequence, nextDirectSequence } = getNextTransactionSequence(
+      currSequence,
+      true
+    );
+    const output = {
+      script: parentNodeOutput.script,
+      amount: parentNodeOutput.amount
+    };
+    const newNodeInput = {
+      txid: nodeInput.txid,
+      index: nodeInput.index,
+      sequence: useTestUnilateralSequence ? TEST_UNILATERAL_SEQUENCE : nextSequence
+    };
+    const newDirectInput = directNodeTx && directNodeInput ? {
+      txid: directNodeInput.txid,
+      index: directNodeInput.index,
+      sequence: useTestUnilateralSequence ? TEST_UNILATERAL_DIRECT_SEQUENCE : nextDirectSequence
+    } : void 0;
+    const { cpfpNodeTx, directNodeTx: newDirectNodeTx } = createNodeTxs(
+      output,
+      newNodeInput,
+      newDirectInput
+    );
+    const newCpfpNodeOutput = cpfpNodeTx.getOutput(0);
+    if (!newCpfpNodeOutput) {
+      throw Error("Could not get new cpfp node output");
+    }
+    const newDirectNodeOutput = newDirectNodeTx?.getOutput(0);
+    const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation({
+      type: "leaf" /* LEAF */,
+      path: node.id
+    });
+    signingJobs.push({
+      signingPublicKey,
+      rawTx: cpfpNodeTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "node",
+      parentTxOut: parentNodeOutput
+    });
+    if (newDirectNodeTx) {
       signingJobs.push({
-        signingPublicKey: await this.config.signer.getPublicKeyFromDerivation({
-          type: "leaf" /* LEAF */,
-          path: node.id
-        }),
-        rawTx: newTx.toBytes(),
-        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
+        signingPublicKey,
+        rawTx: newDirectNodeTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "directNode",
+        parentTxOut: parentNodeOutput
       });
-      newNodeTxs[i] = newTx;
     }
-    const leaf = nodes[nodes.length - 1];
-    if (!leaf?.refundTx) {
-      throw Error("leaf does not have refund tx");
+    const newCpfpRefundOutPoint = {
+      txid: hexToBytes6(getTxId(cpfpNodeTx)),
+      index: 0
+    };
+    let newDirectRefundOutPoint;
+    if (newDirectNodeTx) {
+      newDirectRefundOutPoint = {
+        txid: hexToBytes6(getTxId(newDirectNodeTx)),
+        index: 0
+      };
     }
-    const refundTx = getTxFromRawTxBytes(leaf?.refundTx);
-    const newRefundTx = new Transaction4({
-      version: 3,
-      allowUnknownOutputs: true
+    const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
+      sequence: INITIAL_SEQUENCE,
+      directSequence: INITIAL_DIRECT_SEQUENCE,
+      input: newCpfpRefundOutPoint,
+      directInput: newDirectRefundOutPoint,
+      amountSats: nodeOutput.amount,
+      receivingPubkey: await this.config.signer.getPublicKeyFromDerivation({
+        type: "leaf" /* LEAF */,
+        path: node.id
+      }),
+      network: this.config.getNetwork()
     });
-    const originalRefundOutput = refundTx.getOutput(0);
-    if (!originalRefundOutput) {
-      throw Error("Could not get original refund output");
-    }
-    newRefundTx.addOutput({
-      script: originalRefundOutput.script,
-      amount: originalRefundOutput.amount
+    signingJobs.push({
+      signingPublicKey,
+      rawTx: cpfpRefundTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "cpfp",
+      parentTxOut: newCpfpNodeOutput
     });
-    for (let j = 1; j < refundTx.outputsLength; j++) {
-      const additionalOutput = refundTx.getOutput(j);
-      if (additionalOutput) {
-        newRefundTx.addOutput(additionalOutput);
-      }
-    }
-    const refundTxInput = refundTx.getInput(0);
-    if (!refundTxInput) {
-      throw Error("refund tx doesn't have input");
+    if (directRefundTx && newDirectNodeOutput) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: directRefundTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "direct",
+        parentTxOut: newDirectNodeOutput
+      });
     }
-    if (!newNodeTxs[newNodeTxs.length - 1]) {
-      throw Error("Could not get last node tx");
+    if (directFromCpfpRefundTx && newCpfpNodeOutput) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: directFromCpfpRefundTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "directFromCpfp",
+        parentTxOut: newCpfpNodeOutput
+      });
     }
-    newRefundTx.addInput({
-      ...refundTxInput,
-      sequence: initialSequence(),
-      txid: getTxId(newNodeTxs[newNodeTxs.length - 1])
-    });
-    const refundSigningJob = {
-      signingPublicKey: await this.config.signer.getPublicKeyFromDerivation({
-        type: "leaf" /* LEAF */,
-        path: leaf.id
-      }),
-      rawTx: newRefundTx.toBytes(),
-      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
-    };
-    signingJobs.push(refundSigningJob);
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
-    const response = await sparkClient.refresh_timelock({
-      leafId: leaf.id,
+    const response = await sparkClient.refresh_timelock_v2({
+      leafId: node.id,
       ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
       signingJobs: signingJobs.map(getSigningJobProto)
     });
@@ -23658,45 +24547,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,
@@ -23715,41 +24586,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);
@@ -23758,7 +24623,10 @@ var TransferService = class extends BaseTransferService {
       txid: hexToBytes6(getTxId(nodeTx)),
       index: 0
     };
-    const { nextSequence: newNodeSequence } = getNextTransactionSequence(refundSequence);
+    const {
+      nextSequence: newNodeSequence,
+      nextDirectSequence: newDirectNodeSequence
+    } = getNextTransactionSequence(refundSequence);
     const newNodeTx = new Transaction4({
       version: 3,
       allowUnknownOutputs: true
@@ -23771,81 +24639,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 Transaction4({
+        version: 3,
+        allowUnknownOutputs: true
+      });
+      newDirectNodeTx.addInput({
+        ...newNodeOutPoint,
+        sequence: newDirectNodeSequence
+      });
+      newDirectNodeTx.addOutput({
+        script: originalOutput.script,
+        amount: maybeApplyFee(originalOutput.amount)
+      });
+    }
+    const newCpfpRefundOutPoint = {
       txid: hexToBytes6(getTxId(newNodeTx)),
       index: 0
     };
+    let newDirectRefundOutPoint;
+    if (newDirectNodeTx) {
+      newDirectRefundOutPoint = {
+        txid: hexToBytes6(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,
@@ -23853,122 +24762,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 Transaction4({
-      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: hexToBytes6(getTxId(nodeTx)),
+      index: 0
+    };
+    let directRefundOutPoint;
+    if (directNodeTx) {
+      directRefundOutPoint = {
+        txid: hexToBytes6(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
         }
       ]
     });
@@ -23987,7 +25027,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,
@@ -23996,34 +25041,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 Transaction5();
-    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 Transaction5();
+    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 Transaction5();
+      directRefundTx.addInput({
+        txid: directNodeOutPoint.txid,
+        index: directNodeOutPoint.index,
+        sequence: directSequence
+      });
+      directRefundTx.addInput(connectorOutput);
+      directRefundTx.addOutput({
+        script: receiverScript,
+        amount: maybeApplyFee(amountSats)
+      });
+      directFromCpfpRefundTx = new Transaction5();
+      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) {
@@ -24059,39 +25151,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(
@@ -24099,7 +25219,7 @@ var CoopExitService = class extends BaseTransferService {
     );
     let response;
     try {
-      response = await sparkClient.cooperative_exit({
+      response = await sparkClient.cooperative_exit_v2({
         transfer: {
           transferId: uuidv73(),
           leavesToSend: signingJobs,
@@ -24133,10 +25253,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
+    };
   }
 };
 
@@ -24144,10 +25279,8 @@ var CoopExitService = class extends BaseTransferService {
 import { schnorr as schnorr4, secp256k1 as secp256k19 } from "@noble/curves/secp256k1";
 import { sha256 as sha2569 } from "@noble/hashes/sha2";
 import { hexToBytes as hexToBytes7 } from "@noble/hashes/utils";
-import * as btc5 from "@scure/btc-signer";
-import { p2tr as p2tr2, Transaction as Transaction6 } from "@scure/btc-signer";
+import { p2tr as p2tr2 } from "@scure/btc-signer";
 import { equalBytes as equalBytes4 } from "@scure/btc-signer/utils";
-var INITIAL_TIME_LOCK2 = 2e3;
 var DepositService = class {
   config;
   connectionManager;
@@ -24215,57 +25348,370 @@ var DepositService = class {
         });
       }
     }
-  }
-  async generateDepositAddress({
-    signingPubkey,
-    leafId,
-    isStatic = false
-  }) {
+  }
+  async generateDepositAddress({
+    signingPubkey,
+    leafId,
+    isStatic = false
+  }) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let depositResp;
+    try {
+      depositResp = await sparkClient.generate_deposit_address({
+        signingPublicKey: signingPubkey,
+        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        network: this.config.getNetworkProto(),
+        leafId,
+        isStatic
+      });
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to generate deposit address",
+        {
+          operation: "generate_deposit_address",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error)
+        },
+        error
+      );
+    }
+    if (!depositResp.depositAddress) {
+      throw new ValidationError(
+        "No deposit address response from coordinator",
+        {
+          field: "depositAddress",
+          value: depositResp
+        }
+      );
+    }
+    await this.validateDepositAddress({
+      address: depositResp.depositAddress,
+      userPubkey: signingPubkey
+    });
+    return depositResp;
+  }
+  async createTreeRoot({
+    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: hexToBytes7(getTxId(depositTx)),
+      index: vout
+    };
+    const depositTxOut = {
+      script,
+      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: hexToBytes7(getTxId(cpfpRootTx)), index: 0 },
+      directInput: { txid: hexToBytes7(getTxId(directRootTx)), index: 0 },
+      amountSats: amount,
+      receivingPubkey: signingPubKey,
+      network: this.config.getNetwork()
+    });
+    const cpfpRefundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const directRefundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const directFromCpfpRefundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const cpfpRefundTxSighash = getSigHashFromTx(
+      cpfpRefundTx,
+      0,
+      cpfpRootTx.getOutput(0)
+    );
+    if (!directRefundTx || !directFromCpfpRefundTx) {
+      throw new ValidationError(
+        "Expected direct refund transactions for tree creation",
+        {
+          field: "directRefundTx",
+          value: directRefundTx
+        }
+      );
+    }
+    const directRefundTxSighash = getSigHashFromTx(
+      directRefundTx,
+      0,
+      directRootTx.getOutput(0)
+    );
+    const directFromCpfpRefundTxSighash = getSigHashFromTx(
+      directFromCpfpRefundTx,
+      0,
+      cpfpRootTx.getOutput(0)
+    );
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
-    let depositResp;
+    let treeResp;
     try {
-      depositResp = await sparkClient.generate_deposit_address({
-        signingPublicKey: signingPubkey,
+      treeResp = await sparkClient.start_deposit_tree_creation({
         identityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        network: this.config.getNetworkProto(),
-        leafId,
-        isStatic
+        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 generate deposit address",
+        "Failed to start deposit tree creation",
         {
-          operation: "generate_deposit_address",
+          operation: "start_deposit_tree_creation",
           errorCount: 1,
           errors: error instanceof Error ? error.message : String(error)
         },
         error
       );
     }
-    if (!depositResp.depositAddress) {
+    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 deposit address response from coordinator",
+        "No signing nonce commitments found in tree response",
         {
-          field: "depositAddress",
-          value: depositResp
+          field: "nodeTxSigningResult.signingNonceCommitments",
+          value: treeResp.rootNodeSignatureShares.nodeTxSigningResult,
+          expected: "Non-null signing nonce commitments"
         }
       );
     }
-    await this.validateDepositAddress({
-      address: depositResp.depositAddress,
-      userPubkey: signingPubkey
+    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 (!equalBytes4(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()
     });
-    return depositResp;
+    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;
   }
-  async createTreeRoot({
+  /**
+   * @deprecated
+   * Use createTreeRoot instead.
+   * This is currently only used to test backwards compatibility.
+   */
+  async createTreeWithoutDirectTx({
     keyDerivation,
     verifyingKey,
     depositTx,
     vout
   }) {
-    const rootTx = new Transaction6({ version: 3 });
     const output = depositTx.getOutput(vout);
     if (!output) {
       throw new ValidationError("Invalid deposit transaction output", {
@@ -24283,39 +25729,31 @@ var DepositService = class {
         expected: "Output with script and amount"
       });
     }
-    let outputAmount = amount;
-    rootTx.addInput({
-      txid: getTxId(depositTx),
+    const depositOutPoint = {
+      txid: hexToBytes7(getTxId(depositTx)),
       index: vout
-    });
-    rootTx.addOutput({
+    };
+    const depositTxOut = {
       script,
-      amount: outputAmount
-    });
-    rootTx.addOutput(getEphemeralAnchorOutput());
-    const rootNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const rootTxSighash = getSigHashFromTx(rootTx, 0, output);
-    const refundTx = new Transaction6({ version: 3 });
-    const sequence = 1 << 30 | INITIAL_TIME_LOCK2;
-    refundTx.addInput({
-      txid: getTxId(rootTx),
-      index: 0,
-      sequence
-    });
+      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: hexToBytes7(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()
     );
@@ -24329,14 +25767,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) {
@@ -24382,55 +25820,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
           }
         ]
       });
@@ -24642,7 +26080,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(
@@ -24655,10 +26094,19 @@ var LightningService = class {
         error
       );
     }
-    const leafSigningJobs = await this.signingService.signRefunds(
+    const {
+      cpfpLeafSigningJobs,
+      directLeafSigningJobs,
+      directFromCpfpLeafSigningJobs
+    } = await this.signingService.signRefunds(
       leaves,
-      signingCommitments.signingCommitments,
-      receiverIdentityPubkey
+      receiverIdentityPubkey,
+      signingCommitments.signingCommitments.slice(0, leaves.length),
+      signingCommitments.signingCommitments.slice(
+        leaves.length,
+        2 * leaves.length
+      ),
+      signingCommitments.signingCommitments.slice(2 * leaves.length)
     );
     const transferId = uuidv74();
     let bolt11String = "";
@@ -24695,7 +26143,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: {
@@ -24707,7 +26155,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)
         },
@@ -26961,7 +28411,9 @@ var TokenTransactionService = class {
       issuerPublicKeys,
       tokenTransactionHashes,
       tokenIdentifiers,
-      outputIds
+      outputIds,
+      pageSize,
+      offset
     } = params;
     const tokenClient = await this.connectionManager.createSparkTokenClient(
       this.config.getCoordinatorAddress()
@@ -26972,8 +28424,8 @@ var TokenTransactionService = class {
       tokenIdentifiers: tokenIdentifiers?.map(hexToBytes9),
       tokenTransactionHashes: tokenTransactionHashes?.map(hexToBytes9),
       outputIds: outputIds || [],
-      limit: 100,
-      offset: 0
+      limit: pageSize,
+      offset
     };
     try {
       const response = await tokenClient.query_token_transactions(queryParams);
@@ -27180,14 +28632,7 @@ function isTokenTransaction(tokenTransaction) {
 
 // src/services/tree-creation.ts
 import { hexToBytes as hexToBytes10 } from "@noble/curves/abstract/utils";
-import { Address as Address5, OutScript as OutScript3, Transaction as Transaction7 } from "@scure/btc-signer";
-var INITIAL_TIME_LOCK3 = 2e3;
-function maybeApplyFee2(amount) {
-  if (amount > BigInt(DEFAULT_FEE_SATS)) {
-    return amount - BigInt(DEFAULT_FEE_SATS);
-  }
-  return amount;
-}
+import { Address as Address4, OutScript as OutScript2 } from "@scure/btc-signer";
 var TreeCreationService = class {
   config;
   connectionManager;
@@ -27302,7 +28747,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}`);
     }
@@ -27319,7 +28764,7 @@ var TreeCreationService = class {
     );
     let finalizeResp;
     try {
-      finalizeResp = await sparkClient.finalize_node_signatures({
+      finalizeResp = await sparkClient.finalize_node_signatures_v2({
         nodeSignatures
       });
     } catch (error) {
@@ -27384,91 +28829,111 @@ var TreeCreationService = class {
   async buildChildCreationNode(node, parentTx, vout, network) {
     const internalCreationNode = {
       nodeTxSigningJob: void 0,
-      refundTxSigningJob: void 0,
-      children: [],
       directNodeTxSigningJob: void 0,
+      refundTxSigningJob: void 0,
       directRefundTxSigningJob: void 0,
-      directFromCpfpRefundTxSigningJob: void 0
+      directFromCpfpRefundTxSigningJob: void 0,
+      children: []
     };
-    const tx = new Transaction7({ version: 3 });
-    tx.addInput({
-      txid: getTxId(parentTx),
-      index: vout
-    });
     const parentTxOut = parentTx.getOutput(vout);
     if (!parentTxOut?.script || !parentTxOut?.amount) {
       throw new Error("parentTxOut is undefined");
     }
-    tx.addOutput({
+    const parentOutPoint = {
+      txid: hexToBytes10(getTxId(parentTx)),
+      index: vout
+    };
+    const parentTxOutObj = {
       script: parentTxOut.script,
       amount: parentTxOut.amount
-      // maybeApplyFee(parentTxOut.amount),
-    });
-    tx.addOutput(getEphemeralAnchorOutput());
-    const signingNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const signingJob = {
+    };
+    const { cpfpNodeTx, directNodeTx } = createNodeTxs(
+      parentTxOutObj,
+      parentOutPoint
+    );
+    const cpfpNodeSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const directNodeSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const cpfpNodeSigningJob = {
       signingPublicKey: node.signingPublicKey,
-      rawTx: tx.toBytes(),
-      signingNonceCommitment: signingNonceCommitment.commitment
+      rawTx: cpfpNodeTx.toBytes(),
+      signingNonceCommitment: cpfpNodeSigningCommitment.commitment
     };
-    internalCreationNode.nodeTxSigningCommitment = signingNonceCommitment;
-    internalCreationNode.nodeTxSigningJob = signingJob;
-    const sequence = 1 << 30 | INITIAL_TIME_LOCK3;
+    const directNodeSigningJob = directNodeTx ? {
+      signingPublicKey: node.signingPublicKey,
+      rawTx: directNodeTx.toBytes(),
+      signingNonceCommitment: directNodeSigningCommitment.commitment
+    } : void 0;
+    internalCreationNode.nodeTxSigningCommitment = cpfpNodeSigningCommitment;
+    internalCreationNode.directNodeTxSigningCommitment = directNodeSigningCommitment;
+    internalCreationNode.nodeTxSigningJob = cpfpNodeSigningJob;
+    internalCreationNode.directNodeTxSigningJob = directNodeSigningJob;
+    const sequence = INITIAL_SEQUENCE;
+    const directSequence = INITIAL_DIRECT_SEQUENCE;
     const childCreationNode = {
       nodeTxSigningJob: void 0,
-      refundTxSigningJob: void 0,
-      children: [],
       directNodeTxSigningJob: void 0,
+      refundTxSigningJob: void 0,
       directRefundTxSigningJob: void 0,
-      directFromCpfpRefundTxSigningJob: void 0
+      directFromCpfpRefundTxSigningJob: void 0,
+      children: []
     };
-    const childTx = new Transaction7({ version: 3 });
-    childTx.addInput({
-      txid: getTxId(tx),
-      index: 0,
-      sequence
-    });
-    childTx.addOutput({
-      script: parentTxOut.script,
-      amount: parentTxOut.amount
-      // maybeApplyFee(parentTxOut.amount),
-    });
-    childTx.addOutput(getEphemeralAnchorOutput());
-    const childSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const childSigningJob = {
+    const [cpfpLeafTx, directLeafTx] = createLeafNodeTx(
+      sequence,
+      directSequence,
+      { txid: hexToBytes10(getTxId(cpfpNodeTx)), index: 0 },
+      parentTxOutObj,
+      true
+      // shouldCalculateFee
+    );
+    const cpfpLeafSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const directLeafSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const cpfpLeafSigningJob = {
       signingPublicKey: node.signingPublicKey,
-      rawTx: childTx.toBytes(),
-      signingNonceCommitment: childSigningNonceCommitment.commitment
+      rawTx: cpfpLeafTx.toBytes(),
+      signingNonceCommitment: cpfpLeafSigningCommitment.commitment
     };
-    childCreationNode.nodeTxSigningCommitment = childSigningNonceCommitment;
-    childCreationNode.nodeTxSigningJob = childSigningJob;
-    const refundTx = new Transaction7({ version: 3 });
-    refundTx.addInput({
-      txid: getTxId(childTx),
-      index: 0,
-      sequence
-    });
-    const refundP2trAddress = getP2TRAddressFromPublicKey(
-      node.signingPublicKey,
+    const directLeafSigningJob = {
+      signingPublicKey: node.signingPublicKey,
+      rawTx: directLeafTx.toBytes(),
+      signingNonceCommitment: directLeafSigningCommitment.commitment
+    };
+    childCreationNode.nodeTxSigningCommitment = cpfpLeafSigningCommitment;
+    childCreationNode.directNodeTxSigningCommitment = directLeafSigningCommitment;
+    childCreationNode.nodeTxSigningJob = cpfpLeafSigningJob;
+    childCreationNode.directNodeTxSigningJob = directLeafSigningJob;
+    const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
+      sequence,
+      directSequence,
+      input: { txid: hexToBytes10(getTxId(cpfpLeafTx)), index: 0 },
+      directInput: { txid: hexToBytes10(getTxId(directLeafTx)), index: 0 },
+      amountSats: parentTxOut.amount,
+      receivingPubkey: node.signingPublicKey,
       network
-    );
-    const refundAddress = Address5(getNetwork(network)).decode(
-      refundP2trAddress
-    );
-    const refundPkScript = OutScript3.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;
   }
@@ -27477,40 +28942,49 @@ var TreeCreationService = class {
     if (!parentTxOutput?.script || !parentTxOutput?.amount) {
       throw new Error("parentTxOutput is undefined");
     }
-    const rootNodeTx = new Transaction7({ version: 3 });
-    rootNodeTx.addInput({
-      txid: getTxId(parentTx),
-      index: vout
-    });
+    const childTxOuts = [];
     for (let i = 0; i < root.children.length; i++) {
       const child = root.children[i];
       if (!child || !child.address) {
         throw new Error("child address is undefined");
       }
-      const childAddress = Address5(getNetwork(network)).decode(child.address);
-      const childPkScript = OutScript3.encode(childAddress);
-      rootNodeTx.addOutput({
+      const childAddress = Address4(getNetwork(network)).decode(child.address);
+      const childPkScript = OutScript2.encode(childAddress);
+      childTxOuts.push({
         script: childPkScript,
         amount: parentTxOutput.amount / 2n
-        // feeAdjustedAmount / 2n,
       });
     }
-    rootNodeTx.addOutput(getEphemeralAnchorOutput());
-    const rootNodeSigningCommitment = await this.config.signer.getRandomSigningCommitment();
-    const rootNodeSigningJob = {
+    const parentOutPoint = {
+      txid: hexToBytes10(getTxId(parentTx)),
+      index: vout
+    };
+    const [cpfpSplitTx, directSplitTx] = createSplitTx(
+      parentOutPoint,
+      childTxOuts
+    );
+    const cpfpSplitSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const directSplitSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const cpfpSplitSigningJob = {
+      signingPublicKey: root.signingPublicKey,
+      rawTx: cpfpSplitTx.toBytes(),
+      signingNonceCommitment: cpfpSplitSigningCommitment.commitment
+    };
+    const directSplitSigningJob = {
       signingPublicKey: root.signingPublicKey,
-      rawTx: rootNodeTx.toBytes(),
-      signingNonceCommitment: rootNodeSigningCommitment.commitment
+      rawTx: directSplitTx.toBytes(),
+      signingNonceCommitment: directSplitSigningCommitment.commitment
     };
     const rootCreationNode = {
-      nodeTxSigningJob: rootNodeSigningJob,
+      nodeTxSigningJob: cpfpSplitSigningJob,
+      directNodeTxSigningJob: directSplitSigningJob,
       refundTxSigningJob: void 0,
-      children: [],
-      directNodeTxSigningJob: void 0,
       directRefundTxSigningJob: void 0,
-      directFromCpfpRefundTxSigningJob: void 0
+      directFromCpfpRefundTxSigningJob: void 0,
+      children: []
     };
-    rootCreationNode.nodeTxSigningCommitment = rootNodeSigningCommitment;
+    rootCreationNode.nodeTxSigningCommitment = cpfpSplitSigningCommitment;
+    rootCreationNode.directNodeTxSigningCommitment = directSplitSigningCommitment;
     const leftChild = root.children[0];
     const rightChild = root.children[1];
     if (!leftChild || !rightChild) {
@@ -27518,13 +28992,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
     );
@@ -27533,19 +29009,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 */,
@@ -27555,30 +29031,84 @@ var TreeCreationService = class {
         statechainCommitments: creationResponseNode.nodeTxSigningResult?.signingNonceCommitments,
         verifyingKey: internalNode.verificationKey
       });
-      nodeTxSignature = await this.config.signer.aggregateFrost({
-        message: txSighash,
+      cpfpNodeTxSignature = await this.config.signer.aggregateFrost({
+        message: cpfpNodeTxSighash,
         statechainSignatures: creationResponseNode.nodeTxSigningResult?.signatureShares,
         statechainPublicKeys: creationResponseNode.nodeTxSigningResult?.publicKeys,
         verifyingKey: internalNode.verificationKey,
         statechainCommitments: creationResponseNode.nodeTxSigningResult?.signingNonceCommitments,
         selfCommitment: creationNode.nodeTxSigningCommitment,
-        selfSignature: userSignature,
+        selfSignature: cpfpUserSignature,
+        publicKey: internalNode.signingPublicKey
+      });
+    }
+    const directNodeTx = getTxFromRawTxBytes(
+      creationNode.directNodeTxSigningJob.rawTx
+    );
+    const directNodeTxSighash = getSigHashFromTx(
+      directNodeTx,
+      0,
+      parentTxOutput
+    );
+    let directNodeTxSignature = new Uint8Array();
+    if (creationNode.directNodeTxSigningCommitment) {
+      const directUserSignature = await this.config.signer.signFrost({
+        message: directNodeTxSighash,
+        publicKey: creationNode.directNodeTxSigningJob.signingPublicKey,
+        keyDerivation: {
+          type: "leaf" /* LEAF */,
+          path: creationResponseNode.nodeId
+        },
+        selfCommitment: creationNode.directNodeTxSigningCommitment,
+        statechainCommitments: creationResponseNode.directNodeTxSigningResult?.signingNonceCommitments,
+        verifyingKey: internalNode.verificationKey
+      });
+      directNodeTxSignature = await this.config.signer.aggregateFrost({
+        message: directNodeTxSighash,
+        statechainSignatures: creationResponseNode.directNodeTxSigningResult?.signatureShares,
+        statechainPublicKeys: creationResponseNode.directNodeTxSigningResult?.publicKeys,
+        verifyingKey: internalNode.verificationKey,
+        statechainCommitments: creationResponseNode.directNodeTxSigningResult?.signingNonceCommitments,
+        selfCommitment: creationNode.directNodeTxSigningCommitment,
+        selfSignature: directUserSignature,
         publicKey: internalNode.signingPublicKey
       });
     }
-    let refundTxSignature = new Uint8Array();
-    if (creationNode.refundTxSigningCommitment) {
-      const rawTx = creationNode.refundTxSigningJob?.rawTx;
-      if (!rawTx) {
-        throw new Error("rawTx is undefined");
-      }
-      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,
+    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 */,
@@ -27588,27 +29118,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
       }
     };
   }
@@ -27670,8 +29242,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) {
@@ -27682,14 +29291,20 @@ var SigningService = class {
         });
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
-      const nodeOutPoint = {
+      const cpfpNodeOutPoint = {
         txid: hexToBytes11(getTxId(nodeTx)),
         index: 0
       };
       const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
-      const { nextSequence } = getNextTransactionSequence(
-        currRefundTx.getInput(0).sequence
-      );
+      const sequence = currRefundTx.getInput(0).sequence;
+      if (!sequence) {
+        throw new ValidationError("Invalid refund transaction", {
+          field: "sequence",
+          value: currRefundTx.getInput(0),
+          expected: "Non-null sequence"
+        });
+      }
+      const { nextSequence, nextDirectSequence } = getNextTransactionSequence(sequence);
       const amountSats = currRefundTx.getOutput(0).amount;
       if (amountSats === void 0) {
         throw new ValidationError("Invalid refund transaction", {
@@ -27698,56 +29313,98 @@ 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: hexToBytes11(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
+    };
   }
 };
 
 // src/tests/utils/test-faucet.ts
 import { bytesToHex as bytesToHex12, hexToBytes as hexToBytes12 } from "@noble/curves/abstract/utils";
 import { schnorr as schnorr5, secp256k1 as secp256k113 } from "@noble/curves/secp256k1";
-import * as btc6 from "@scure/btc-signer";
-import { Address as Address6, OutScript as OutScript4, SigHash as SigHash2, Transaction as Transaction8 } from "@scure/btc-signer";
+import * as btc5 from "@scure/btc-signer";
+import { Address as Address5, OutScript as OutScript3, SigHash as SigHash2, Transaction as Transaction8 } from "@scure/btc-signer";
 import { taprootTweakPrivKey as taprootTweakPrivKey2 } from "@scure/btc-signer/utils";
 var STATIC_FAUCET_KEY = hexToBytes12(
   "deadbeef1337cafe4242424242424242deadbeef1337cafe4242424242424242"
@@ -27892,7 +29549,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
   }
   async sendFaucetCoinToP2WPKHAddress(pubKey) {
     const sendToPubKeyTx = new Transaction8();
-    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");
     }
@@ -27948,12 +29605,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",
@@ -28008,10 +29666,10 @@ var BitcoinFaucet = class _BitcoinFaucet {
     const tx = new Transaction8();
     tx.addInput(coin.outpoint);
     const availableAmount = COIN_AMOUNT - FEE_AMOUNT;
-    const destinationAddress = Address6(getNetwork(4 /* LOCAL */)).decode(
+    const destinationAddress = Address5(getNetwork(4 /* LOCAL */)).decode(
       address2
     );
-    const destinationScript = OutScript4.encode(destinationAddress);
+    const destinationScript = OutScript3.encode(destinationAddress);
     tx.addOutput({
       script: destinationScript,
       amount
@@ -28282,31 +29940,37 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     }
   }
   async getLeaves(isBalanceCheck = false) {
-    const leaves = await this.queryNodes({
-      source: {
-        $case: "ownerIdentityPubkey",
-        ownerIdentityPubkey: await this.config.signer.getIdentityPublicKey()
-      },
-      includeParents: false,
-      network: NetworkToProto[this.config.getNetwork()]
-    });
+    const operatorToLeaves = /* @__PURE__ */ new Map();
+    const ownerIdentityPubkey = await this.config.signer.getIdentityPublicKey();
+    let signingOperators = Object.entries(this.config.getSigningOperators());
+    if (isBalanceCheck) {
+      signingOperators = signingOperators.filter(
+        ([id, _]) => id === this.config.getCoordinatorIdentifier()
+      );
+    }
+    await Promise.all(
+      signingOperators.map(async ([id, operator]) => {
+        const leaves2 = await this.queryNodes(
+          {
+            source: {
+              $case: "ownerIdentityPubkey",
+              ownerIdentityPubkey
+            },
+            includeParents: false,
+            network: NetworkToProto[this.config.getNetwork()]
+          },
+          operator.address
+        );
+        operatorToLeaves.set(id, leaves2);
+      })
+    );
+    const leaves = operatorToLeaves.get(
+      this.config.getCoordinatorIdentifier()
+    );
     const leavesToIgnore = /* @__PURE__ */ new Set();
     if (!isBalanceCheck) {
-      for (const [id, operator] of Object.entries(
-        this.config.getSigningOperators()
-      )) {
+      for (const [id, operatorLeaves] of operatorToLeaves) {
         if (id !== this.config.getCoordinatorIdentifier()) {
-          const operatorLeaves = await this.queryNodes(
-            {
-              source: {
-                $case: "ownerIdentityPubkey",
-                ownerIdentityPubkey: await this.config.signer.getIdentityPublicKey()
-              },
-              includeParents: false,
-              network: NetworkToProto[this.config.getNetwork()]
-            },
-            operator.address
-          );
           for (const [nodeId, leaf] of Object.entries(leaves.nodes)) {
             const operatorLeaf = operatorLeaves.nodes[nodeId];
             if (!operatorLeaf) {
@@ -28323,11 +29987,24 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         }
       }
     }
-    const verifyKey = (pubkey1, pubkey2, verifyingKey) => {
-      return equalBytes5(addPublicKeys(pubkey1, pubkey2), verifyingKey);
-    };
-    for (const [id, leaf] of Object.entries(leaves.nodes)) {
-      if (!verifyKey(
+    const availableLeaves = Object.entries(leaves.nodes).filter(
+      ([_, node]) => node.status === "AVAILABLE"
+    );
+    for (const [id, leaf] of availableLeaves) {
+      if (leaf.parentNodeId && leaf.status === "AVAILABLE" && this.verifyKey(
+        await this.config.signer.getPublicKeyFromDerivation({
+          type: "leaf" /* LEAF */,
+          path: leaf.parentNodeId
+        }),
+        leaf.signingKeyshare?.publicKey ?? new Uint8Array(),
+        leaf.verifyingPublicKey
+      )) {
+        this.transferLeavesToSelf([leaf], {
+          type: "leaf" /* LEAF */,
+          path: leaf.parentNodeId
+        });
+        leavesToIgnore.add(id);
+      } else if (!this.verifyKey(
         await this.config.signer.getPublicKeyFromDerivation({
           type: "leaf" /* LEAF */,
           path: leaf.id
@@ -28338,9 +30015,23 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         leavesToIgnore.add(id);
       }
     }
-    return Object.entries(leaves.nodes).filter(
-      ([_, node]) => node.status === "AVAILABLE" && !leavesToIgnore.has(node.id)
-    ).map(([_, node]) => node);
+    return availableLeaves.filter(([_, node]) => !leavesToIgnore.has(node.id)).map(([_, node]) => node);
+  }
+  async checkExtendLeaves(leaves) {
+    await this.withLeaves(async () => {
+      for (const leaf of leaves) {
+        if (!leaf.parentNodeId && leaf.status === "AVAILABLE") {
+          const res = await this.transferService.extendTimelock(leaf);
+          await this.transferLeavesToSelf(res.nodes, {
+            type: "leaf" /* LEAF */,
+            path: leaf.id
+          });
+        }
+      }
+    });
+  }
+  verifyKey(pubkey1, pubkey2, verifyingKey) {
+    return equalBytes5(addPublicKeys(pubkey1, pubkey2), verifyingKey);
   }
   async selectLeaves(targetAmounts) {
     if (targetAmounts.length === 0) {
@@ -28479,6 +30170,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     leaves = await this.checkRefreshTimelockNodes(leaves);
     leaves = await this.checkExtendTimeLockNodes(leaves);
     this.leaves = leaves;
+    this.checkExtendLeaves(leaves);
     this.optimizeLeaves().catch((e) => {
       console.error("Failed to optimize leaves", e);
     });
@@ -28719,21 +30411,68 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         }
       }))
     );
-    const { transfer, signatureMap } = await this.transferService.startSwapSignRefund(
+    const {
+      transfer,
+      signatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap
+    } = await this.transferService.startSwapSignRefund(
       leafKeyTweaks,
       hexToBytes13(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 = [];
@@ -28742,37 +30481,113 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         raw_unsigned_refund_transaction: bytesToHex13(
           transfer.leaves[0].intermediateRefundTx
         ),
-        adaptor_added_signature: bytesToHex13(adaptorSignature)
+        direct_raw_unsigned_refund_transaction: bytesToHex13(
+          transfer.leaves[0].intermediateDirectRefundTx
+        ),
+        direct_from_cpfp_raw_unsigned_refund_transaction: bytesToHex13(
+          transfer.leaves[0].intermediateDirectFromCpfpRefundTx
+        ),
+        adaptor_added_signature: bytesToHex13(cpfpAdaptorSignature),
+        direct_adaptor_added_signature: bytesToHex13(directAdaptorSignature),
+        direct_from_cpfp_adaptor_added_signature: bytesToHex13(
+          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: bytesToHex13(
             leaf.intermediateRefundTx
           ),
-          adaptor_added_signature: bytesToHex13(signature)
+          direct_raw_unsigned_refund_transaction: bytesToHex13(
+            leaf.intermediateDirectRefundTx
+          ),
+          direct_from_cpfp_raw_unsigned_refund_transaction: bytesToHex13(
+            leaf.intermediateDirectFromCpfpRefundTx
+          ),
+          adaptor_added_signature: bytesToHex13(cpfpSignature),
+          direct_adaptor_added_signature: bytesToHex13(directSignature),
+          direct_from_cpfp_adaptor_added_signature: bytesToHex13(
+            directFromCpfpSignature
+          )
         });
       }
       const sspClient = this.getSspClient();
-      const adaptorPubkey = bytesToHex13(
-        secp256k114.getPublicKey(adaptorPrivateKey)
+      const cpfpAdaptorPubkey = bytesToHex13(
+        secp256k114.getPublicKey(cpfpAdaptorPrivateKey)
       );
+      if (!cpfpAdaptorPubkey) {
+        throw new Error("Failed to generate CPFP adaptor pubkey");
+      }
+      let directAdaptorPubkey;
+      if (directAdaptorPrivateKey.length > 0) {
+        directAdaptorPubkey = bytesToHex13(
+          secp256k114.getPublicKey(directAdaptorPrivateKey)
+        );
+      }
+      let directFromCpfpAdaptorPubkey;
+      if (directFromCpfpAdaptorPrivateKey.length > 0) {
+        directFromCpfpAdaptorPubkey = bytesToHex13(
+          secp256k114.getPublicKey(directFromCpfpAdaptorPrivateKey)
+        );
+      }
       let request = null;
+      const targetAmountSats = targetAmounts?.reduce((acc, amount) => acc + amount, 0) || leavesBatch.reduce((acc, leaf) => acc + leaf.value, 0);
+      const totalAmountSats = leavesBatch.reduce(
+        (acc, leaf) => acc + leaf.value,
+        0
+      );
       request = await sspClient.requestLeaveSwap({
         userLeaves,
-        adaptorPubkey,
+        adaptorPubkey: cpfpAdaptorPubkey,
+        directAdaptorPubkey,
+        directFromCpfpAdaptorPubkey,
         targetAmountSats: targetAmounts?.reduce((acc, amount) => acc + amount, 0) || leavesBatch.reduce((acc, leaf) => acc + leaf.value, 0),
         totalAmountSats: leavesBatch.reduce((acc, leaf) => acc + leaf.value, 0),
         targetAmountSatsList: targetAmounts,
@@ -28781,6 +30596,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         idempotencyKey: uuidv75()
       });
       if (!request) {
+        console.error("[processSwapBatch] Leave swap request returned null");
         throw new Error("Failed to request leaves swap. No response returned.");
       }
       const nodes = await this.queryNodes({
@@ -28794,50 +30610,140 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         network: NetworkToProto[this.config.getNetwork()]
       });
       if (Object.values(nodes.nodes).length !== request.swapLeaves.length) {
+        console.error("[processSwapBatch] Node count mismatch:", {
+          actual: Object.values(nodes.nodes).length,
+          expected: request.swapLeaves.length
+        });
         throw new Error("Expected same number of nodes as swapLeaves");
       }
       for (const [nodeId, node] of Object.entries(nodes.nodes)) {
         if (!node.nodeTx) {
+          console.error(`[processSwapBatch] Node tx missing for ${nodeId}`);
           throw new Error(`Node tx not found for leaf ${nodeId}`);
         }
         if (!node.verifyingPublicKey) {
+          console.error(
+            `[processSwapBatch] Verifying public key missing for ${nodeId}`
+          );
           throw new Error(`Node public key not found for leaf ${nodeId}`);
         }
         const leaf = request.swapLeaves.find((leaf2) => leaf2.leafId === nodeId);
         if (!leaf) {
+          console.error(`[processSwapBatch] Leaf not found for node ${nodeId}`);
           throw new Error(`Leaf not found for node ${nodeId}`);
         }
-        const nodeTx = getTxFromRawTxBytes(node.nodeTx);
-        const refundTxBytes = hexToBytes13(leaf.rawUnsignedRefundTransaction);
-        const refundTx = getTxFromRawTxBytes(refundTxBytes);
-        const sighash = getSigHashFromTx(refundTx, 0, nodeTx.getOutput(0));
+        const cpfpNodeTx = getTxFromRawTxBytes(node.nodeTx);
+        const cpfpRefundTxBytes = hexToBytes13(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 = hexToBytes13(leaf.adaptorSignedSignature);
+        const cpfpAdaptorSignatureBytes = hexToBytes13(
+          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 = hexToBytes13(
+          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 = hexToBytes13(
+          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 = hexToBytes13(
+          leaf.directFromCpfpRawUnsignedRefundTransaction
+        );
+        const directFromCpfpRefundTx = getTxFromRawTxBytes(
+          directFromCpfpRefundTxBytes
+        );
+        const directFromCpfpSighash = getSigHashFromTx(
+          directFromCpfpRefundTx,
+          0,
+          cpfpNodeTx.getOutput(0)
+        );
+        const directFromCpfpAdaptorSignatureBytes = hexToBytes13(
+          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: bytesToHex13(adaptorPrivateKey),
+        adaptorSecretKey: bytesToHex13(cpfpAdaptorPrivateKey),
+        directAdaptorSecretKey: bytesToHex13(directAdaptorPrivateKey),
+        directFromCpfpAdaptorSecretKey: bytesToHex13(
+          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({
@@ -28847,6 +30753,11 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         optimize: false
       });
     } catch (e) {
+      console.error("[processSwapBatch] Error details:", {
+        error: e,
+        message: e.message,
+        stack: e.stack
+      });
       await this.cancelAllSenderInitiatedTransfers();
       throw new Error(`Failed to request leaves swap: ${e}`);
     }
@@ -29161,10 +31072,10 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       index: outputIndex,
       witnessScript: new Uint8Array()
     });
-    const addressDecoded = Address7(getNetwork(network)).decode(
+    const addressDecoded = Address6(getNetwork(network)).decode(
       destinationAddress
     );
-    const outputScript = OutScript5.encode(addressDecoded);
+    const outputScript = OutScript4.encode(addressDecoded);
     tx.addOutput({
       script: outputScript,
       amount: BigInt(creditAmountSats)
@@ -29297,8 +31208,8 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       if (!output) {
         continue;
       }
-      const parsedScript = OutScript5.decode(output.script);
-      const address2 = Address7(getNetwork(this.config.getNetwork())).encode(
+      const parsedScript = OutScript4.decode(output.script);
+      const address2 = Address6(getNetwork(this.config.getNetwork())).encode(
         parsedScript
       );
       if (staticDepositAddresses.has(address2)) {
@@ -29317,8 +31228,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         field: "txid"
       });
     }
+    const { fetch: fetch2, Headers: Headers2 } = getFetch();
     const baseUrl = this.config.getElectrsUrl();
-    const headers = {};
+    const headers = new Headers2();
     let txHex;
     if (this.config.getNetwork() === 4 /* LOCAL */) {
       const localFaucet = BitcoinFaucet.getInstance();
@@ -29329,9 +31241,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         const auth = btoa(
           `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`
         );
-        headers["Authorization"] = `Basic ${auth}`;
+        headers.set("Authorization", `Basic ${auth}`);
       }
-      const response = await fetch(`${baseUrl}/tx/${txid}/hex`, {
+      const response = await fetch2(`${baseUrl}/tx/${txid}/hex`, {
         headers
       });
       txHex = await response.text();
@@ -29459,8 +31371,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       this.mutexes.set(txid, mutex);
     }
     const nodes = await mutex.runExclusive(async () => {
+      const { fetch: fetch2, Headers: Headers2 } = getFetch();
       const baseUrl = this.config.getElectrsUrl();
-      const headers = {};
+      const headers = new Headers2();
       let txHex;
       if (this.config.getNetwork() === 4 /* LOCAL */) {
         const localFaucet = BitcoinFaucet.getInstance();
@@ -29471,9 +31384,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
           const auth = btoa(
             `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`
           );
-          headers["Authorization"] = `Basic ${auth}`;
+          headers.set("Authorization", `Basic ${auth}`);
         }
-        const response = await fetch(`${baseUrl}/tx/${txid}/hex`, {
+        const response = await fetch2(`${baseUrl}/tx/${txid}/hex`, {
           headers
         });
         txHex = await response.text();
@@ -29501,8 +31414,8 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         if (!output) {
           continue;
         }
-        const parsedScript = OutScript5.decode(output.script);
-        const address2 = Address7(getNetwork(this.config.getNetwork())).encode(
+        const parsedScript = OutScript4.decode(output.script);
+        const address2 = Address6(getNetwork(this.config.getNetwork())).encode(
           parsedScript
         );
         if (unusedDepositAddresses.has(address2)) {
@@ -29562,8 +31475,8 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       if (!output) {
         continue;
       }
-      const parsedScript = OutScript5.decode(output.script);
-      const address2 = Address7(getNetwork(this.config.getNetwork())).encode(
+      const parsedScript = OutScript4.decode(output.script);
+      const address2 = Address6(getNetwork(this.config.getNetwork())).encode(
         parsedScript
       );
       const unusedDepositAddress = unusedDepositAddresses.get(address2);
@@ -29715,10 +31628,16 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     const validNodes = [];
     for (const node of nodes) {
       const nodeTx = getTxFromRawTxBytes(node.nodeTx);
-      const { needRefresh } = getNextTransactionSequence(
-        nodeTx.getInput(0).sequence
-      );
-      if (needRefresh) {
+      const sequence = nodeTx.getInput(0).sequence;
+      if (!sequence) {
+        throw new ValidationError("Invalid node transaction", {
+          field: "sequence",
+          value: nodeTx.getInput(0),
+          expected: "Non-null sequence"
+        });
+      }
+      const needsRefresh = doesLeafNeedRefresh(sequence, true);
+      if (needsRefresh) {
         nodesToExtend.push(node);
         nodeIds.push(node.id);
       } else {
@@ -29755,11 +31674,16 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     const validNodes = [];
     for (const node of nodes) {
       const refundTx = getTxFromRawTxBytes(node.refundTx);
-      const { needRefresh } = getNextTransactionSequence(
-        refundTx.getInput(0).sequence,
-        true
-      );
-      if (needRefresh) {
+      const sequence = refundTx.getInput(0).sequence;
+      if (!sequence) {
+        throw new ValidationError("Invalid refund transaction", {
+          field: "sequence",
+          value: refundTx.getInput(0),
+          expected: "Non-null sequence"
+        });
+      }
+      const needsRefresh = doesLeafNeedRefresh(sequence);
+      if (needsRefresh) {
         nodesToRefresh.push(node);
         nodeIds.push(node.id);
       } else {
@@ -29793,7 +31717,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         throw new Error(`parent node ${node.parentNodeId} not found`);
       }
       const { nodes: nodes2 } = await this.transferService.refreshTimelockNodes(
-        [node],
+        node,
         parentNode
       );
       if (nodes2.length !== 1) {
@@ -29842,7 +31766,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
               leavesToClaim.push({
                 leaf: {
                   ...leaf.leaf,
-                  refundTx: leaf.intermediateRefundTx
+                  refundTx: leaf.intermediateRefundTx,
+                  directRefundTx: leaf.intermediateDirectRefundTx,
+                  directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx
                 },
                 keyDerivation: {
                   type: "ecies" /* ECIES */,
@@ -29918,7 +31844,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       if (type && transfer.type !== type) {
         continue;
       }
-      if (transfer.status !== 2 /* TRANSFER_STATUS_SENDER_KEY_TWEAKED */ && transfer.status !== 3 /* TRANSFER_STATUS_RECEIVER_KEY_TWEAKED */ && transfer.status !== 4 /* TRANSFER_STATUS_RECEIVER_REFUND_SIGNED */ && transfer.status !== 10 /* TRANSFER_STATUS_RECEIVER_KEY_TWEAK_APPLIED */) {
+      if (transfer.status !== 2 /* TRANSFER_STATUS_SENDER_KEY_TWEAKED */ && transfer.status !== 3 /* TRANSFER_STATUS_RECEIVER_KEY_TWEAKED */ && transfer.status !== 4 /* TRANSFER_STATUS_RECEIVER_REFUND_SIGNED */ && transfer.status !== 10 /* TRANSFER_STATUS_RECEIVER_KEY_TWEAK_APPLIED */ && transfer.status !== 9 /* TRANSFER_STATUS_RECEIVER_KEY_TWEAK_LOCKED */) {
         continue;
       }
       promises.push(
@@ -30206,6 +32132,8 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       await this.transferService.deliverTransferPackage(
         swapResponse.transfer,
         leavesToSend,
+        /* @__PURE__ */ new Map(),
+        /* @__PURE__ */ new Map(),
         /* @__PURE__ */ new Map()
       );
       const sspResponse = await sspClient.requestLightningSend({
@@ -30639,14 +32567,18 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     issuerPublicKeys,
     tokenTransactionHashes,
     tokenIdentifiers,
-    outputIds
+    outputIds,
+    pageSize = 100,
+    offset = 0
   }) {
     return this.tokenTransactionService.queryTokenTransactions({
       ownerPublicKeys,
       issuerPublicKeys,
       tokenTransactionHashes,
       tokenIdentifiers,
-      outputIds
+      outputIds,
+      pageSize,
+      offset
     });
   }
   async getTokenL1Address() {
@@ -30964,87 +32896,64 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         },
         includeParents: true
       });
-      const node = response.nodes[nodeId];
-      if (!node) {
+      let leaf = response.nodes[nodeId];
+      if (!leaf) {
         throw new ValidationError("Node not found", {
           field: "nodeId",
           value: nodeId
         });
       }
-      if (!node.parentNodeId) {
-        throw new ValidationError("Node has no parent", {
-          field: "parentNodeId",
-          value: node.parentNodeId
-        });
-      }
-      const parentNode = response.nodes[node.parentNodeId];
-      if (!parentNode) {
-        throw new ValidationError("Parent node not found", {
-          field: "parentNodeId",
-          value: node.parentNodeId
-        });
-      }
-      const result = await this.transferService.refreshTimelockNodes(
-        [node],
-        parentNode
-      );
-      const leafIndex = this.leaves.findIndex((leaf) => leaf.id === node.id);
-      if (leafIndex !== -1 && result.nodes.length > 0) {
-        const newNode = result.nodes[0];
-        if (newNode) {
-          this.leaves[leafIndex] = newNode;
+      let parentNode;
+      let hasParentNode = false;
+      if (!leaf.parentNodeId) {
+      } else {
+        hasParentNode = true;
+        parentNode = response.nodes[leaf.parentNodeId];
+        if (!parentNode) {
+          throw new ValidationError("Parent node not found", {
+            field: "parentNodeId",
+            value: leaf.parentNodeId
+          });
         }
       }
-    } catch (error) {
-      throw new NetworkError(
-        "Failed to refresh timelock",
-        {
-          method: "refresh_timelock"
-        },
-        error
-      );
-    }
-  }
-  /**
-   * Refresh the timelock of a specific node's refund transaction only.
-   *
-   * @param {string} nodeId - The ID of the node whose refund transaction to refresh
-   * @returns {Promise<void>} Promise that resolves when the refund timelock is refreshed
-   */
-  async testOnly_expireTimelockRefundTx(nodeId) {
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    try {
-      const response = await sparkClient.query_nodes({
-        source: {
-          $case: "nodeIds",
-          nodeIds: {
-            nodeIds: [nodeId]
+      const nodeTx = getTxFromRawTxBytes(leaf.nodeTx);
+      const refundTx = getTxFromRawTxBytes(leaf.refundTx);
+      if (hasParentNode) {
+        const nodeTimelock = getCurrentTimelock(nodeTx.getInput(0).sequence);
+        if (nodeTimelock > 100) {
+          const expiredNodeTxLeaf = await this.transferService.testonly_expireTimeLockNodeTx(
+            leaf,
+            parentNode
+          );
+          if (!expiredNodeTxLeaf.nodes[0]) {
+            throw new ValidationError("No expired node tx leaf", {
+              field: "expiredNodeTxLeaf",
+              value: expiredNodeTxLeaf
+            });
           }
-        },
-        includeParents: false
-      });
-      const node = response.nodes[nodeId];
-      if (!node) {
-        throw new ValidationError("Node not found", {
-          field: "nodeId",
-          value: nodeId
-        });
+          leaf = expiredNodeTxLeaf.nodes[0];
+        }
       }
-      const result = await this.transferService.refreshTimelockRefundTx(node);
-      const leafIndex = this.leaves.findIndex((leaf) => leaf.id === node.id);
-      if (leafIndex !== -1 && result.nodes.length > 0) {
-        const newNode = result.nodes[0];
-        if (newNode) {
-          this.leaves[leafIndex] = newNode;
+      const refundTimelock = getCurrentTimelock(refundTx.getInput(0).sequence);
+      if (refundTimelock > 100) {
+        const expiredTxLeaf = await this.transferService.testonly_expireTimeLockRefundtx(leaf);
+        if (!expiredTxLeaf.nodes[0]) {
+          throw new ValidationError("No expired tx leaf", {
+            field: "expiredTxLeaf",
+            value: expiredTxLeaf
+          });
         }
+        leaf = expiredTxLeaf.nodes[0];
+      }
+      const leafIndex = this.leaves.findIndex((leaf2) => leaf2.id === leaf2.id);
+      if (leafIndex !== -1) {
+        this.leaves[leafIndex] = leaf;
       }
     } catch (error) {
       throw new NetworkError(
-        "Failed to refresh refund timelock",
+        "Failed to refresh timelock",
         {
-          method: "refresh_timelock_refund_tx"
+          method: "refresh_timelock"
         },
         error
       );
@@ -31110,7 +33019,10 @@ export {
   AuthenticationError,
   ConfigurationError,
   DEFAULT_FEE_SATS,
+  DIRECT_TIMELOCK_OFFSET,
   ReactNativeSparkSigner as DefaultSparkSigner,
+  INITIAL_DIRECT_SEQUENCE,
+  INITIAL_SEQUENCE,
   InternalValidationError,
   LRC_WALLET_NETWORK,
   LRC_WALLET_NETWORK_TYPE,
@@ -31122,6 +33034,8 @@ export {
   ReactNativeSparkSigner,
   SparkSDKError,
   SparkWallet,
+  TEST_UNILATERAL_DIRECT_SEQUENCE,
+  TEST_UNILATERAL_SEQUENCE,
   TokenTransactionService,
   ValidationError,
   WalletConfig,
@@ -31138,13 +33052,21 @@ export {
   constructFeeBumpTx,
   constructUnilateralExitFeeBumpPackages,
   constructUnilateralExitTxs,
+  createConnectorRefundTransactions,
+  createLeafNodeTx,
+  createNodeTx,
+  createNodeTxs,
   createRefundTx,
+  createRefundTxs,
+  createRootTx,
   createSigningCommitment,
   createSigningNonce,
+  createSplitTx,
   decodeBech32mTokenIdentifier,
   decodeBytesToSigningCommitment,
   decodeBytesToSigningNonce,
   decodeSparkAddress,
+  doesLeafNeedRefresh,
   encodeBech32mTokenIdentifier,
   encodeSigningCommitmentToBytes,
   encodeSigningNonceToBytes,