@buildonspark/spark-sdk 0.3.8 → 0.3.9

package/dist/{chunk-FP2CRVQH.js → chunk-O4C4HGQL.js}

@@ -4,11 +4,11 @@ import {
 } from "./chunk-NX5KPN5F.js";
 import {
   SparkTokenServiceDefinition
-} from "./chunk-XI6FCNYG.js";
+} from "./chunk-JLF6WJ7K.js";
 import {
   mapTransferToWalletTransfer,
   mapTreeNodeToWalletLeaf
-} from "./chunk-5ASXVNTM.js";
+} from "./chunk-4YFT7DAE.js";
 import {
   SatsPayment,
   SendLeafKeyTweaks,
@@ -18,7 +18,7 @@ import {
   TokensPayment,
   TreeNode,
   networkToJSON
-} from "./chunk-VFN34EOX.js";
+} from "./chunk-YEBEN7XD.js";
 import {
   BitcoinNetwork_default,
   ClaimStaticDepositFromJson,
@@ -700,6 +700,7 @@ function getTxEstimatedVbytesSizeByNumberOfInputsOutputs(numInputs, numOutputs)
 }
 
 // src/utils/transaction.ts
+import { hexToBytes as hexToBytes2 } from "@noble/hashes/utils";
 import { Transaction as Transaction2 } from "@scure/btc-signer";
 var INITIAL_TIMELOCK = 2e3;
 var TEST_UNILATERAL_TIMELOCK = 100;
@@ -708,9 +709,9 @@ var DIRECT_TIMELOCK_OFFSET = 50;
 var HTLC_TIMELOCK_OFFSET = 70;
 var DIRECT_HTLC_TIMELOCK_OFFSET = 85;
 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 INITIAL_ROOT_NODE_SEQUENCE = 1 << 30 | 0;
 var ESTIMATED_TX_SIZE = 191;
 var DEFAULT_SATS_PER_VBYTE = 5;
 var DEFAULT_FEE_SATS = ESTIMATED_TX_SIZE * DEFAULT_SATS_PER_VBYTE;
@@ -720,63 +721,8 @@ function maybeApplyFee(amount) {
   }
   return amount;
 }
-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({
+  sequence,
   txOut,
   parentOutPoint,
   applyFee,
@@ -786,7 +732,10 @@ function createNodeTx({
     version: 3,
     allowUnknownOutputs: true
   });
-  nodeTx.addInput(parentOutPoint);
+  nodeTx.addInput({
+    ...parentOutPoint,
+    sequence
+  });
   if (applyFee) {
     nodeTx.addOutput({
       script: txOut.script,
@@ -800,52 +749,92 @@ function createNodeTx({
   }
   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
+function createNodeTxs({
+  parentTx,
+  sequence,
+  directSequence,
+  vout
+}) {
+  const parentOutput = parentTx.getOutput(vout);
+  if (!parentOutput.amount || !parentOutput.script) {
+    throw new ValidationError("Parent output amount or script not found", {
+      field: "parentOutput",
+      value: parentOutput
     });
   }
-  return { cpfpNodeTx, directNodeTx };
+  const output = {
+    script: parentOutput.script,
+    amount: parentOutput.amount
+  };
+  const input = {
+    txid: hexToBytes2(getTxId(parentTx)),
+    index: vout
+  };
+  const nodeTx = createNodeTx({
+    sequence,
+    txOut: output,
+    parentOutPoint: input,
+    includeAnchor: true
+  });
+  const directNodeTx = createNodeTx({
+    sequence: directSequence ?? sequence + DIRECT_TIMELOCK_OFFSET,
+    txOut: output,
+    parentOutPoint: input,
+    includeAnchor: false,
+    applyFee: true
+  });
+  return { nodeTx, directNodeTx };
 }
-function createLeafNodeTx(sequence, directSequence, parentOutPoint, txOut, shouldCalculateFee) {
-  const cpfpLeafTx = new Transaction2({
-    version: 3,
-    allowUnknownOutputs: true
+function createRootNodeTx(parentTx, vout) {
+  return createNodeTxs({
+    parentTx,
+    sequence: INITIAL_ROOT_NODE_SEQUENCE,
+    vout
   });
-  cpfpLeafTx.addInput({
-    ...parentOutPoint,
-    sequence
+}
+function createZeroTimelockNodeTx(parentTx) {
+  return createNodeTxs({
+    parentTx,
+    sequence: INITIAL_ROOT_NODE_SEQUENCE,
+    directSequence: DIRECT_TIMELOCK_OFFSET,
+    vout: 0
   });
-  cpfpLeafTx.addOutput(txOut);
-  cpfpLeafTx.addOutput(getEphemeralAnchorOutput());
-  const directLeafTx = new Transaction2({
-    version: 3,
-    allowUnknownOutputs: true
+}
+function createInitialTimelockNodeTx(parentTx) {
+  return createNodeTxs({
+    parentTx,
+    sequence: INITIAL_SEQUENCE,
+    vout: 0
   });
-  directLeafTx.addInput({
-    ...parentOutPoint,
-    sequence: directSequence
+}
+function createDecrementedTimelockNodeTx(parentTx, currentTx) {
+  const currentSequence = currentTx.getInput(0).sequence;
+  if (!currentSequence) {
+    throw new ValidationError("Current sequence not found", {
+      field: "currentSequence",
+      value: currentSequence
+    });
+  }
+  return createNodeTxs({
+    parentTx,
+    sequence: getNextTransactionSequence(currentSequence).nextSequence,
+    vout: 0
   });
-  const amountSats = txOut.amount ?? 0n;
-  let outputAmount = amountSats;
-  if (shouldCalculateFee) {
-    outputAmount = maybeApplyFee(amountSats);
+}
+function createTestUnilateralTimelockNodeTx(parentTx, nodeTx) {
+  const sequence = nodeTx.getInput(0).sequence;
+  if (!sequence) {
+    throw new ValidationError("Sequence not found", {
+      field: "sequence",
+      value: sequence
+    });
   }
-  directLeafTx.addOutput({
-    script: txOut.script,
-    amount: outputAmount
+  const isBit30Defined = (sequence || 0) & 1 << 30;
+  return createNodeTxs({
+    parentTx,
+    sequence: isBit30Defined | TEST_UNILATERAL_TIMELOCK,
+    vout: 0
   });
-  return [cpfpLeafTx, directLeafTx];
 }
 function createRefundTx({
   sequence,
@@ -901,110 +890,109 @@ function getNextHTLCTransactionSequence(currSequence, isNodeTx) {
   };
 }
 function createRefundTxs({
-  sequence,
-  directSequence,
-  input,
-  directInput,
-  amountSats,
+  nodeTx,
+  directNodeTx,
   receivingPubkey,
-  network
+  network,
+  sequence
 }) {
-  const cpfpRefundTx = createRefundTx({
-    sequence,
-    input,
-    amountSats,
-    receivingPubkey,
-    network,
-    shouldCalculateFee: false,
-    includeAnchor: true
-  });
+  const refundInput = {
+    txid: hexToBytes2(getTxId(nodeTx)),
+    index: 0
+  };
+  const nodeAmountSats = nodeTx.getOutput(0).amount;
+  if (nodeAmountSats === void 0) {
+    throw new ValidationError("Node amount not found", {
+      field: "nodeAmountSats",
+      value: nodeAmountSats
+    });
+  }
   let directRefundTx;
-  let directFromCpfpRefundTx;
-  if (directSequence && directInput) {
+  if (directNodeTx) {
+    const directRefundInput = {
+      txid: hexToBytes2(getTxId(directNodeTx)),
+      index: 0
+    };
+    const directAmountSats = directNodeTx.getOutput(0).amount;
+    if (directAmountSats === void 0) {
+      throw new ValidationError("Direct amount not found", {
+        field: "directAmountSats",
+        value: directAmountSats
+      });
+    }
     directRefundTx = createRefundTx({
-      sequence: directSequence,
-      input: directInput,
-      amountSats,
-      receivingPubkey,
-      network,
-      shouldCalculateFee: true,
-      includeAnchor: false
-    });
-    directFromCpfpRefundTx = createRefundTx({
-      sequence: directSequence,
-      input,
-      amountSats,
+      sequence: sequence + DIRECT_TIMELOCK_OFFSET,
+      input: directRefundInput,
+      amountSats: directAmountSats,
       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
+  const cpfpRefundTx = createRefundTx({
+    sequence,
+    input: refundInput,
+    amountSats: nodeAmountSats,
+    receivingPubkey,
+    network,
+    shouldCalculateFee: false,
+    includeAnchor: true
   });
-  cpfpRefundTx.addInput({
-    ...cpfpNodeOutPoint,
-    sequence
+  const directFromCpfpRefundTx = createRefundTx({
+    sequence: sequence + DIRECT_TIMELOCK_OFFSET,
+    input: refundInput,
+    amountSats: nodeAmountSats,
+    receivingPubkey,
+    network,
+    shouldCalculateFee: true,
+    includeAnchor: false
   });
-  cpfpRefundTx.addInput(connectorOutput);
-  const receiverScript = getP2TRScriptFromPublicKey(receiverPubKey, network);
-  cpfpRefundTx.addOutput({
-    script: receiverScript,
-    amount: amountSats
+  return { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx };
+}
+function createInitialTimelockRefundTxs(params) {
+  return createRefundTxs({
+    ...params,
+    sequence: INITIAL_SEQUENCE
   });
-  const directRefundTx = new Transaction2({
-    version: 3,
-    allowUnknownOutputs: true
+}
+function createDecrementedTimelockRefundTxs(params) {
+  const nextSequence = getNextTransactionSequence(params.sequence).nextSequence;
+  return createRefundTxs({
+    ...params,
+    sequence: nextSequence
   });
-  directRefundTx.addInput({
-    ...directNodeOutPoint,
-    sequence
+}
+function createCurrentTimelockRefundTxs(params) {
+  return createRefundTxs(params);
+}
+function createTestUnilateralRefundTxs(params) {
+  return createRefundTxs({
+    ...params,
+    sequence: TEST_UNILATERAL_SEQUENCE
   });
-  directRefundTx.addInput(connectorOutput);
-  let outputAmount = amountSats;
-  if (shouldCalculateFee) {
-    outputAmount = maybeApplyFee(amountSats);
+}
+function createConnectorRefundTxs(params) {
+  const { connectorOutput, ...baseParams } = params;
+  const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createDecrementedTimelockRefundTxs(baseParams);
+  cpfpRefundTx.addInput(connectorOutput);
+  if (directRefundTx) {
+    directRefundTx.addInput(connectorOutput);
   }
-  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];
+  if (directFromCpfpRefundTx) {
+    directFromCpfpRefundTx.addInput(connectorOutput);
+  }
+  return { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx };
 }
 function getCurrentTimelock(currSequence) {
   return (currSequence || 0) & 65535;
 }
 function getTransactionSequence(currSequence) {
   const timelock = getCurrentTimelock(currSequence);
+  const isBit30Defined = (currSequence || 0) & 1 << 30;
   return {
-    nextSequence: 1 << 30 | timelock,
-    nextDirectSequence: 1 << 30 | timelock + DIRECT_TIMELOCK_OFFSET
+    nextSequence: isBit30Defined | timelock,
+    nextDirectSequence: isBit30Defined | timelock + DIRECT_TIMELOCK_OFFSET
   };
 }
 function checkIfValidSequence(currSequence) {
@@ -1023,6 +1011,13 @@ function checkIfValidSequence(currSequence) {
     });
   }
 }
+function isZeroTimelock(currSequence) {
+  return getCurrentTimelock(currSequence) === 0;
+}
+function doesTxnNeedRenewed(currSequence) {
+  const currentTimelock = getCurrentTimelock(currSequence);
+  return currentTimelock <= 100;
+}
 function doesLeafNeedRefresh(currSequence, isNodeTx) {
   const currentTimelock = getCurrentTimelock(currSequence);
   if (isNodeTx) {
@@ -1033,6 +1028,7 @@ function doesLeafNeedRefresh(currSequence, isNodeTx) {
 function getNextTransactionSequence(currSequence, isNodeTx) {
   const currentTimelock = getCurrentTimelock(currSequence);
   const nextTimelock = currentTimelock - TIME_LOCK_INTERVAL;
+  const isBit30Defined = (currSequence || 0) & 1 << 30;
   if (isNodeTx && nextTimelock < 0) {
     throw new ValidationError("timelock interval is less than 0", {
       field: "nextTimelock",
@@ -1047,8 +1043,8 @@ function getNextTransactionSequence(currSequence, isNodeTx) {
     });
   }
   return {
-    nextSequence: 1 << 30 | nextTimelock,
-    nextDirectSequence: 1 << 30 | nextTimelock + DIRECT_TIMELOCK_OFFSET
+    nextSequence: isBit30Defined | nextTimelock,
+    nextDirectSequence: isBit30Defined | nextTimelock + DIRECT_TIMELOCK_OFFSET
   };
 }
 function getEphemeralAnchorOutput() {
@@ -1070,7 +1066,7 @@ var KeyDerivationType = /* @__PURE__ */ ((KeyDerivationType2) => {
 })(KeyDerivationType || {});
 
 // src/utils/transfer_package.ts
-import { hexToBytes as hexToBytes2 } from "@noble/curves/utils";
+import { hexToBytes as hexToBytes3 } from "@noble/curves/utils";
 import { sha256 as sha2562 } from "@noble/hashes/sha2";
 function getTransferPackageSigningPayload(transferID, transferPackage) {
   const encryptedPayload = transferPackage.keyTweakPackage;
@@ -1079,7 +1075,7 @@ function getTransferPackageSigningPayload(transferID, transferPackage) {
   ).map(([key, value]) => ({ key, value }));
   pairs.sort((a, b) => a.key.localeCompare(b.key));
   const encoder = new TextEncoder();
-  let message = hexToBytes2(transferID.replaceAll("-", ""));
+  let message = hexToBytes3(transferID.replaceAll("-", ""));
   for (const pair of pairs) {
     const keyPart = encoder.encode(pair.key + ":");
     const separator = encoder.encode(";");
@@ -1207,7 +1203,7 @@ function proofOfPossessionMessageHashForDepositAddress(userPubkey, operatorPubke
 // src/services/deposit.ts
 import { schnorr as schnorr2, secp256k1 as secp256k13 } from "@noble/curves/secp256k1";
 import { sha256 as sha2564 } from "@noble/hashes/sha2";
-import { hexToBytes as hexToBytes3 } from "@noble/hashes/utils";
+import { hexToBytes as hexToBytes4 } from "@noble/hashes/utils";
 import { p2tr as p2tr2 } from "@scure/btc-signer";
 import { equalBytes } from "@scure/btc-signer/utils";
 var DepositService = class {
@@ -1261,7 +1257,7 @@ var DepositService = class {
       if (operator.identifier === this.config.getCoordinatorIdentifier() && !verifyCoordinatorProof) {
         continue;
       }
-      const operatorPubkey2 = hexToBytes3(operator.identityPublicKey);
+      const operatorPubkey2 = hexToBytes4(operator.identityPublicKey);
       const operatorSig = address.depositAddressProof.addressSignatures[operator.identifier];
       if (!operatorSig) {
         throw new ValidationError("Operator signature not found", {
@@ -1380,38 +1376,18 @@ var DepositService = class {
         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: hexToBytes3(getTxId(depositTx)),
-      index: vout
-    };
-    const depositTxOut = {
-      script,
-      amount
-    };
-    const [cpfpRootTx, directRootTx] = createRootTx(
-      depositOutPoint,
-      depositTxOut
+    const { nodeTx: cpfpRootTx, directNodeTx: directRootTx } = createRootNodeTx(
+      depositTx,
+      vout
     );
     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: hexToBytes3(getTxId(cpfpRootTx)), index: 0 },
-      directInput: { txid: hexToBytes3(getTxId(directRootTx)), index: 0 },
-      amountSats: amount,
+    const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createInitialTimelockRefundTxs({
+      nodeTx: cpfpRootTx,
+      directNodeTx: directRootTx,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
     });
@@ -1703,22 +1679,12 @@ var DepositService = class {
         expected: "Output with script and amount"
       });
     }
-    const depositOutPoint = {
-      txid: hexToBytes3(getTxId(depositTx)),
-      index: vout
-    };
-    const depositTxOut = {
-      script,
-      amount
-    };
-    const [cpfpRootTx, _] = createRootTx(depositOutPoint, depositTxOut);
+    const { nodeTx: cpfpRootTx } = createRootNodeTx(depositTx, vout);
     const cpfpRootNonceCommitment = await this.config.signer.getRandomSigningCommitment();
     const cpfpRootTxSighash = getSigHashFromTx(cpfpRootTx, 0, output);
     const signingPubKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
-    const { cpfpRefundTx } = createRefundTxs({
-      sequence: INITIAL_SEQUENCE,
-      input: { txid: hexToBytes3(getTxId(cpfpRootTx)), index: 0 },
-      amountSats: amount,
+    const { cpfpRefundTx } = createInitialTimelockRefundTxs({
+      nodeTx: cpfpRootTx,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
     });
@@ -1879,7 +1845,7 @@ var setCrypto = (cryptoImplParam) => {
 import { BinaryWriter } from "@bufbuild/protobuf/wire";
 import { schnorr as schnorr3, secp256k1 as secp256k14 } from "@noble/curves/secp256k1";
 import { bytesToNumberBE as bytesToNumberBE2 } from "@noble/curves/utils";
-import { bytesToHex as bytesToHex3, hexToBytes as hexToBytes4 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex3, hexToBytes as hexToBytes5 } from "@noble/hashes/utils";
 import { bech32m as bech32m2 } from "@scure/base";
 import { UUID } from "uuidv7";
 
@@ -2071,7 +2037,7 @@ function encodeSparkAddress(payload) {
 function encodeSparkAddressWithSignature(payload, signature) {
   try {
     isValidPublicKey(payload.identityPublicKey);
-    const identityPublicKey = hexToBytes4(payload.identityPublicKey);
+    const identityPublicKey = hexToBytes5(payload.identityPublicKey);
     let sparkInvoiceFields;
     if (payload.sparkInvoiceFields) {
       validateSparkInvoiceFields(payload.sparkInvoiceFields);
@@ -2575,7 +2541,7 @@ import {
   bytesToNumberBE as bytesToNumberBE4,
   numberToBytesBE as numberToBytesBE2
 } from "@noble/curves/utils";
-import { hexToBytes as hexToBytes5 } from "@noble/hashes/utils";
+import { hexToBytes as hexToBytes6 } from "@noble/hashes/utils";
 
 // src/utils/token-hashing.ts
 import { sha256 as sha2566 } from "@noble/hashes/sha2";
@@ -3895,14 +3861,14 @@ var TokenTransactionService = class {
       }
       if (receiverAddress.sparkInvoiceFields) {
         return {
-          receiverPublicKey: hexToBytes5(receiverAddress.identityPublicKey),
+          receiverPublicKey: hexToBytes6(receiverAddress.identityPublicKey),
           rawTokenIdentifier,
           tokenAmount: transfer.tokenAmount,
           sparkInvoice: transfer.receiverSparkAddress
         };
       }
       return {
-        receiverPublicKey: hexToBytes5(receiverAddress.identityPublicKey),
+        receiverPublicKey: hexToBytes6(receiverAddress.identityPublicKey),
         rawTokenIdentifier,
         tokenAmount: transfer.tokenAmount
       };
@@ -3968,7 +3934,7 @@ var TokenTransactionService = class {
     for (const [_, operator] of Object.entries(
       this.config.getSigningOperators()
     )) {
-      operatorKeys.push(hexToBytes5(operator.identityPublicKey));
+      operatorKeys.push(hexToBytes6(operator.identityPublicKey));
     }
     return operatorKeys;
   }
@@ -4231,8 +4197,8 @@ var TokenTransactionService = class {
       this.config.getCoordinatorAddress()
     );
     let queryParams = {
-      issuerPublicKeys: issuerPublicKeys?.map(hexToBytes5),
-      ownerPublicKeys: ownerPublicKeys?.map(hexToBytes5),
+      issuerPublicKeys: issuerPublicKeys?.map(hexToBytes6),
+      ownerPublicKeys: ownerPublicKeys?.map(hexToBytes6),
       tokenIdentifiers: tokenIdentifiers?.map((identifier) => {
         const { tokenIdentifier } = decodeBech32mTokenIdentifier(
           identifier,
@@ -4240,7 +4206,7 @@ var TokenTransactionService = class {
         );
         return tokenIdentifier;
       }),
-      tokenTransactionHashes: tokenTransactionHashes?.map(hexToBytes5),
+      tokenTransactionHashes: tokenTransactionHashes?.map(hexToBytes6),
       outputIds: outputIds || [],
       limit: pageSize,
       offset
@@ -4345,7 +4311,7 @@ var TokenTransactionService = class {
         }
         const payload = {
           finalTokenTransactionHash,
-          operatorIdentityPublicKey: hexToBytes5(operator.identityPublicKey)
+          operatorIdentityPublicKey: hexToBytes6(operator.identityPublicKey)
         };
         const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
         const ownerSignature = await this.signMessageWithKey(
@@ -4367,7 +4333,7 @@ var TokenTransactionService = class {
         }
         const payload = {
           finalTokenTransactionHash,
-          operatorIdentityPublicKey: hexToBytes5(operator.identityPublicKey)
+          operatorIdentityPublicKey: hexToBytes6(operator.identityPublicKey)
         };
         const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
         const ownerSignature = await this.signMessageWithKey(
@@ -4383,7 +4349,7 @@ var TokenTransactionService = class {
         for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
           const payload = {
             finalTokenTransactionHash,
-            operatorIdentityPublicKey: hexToBytes5(operator.identityPublicKey)
+            operatorIdentityPublicKey: hexToBytes6(operator.identityPublicKey)
           };
           const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
           let ownerSignature;
@@ -4400,7 +4366,7 @@ var TokenTransactionService = class {
       }
       inputTtxoSignaturesPerOperator.push({
         ttxoSignatures,
-        operatorIdentityPublicKey: hexToBytes5(operator.identityPublicKey)
+        operatorIdentityPublicKey: hexToBytes6(operator.identityPublicKey)
       });
     }
     return inputTtxoSignaturesPerOperator;
@@ -4830,7 +4796,7 @@ import {
   bytesToHex as bytesToHex6,
   bytesToNumberBE as bytesToNumberBE6,
   equalBytes as equalBytes4,
-  hexToBytes as hexToBytes6
+  hexToBytes as hexToBytes7
 } from "@noble/curves/utils";
 import { sha256 as sha2567 } from "@noble/hashes/sha2";
 import { HDKey } from "@scure/bip32";
@@ -4848,7 +4814,7 @@ var isWebExtension = (
   "chrome" in globalThis && globalThis.chrome.runtime?.id
 );
 var userAgent = "navigator" in globalThis ? globalThis.navigator.userAgent || "unknown-user-agent" : void 0;
-var packageVersion = true ? "0.3.8" : "unknown";
+var packageVersion = true ? "0.3.9" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -5228,7 +5194,7 @@ var DefaultSparkSigner = class {
   }
   async createSparkWalletFromSeed(seed, accountNumber) {
     if (typeof seed === "string") {
-      seed = hexToBytes6(seed);
+      seed = hexToBytes7(seed);
     }
     const {
       identityKey,
@@ -5367,7 +5333,7 @@ var TaprootSparkSigner = class extends DefaultSparkSigner {
 
 // src/tests/utils/test-faucet.ts
 import { schnorr as schnorr6, secp256k1 as secp256k19 } from "@noble/curves/secp256k1";
-import { bytesToHex as bytesToHex7, hexToBytes as hexToBytes7 } from "@noble/curves/utils";
+import { bytesToHex as bytesToHex7, hexToBytes as hexToBytes8 } from "@noble/curves/utils";
 import * as btc3 from "@scure/btc-signer";
 import { Address as Address2, OutScript as OutScript2, SigHash as SigHash2, Transaction as Transaction4 } from "@scure/btc-signer";
 import { taprootTweakPrivKey as taprootTweakPrivKey2 } from "@scure/btc-signer/utils";
@@ -5394,10 +5360,10 @@ var getFetch = () => {
 };
 
 // src/tests/utils/test-faucet.ts
-var STATIC_FAUCET_KEY = hexToBytes7(
+var STATIC_FAUCET_KEY = hexToBytes8(
   "deadbeef1337cafe4242424242424242deadbeef1337cafe4242424242424242"
 );
-var STATIC_MINING_KEY = hexToBytes7(
+var STATIC_MINING_KEY = hexToBytes8(
   "1337cafe4242deadbeef4242424242421337cafe4242deadbeef424242424242"
 );
 var SATS_PER_BTC = 1e8;
@@ -5480,7 +5446,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       );
       await this.generateToAddress(1, address);
       const fundingTxRaw = await this.getRawTransaction(fundingTxid);
-      const fundingTx = Transaction4.fromRaw(hexToBytes7(fundingTxRaw.hex));
+      const fundingTx = Transaction4.fromRaw(hexToBytes8(fundingTxRaw.hex));
       for (let i = 0; i < fundingTx.outputsLength; i++) {
         const output = fundingTx.getOutput(i);
         if (!output.script || !output.amount) continue;
@@ -5546,7 +5512,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       this.coins.push({
         key: STATIC_FAUCET_KEY,
         outpoint: {
-          txid: hexToBytes7(splitTxId),
+          txid: hexToBytes8(splitTxId),
           index: i
         },
         txout: signedSplitTx.getOutput(i)
@@ -6635,7 +6601,7 @@ function collectResponses(responses) {
 }
 
 // src/utils/unilateral-exit.ts
-import { bytesToHex as bytesToHex8, hexToBytes as hexToBytes8 } from "@noble/curves/utils";
+import { bytesToHex as bytesToHex8, hexToBytes as hexToBytes9 } from "@noble/curves/utils";
 import { ripemd160 } from "@noble/hashes/legacy";
 import { sha256 as sha2569 } from "@noble/hashes/sha2";
 import * as btc4 from "@scure/btc-signer";
@@ -6650,7 +6616,7 @@ function isEphemeralAnchorOutput(script, amount) {
 }
 async function constructUnilateralExitTxs(nodeHexStrings, sparkClient, network) {
   const result = [];
-  const nodes = nodeHexStrings.map((hex) => TreeNode.decode(hexToBytes8(hex)));
+  const nodes = nodeHexStrings.map((hex) => TreeNode.decode(hexToBytes9(hex)));
   const nodeMap = /* @__PURE__ */ new Map();
   for (const node of nodes) {
     nodeMap.set(node.id, node);
@@ -6739,7 +6705,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           `Node hex string at index ${i} appears to be a raw transaction hex, not a TreeNode protobuf. Use 'leafidtohex' command to convert node IDs to proper hex strings.`
         );
       }
-      const nodeBytes = hexToBytes8(hex);
+      const nodeBytes = hexToBytes9(hex);
       const node = TreeNode.decode(nodeBytes);
       if (!node.id) {
         throw new Error(
@@ -6853,7 +6819,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
         usedUtxos,
         correctedParentTx
       } = constructFeeBumpTx(nodeTxHex, availableUtxos, feeRate, void 0);
-      const feeBumpTx = btc4.Transaction.fromPSBT(hexToBytes8(nodeFeeBumpPsbt));
+      const feeBumpTx = btc4.Transaction.fromPSBT(hexToBytes9(nodeFeeBumpPsbt));
       var feeBumpOut = feeBumpTx.outputsLength === 1 ? feeBumpTx.getOutput(0) : null;
       var feeBumpOutPubKey = null;
       for (const usedUtxo of usedUtxos) {
@@ -6908,7 +6874,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           void 0
         );
         const feeBumpTx2 = btc4.Transaction.fromPSBT(
-          hexToBytes8(refundFeeBump.feeBumpPsbt)
+          hexToBytes9(refundFeeBump.feeBumpPsbt)
         );
         var feeBumpOut = feeBumpTx2.outputsLength === 1 ? feeBumpTx2.getOutput(0) : null;
         var feeBumpOutPubKey = null;
@@ -7023,9 +6989,9 @@ function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
     if (!fundingUtxo) {
       throw new Error(`UTXO at index ${i} is undefined`);
     }
-    const pubKeyHash = hash160(hexToBytes8(fundingUtxo.publicKey));
+    const pubKeyHash = hash160(hexToBytes9(fundingUtxo.publicKey));
     const scriptToUse = new Uint8Array([0, 20, ...pubKeyHash]);
-    const providedScript = hexToBytes8(fundingUtxo.script);
+    const providedScript = hexToBytes9(fundingUtxo.script);
     if (bytesToHex8(scriptToUse) !== bytesToHex8(providedScript)) {
       throw new Error(
         `\u274C  Derived script doesn't match provided script for UTXO ${i + 1}.`
@@ -7139,7 +7105,6 @@ __export(utils_exports, {
   DIRECT_HTLC_TIMELOCK_OFFSET: () => DIRECT_HTLC_TIMELOCK_OFFSET,
   DIRECT_TIMELOCK_OFFSET: () => DIRECT_TIMELOCK_OFFSET,
   HTLC_TIMELOCK_OFFSET: () => HTLC_TIMELOCK_OFFSET,
-  INITIAL_DIRECT_SEQUENCE: () => INITIAL_DIRECT_SEQUENCE,
   INITIAL_SEQUENCE: () => INITIAL_SEQUENCE,
   LOGGER_NAMES: () => LOGGER_NAMES,
   Network: () => Network2,
@@ -7162,21 +7127,24 @@ __export(utils_exports, {
   constructFeeBumpTx: () => constructFeeBumpTx,
   constructUnilateralExitFeeBumpPackages: () => constructUnilateralExitFeeBumpPackages,
   constructUnilateralExitTxs: () => constructUnilateralExitTxs,
-  createConnectorRefundTransactions: () => createConnectorRefundTransactions,
-  createLeafNodeTx: () => createLeafNodeTx,
-  createNodeTx: () => createNodeTx,
-  createNodeTxs: () => createNodeTxs,
-  createRefundTx: () => createRefundTx,
-  createRefundTxs: () => createRefundTxs,
-  createRootTx: () => createRootTx,
+  createConnectorRefundTxs: () => createConnectorRefundTxs,
+  createCurrentTimelockRefundTxs: () => createCurrentTimelockRefundTxs,
+  createDecrementedTimelockNodeTx: () => createDecrementedTimelockNodeTx,
+  createDecrementedTimelockRefundTxs: () => createDecrementedTimelockRefundTxs,
+  createInitialTimelockNodeTx: () => createInitialTimelockNodeTx,
+  createInitialTimelockRefundTxs: () => createInitialTimelockRefundTxs,
+  createRootNodeTx: () => createRootNodeTx,
   createSigningCommitment: () => createSigningCommitment,
   createSigningNonce: () => createSigningNonce,
-  createSplitTx: () => createSplitTx,
+  createTestUnilateralRefundTxs: () => createTestUnilateralRefundTxs,
+  createTestUnilateralTimelockNodeTx: () => createTestUnilateralTimelockNodeTx,
+  createZeroTimelockNodeTx: () => createZeroTimelockNodeTx,
   decodeBech32mTokenIdentifier: () => decodeBech32mTokenIdentifier,
   decodeBytesToSigningCommitment: () => decodeBytesToSigningCommitment,
   decodeBytesToSigningNonce: () => decodeBytesToSigningNonce,
   decodeSparkAddress: () => decodeSparkAddress,
   doesLeafNeedRefresh: () => doesLeafNeedRefresh,
+  doesTxnNeedRenewed: () => doesTxnNeedRenewed,
   encodeBech32mTokenIdentifier: () => encodeBech32mTokenIdentifier,
   encodeSigningCommitmentToBytes: () => encodeSigningCommitmentToBytes,
   encodeSigningNonceToBytes: () => encodeSigningNonceToBytes,
@@ -7220,6 +7188,7 @@ __export(utils_exports, {
   isTxBroadcast: () => isTxBroadcast,
   isValidPublicKey: () => isValidPublicKey,
   isValidSparkAddress: () => isValidSparkAddress,
+  isZeroTimelock: () => isZeroTimelock,
   lastKeyWithTarget: () => lastKeyWithTarget,
   maybeApplyFee: () => maybeApplyFee,
   modInverse: () => modInverse,
@@ -7246,11 +7215,11 @@ import {
   bytesToHex as bytesToHex11,
   bytesToNumberBE as bytesToNumberBE8,
   equalBytes as equalBytes6,
-  hexToBytes as hexToBytes13
+  hexToBytes as hexToBytes12
 } from "@noble/curves/utils";
 import { validateMnemonic } from "@scure/bip39";
 import { wordlist as wordlist2 } from "@scure/bip39/wordlists/english";
-import { Address as Address4, OutScript as OutScript3, Transaction as Transaction9 } from "@scure/btc-signer";
+import { Address as Address4, OutScript as OutScript3, Transaction as Transaction7 } from "@scure/btc-signer";
 import { Mutex } from "async-mutex";
 import { uuidv7 as uuidv74 } from "uuidv7";
 
@@ -8372,28 +8341,14 @@ var SparkAuthProvider = class {
 };
 
 // src/services/coop-exit.ts
-import { Transaction as Transaction7 } from "@scure/btc-signer";
 import { uuidv7 as uuidv72 } from "uuidv7";
 
 // src/services/transfer.ts
 import { secp256k1 as secp256k110 } from "@noble/curves/secp256k1";
-import {
-  bytesToHex as bytesToHex10,
-  equalBytes as equalBytes5,
-  hexToBytes as hexToBytes9,
-  numberToBytesBE as numberToBytesBE4
-} from "@noble/curves/utils";
+import { bytesToHex as bytesToHex10, equalBytes as equalBytes5, numberToBytesBE as numberToBytesBE4 } from "@noble/curves/utils";
 import { sha256 as sha25611 } from "@noble/hashes/sha2";
-import { Transaction as Transaction6 } from "@scure/btc-signer";
 import * as ecies2 from "eciesjs";
 import { uuidv7 } from "uuidv7";
-function getSigningJobProto(signingJob) {
-  return {
-    signingPublicKey: signingJob.signingPublicKey,
-    rawTx: signingJob.rawTx,
-    signingNonceCommitment: signingJob.signingNonceCommitment.commitment
-  };
-}
 var BaseTransferService = class {
   config;
   connectionManager;
@@ -9075,42 +9030,27 @@ var TransferService = class extends BaseTransferService {
         throw new Error(`Leaf data not found for leaf ${leaf.leaf.id}`);
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
-      const cpfpNodeOutPoint = {
-        txid: hexToBytes9(getTxId(nodeTx)),
-        index: 0
-      };
       let directNodeTx;
-      let directNodeOutPoint;
       if (leaf.leaf.directTx.length > 0) {
         directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
-        directNodeOutPoint = {
-          txid: hexToBytes9(getTxId(directNodeTx)),
-          index: 0
-        };
       }
       const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
-      const sequence = currRefundTx.getInput(0).sequence;
-      if (!sequence) {
+      const currentSequence = currRefundTx.getInput(0).sequence;
+      if (!currentSequence) {
         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 { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
-        sequence: nextSequence,
-        directSequence: nextDirectSequence,
-        input: cpfpNodeOutPoint,
-        directInput: directNodeOutPoint,
-        amountSats,
+      const refundTxsParams = {
+        nodeTx,
+        directNodeTx,
+        sequence: currentSequence,
         receivingPubkey: refundSigningData.receivingPubkey,
         network: this.config.getNetwork()
-      });
+      };
+      const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = isForClaim ? createCurrentTimelockRefundTxs(refundTxsParams) : createDecrementedTimelockRefundTxs(refundTxsParams);
       refundSigningData.refundTx = cpfpRefundTx;
       refundSigningData.directRefundTx = directRefundTx;
       refundSigningData.directFromCpfpRefundTx = directFromCpfpRefundTx;
@@ -9323,71 +9263,127 @@ var TransferService = class extends BaseTransferService {
       throw new Error(`Error querying pending transfers by sender: ${error}`);
     }
   }
-  async refreshTimelockNodesInternal(node, parentNode, useTestUnilateralSequence) {
+  async renewRefundTxn(node, parentNode) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    const signingJobs = await this.createRenewRefundSigningJobs(
+      node,
+      parentNode
+    );
+    const statechainCommitments = await sparkClient.get_signing_commitments({
+      nodeIds: [node.id],
+      count: signingJobs.length
+    });
+    const mappedSigningJobs = signingJobs.map((signingJob, index) => {
+      const signingNonceCommitments = statechainCommitments.signingCommitments[index]?.signingNonceCommitments;
+      if (!signingNonceCommitments) {
+        throw new Error("Signing nonce commitments not found");
+      }
+      return {
+        ...signingJob,
+        signingNonceCommitments
+      };
+    });
+    const userSignedTxSigningJobs = await this.signingService.signSigningJobs(mappedSigningJobs);
+    const renewRefundTimelockSigningJob = {
+      nodeTxSigningJob: userSignedTxSigningJobs.get("node"),
+      refundTxSigningJob: userSignedTxSigningJobs.get("cpfp"),
+      directNodeTxSigningJob: userSignedTxSigningJobs.get("directNode"),
+      directRefundTxSigningJob: userSignedTxSigningJobs.get("direct"),
+      directFromCpfpRefundTxSigningJob: userSignedTxSigningJobs.get("directFromCpfp")
+    };
+    const response = await sparkClient.renew_leaf({
+      leafId: node.id,
+      signingJobs: {
+        $case: "renewRefundTimelockSigningJob",
+        renewRefundTimelockSigningJob
+      }
+    });
+    if (response.renewResult?.$case !== "renewRefundTimelockResult" || !response.renewResult?.renewRefundTimelockResult.node) {
+      throw new ValidationError("Unexpected renew result", {
+        field: "renewResult",
+        value: response.renewResult
+      });
+    }
+    return response.renewResult?.renewRefundTimelockResult.node;
+  }
+  async renewNodeTxn(node, parentNode) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    const signingJobs = await this.createRenewNodeSigningJobs(node, parentNode);
+    const statechainCommitments = await sparkClient.get_signing_commitments({
+      nodeIds: [node.id],
+      count: signingJobs.length
+    });
+    const mappedSigningJobs = signingJobs.map((signingJob, index) => {
+      const signingNonceCommitments = statechainCommitments.signingCommitments[index]?.signingNonceCommitments;
+      if (!signingNonceCommitments) {
+        throw new Error("Signing nonce commitments not found");
+      }
+      return {
+        ...signingJob,
+        signingNonceCommitments
+      };
+    });
+    const userSignedTxSigningJobs = await this.signingService.signSigningJobs(mappedSigningJobs);
+    const response = await sparkClient.renew_leaf({
+      leafId: node.id,
+      signingJobs: {
+        $case: "renewNodeTimelockSigningJob",
+        renewNodeTimelockSigningJob: {
+          splitNodeTxSigningJob: userSignedTxSigningJobs.get("split"),
+          splitNodeDirectTxSigningJob: userSignedTxSigningJobs.get("directSplit"),
+          nodeTxSigningJob: userSignedTxSigningJobs.get("node"),
+          directNodeTxSigningJob: userSignedTxSigningJobs.get("directNode"),
+          refundTxSigningJob: userSignedTxSigningJobs.get("cpfp"),
+          directRefundTxSigningJob: userSignedTxSigningJobs.get("direct"),
+          directFromCpfpRefundTxSigningJob: userSignedTxSigningJobs.get("directFromCpfp")
+        }
+      }
+    });
+    if (response.renewResult?.$case !== "renewNodeTimelockResult" || !response.renewResult?.renewNodeTimelockResult.node) {
+      throw new ValidationError("Unexpected renew result", {
+        field: "renewResult",
+        value: response.renewResult
+      });
+    }
+    return response.renewResult.renewNodeTimelockResult.node;
+  }
+  async createRenewRefundSigningJobs(node, parentNode) {
     const signingJobs = [];
-    const parentNodeTx = getTxFromRawTxBytes(parentNode.nodeTx);
-    const parentNodeOutput = parentNodeTx.getOutput(0);
+    const parentTx = getTxFromRawTxBytes(parentNode.nodeTx);
+    const parentNodeOutput = getTxFromRawTxBytes(parentNode.nodeTx).getOutput(
+      0
+    );
     if (!parentNodeOutput) {
-      throw Error("Could not get parent node output");
+      throw new Error("Parent node output not found");
     }
-    const nodeTx = getTxFromRawTxBytes(node.nodeTx);
-    const nodeInput = nodeTx.getInput(0);
-    const nodeOutput = nodeTx.getOutput(0);
-    if (!nodeOutput) {
-      throw Error("Could not get node output");
-    }
-    let directNodeTx;
-    let directNodeInput;
-    if (node.directTx.length > 0) {
-      directNodeTx = getTxFromRawTxBytes(node.directTx);
-      directNodeInput = directNodeTx.getInput(0);
-    }
-    const currSequence = nodeInput.sequence;
-    if (!currSequence) {
-      throw new ValidationError("Invalid node transaction", {
-        field: "sequence",
-        value: nodeInput,
-        expected: "Non-null sequence"
-      });
-    }
-    let { nextSequence, nextDirectSequence } = getNextTransactionSequence(
-      currSequence,
-      true
-    );
-    const output = {
+    const unsignedParentNodeOutput = {
       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({
+    const keyDerivation = {
       type: "leaf" /* LEAF */,
       path: node.id
-    });
+    };
+    const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
+    const nodeTx = getTxFromRawTxBytes(node.nodeTx);
+    const refundTx = getTxFromRawTxBytes(node.refundTx);
+    const { nodeTx: newNodeTx, directNodeTx: newDirectNodeTx } = createDecrementedTimelockNodeTx(parentTx, nodeTx);
     signingJobs.push({
       signingPublicKey,
-      rawTx: cpfpNodeTx.toBytes(),
+      rawTx: newNodeTx.toBytes(),
       signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
       type: "node",
-      parentTxOut: parentNodeOutput
+      parentTxOut: unsignedParentNodeOutput,
+      leafId: node.id,
+      keyDerivation: {
+        type: "leaf" /* LEAF */,
+        path: node.id
+      },
+      verifyingKey: node.verifyingPublicKey
     });
     if (newDirectNodeTx) {
       signingJobs.push({
@@ -9395,537 +9391,299 @@ var TransferService = class extends BaseTransferService {
         rawTx: newDirectNodeTx.toBytes(),
         signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
         type: "directNode",
-        parentTxOut: parentNodeOutput
+        parentTxOut: unsignedParentNodeOutput,
+        leafId: node.id,
+        keyDerivation: {
+          type: "leaf" /* LEAF */,
+          path: node.id
+        },
+        verifyingKey: node.verifyingPublicKey
       });
     }
-    const newCpfpRefundOutPoint = {
-      txid: hexToBytes9(getTxId(cpfpNodeTx)),
-      index: 0
-    };
-    let newDirectRefundOutPoint;
-    if (newDirectNodeTx) {
-      newDirectRefundOutPoint = {
-        txid: hexToBytes9(getTxId(newDirectNodeTx)),
-        index: 0
-      };
-    }
-    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()
-    });
-    signingJobs.push({
-      signingPublicKey,
-      rawTx: cpfpRefundTx.toBytes(),
-      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
-      type: "cpfp",
-      parentTxOut: newCpfpNodeOutput
-    });
-    if (directRefundTx && newDirectNodeOutput) {
-      signingJobs.push({
-        signingPublicKey,
-        rawTx: directRefundTx.toBytes(),
-        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
-        type: "direct",
-        parentTxOut: newDirectNodeOutput
-      });
-    }
-    if (directFromCpfpRefundTx && newCpfpNodeOutput) {
-      signingJobs.push({
-        signingPublicKey,
-        rawTx: directFromCpfpRefundTx.toBytes(),
-        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
-        type: "directFromCpfp",
-        parentTxOut: newCpfpNodeOutput
-      });
-    }
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    const response = await sparkClient.refresh_timelock_v2({
-      leafId: node.id,
-      ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
-      signingJobs: signingJobs.map(getSigningJobProto)
-    });
-    if (signingJobs.length !== response.signingResults.length) {
-      throw Error(
-        `number of signing jobs and signing results do not match: ${signingJobs.length} !== ${response.signingResults.length}`
-      );
-    }
-    let nodeSignatures = [];
-    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");
-      }
-      const rawTx = getTxFromRawTxBytes(signingJob.rawTx);
-      const txOut = signingJob.parentTxOut;
-      if (!txOut) {
-        throw Error("Could not get tx out");
-      }
-      const rawTxSighash = getSigHashFromTx(rawTx, 0, txOut);
-      const userSignature = await this.config.signer.signFrost({
-        message: rawTxSighash,
-        keyDerivation: {
-          type: "leaf" /* LEAF */,
-          path: node.id
-        },
-        publicKey: signingJob.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: signingJob.signingPublicKey,
-        selfSignature: userSignature,
-        adaptorPubKey: new Uint8Array()
-      });
-      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;
-      }
-    }
-    nodeSignatures.push({
-      nodeId: node.id,
-      nodeTxSignature: leafCpfpSignature || new Uint8Array(),
-      directNodeTxSignature: leafDirectSignature || new Uint8Array(),
-      refundTxSignature: cpfpRefundSignature || new Uint8Array(),
-      directRefundTxSignature: directRefundSignature || new Uint8Array(),
-      directFromCpfpRefundTxSignature: directFromCpfpRefundSignature || new Uint8Array()
-    });
-    const result = await sparkClient.finalize_node_signatures_v2({
-      intent: 3 /* REFRESH */,
-      nodeSignatures
-    });
-    return result;
-  }
-  async refreshTimelockNodes(node, parentNode) {
-    return await this.refreshTimelockNodesInternal(node, parentNode);
-  }
-  async extendTimelock(node) {
-    const nodeTx = getTxFromRawTxBytes(node.nodeTx);
-    const refundTx = getTxFromRawTxBytes(node.refundTx);
-    const refundSequence = refundTx.getInput(0).sequence || 0;
-    const newNodeOutPoint = {
-      txid: hexToBytes9(getTxId(nodeTx)),
-      index: 0
-    };
-    const {
-      nextSequence: newNodeSequence,
-      nextDirectSequence: newDirectNodeSequence
-    } = getNextTransactionSequence(refundSequence);
-    const newNodeTx = new Transaction6({
-      version: 3,
-      allowUnknownOutputs: true
-    });
-    newNodeTx.addInput({ ...newNodeOutPoint, sequence: newNodeSequence });
-    const originalOutput = nodeTx.getOutput(0);
-    if (!originalOutput) {
-      throw Error("Could not get original node output");
-    }
-    newNodeTx.addOutput({
-      script: originalOutput.script,
-      amount: originalOutput.amount
-    });
-    newNodeTx.addOutput(getEphemeralAnchorOutput());
-    let newDirectNodeTx;
-    if (node.directTx.length > 0) {
-      newDirectNodeTx = new Transaction6({
-        version: 3,
-        allowUnknownOutputs: true
-      });
-      newDirectNodeTx.addInput({
-        ...newNodeOutPoint,
-        sequence: newDirectNodeSequence
-      });
-      newDirectNodeTx.addOutput({
-        script: originalOutput.script,
-        amount: maybeApplyFee(originalOutput.amount)
-      });
-    }
-    const newCpfpRefundOutPoint = {
-      txid: hexToBytes9(getTxId(newNodeTx)),
-      index: 0
-    };
-    let newDirectRefundOutPoint;
-    if (newDirectNodeTx) {
-      newDirectRefundOutPoint = {
-        txid: hexToBytes9(getTxId(newDirectNodeTx)),
-        index: 0
-      };
+    const newCpfpNodeOutput = newNodeTx.getOutput(0);
+    if (!newCpfpNodeOutput) {
+      throw Error("Could not get new cpfp node output");
     }
+    const newDirectNodeOutput = newDirectNodeTx?.getOutput(0);
     const amountSats = refundTx.getOutput(0).amount;
     if (amountSats === void 0) {
       throw new Error("Amount not found in extendTimelock");
     }
-    const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation({
-      type: "leaf" /* LEAF */,
-      path: node.id
-    });
+    const directAmountSats = newDirectNodeOutput?.amount;
+    if (directAmountSats === void 0) {
+      throw new Error("Amount not found in extendTimelock");
+    }
     const {
-      cpfpRefundTx: newCpfpRefundTx,
+      cpfpRefundTx: newRefundTx,
       directRefundTx: newDirectRefundTx,
       directFromCpfpRefundTx: newDirectFromCpfpRefundTx
-    } = createRefundTxs({
-      sequence: INITIAL_SEQUENCE,
-      directSequence: INITIAL_DIRECT_SEQUENCE,
-      input: newCpfpRefundOutPoint,
-      directInput: newDirectRefundOutPoint,
-      amountSats,
+    } = createInitialTimelockRefundTxs({
+      nodeTx: newNodeTx,
+      directNodeTx: newDirectNodeTx,
       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 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,
-      rawTx: newNodeTx.toBytes(),
-      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
-    };
-    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 ? {
+    signingJobs.push({
       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_v2({
+      rawTx: newRefundTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "cpfp",
+      parentTxOut: newCpfpNodeOutput,
       leafId: node.id,
-      ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
-      nodeTxSigningJob: getSigningJobProto(newNodeSigningJob),
-      directNodeTxSigningJob: newDirectNodeSigningJob ? getSigningJobProto(newDirectNodeSigningJob) : void 0,
-      refundTxSigningJob: getSigningJobProto(newCpfpRefundSigningJob),
-      directRefundTxSigningJob: newDirectRefundSigningJob ? getSigningJobProto(newDirectRefundSigningJob) : void 0,
-      directFromCpfpRefundTxSigningJob: newDirectFromCpfpRefundSigningJob ? getSigningJobProto(newDirectFromCpfpRefundSigningJob) : void 0
+      keyDerivation,
+      verifyingKey: node.verifyingPublicKey
     });
-    if (!response.nodeTxSigningResult || !response.refundTxSigningResult) {
-      throw new Error("Signing result does not exist");
+    if (newDirectRefundTx && newDirectNodeOutput) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: newDirectRefundTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "direct",
+        parentTxOut: newDirectNodeOutput,
+        leafId: node.id,
+        keyDerivation,
+        verifyingKey: node.verifyingPublicKey
+      });
+    }
+    if (newDirectFromCpfpRefundTx && newDirectNodeOutput) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: newDirectFromCpfpRefundTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "directFromCpfp",
+        parentTxOut: newCpfpNodeOutput,
+        leafId: node.id,
+        keyDerivation,
+        verifyingKey: node.verifyingPublicKey
+      });
     }
+    return signingJobs;
+  }
+  async createRenewNodeSigningJobs(node, parentNode) {
+    const signingJobs = [];
+    const parentTx = getTxFromRawTxBytes(parentNode.nodeTx);
+    const parentNodeOutput = getTxFromRawTxBytes(parentNode.nodeTx).getOutput(
+      0
+    );
+    const unsignedParentNodeOutput = {
+      script: parentNodeOutput.script,
+      amount: parentNodeOutput.amount
+    };
     const keyDerivation = {
       type: "leaf" /* LEAF */,
       path: node.id
     };
-    const nodeUserSig = await this.config.signer.signFrost({
-      message: nodeSighash,
+    const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
+    const { nodeTx: splitNodeTx, directNodeTx: splitNodeDirectTx } = createZeroTimelockNodeTx(parentTx);
+    signingJobs.push({
+      signingPublicKey,
+      rawTx: splitNodeTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "split",
+      parentTxOut: unsignedParentNodeOutput,
+      leafId: node.id,
       keyDerivation,
-      publicKey: signingPublicKey,
-      verifyingKey: response.nodeTxSigningResult.verifyingKey,
-      selfCommitment: newNodeSigningJob.signingNonceCommitment,
-      statechainCommitments: response.nodeTxSigningResult.signingResult?.signingNonceCommitments,
-      adaptorPubKey: new Uint8Array()
-    });
-    const nodeSig = await this.config.signer.aggregateFrost({
-      message: nodeSighash,
-      statechainSignatures: response.nodeTxSigningResult.signingResult?.signatureShares,
-      statechainPublicKeys: response.nodeTxSigningResult.signingResult?.publicKeys,
-      verifyingKey: response.nodeTxSigningResult.verifyingKey,
-      statechainCommitments: response.nodeTxSigningResult.signingResult?.signingNonceCommitments,
-      selfCommitment: newNodeSigningJob.signingNonceCommitment,
-      publicKey: signingPublicKey,
-      selfSignature: nodeUserSig,
-      adaptorPubKey: new Uint8Array()
+      verifyingKey: node.verifyingPublicKey
     });
-    let directNodeSig;
-    if (directNodeSighash && newDirectNodeSigningJob && response.directNodeTxSigningResult) {
-      const directNodeUserSig = await this.config.signer.signFrost({
-        message: directNodeSighash,
+    if (splitNodeDirectTx) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: splitNodeDirectTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "directSplit",
+        parentTxOut: unsignedParentNodeOutput,
+        leafId: node.id,
         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()
+        verifyingKey: node.verifyingPublicKey
       });
     }
-    const cpfpRefundUserSig = await this.config.signer.signFrost({
-      message: cpfpRefundSighash,
+    const splitNodeOutput = splitNodeTx.getOutput(0);
+    const splitNodeDirectOutput = splitNodeDirectTx.getOutput(0);
+    if (!splitNodeDirectOutput.amount || !splitNodeDirectOutput.script) {
+      throw new Error("Could not get split node output");
+    }
+    const unsignedSplitNodeOutput = {
+      script: splitNodeDirectOutput.script,
+      amount: splitNodeDirectOutput.amount
+    };
+    const { nodeTx: newNodeTx, directNodeTx: newDirectNodeTx } = createInitialTimelockNodeTx(splitNodeTx);
+    signingJobs.push({
+      signingPublicKey,
+      rawTx: newNodeTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "node",
+      parentTxOut: splitNodeOutput,
+      leafId: node.id,
       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: newCpfpRefundSigningJob.signingNonceCommitment,
-      publicKey: signingPublicKey,
-      selfSignature: cpfpRefundUserSig,
-      adaptorPubKey: new Uint8Array()
+      verifyingKey: node.verifyingPublicKey
     });
-    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,
+    if (newDirectNodeTx) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: newDirectNodeTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "directNode",
+        parentTxOut: splitNodeOutput,
+        leafId: node.id,
         keyDerivation,
-        publicKey: signingPublicKey,
-        verifyingKey: response.directFromCpfpRefundTxSigningResult.verifyingKey,
-        selfCommitment: newDirectFromCpfpRefundSigningJob.signingNonceCommitment,
-        statechainCommitments: response.directFromCpfpRefundTxSigningResult.signingResult?.signingNonceCommitments,
-        adaptorPubKey: new Uint8Array()
+        verifyingKey: node.verifyingPublicKey
       });
-      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,
-          directNodeTxSignature: directNodeSig,
-          refundTxSignature: cpfpRefundSig,
-          directRefundTxSignature: directRefundSig,
-          directFromCpfpRefundTxSignature: directFromCpfpRefundSig
-        }
-      ]
-    });
-  }
-  async testonly_expireTimeLockNodeTx(node, parentNode) {
-    return await this.refreshTimelockNodesInternal(node, parentNode, true);
-  }
-  async testonly_expireTimeLockRefundtx(node) {
-    const nodeTx = getTxFromRawTxBytes(node.nodeTx);
-    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 signingPublicKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
-    const cpfpRefundOutPoint = {
-      txid: hexToBytes9(getTxId(nodeTx)),
-      index: 0
-    };
-    let directRefundOutPoint;
-    if (directNodeTx) {
-      directRefundOutPoint = {
-        txid: hexToBytes9(getTxId(directNodeTx)),
-        index: 0
-      };
+    const newCpfpNodeOutput = newNodeTx.getOutput(0);
+    if (!newCpfpNodeOutput) {
+      throw Error("Could not get new cpfp node output");
     }
+    const newDirectNodeOutput = newDirectNodeTx?.getOutput(0);
     const {
-      cpfpRefundTx: newCpfpRefundTx,
+      cpfpRefundTx: newRefundTx,
       directRefundTx: newDirectRefundTx,
       directFromCpfpRefundTx: newDirectFromCpfpRefundTx
-    } = createRefundTxs({
-      sequence: nextSequence,
-      directSequence: nextDirectSequence,
-      input: cpfpRefundOutPoint,
-      directInput: directRefundOutPoint,
-      amountSats: nodeOutput.amount,
+    } = createInitialTimelockRefundTxs({
+      nodeTx: newNodeTx,
+      directNodeTx: newDirectNodeTx,
       receivingPubkey: signingPublicKey,
       network: this.config.getNetwork()
     });
-    const signingJobs = [];
     signingJobs.push({
       signingPublicKey,
-      rawTx: newCpfpRefundTx.toBytes(),
+      rawTx: newRefundTx.toBytes(),
       signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
       type: "cpfp",
-      parentTxOut: nodeOutput
+      parentTxOut: newCpfpNodeOutput,
+      leafId: node.id,
+      keyDerivation,
+      verifyingKey: node.verifyingPublicKey
     });
-    const directNodeTxOut = directNodeTx?.getOutput(0);
-    if (newDirectRefundTx && directNodeTxOut) {
+    if (newDirectRefundTx && newDirectNodeOutput) {
       signingJobs.push({
         signingPublicKey,
         rawTx: newDirectRefundTx.toBytes(),
         signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
         type: "direct",
-        parentTxOut: directNodeTxOut
+        parentTxOut: newDirectNodeOutput,
+        leafId: node.id,
+        keyDerivation,
+        verifyingKey: node.verifyingPublicKey
       });
     }
-    if (newDirectFromCpfpRefundTx) {
+    if (newDirectFromCpfpRefundTx && newDirectNodeOutput) {
       signingJobs.push({
         signingPublicKey,
         rawTx: newDirectFromCpfpRefundTx.toBytes(),
         signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
         type: "directFromCpfp",
-        parentTxOut: nodeOutput
+        parentTxOut: newCpfpNodeOutput,
+        leafId: node.id,
+        keyDerivation,
+        verifyingKey: node.verifyingPublicKey
       });
     }
+    return signingJobs;
+  }
+  async renewZeroTimelockNodeTxn(node) {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
-    const response = await sparkClient.refresh_timelock_v2({
-      leafId: node.id,
-      ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
-      signingJobs: signingJobs.map(getSigningJobProto)
+    const signingJobs = await this.createRenewZeroTimelockNodeSigningJobs(node);
+    const statechainCommitments = await sparkClient.get_signing_commitments({
+      nodeIds: [node.id],
+      count: signingJobs.length
+    });
+    const mappedSigningJobs = signingJobs.map((signingJob, index) => {
+      const signingNonceCommitments = statechainCommitments.signingCommitments[index]?.signingNonceCommitments;
+      if (!signingNonceCommitments) {
+        throw new ValidationError("Signing nonce commitments not found", {
+          field: "signingNonceCommitments",
+          value: signingNonceCommitments
+        });
+      }
+      return {
+        ...signingJob,
+        signingNonceCommitments
+      };
     });
-    if (response.signingResults.length !== signingJobs.length) {
-      throw Error(
-        `Expected ${signingJobs.length} signing results, got ${response.signingResults.length}`
-      );
-    }
-    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 userSignedTxSigningJobs = await this.signingService.signSigningJobs(mappedSigningJobs);
+    const renewZeroTimelockNodeSigningJob = {
+      nodeTxSigningJob: userSignedTxSigningJobs.get("node"),
+      refundTxSigningJob: userSignedTxSigningJobs.get("cpfp"),
+      directNodeTxSigningJob: userSignedTxSigningJobs.get("directNode"),
+      directRefundTxSigningJob: void 0,
+      directFromCpfpRefundTxSigningJob: userSignedTxSigningJobs.get("directFromCpfp")
+    };
+    const response = await sparkClient.renew_leaf({
+      leafId: node.id,
+      signingJobs: {
+        $case: "renewNodeZeroTimelockSigningJob",
+        renewNodeZeroTimelockSigningJob: renewZeroTimelockNodeSigningJob
       }
-      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 (response.renewResult?.$case !== "renewNodeZeroTimelockResult" || !response.renewResult?.renewNodeZeroTimelockResult.node) {
+      throw new ValidationError("Unexpected renew result", {
+        field: "renewResult",
+        value: response.renewResult
       });
-      if (signingJob.type === "cpfp") {
-        cpfpRefundSignature = signature;
-      } else if (signingJob.type === "direct") {
-        directRefundSignature = signature;
-      } else if (signingJob.type === "directFromCpfp") {
-        directFromCpfpRefundSignature = signature;
-      }
     }
-    const result = await sparkClient.finalize_node_signatures_v2({
-      intent: 3 /* REFRESH */,
-      nodeSignatures: [
-        {
-          nodeId: node.id,
-          nodeTxSignature: new Uint8Array(),
-          directNodeTxSignature: new Uint8Array(),
-          refundTxSignature: cpfpRefundSignature,
-          directRefundTxSignature: directRefundSignature,
-          directFromCpfpRefundTxSignature: directFromCpfpRefundSignature
-        }
-      ]
+    return response.renewResult.renewNodeZeroTimelockResult.node;
+  }
+  async createRenewZeroTimelockNodeSigningJobs(node) {
+    const signingJobs = [];
+    const keyDerivation = {
+      type: "leaf" /* LEAF */,
+      path: node.id
+    };
+    const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
+    const nodeTx = getTxFromRawTxBytes(node.nodeTx);
+    const { nodeTx: newNodeTx, directNodeTx: newDirectNodeTx } = createZeroTimelockNodeTx(nodeTx);
+    signingJobs.push({
+      signingPublicKey,
+      rawTx: newNodeTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "node",
+      parentTxOut: nodeTx.getOutput(0),
+      leafId: node.id,
+      keyDerivation,
+      verifyingKey: node.verifyingPublicKey
     });
-    return result;
+    signingJobs.push({
+      signingPublicKey,
+      rawTx: newDirectNodeTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "directNode",
+      parentTxOut: nodeTx.getOutput(0),
+      leafId: node.id,
+      keyDerivation,
+      verifyingKey: node.verifyingPublicKey
+    });
+    const { cpfpRefundTx, directFromCpfpRefundTx } = createInitialTimelockRefundTxs({
+      nodeTx: newNodeTx,
+      directNodeTx: newDirectNodeTx,
+      receivingPubkey: signingPublicKey,
+      network: this.config.getNetwork()
+    });
+    signingJobs.push({
+      signingPublicKey,
+      rawTx: cpfpRefundTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "cpfp",
+      parentTxOut: newNodeTx.getOutput(0),
+      leafId: node.id,
+      keyDerivation,
+      verifyingKey: node.verifyingPublicKey
+    });
+    if (!directFromCpfpRefundTx) {
+      throw new Error("Could not create direct refund transactions");
+    }
+    signingJobs.push({
+      signingPublicKey,
+      rawTx: directFromCpfpRefundTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "directFromCpfp",
+      parentTxOut: newNodeTx.getOutput(0),
+      leafId: node.id,
+      keyDerivation,
+      verifyingKey: node.verifyingPublicKey
+    });
+    return signingJobs;
   }
 };
 
@@ -9967,71 +9725,6 @@ var CoopExitService = class extends BaseTransferService {
       directFromCpfpSignaturesMap
     };
   }
-  createConnectorRefundTransactions(sequence, directSequence, cpfpNodeOutPoint, directNodeOutPoint, connectorOutput, amountSats, receiverPubKey) {
-    const cpfpRefundTx = new Transaction7();
-    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"
-      });
-    }
-    cpfpRefundTx.addInput({
-      txid: cpfpNodeOutPoint.txid,
-      index: cpfpNodeOutPoint.index,
-      sequence
-    });
-    cpfpRefundTx.addInput(connectorOutput);
-    const receiverScript = getP2TRScriptFromPublicKey(
-      receiverPubKey,
-      this.config.getNetwork()
-    );
-    cpfpRefundTx.addOutput({
-      script: receiverScript,
-      amount: amountSats
-    });
-    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 Transaction7();
-      directRefundTx.addInput({
-        txid: directNodeOutPoint.txid,
-        index: directNodeOutPoint.index,
-        sequence: directSequence
-      });
-      directRefundTx.addInput(connectorOutput);
-      directRefundTx.addOutput({
-        script: receiverScript,
-        amount: maybeApplyFee(amountSats)
-      });
-      directFromCpfpRefundTx = new Transaction7();
-      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, transferId) {
     if (leaves.length !== connectorOutputs.length) {
       throw new ValidationError(
@@ -10065,29 +9758,39 @@ var CoopExitService = class extends BaseTransferService {
           expected: "Valid connector output"
         });
       }
+      const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
+      let directNodeTx;
+      if (leaf.leaf.directTx.length > 0) {
+        directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
+      }
       const currentRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
-      const sequence = currentRefundTx.getInput(0).sequence;
-      if (!sequence) {
+      if (!currentRefundTx) {
+        throw new ValidationError("Invalid refund transaction", {
+          field: "currentRefundTx",
+          value: currentRefundTx,
+          expected: "Non-null refund transaction"
+        });
+      }
+      const currentSequence = currentRefundTx.getInput(0).sequence;
+      if (!currentSequence) {
         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),
+      const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createConnectorRefundTxs({
+        nodeTx,
+        directNodeTx,
+        sequence: currentSequence,
         connectorOutput,
-        BigInt(leaf.leaf.value),
-        receiverPubKey
-      );
+        receivingPubkey: receiverPubKey,
+        network: this.config.getNetwork()
+      });
       const signingNonceCommitment = await this.config.signer.getRandomSigningCommitment();
       const directSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
       const directFromCpfpSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
@@ -10568,12 +10271,9 @@ import {
 import { EventEmitter } from "eventemitter3";
 import { ClientError, Status } from "nice-grpc-common";
 
-// src/services/signing.ts
-import { hexToBytes as hexToBytes12 } from "@noble/curves/utils";
-
 // src/utils/htlc-transactions.ts
 import {
-  Transaction as Transaction8,
+  Transaction as Transaction6,
   Script,
   taprootListToTree,
   p2tr as p2tr3,
@@ -10661,7 +10361,7 @@ function createLightningHTLCTransaction({
     txid: hexToBytes11(getTxId(nodeTx)),
     index: 0
   };
-  const htlcTransaction = new Transaction8({
+  const htlcTransaction = new Transaction6({
     version: 3,
     allowUnknownOutputs: true
   });
@@ -10780,20 +10480,7 @@ var SigningService = class {
         });
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
-      const cpfpNodeOutPoint = {
-        txid: hexToBytes12(getTxId(nodeTx)),
-        index: 0
-      };
       const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
-      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", {
@@ -10803,20 +10490,21 @@ var SigningService = class {
         });
       }
       let directNodeTx;
-      let directNodeOutPoint;
       if (leaf.leaf.directTx.length > 0) {
         directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
-        directNodeOutPoint = {
-          txid: hexToBytes12(getTxId(directNodeTx)),
-          index: 0
-        };
       }
-      const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
-        sequence: nextSequence,
-        directSequence: nextDirectSequence,
-        input: cpfpNodeOutPoint,
-        directInput: directNodeOutPoint,
-        amountSats,
+      const currentSequence = currRefundTx.getInput(0).sequence;
+      if (!currentSequence) {
+        throw new ValidationError("Invalid refund transaction", {
+          field: "sequence",
+          value: currRefundTx.getInput(0),
+          expected: "Non-null sequence"
+        });
+      }
+      const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createDecrementedTimelockRefundTxs({
+        nodeTx,
+        directNodeTx,
+        sequence: currentSequence,
         receivingPubkey: receiverIdentityPubkey,
         network: this.config.getNetwork()
       });
@@ -10832,7 +10520,8 @@ var SigningService = class {
         cpfpSigningCommitments[i]?.signingNonceCommitments
       );
       cpfpLeafSigningJobs.push(...signingJobs);
-      if (directRefundTx) {
+      const isZeroNode = getCurrentTimelock(nodeTx.getInput(0).sequence);
+      if (directRefundTx && !isZeroNode) {
         if (!directNodeTx) {
           throw new ValidationError(
             "Direct node transaction undefined while direct refund transaction is defined",
@@ -10857,16 +10546,6 @@ var SigningService = class {
         directLeafSigningJobs.push(...signingJobs2);
       }
       if (directFromCpfpRefundTx) {
-        if (!directNodeTx) {
-          throw new ValidationError(
-            "Direct node transaction undefined while direct from CPFP refund transaction is defined",
-            {
-              field: "directNodeTx",
-              value: directNodeTx,
-              expected: "Non-null direct node transaction"
-            }
-          );
-        }
         const refundSighash2 = getSigHashFromTx(
           directFromCpfpRefundTx,
           0,
@@ -10993,6 +10672,35 @@ var SigningService = class {
       directFromCpfpLeafSigningJobs
     };
   }
+  async signSigningJobs(signingJobs) {
+    const userSignedTxSigningJobs = /* @__PURE__ */ new Map();
+    for (const signingJob of signingJobs) {
+      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: signingJob.keyDerivation,
+        publicKey: signingJob.signingPublicKey,
+        verifyingKey: signingJob.verifyingKey,
+        selfCommitment: signingJob.signingNonceCommitment,
+        statechainCommitments: signingJob.signingNonceCommitments,
+        adaptorPubKey: new Uint8Array()
+      });
+      const userSignedTxSigningJob = {
+        leafId: signingJob.leafId,
+        signingPublicKey: signingJob.signingPublicKey,
+        rawTx: rawTx.toBytes(),
+        signingNonceCommitment: signingJob.signingNonceCommitment.commitment,
+        signingCommitments: {
+          signingCommitments: signingJob.signingNonceCommitments
+        },
+        userSignature
+      };
+      userSignedTxSigningJobs.set(signingJob.type, userSignedTxSigningJob);
+    }
+    return userSignedTxSigningJobs;
+  }
 };
 
 // src/utils/chunkArray.ts
@@ -11249,10 +10957,8 @@ var SparkWallet = class extends EventEmitter {
         }
       } else if (isDepositStreamEvent(event)) {
         const deposit = event.deposit.deposit;
-        const newLeaf = await this.transferService.extendTimelock(deposit);
-        await this.transferLeavesToSelf(newLeaf.nodes, {
-          type: "leaf" /* LEAF */,
-          path: deposit.id
+        await this.withLeaves(async () => {
+          this.leaves.push(deposit);
         });
         this.emit(
           SparkWalletEvent.DepositConfirmed,
@@ -11428,19 +11134,6 @@ var SparkWallet = class extends EventEmitter {
     }
     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 equalBytes6(addPublicKeys(pubkey1, pubkey2), verifyingKey);
   }
@@ -11612,10 +11305,8 @@ var SparkWallet = class extends EventEmitter {
   async syncWallet() {
     await this.syncTokenOutputs();
     let leaves = await this.getLeaves();
-    leaves = await this.checkRefreshTimelockNodes(leaves);
-    leaves = await this.checkExtendTimeLockNodes(leaves);
+    leaves = await this.checkRenewLeaves(leaves);
     this.leaves = leaves;
-    this.checkExtendLeaves(leaves);
     this.optimizeLeaves().catch((e) => {
       console.error("Failed to optimize leaves", e);
     });
@@ -11735,7 +11426,7 @@ var SparkWallet = class extends EventEmitter {
         mnemonic = mnemonicOrSeed;
         seed = await this.config.signer.mnemonicToSeed(mnemonicOrSeed);
       } else {
-        seed = hexToBytes13(mnemonicOrSeed);
+        seed = hexToBytes12(mnemonicOrSeed);
       }
     }
     await this.initWalletFromSeed(seed, accountNumber);
@@ -11878,7 +11569,7 @@ var SparkWallet = class extends EventEmitter {
       directFromCpfpSignatureMap
     } = await this.transferService.startSwapSignRefund(
       leafKeyTweaks,
-      hexToBytes13(this.config.getSspIdentityPublicKey()),
+      hexToBytes12(this.config.getSspIdentityPublicKey()),
       new Date(Date.now() + 2 * 60 * 1e3)
     );
     try {
@@ -12093,7 +11784,7 @@ var SparkWallet = class extends EventEmitter {
           throw new Error(`Leaf not found for node ${nodeId}`);
         }
         const cpfpNodeTx = getTxFromRawTxBytes(node.nodeTx);
-        const cpfpRefundTxBytes = hexToBytes13(leaf.rawUnsignedRefundTransaction);
+        const cpfpRefundTxBytes = hexToBytes12(leaf.rawUnsignedRefundTransaction);
         const cpfpRefundTx = getTxFromRawTxBytes(cpfpRefundTxBytes);
         const cpfpSighash = getSigHashFromTx(
           cpfpRefundTx,
@@ -12102,7 +11793,7 @@ var SparkWallet = class extends EventEmitter {
         );
         const nodePublicKey = node.verifyingPublicKey;
         const taprootKey = computeTaprootKeyNoScript(nodePublicKey.slice(1));
-        const cpfpAdaptorSignatureBytes = hexToBytes13(
+        const cpfpAdaptorSignatureBytes = hexToBytes12(
           leaf.adaptorSignedSignature
         );
         applyAdaptorToSignature(
@@ -12113,7 +11804,7 @@ var SparkWallet = class extends EventEmitter {
         );
         if (leaf.directRawUnsignedRefundTransaction) {
           const directNodeTx = getTxFromRawTxBytes(node.directTx);
-          const directRefundTxBytes = hexToBytes13(
+          const directRefundTxBytes = hexToBytes12(
             leaf.directRawUnsignedRefundTransaction
           );
           const directRefundTx = getTxFromRawTxBytes(directRefundTxBytes);
@@ -12127,7 +11818,7 @@ var SparkWallet = class extends EventEmitter {
               `Direct adaptor signed signature missing for node ${nodeId}`
             );
           }
-          const directAdaptorSignatureBytes = hexToBytes13(
+          const directAdaptorSignatureBytes = hexToBytes12(
             leaf.directAdaptorSignedSignature
           );
           applyAdaptorToSignature(
@@ -12138,7 +11829,7 @@ var SparkWallet = class extends EventEmitter {
           );
         }
         if (leaf.directFromCpfpRawUnsignedRefundTransaction) {
-          const directFromCpfpRefundTxBytes = hexToBytes13(
+          const directFromCpfpRefundTxBytes = hexToBytes12(
             leaf.directFromCpfpRawUnsignedRefundTransaction
           );
           const directFromCpfpRefundTx = getTxFromRawTxBytes(
@@ -12154,7 +11845,7 @@ var SparkWallet = class extends EventEmitter {
               `Direct adaptor signed signature missing for node ${nodeId}`
             );
           }
-          const directFromCpfpAdaptorSignatureBytes = hexToBytes13(
+          const directFromCpfpAdaptorSignatureBytes = hexToBytes12(
             leaf.directFromCpfpAdaptorSignedSignature
           );
           applyAdaptorToSignature(
@@ -12596,7 +12287,7 @@ var SparkWallet = class extends EventEmitter {
         }
       );
     }
-    const tx = new Transaction9();
+    const tx = new Transaction7();
     tx.addInput({
       txid: depositTransactionId,
       index: outputIndex,
@@ -12636,7 +12327,7 @@ var SparkWallet = class extends EventEmitter {
     );
     const swapResponse = await sparkClient.initiate_static_deposit_utxo_refund({
       onChainUtxo: {
-        txid: hexToBytes13(depositTransactionId),
+        txid: hexToBytes12(depositTransactionId),
         vout: outputIndex,
         network: networkType
       },
@@ -12763,7 +12454,7 @@ var SparkWallet = class extends EventEmitter {
     creditAmountView.setUint32(0, lowerHalf, true);
     creditAmountView.setUint32(4, upperHalf, true);
     parts.push(new Uint8Array(creditAmountBuffer));
-    parts.push(hexToBytes13(sspSignature));
+    parts.push(hexToBytes12(sspSignature));
     const totalLength = parts.reduce((sum2, part) => sum2 + part.length, 0);
     const payload = new Uint8Array(totalLength);
     let offset = 0;
@@ -12867,26 +12558,7 @@ var SparkWallet = class extends EventEmitter {
       depositTx,
       vout
     });
-    const resultingNodes = [];
-    for (const node of res.nodes) {
-      if (node.status === "AVAILABLE") {
-        const { nodes } = await this.transferService.extendTimelock(node);
-        for (const n of nodes) {
-          if (n.status === "AVAILABLE") {
-            const transfer = await this.transferLeavesToSelf([n], {
-              type: "leaf" /* LEAF */,
-              path: node.id
-            });
-            resultingNodes.push(...transfer);
-          } else {
-            resultingNodes.push(n);
-          }
-        }
-      } else {
-        resultingNodes.push(node);
-      }
-    }
-    return resultingNodes;
+    return res.nodes;
   }
   /**
    * Gets all unused deposit addresses for the wallet.
@@ -13028,6 +12700,9 @@ var SparkWallet = class extends EventEmitter {
         depositTx,
         vout
       });
+      await this.withLeaves(async () => {
+        this.leaves.push(...nodes2);
+      });
       return nodes2;
     });
     this.mutexes.delete(txid);
@@ -13157,7 +12832,7 @@ var SparkWallet = class extends EventEmitter {
     const [outcome] = await this.transferWithInvoice([
       {
         amountSats,
-        receiverIdentityPubkey: hexToBytes13(receiverAddress.identityPublicKey)
+        receiverIdentityPubkey: hexToBytes12(receiverAddress.identityPublicKey)
       }
     ]);
     if (!outcome) throw new Error("no transfer created");
@@ -13204,8 +12879,7 @@ var SparkWallet = class extends EventEmitter {
               `TreeNode group at index ${groupIndex} not found for amount ${amount} after selection`
             );
           }
-          let available = await this.checkRefreshTimelockNodes(group);
-          available = await this.checkExtendTimeLockNodes(available);
+          const available = await this.checkRenewLeaves(group);
           if (available.length < group.length) {
             throw new Error(
               `Not enough available nodes after refresh/extend. Expected ${group.length}, got ${available.length}`
@@ -13298,75 +12972,45 @@ var SparkWallet = class extends EventEmitter {
       newKeyDerivation: { type: "random" /* RANDOM */ }
     };
   }
-  async checkExtendTimeLockNodes(nodes) {
-    const nodesToExtend = [];
+  async checkRenewLeaves(nodes) {
+    const nodesToRenewNode = [];
+    const nodesToRenewRefund = [];
+    const nodesToRenewZeroTimelock = [];
     const nodeIds = [];
     const validNodes = [];
     for (const node of nodes) {
       const nodeTx = getTxFromRawTxBytes(node.nodeTx);
-      const sequence = nodeTx.getInput(0).sequence;
-      if (!sequence) {
+      const refundTx = getTxFromRawTxBytes(node.refundTx);
+      const nodeSequence = nodeTx.getInput(0).sequence;
+      const refundSequence = refundTx.getInput(0).sequence;
+      if (nodeSequence === void 0) {
         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 {
-        validNodes.push(node);
-      }
-    }
-    if (nodesToExtend.length === 0) {
-      return validNodes;
-    }
-    const nodesToAdd = [];
-    for (const node of nodesToExtend) {
-      const { nodes: nodes2 } = await this.transferService.extendTimelock(node);
-      this.leaves = this.leaves.filter((leaf) => leaf.id !== node.id);
-      const newNodes = await this.transferLeavesToSelf(nodes2, {
-        type: "leaf" /* LEAF */,
-        path: node.id
-      });
-      nodesToAdd.push(...newNodes);
-    }
-    this.updateLeaves(nodeIds, nodesToAdd);
-    validNodes.push(...nodesToAdd);
-    return validNodes;
-  }
-  /**
-   * Internal method to refresh timelock nodes.
-   *
-   * @param {string} nodeId - The optional ID of the node to refresh. If not provided, all nodes will be checked.
-   * @returns {Promise<void>}
-   * @private
-   */
-  async checkRefreshTimelockNodes(nodes) {
-    const nodesToRefresh = [];
-    const nodeIds = [];
-    const validNodes = [];
-    for (const node of nodes) {
-      const refundTx = getTxFromRawTxBytes(node.refundTx);
-      const sequence = refundTx.getInput(0).sequence;
-      if (!sequence) {
+      if (!refundSequence) {
         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);
+      if (doesTxnNeedRenewed(refundSequence)) {
+        if (isZeroTimelock(nodeSequence)) {
+          nodesToRenewZeroTimelock.push(node);
+        } else if (doesTxnNeedRenewed(nodeSequence)) {
+          nodesToRenewNode.push(node);
+        } else {
+          nodesToRenewRefund.push(node);
+        }
         nodeIds.push(node.id);
       } else {
         validNodes.push(node);
       }
     }
-    if (nodesToRefresh.length === 0) {
+    if (nodesToRenewNode.length === 0 && nodesToRenewRefund.length === 0 && nodesToRenewZeroTimelock.length === 0) {
       return validNodes;
     }
     const nodesResp = await this.queryNodes({
@@ -13384,7 +13028,18 @@ var SparkWallet = class extends EventEmitter {
       nodesMap.set(node.id, node);
     }
     const nodesToAdd = [];
-    for (const node of nodesToRefresh) {
+    for (const node of nodesToRenewNode) {
+      if (!node.parentNodeId) {
+        throw new Error(`node ${node.id} has no parent`);
+      }
+      const parentNode = nodesMap.get(node.parentNodeId);
+      if (!parentNode) {
+        throw new Error(`parent node ${node.parentNodeId} not found`);
+      }
+      const newNode = await this.transferService.renewNodeTxn(node, parentNode);
+      nodesToAdd.push(newNode);
+    }
+    for (const node of nodesToRenewRefund) {
       if (!node.parentNodeId) {
         throw new Error(`node ${node.id} has no parent`);
       }
@@ -13392,17 +13047,14 @@ var SparkWallet = class extends EventEmitter {
       if (!parentNode) {
         throw new Error(`parent node ${node.parentNodeId} not found`);
       }
-      const { nodes: nodes2 } = await this.transferService.refreshTimelockNodes(
+      const newNode = await this.transferService.renewRefundTxn(
         node,
         parentNode
       );
-      if (nodes2.length !== 1) {
-        throw new Error(`expected 1 node, got ${nodes2.length}`);
-      }
-      const newNode = nodes2[0];
-      if (!newNode) {
-        throw new Error("Failed to refresh timelock node");
-      }
+      nodesToAdd.push(newNode);
+    }
+    for (const node of nodesToRenewZeroTimelock) {
+      const newNode = await this.transferService.renewZeroTimelockNodeTxn(node);
       nodesToAdd.push(newNode);
     }
     this.updateLeaves(nodeIds, nodesToAdd);
@@ -13444,8 +13096,7 @@ var SparkWallet = class extends EventEmitter {
     });
   }
   async processClaimedTransferResults(result, transfer, emit, optimize) {
-    result = await this.checkRefreshTimelockNodes(result);
-    result = await this.checkExtendTimeLockNodes(result);
+    result = await this.checkRenewLeaves(result);
     const existingIds = new Set(this.leaves.map((leaf) => leaf.id));
     const uniqueResults = result.filter((node) => !existingIds.has(node.id));
     this.leaves.push(...uniqueResults);
@@ -13779,7 +13430,7 @@ var SparkWallet = class extends EventEmitter {
     const sparkFallbackAddress = decodedInvoice.fallbackAddress;
     const paymentHash = decodedInvoice.paymentHash;
     if (preferSpark) {
-      if (sparkFallbackAddress === void 0 || isValidSparkFallback(hexToBytes13(sparkFallbackAddress)) === false) {
+      if (sparkFallbackAddress === void 0 || isValidSparkFallback(hexToBytes12(sparkFallbackAddress)) === false) {
         console.warn(
           "No valid spark address found in invoice. Defaulting to lightning."
         );
@@ -13824,8 +13475,7 @@ var SparkWallet = class extends EventEmitter {
         selectedLeaves,
         `no leaves for ${totalAmount}`
       );
-      leaves = await this.checkRefreshTimelockNodes(leaves);
-      leaves = await this.checkExtendTimeLockNodes(leaves);
+      leaves = await this.checkRenewLeaves(leaves);
       const leavesToSend = await Promise.all(
         leaves.map(async (leaf) => ({
           leaf,
@@ -13841,17 +13491,17 @@ var SparkWallet = class extends EventEmitter {
       const transferID = uuidv74();
       const startTransferRequest = await this.transferService.prepareTransferForLightning(
         leavesToSend,
-        hexToBytes13(this.config.getSspIdentityPublicKey()),
-        hexToBytes13(paymentHash),
+        hexToBytes12(this.config.getSspIdentityPublicKey()),
+        hexToBytes12(paymentHash),
         expiryTime,
         transferID
       );
       const swapResponse = await this.lightningService.swapNodesForPreimage({
         leaves: leavesToSend,
-        receiverIdentityPubkey: hexToBytes13(
+        receiverIdentityPubkey: hexToBytes12(
           this.config.getSspIdentityPublicKey()
         ),
-        paymentHash: hexToBytes13(paymentHash),
+        paymentHash: hexToBytes12(paymentHash),
         isInboundPayment: false,
         invoiceString: invoice,
         feeSats: feeEstimate,
@@ -13954,7 +13604,7 @@ var SparkWallet = class extends EventEmitter {
         }
         satsInvoices.push({
           amountSats: encodedAmount ?? Number(amount),
-          receiverIdentityPubkey: hexToBytes13(addressData.identityPublicKey),
+          receiverIdentityPubkey: hexToBytes12(addressData.identityPublicKey),
           sparkInvoice: invoice
         });
       } else if (fields.paymentType?.type === "tokens") {
@@ -14156,10 +13806,8 @@ var SparkWallet = class extends EventEmitter {
       leavesToSendToSsp = leavesForTargetAmount;
       leavesToSendToSE = leavesForFee;
     }
-    leavesToSendToSsp = await this.checkRefreshTimelockNodes(leavesToSendToSsp);
-    leavesToSendToSsp = await this.checkExtendTimeLockNodes(leavesToSendToSsp);
-    leavesToSendToSE = await this.checkRefreshTimelockNodes(leavesToSendToSE);
-    leavesToSendToSE = await this.checkExtendTimeLockNodes(leavesToSendToSE);
+    leavesToSendToSsp = await this.checkRenewLeaves(leavesToSendToSsp);
+    leavesToSendToSE = await this.checkRenewLeaves(leavesToSendToSE);
     const leafKeyTweaks = await Promise.all(
       [...leavesToSendToSE, ...leavesToSendToSsp].map(async (leaf) => ({
         leaf,
@@ -14204,11 +13852,11 @@ var SparkWallet = class extends EventEmitter {
     const connectorOutputs = [];
     for (let i = 0; i < connectorTx.outputsLength - 1; i++) {
       connectorOutputs.push({
-        txid: hexToBytes13(connectorTxId),
+        txid: hexToBytes12(connectorTxId),
         index: i
       });
     }
-    const sspPubIdentityKey = hexToBytes13(this.config.getSspIdentityPublicKey());
+    const sspPubIdentityKey = hexToBytes12(this.config.getSspIdentityPublicKey());
     const transfer = await this.coopExitService.getConnectorRefundSignatures({
       leaves: leafKeyTweaks,
       exitTxId: coopExitTxId,
@@ -14245,8 +13893,7 @@ var SparkWallet = class extends EventEmitter {
       (await this.selectLeaves([amountSats])).get(amountSats),
       `no leaves for ${amountSats}`
     );
-    leaves = await this.checkRefreshTimelockNodes(leaves);
-    leaves = await this.checkExtendTimeLockNodes(leaves);
+    leaves = await this.checkRenewLeaves(leaves);
     const feeEstimate = await sspClient.getCoopExitFeeQuote({
       leafExternalIds: leaves.map((leaf) => leaf.id),
       withdrawalAddress
@@ -14521,7 +14168,7 @@ var SparkWallet = class extends EventEmitter {
   async validateMessageWithIdentityKey(message, signature) {
     const hash = sha25613(message);
     if (typeof signature === "string") {
-      signature = hexToBytes13(signature);
+      signature = hexToBytes12(signature);
     }
     return this.config.signer.validateMessageWithIdentityKey(hash, signature);
   }
@@ -14534,7 +14181,7 @@ var SparkWallet = class extends EventEmitter {
    */
   async signTransaction(txHex, keyType = "auto-detect") {
     try {
-      const tx = Transaction9.fromRaw(hexToBytes13(txHex));
+      const tx = Transaction7.fromRaw(hexToBytes12(txHex));
       let publicKey;
       switch (keyType.toLowerCase()) {
         case "identity":
@@ -14741,15 +14388,6 @@ var SparkWallet = class extends EventEmitter {
           }
         );
       }
-      if (!nodeInput.sequence) {
-        throw new ValidationError(
-          `Node transaction has no sequence for ${isRootNode ? "root" : "non-root"} node`,
-          {
-            field: "sequence",
-            value: nodeInput.sequence
-          }
-        );
-      }
       const refundInput = refundTx.getInput(0);
       if (!refundInput) {
         throw new ValidationError(
@@ -14785,89 +14423,6 @@ var SparkWallet = class extends EventEmitter {
       );
     }
   }
-  /**
-   * Refresh the timelock of a specific node.
-   *
-   * @param {string} nodeId - The ID of the node to refresh
-   * @returns {Promise<void>} Promise that resolves when the timelock is refreshed
-   */
-  async testOnly_expireTimelock(nodeId) {
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    try {
-      const response = await sparkClient.query_nodes({
-        source: {
-          $case: "nodeIds",
-          nodeIds: {
-            nodeIds: [nodeId]
-          }
-        },
-        includeParents: true
-      });
-      let leaf = response.nodes[nodeId];
-      if (!leaf) {
-        throw new ValidationError("Node not found", {
-          field: "nodeId",
-          value: nodeId
-        });
-      }
-      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
-          });
-        }
-      }
-      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
-            });
-          }
-          leaf = expiredNodeTxLeaf.nodes[0];
-        }
-      }
-      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 timelock",
-        {
-          method: "refresh_timelock"
-        },
-        error
-      );
-    }
-  }
   cleanup() {
     if (this.claimTransfersInterval) {
       clearInterval(this.claimTransfersInterval);
@@ -15022,8 +14577,7 @@ var SparkWallet = class extends EventEmitter {
       "getLightningReceiveRequest",
       "getLightningSendRequest",
       "getCoopExitRequest",
-      "checkTimelock",
-      "testOnly_expireTimelock"
+      "checkTimelock"
     ];
     methods.forEach((m) => this.wrapPublicSparkWalletMethodWithOtelSpan(m));
     this.initWallet = this.wrapWithOtelSpan(
@@ -15074,23 +14628,26 @@ export {
   HTLC_TIMELOCK_OFFSET,
   DIRECT_HTLC_TIMELOCK_OFFSET,
   INITIAL_SEQUENCE,
-  INITIAL_DIRECT_SEQUENCE,
   TEST_UNILATERAL_SEQUENCE,
   TEST_UNILATERAL_DIRECT_SEQUENCE,
   DEFAULT_FEE_SATS,
   maybeApplyFee,
-  createRootTx,
-  createSplitTx,
-  createNodeTx,
-  createNodeTxs,
-  createLeafNodeTx,
-  createRefundTx,
+  createRootNodeTx,
+  createZeroTimelockNodeTx,
+  createInitialTimelockNodeTx,
+  createDecrementedTimelockNodeTx,
+  createTestUnilateralTimelockNodeTx,
   getNextHTLCTransactionSequence,
-  createRefundTxs,
-  createConnectorRefundTransactions,
+  createInitialTimelockRefundTxs,
+  createDecrementedTimelockRefundTxs,
+  createCurrentTimelockRefundTxs,
+  createTestUnilateralRefundTxs,
+  createConnectorRefundTxs,
   getCurrentTimelock,
   getTransactionSequence,
   checkIfValidSequence,
+  isZeroTimelock,
+  doesTxnNeedRenewed,
   doesLeafNeedRefresh,
   getNextTransactionSequence,
   getEphemeralAnchorOutput,