@buildonspark/spark-sdk 0.3.8 → 0.4.0

package/dist/{chunk-FP2CRVQH.js → chunk-G3LHXHF3.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,
@@ -335,7 +335,11 @@ var BASE_CONFIG = {
   console: {
     otel: false
   },
-  events: {}
+  events: {},
+  optimizationOptions: {
+    auto: true,
+    multiplicity: 0
+  }
 };
 var LOCAL_WALLET_CONFIG = {
   ...BASE_CONFIG,
@@ -546,6 +550,9 @@ var WalletConfigService = class {
   getEvents() {
     return this.config.events;
   }
+  getOptimizationOptions() {
+    return this.config.optimizationOptions;
+  }
 };
 
 // src/utils/bitcoin.ts
@@ -700,6 +707,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 +716,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 +728,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 +739,10 @@ function createNodeTx({
     version: 3,
     allowUnknownOutputs: true
   });
-  nodeTx.addInput(parentOutPoint);
+  nodeTx.addInput({
+    ...parentOutPoint,
+    sequence
+  });
   if (applyFee) {
     nodeTx.addOutput({
       script: txOut.script,
@@ -800,52 +756,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 +897,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 +1018,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 +1035,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 +1050,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 +1073,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 +1082,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 +1210,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 +1264,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 +1383,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 +1686,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 +1852,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 +2044,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 +2548,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 +3868,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 +3941,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 +4204,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 +4213,7 @@ var TokenTransactionService = class {
         );
         return tokenIdentifier;
       }),
-      tokenTransactionHashes: tokenTransactionHashes?.map(hexToBytes5),
+      tokenTransactionHashes: tokenTransactionHashes?.map(hexToBytes6),
       outputIds: outputIds || [],
       limit: pageSize,
       offset
@@ -4345,7 +4318,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 +4340,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 +4356,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 +4373,7 @@ var TokenTransactionService = class {
       }
       inputTtxoSignaturesPerOperator.push({
         ttxoSignatures,
-        operatorIdentityPublicKey: hexToBytes5(operator.identityPublicKey)
+        operatorIdentityPublicKey: hexToBytes6(operator.identityPublicKey)
       });
     }
     return inputTtxoSignaturesPerOperator;
@@ -4830,7 +4803,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 +4821,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.4.0" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -5228,7 +5201,7 @@ var DefaultSparkSigner = class {
   }
   async createSparkWalletFromSeed(seed, accountNumber) {
     if (typeof seed === "string") {
-      seed = hexToBytes6(seed);
+      seed = hexToBytes7(seed);
     }
     const {
       identityKey,
@@ -5367,7 +5340,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 +5367,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 +5453,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 +5519,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)
@@ -5609,6 +5582,14 @@ var BitcoinFaucet = class _BitcoinFaucet {
   async mineBlocks(numBlocks) {
     return await this.generateToAddress(numBlocks, this.miningAddress);
   }
+  async mineBlocksAndWaitForMiningToComplete(numBlocks) {
+    const startBlock = await this.getBlockCount();
+    await this.mineBlocks(numBlocks);
+    await this.waitForBlocksMined({
+      startBlock,
+      expectedIncrease: numBlocks
+    });
+  }
   async call(method, params) {
     try {
       const { fetch, Headers: Headers2 } = getFetch();
@@ -5661,15 +5642,50 @@ var BitcoinFaucet = class _BitcoinFaucet {
   async getBlock(blockHash) {
     return await this.call("getblock", [blockHash, 2]);
   }
+  async getBlockCount() {
+    return await this.call("getblockcount", []);
+  }
+  async waitForBlocksMined({
+    startBlock,
+    expectedIncrease,
+    timeoutMs = 3e4,
+    intervalMs = 5e3
+  }) {
+    const deadline = Date.now() + timeoutMs;
+    await new Promise((r) => setTimeout(r, intervalMs));
+    const start = startBlock;
+    const target = start + expectedIncrease;
+    while (Date.now() < deadline) {
+      const currentBlock = await this.getBlockCount();
+      if (currentBlock >= target) return currentBlock;
+      await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    throw new Error(
+      `Timed out waiting for ${expectedIncrease} blocks (target height ${target})`
+    );
+  }
   async broadcastTx(txHex) {
     let response = await this.call("sendrawtransaction", [txHex, 0]);
     return response;
   }
+  async submitPackage(txHexs) {
+    let response = await this.call("submitpackage", [txHexs]);
+    return response;
+  }
   async getNewAddress() {
     const key = secp256k19.utils.randomPrivateKey();
     const pubKey = secp256k19.getPublicKey(key);
     return getP2TRAddressFromPublicKey(pubKey, 4 /* LOCAL */);
   }
+  async getNewExternalWallet() {
+    const key = secp256k19.utils.randomPrivateKey();
+    const pubKey = secp256k19.getPublicKey(key);
+    return {
+      address: getP2TRAddressFromPublicKey(pubKey, 4 /* LOCAL */),
+      key,
+      pubKey
+    };
+  }
   async sendToAddress(address, amount, blocksToGenerate = 1) {
     const coin = await this.fund();
     if (!coin) {
@@ -6635,7 +6651,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 +6666,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 +6755,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 +6869,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 +6924,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 +7039,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 +7155,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 +7177,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,
@@ -7214,12 +7232,14 @@ __export(utils_exports, {
   getTxFromRawTxHex: () => getTxFromRawTxHex,
   getTxId: () => getTxId,
   getTxIdNoReverse: () => getTxIdNoReverse,
+  hash160: () => hash160,
   isEphemeralAnchorOutput: () => isEphemeralAnchorOutput,
   isLegacySparkAddress: () => isLegacySparkAddress,
   isSafeForNumber: () => isSafeForNumber,
   isTxBroadcast: () => isTxBroadcast,
   isValidPublicKey: () => isValidPublicKey,
   isValidSparkAddress: () => isValidSparkAddress,
+  isZeroTimelock: () => isZeroTimelock,
   lastKeyWithTarget: () => lastKeyWithTarget,
   maybeApplyFee: () => maybeApplyFee,
   modInverse: () => modInverse,
@@ -7246,11 +7266,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 +8392,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 +9081,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 +9314,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 +9442,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 newCpfpNodeOutput = newNodeTx.getOutput(0);
+    if (!newCpfpNodeOutput) {
+      throw Error("Could not get new cpfp node output");
     }
-    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
-      }),
+    const newDirectNodeOutput = newDirectNodeTx?.getOutput(0);
+    const amountSats = refundTx.getOutput(0).amount;
+    if (amountSats === void 0) {
+      throw new Error("Amount not found in extendTimelock");
+    }
+    const directAmountSats = newDirectNodeOutput?.amount;
+    if (directAmountSats === void 0) {
+      throw new Error("Amount not found in extendTimelock");
+    }
+    const {
+      cpfpRefundTx: newRefundTx,
+      directRefundTx: newDirectRefundTx,
+      directFromCpfpRefundTx: newDirectFromCpfpRefundTx
+    } = createInitialTimelockRefundTxs({
+      nodeTx: newNodeTx,
+      directNodeTx: newDirectNodeTx,
+      receivingPubkey: signingPublicKey,
       network: this.config.getNetwork()
     });
     signingJobs.push({
       signingPublicKey,
-      rawTx: cpfpRefundTx.toBytes(),
+      rawTx: newRefundTx.toBytes(),
       signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
       type: "cpfp",
-      parentTxOut: newCpfpNodeOutput
+      parentTxOut: newCpfpNodeOutput,
+      leafId: node.id,
+      keyDerivation,
+      verifyingKey: node.verifyingPublicKey
     });
-    if (directRefundTx && newDirectNodeOutput) {
+    if (newDirectRefundTx && newDirectNodeOutput) {
       signingJobs.push({
         signingPublicKey,
-        rawTx: directRefundTx.toBytes(),
+        rawTx: newDirectRefundTx.toBytes(),
         signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
         type: "direct",
-        parentTxOut: newDirectNodeOutput
+        parentTxOut: newDirectNodeOutput,
+        leafId: node.id,
+        keyDerivation,
+        verifyingKey: node.verifyingPublicKey
       });
     }
-    if (directFromCpfpRefundTx && newCpfpNodeOutput) {
+    if (newDirectFromCpfpRefundTx && newDirectNodeOutput) {
       signingJobs.push({
         signingPublicKey,
-        rawTx: directFromCpfpRefundTx.toBytes(),
+        rawTx: newDirectFromCpfpRefundTx.toBytes(),
         signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
         type: "directFromCpfp",
-        parentTxOut: newCpfpNodeOutput
+        parentTxOut: newCpfpNodeOutput,
+        leafId: node.id,
+        keyDerivation,
+        verifyingKey: node.verifyingPublicKey
       });
     }
-    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);
+    return signingJobs;
   }
-  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 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 {
-      cpfpRefundTx: newCpfpRefundTx,
-      directRefundTx: newDirectRefundTx,
-      directFromCpfpRefundTx: newDirectFromCpfpRefundTx
-    } = createRefundTxs({
-      sequence: INITIAL_SEQUENCE,
-      directSequence: INITIAL_DIRECT_SEQUENCE,
-      input: newCpfpRefundOutPoint,
-      directInput: newDirectRefundOutPoint,
-      amountSats,
-      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)
+  async createRenewNodeSigningJobs(node, parentNode) {
+    const signingJobs = [];
+    const parentTx = getTxFromRawTxBytes(parentNode.nodeTx);
+    const parentNodeOutput = getTxFromRawTxBytes(parentNode.nodeTx).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 unsignedParentNodeOutput = {
+      script: parentNodeOutput.script,
+      amount: parentNodeOutput.amount
     };
-    const newDirectRefundSigningJob = newDirectRefundTx ? {
-      signingPublicKey,
-      rawTx: newDirectRefundTx.toBytes(),
-      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
-    } : void 0;
-    const newDirectFromCpfpRefundSigningJob = newDirectFromCpfpRefundTx ? {
-      signingPublicKey,
-      rawTx: newDirectFromCpfpRefundTx.toBytes(),
-      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
-    } : void 0;
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    const response = await sparkClient.extend_leaf_v2({
-      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
-    });
-    if (!response.nodeTxSigningResult || !response.refundTxSigningResult) {
-      throw new Error("Signing result does not exist");
-    }
     const keyDerivation = {
       type: "leaf" /* LEAF */,
       path: node.id
     };
-    const nodeUserSig = await this.config.signer.signFrost({
-      message: nodeSighash,
+    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()
+      verifyingKey: node.verifyingPublicKey
     });
-    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()
-    });
-    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()
+      verifyingKey: node.verifyingPublicKey
     });
-    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()
-    });
-    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()
-      });
-      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()
+        verifyingKey: node.verifyingPublicKey
       });
     }
-    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 +9776,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 +9809,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 +10322,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 +10412,7 @@ function createLightningHTLCTransaction({
     txid: hexToBytes11(getTxId(nodeTx)),
     index: 0
   };
-  const htlcTransaction = new Transaction8({
+  const htlcTransaction = new Transaction6({
     version: 3,
     allowUnknownOutputs: true
   });
@@ -10780,20 +10531,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 +10541,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 +10571,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 +10597,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,
@@ -10987,21 +10717,116 @@ var SigningService = class {
         directFromCpfpLeafSigningJobs.push(...signingJobs2);
       }
     }
-    return {
-      cpfpLeafSigningJobs,
-      directLeafSigningJobs,
-      directFromCpfpLeafSigningJobs
-    };
-  }
-};
-
-// src/utils/chunkArray.ts
-function chunkArray(arr, size) {
-  const chunks = [];
-  for (let i = 0; i < arr.length; i += size) {
-    chunks.push(arr.slice(i, i + size));
+    return {
+      cpfpLeafSigningJobs,
+      directLeafSigningJobs,
+      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
+function chunkArray(arr, size) {
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
+  }
+  return chunks;
+}
+
+// src/utils/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxAttempts: 5,
+  baseDelayMs: 1e3,
+  maxDelayMs: 1e4,
+  backoffFactor: 2
+};
+function calculateBackoffDelay(attempt, config) {
+  const delay = config.baseDelayMs * Math.pow(config.backoffFactor, attempt - 1);
+  return Math.min(delay, config.maxDelayMs);
+}
+async function withRetry(operation, options = {}) {
+  const config = options.config ?? DEFAULT_RETRY_CONFIG;
+  const callbacks = options.callbacks ?? {};
+  const { fetchData, onRetry, onError, onMaxAttemptsReached, onStart } = callbacks;
+  if (onStart) {
+    await onStart();
+  }
+  let currentData = void 0;
+  for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
+    try {
+      if (attempt > 1 && fetchData) {
+        const context = {
+          attempt,
+          maxAttempts: config.maxAttempts,
+          error: new Error("Placeholder"),
+          delayMs: calculateBackoffDelay(attempt, config),
+          data: currentData
+        };
+        currentData = await fetchData(context);
+      }
+      return await operation(currentData);
+    } catch (error) {
+      const lastError = error instanceof Error ? error : new Error(String(error));
+      const delayMs = calculateBackoffDelay(attempt, config);
+      const context = {
+        attempt,
+        maxAttempts: config.maxAttempts,
+        error: lastError,
+        delayMs,
+        data: currentData
+      };
+      if (onError) {
+        const result = await onError(context);
+        if (result) {
+          return result;
+        }
+      }
+      if (attempt === config.maxAttempts) {
+        if (onMaxAttemptsReached) {
+          const result = await onMaxAttemptsReached(context);
+          if (result) {
+            return result;
+          }
+        }
+        throw lastError;
+      }
+      if (onRetry) {
+        await onRetry(context);
+      }
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
   }
-  return chunks;
+  throw new Error("Unexpected retry loop exit");
 }
 
 // src/utils/optimize.ts
@@ -11020,6 +10845,34 @@ function sorted(arr) {
 function equals(a, b) {
   return a.length === b.length && a.every((val, index) => val === b[index]);
 }
+function countOccurrences(arr) {
+  const map = /* @__PURE__ */ new Map();
+  for (const x of arr) {
+    map.set(x, (map.get(x) ?? 0) + 1);
+  }
+  return map;
+}
+function subtractCounters(a, b) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [key, value] of a.entries()) {
+    const diff = value - (b.get(key) ?? 0);
+    if (diff > 0) {
+      result.set(key, diff);
+    }
+  }
+  return result;
+}
+function counterToFlatArray(counter) {
+  const arr = [];
+  for (const [k, v] of Array.from(counter.entries()).sort(
+    (a, b) => a[0] - b[0]
+  )) {
+    for (let i = 0; i < v; i++) {
+      arr.push(k);
+    }
+  }
+  return arr;
+}
 function greedyLeaves(amount) {
   const leaves = [];
   let remaining = amount;
@@ -11035,6 +10888,24 @@ function greedyLeaves(amount) {
   assert(sum(leaves) === amount, "greedy_leaves: sum mismatch");
   return sorted(leaves);
 }
+function swapMinimizingLeaves(amount, multiplicity = 1) {
+  const leaves = [];
+  let remaining = amount;
+  assert(multiplicity > 0, "multiplicity must be > 0");
+  for (const leaf of DENOMINATIONS) {
+    if (typeof leaf === "number" && leaf > 0) {
+      for (let i = 0; i < multiplicity; i++) {
+        if (remaining >= leaf) {
+          remaining -= leaf;
+          leaves.push(leaf);
+        }
+      }
+    }
+  }
+  leaves.push(...greedyLeaves(remaining));
+  assert(sum(leaves) === amount, "swap_minimizing_leaves: sum mismatch");
+  return sorted(leaves);
+}
 var Swap = class {
   inLeaves;
   outLeaves;
@@ -11072,71 +10943,83 @@ function maximizeUnilateralExit(inputLeaves, maxLeavesPerSwap = 64) {
   }
   return swaps;
 }
-
-// src/utils/retry.ts
-var DEFAULT_RETRY_CONFIG = {
-  maxAttempts: 5,
-  baseDelayMs: 1e3,
-  maxDelayMs: 1e4,
-  backoffFactor: 2
-};
-function calculateBackoffDelay(attempt, config) {
-  const delay = config.baseDelayMs * Math.pow(config.backoffFactor, attempt - 1);
-  return Math.min(delay, config.maxDelayMs);
-}
-async function withRetry(operation, options = {}) {
-  const config = options.config ?? DEFAULT_RETRY_CONFIG;
-  const callbacks = options.callbacks ?? {};
-  const { fetchData, onRetry, onError, onMaxAttemptsReached, onStart } = callbacks;
-  if (onStart) {
-    await onStart();
-  }
-  let currentData = void 0;
-  for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
-    try {
-      if (attempt > 1 && fetchData) {
-        const context = {
-          attempt,
-          maxAttempts: config.maxAttempts,
-          error: new Error("Placeholder"),
-          delayMs: calculateBackoffDelay(attempt, config),
-          data: currentData
-        };
-        currentData = await fetchData(context);
-      }
-      return await operation(currentData);
-    } catch (error) {
-      const lastError = error instanceof Error ? error : new Error(String(error));
-      const delayMs = calculateBackoffDelay(attempt, config);
-      const context = {
-        attempt,
-        maxAttempts: config.maxAttempts,
-        error: lastError,
-        delayMs,
-        data: currentData
-      };
-      if (onError) {
-        const result = await onError(context);
-        if (result) {
-          return result;
-        }
-      }
-      if (attempt === config.maxAttempts) {
-        if (onMaxAttemptsReached) {
-          const result = await onMaxAttemptsReached(context);
-          if (result) {
-            return result;
+function minimizeTransferSwap(inputLeaves, multiplicity = 1, maxLeavesPerSwap = 64) {
+  const balance = sum(inputLeaves);
+  const optimalLeaves = swapMinimizingLeaves(balance, multiplicity);
+  const walletCounter = countOccurrences(inputLeaves);
+  const optimalCounter = countOccurrences(optimalLeaves);
+  const leavesToGive = subtractCounters(walletCounter, optimalCounter);
+  const leavesToReceive = subtractCounters(optimalCounter, walletCounter);
+  const leavesToGiveFlat = counterToFlatArray(leavesToGive);
+  const leavesToReceiveFlat = counterToFlatArray(leavesToReceive);
+  const swaps = [];
+  let toGiveBatch = [];
+  let toReceiveBatch = [];
+  let give = [...leavesToGiveFlat];
+  let receive = [...leavesToReceiveFlat];
+  while (give.length > 0 || receive.length > 0) {
+    if (sum(toGiveBatch) > sum(toReceiveBatch)) {
+      if (receive.length === 0) break;
+      toReceiveBatch.push(receive.shift());
+    } else {
+      if (give.length === 0) break;
+      toGiveBatch.push(give.shift());
+    }
+    if (toGiveBatch.length > 0 && toReceiveBatch.length > 0 && sum(toGiveBatch) === sum(toReceiveBatch)) {
+      if (toGiveBatch.length > maxLeavesPerSwap) {
+        for (let i = 0; i < toGiveBatch.length; i += maxLeavesPerSwap) {
+          const subset = toGiveBatch.slice(i, i + maxLeavesPerSwap);
+          swaps.push(new Swap(subset, greedyLeaves(sum(subset))));
+        }
+      } else if (toReceiveBatch.length > maxLeavesPerSwap) {
+        for (let cutoff = maxLeavesPerSwap; cutoff > 0; cutoff--) {
+          const sumCut = sum(toReceiveBatch.slice(0, cutoff));
+          const remainder = sum(toGiveBatch) - sumCut;
+          const alternateBatch = [
+            ...toReceiveBatch.slice(0, cutoff),
+            ...greedyLeaves(remainder)
+          ];
+          if (alternateBatch.length <= maxLeavesPerSwap) {
+            swaps.push(new Swap([...toGiveBatch], alternateBatch));
+            break;
           }
         }
-        throw lastError;
-      }
-      if (onRetry) {
-        await onRetry(context);
+      } else {
+        swaps.push(new Swap([...toGiveBatch], [...toReceiveBatch]));
       }
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      toGiveBatch = [];
+      toReceiveBatch = [];
     }
   }
-  throw new Error("Unexpected retry loop exit");
+  return swaps;
+}
+function shouldOptimize(inputLeaves, multiplicity = 1, maxLeavesPerSwap = 64) {
+  if (multiplicity == 0) {
+    const swaps = maximizeUnilateralExit(inputLeaves, maxLeavesPerSwap);
+    const numInputs = sum(swaps.map((swap) => swap.inLeaves.length));
+    const numOutputs = sum(swaps.map((swap) => swap.outLeaves.length));
+    return numOutputs * 5 < numInputs;
+  } else {
+    const swaps = minimizeTransferSwap(
+      inputLeaves,
+      multiplicity,
+      maxLeavesPerSwap
+    );
+    const inputCounter = countOccurrences(
+      swaps.flatMap((swap) => swap.inLeaves)
+    );
+    const outputCounter = countOccurrences(
+      swaps.flatMap((swap) => swap.outLeaves)
+    );
+    return Math.abs(inputCounter.size - outputCounter.size) > 1;
+  }
+}
+function optimize(inputLeaves, multiplicity = 1, maxLeavesPerSwap = 64) {
+  if (multiplicity == 0) {
+    return maximizeUnilateralExit(inputLeaves, maxLeavesPerSwap);
+  } else {
+    return minimizeTransferSwap(inputLeaves, multiplicity, maxLeavesPerSwap);
+  }
 }
 
 // src/spark-wallet/spark-wallet.ts
@@ -11243,16 +11126,13 @@ var SparkWallet = class extends EventEmitter {
         if (event.transfer.transfer && !equalBytes6(senderIdentityPublicKey, receiverIdentityPublicKey)) {
           await this.claimTransfer({
             transfer: event.transfer.transfer,
-            emit: true,
-            optimize: true
+            emit: true
           });
         }
       } 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 +11308,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);
   }
@@ -11550,75 +11417,84 @@ var SparkWallet = class extends EventEmitter {
     }
     return nodes;
   }
-  areLeavesInefficient() {
-    const totalAmount = this.getInternalBalance();
-    if (this.leaves.length <= 1) {
-      return false;
-    }
-    const nextLowerPowerOfTwo = 31 - Math.clz32(totalAmount);
-    let remainingAmount = totalAmount;
-    let optimalLeavesLength = 0;
-    for (let i = nextLowerPowerOfTwo; i >= 0; i--) {
-      const denomination = 2 ** i;
-      while (remainingAmount >= denomination) {
-        remainingAmount -= denomination;
-        optimalLeavesLength++;
-      }
+  async *optimizeLeaves(multiplicity = void 0) {
+    const multiplicityValue = multiplicity ?? this.config.getOptimizationOptions().multiplicity ?? 0;
+    if (multiplicityValue < 0) {
+      throw new ValidationError("Multiplicity cannot be negative");
+    } else if (multiplicityValue > 5) {
+      throw new ValidationError("Multiplicity cannot be greater than 5");
     }
-    return this.leaves.length > optimalLeavesLength * 5;
-  }
-  async optimizeLeaves() {
-    if (this.optimizationInProgress || !this.areLeavesInefficient()) {
+    if (this.optimizationInProgress || !shouldOptimize(
+      this.leaves.map((leaf) => leaf.value),
+      multiplicityValue
+    )) {
       return;
     }
-    await this.withLeaves(async () => {
+    const controller = new AbortController();
+    const release = await this.leavesMutex.acquire();
+    try {
       this.optimizationInProgress = true;
-      try {
-        this.leaves = await this.getLeaves();
-        const swaps = maximizeUnilateralExit(
-          this.leaves.map((leaf) => leaf.value)
-        );
-        const valueToNodes = /* @__PURE__ */ new Map();
-        this.leaves.forEach((leaf) => {
-          if (!valueToNodes.has(leaf.value)) {
-            valueToNodes.set(leaf.value, []);
-          }
-          valueToNodes.get(leaf.value).push(leaf);
-        });
-        for (const swap of swaps) {
-          const leavesToSend = [];
-          for (const leafValue of swap.inLeaves) {
-            const nodes = valueToNodes.get(leafValue);
-            if (nodes && nodes.length > 0) {
-              const node = nodes.shift();
-              leavesToSend.push(node);
-            } else {
-              throw new InternalValidationError(
-                `No unused leaf with value ${leafValue} found in leaves`
-              );
-            }
+      this.leaves = await this.getLeaves();
+      const swaps = optimize(
+        this.leaves.map((leaf) => leaf.value),
+        multiplicityValue
+      );
+      if (swaps.length === 0) {
+        return;
+      }
+      yield {
+        step: 0,
+        total: swaps.length,
+        controller
+      };
+      const valueToNodes = /* @__PURE__ */ new Map();
+      this.leaves.forEach((leaf) => {
+        if (!valueToNodes.has(leaf.value)) {
+          valueToNodes.set(leaf.value, []);
+        }
+        valueToNodes.get(leaf.value).push(leaf);
+      });
+      for (const swap of swaps) {
+        if (controller.signal.aborted) {
+          break;
+        }
+        const leavesToSend = [];
+        for (const leafValue of swap.inLeaves) {
+          const nodes = valueToNodes.get(leafValue);
+          if (nodes && nodes.length > 0) {
+            const node = nodes.shift();
+            leavesToSend.push(node);
+          } else {
+            throw new InternalValidationError(
+              `No unused leaf with value ${leafValue} found in leaves`
+            );
           }
-          await this.requestLeavesSwap({
-            leaves: leavesToSend,
-            targetAmounts: swap.outLeaves
-          });
         }
-        this.leaves = await this.getLeaves();
-      } finally {
-        this.optimizationInProgress = false;
+        await this.requestLeavesSwap({
+          leaves: leavesToSend,
+          targetAmounts: swap.outLeaves
+        });
+        yield {
+          step: swaps.indexOf(swap) + 1,
+          total: swaps.length,
+          controller
+        };
       }
-    });
+      this.leaves = await this.getLeaves();
+    } finally {
+      this.optimizationInProgress = false;
+      release();
+    }
   }
   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);
-    });
+    if (this.config.getOptimizationOptions().auto) {
+      for await (const _ of this.optimizeLeaves()) {
+      }
+    }
   }
   async withLeaves(operation) {
     const release = await this.leavesMutex.acquire();
@@ -11735,7 +11611,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 +11754,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 +11969,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 +11978,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 +11989,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 +12003,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 +12014,7 @@ var SparkWallet = class extends EventEmitter {
           );
         }
         if (leaf.directFromCpfpRawUnsignedRefundTransaction) {
-          const directFromCpfpRefundTxBytes = hexToBytes13(
+          const directFromCpfpRefundTxBytes = hexToBytes12(
             leaf.directFromCpfpRawUnsignedRefundTransaction
           );
           const directFromCpfpRefundTx = getTxFromRawTxBytes(
@@ -12154,7 +12030,7 @@ var SparkWallet = class extends EventEmitter {
               `Direct adaptor signed signature missing for node ${nodeId}`
             );
           }
-          const directFromCpfpAdaptorSignatureBytes = hexToBytes13(
+          const directFromCpfpAdaptorSignatureBytes = hexToBytes12(
             leaf.directFromCpfpAdaptorSignedSignature
           );
           applyAdaptorToSignature(
@@ -12201,8 +12077,7 @@ var SparkWallet = class extends EventEmitter {
       }
       return await this.claimTransfer({
         transfer: incomingTransfer,
-        emit: false,
-        optimize: false
+        emit: false
       });
     } catch (e) {
       console.error("[processSwapBatch] Error details:", {
@@ -12596,7 +12471,7 @@ var SparkWallet = class extends EventEmitter {
         }
       );
     }
-    const tx = new Transaction9();
+    const tx = new Transaction7();
     tx.addInput({
       txid: depositTransactionId,
       index: outputIndex,
@@ -12636,7 +12511,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 +12638,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 +12742,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 +12884,9 @@ var SparkWallet = class extends EventEmitter {
         depositTx,
         vout
       });
+      await this.withLeaves(async () => {
+        this.leaves.push(...nodes2);
+      });
       return nodes2;
     });
     this.mutexes.delete(txid);
@@ -13157,7 +13016,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 +13063,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}`
@@ -13248,7 +13106,7 @@ var SparkWallet = class extends EventEmitter {
                 transfer.id
               );
               if (pending) {
-                await this.claimTransfer({ transfer: pending, optimize: true });
+                await this.claimTransfer({ transfer: pending });
               }
             }
             return {
@@ -13298,75 +13156,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 +13212,7 @@ 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`);
       }
@@ -13392,17 +13220,25 @@ 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.renewNodeTxn(node, parentNode);
+      nodesToAdd.push(newNode);
+    }
+    for (const node of nodesToRenewRefund) {
+      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.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);
@@ -13443,14 +13279,14 @@ var SparkWallet = class extends EventEmitter {
       return response.nodes;
     });
   }
-  async processClaimedTransferResults(result, transfer, emit, optimize) {
-    result = await this.checkRefreshTimelockNodes(result);
-    result = await this.checkExtendTimeLockNodes(result);
+  async processClaimedTransferResults(result, transfer, emit) {
+    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);
-    if (optimize && transfer.type !== 40 /* COUNTER_SWAP */) {
-      await this.optimizeLeaves();
+    if (this.config.getOptimizationOptions().auto && transfer.type !== 40 /* COUNTER_SWAP */) {
+      for await (const _ of this.optimizeLeaves()) {
+      }
     }
     if (emit) {
       this.emit(
@@ -13469,8 +13305,7 @@ var SparkWallet = class extends EventEmitter {
    */
   async claimTransfer({
     transfer,
-    emit,
-    optimize
+    emit
   }) {
     const onError = async (context) => {
       const error = context.error;
@@ -13515,12 +13350,7 @@ var SparkWallet = class extends EventEmitter {
       if (result.length === 0) {
         return [];
       }
-      return await this.processClaimedTransferResults(
-        result,
-        transfer,
-        emit,
-        optimize
-      );
+      return await this.processClaimedTransferResults(result, transfer, emit);
     } catch (error) {
       console.warn(
         `Failed to claim transfer after all retries. Please try reinitializing your wallet in a few minutes. Transfer ID: ${transfer.id}`,
@@ -13553,7 +13383,7 @@ var SparkWallet = class extends EventEmitter {
         continue;
       }
       promises.push(
-        this.claimTransfer({ transfer, emit, optimize: true }).then(() => transfer.id).catch((error) => {
+        this.claimTransfer({ transfer, emit }).then(() => transfer.id).catch((error) => {
           console.warn(`Failed to claim transfer ${transfer.id}:`, error);
           return null;
         })
@@ -13779,7 +13609,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 +13654,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 +13670,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 +13783,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 +13985,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 +14031,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 +14072,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 +14347,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 +14360,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 +14567,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 +14602,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 +14756,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 +14807,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,
@@ -15164,6 +14900,7 @@ export {
   isEphemeralAnchorOutput,
   constructUnilateralExitTxs,
   constructUnilateralExitFeeBumpPackages,
+  hash160,
   constructFeeBumpTx,
   getSparkAddressFromTaproot,
   utils_exports