@buildonspark/spark-sdk 0.3.8 → 0.4.0

package/dist/bare/index.js

@@ -170,11 +170,11 @@ import {
   bytesToHex as bytesToHex11,
   bytesToNumberBE as bytesToNumberBE8,
   equalBytes as equalBytes6,
-  hexToBytes as hexToBytes12
+  hexToBytes as hexToBytes11
 } 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 Transaction8 } from "@scure/btc-signer";
+import { Address as Address4, OutScript as OutScript3, Transaction as Transaction6 } from "@scure/btc-signer";
 import { Mutex } from "async-mutex";
 import { uuidv7 as uuidv74 } from "uuidv7";
 
@@ -4627,6 +4627,12 @@ var RenewLeafRequest = {
           writer.uint32(26).fork()
         ).join();
         break;
+      case "renewNodeZeroTimelockSigningJob":
+        RenewNodeZeroTimelockSigningJob.encode(
+          message.signingJobs.renewNodeZeroTimelockSigningJob,
+          writer.uint32(34).fork()
+        ).join();
+        break;
     }
     return writer;
   },
@@ -4664,6 +4670,16 @@ var RenewLeafRequest = {
           };
           continue;
         }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.signingJobs = {
+            $case: "renewNodeZeroTimelockSigningJob",
+            renewNodeZeroTimelockSigningJob: RenewNodeZeroTimelockSigningJob.decode(reader, reader.uint32())
+          };
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -4681,6 +4697,11 @@ var RenewLeafRequest = {
       } : isSet3(object.renewRefundTimelockSigningJob) ? {
         $case: "renewRefundTimelockSigningJob",
         renewRefundTimelockSigningJob: RenewRefundTimelockSigningJob.fromJSON(object.renewRefundTimelockSigningJob)
+      } : isSet3(object.renewNodeZeroTimelockSigningJob) ? {
+        $case: "renewNodeZeroTimelockSigningJob",
+        renewNodeZeroTimelockSigningJob: RenewNodeZeroTimelockSigningJob.fromJSON(
+          object.renewNodeZeroTimelockSigningJob
+        )
       } : void 0
     };
   },
@@ -4697,6 +4718,10 @@ var RenewLeafRequest = {
       obj.renewRefundTimelockSigningJob = RenewRefundTimelockSigningJob.toJSON(
         message.signingJobs.renewRefundTimelockSigningJob
       );
+    } else if (message.signingJobs?.$case === "renewNodeZeroTimelockSigningJob") {
+      obj.renewNodeZeroTimelockSigningJob = RenewNodeZeroTimelockSigningJob.toJSON(
+        message.signingJobs.renewNodeZeroTimelockSigningJob
+      );
     }
     return obj;
   },
@@ -4729,6 +4754,17 @@ var RenewLeafRequest = {
         }
         break;
       }
+      case "renewNodeZeroTimelockSigningJob": {
+        if (object.signingJobs?.renewNodeZeroTimelockSigningJob !== void 0 && object.signingJobs?.renewNodeZeroTimelockSigningJob !== null) {
+          message.signingJobs = {
+            $case: "renewNodeZeroTimelockSigningJob",
+            renewNodeZeroTimelockSigningJob: RenewNodeZeroTimelockSigningJob.fromPartial(
+              object.signingJobs.renewNodeZeroTimelockSigningJob
+            )
+          };
+        }
+        break;
+      }
     }
     return message;
   }
@@ -5003,6 +5039,125 @@ var RenewRefundTimelockSigningJob = {
     return message;
   }
 };
+function createBaseRenewNodeZeroTimelockSigningJob() {
+  return {
+    nodeTxSigningJob: void 0,
+    refundTxSigningJob: void 0,
+    directNodeTxSigningJob: void 0,
+    directRefundTxSigningJob: void 0,
+    directFromCpfpRefundTxSigningJob: void 0
+  };
+}
+var RenewNodeZeroTimelockSigningJob = {
+  encode(message, writer = new BinaryWriter4()) {
+    if (message.nodeTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.nodeTxSigningJob, writer.uint32(10).fork()).join();
+    }
+    if (message.refundTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.refundTxSigningJob, writer.uint32(18).fork()).join();
+    }
+    if (message.directNodeTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.directNodeTxSigningJob, writer.uint32(26).fork()).join();
+    }
+    if (message.directRefundTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.directRefundTxSigningJob, writer.uint32(34).fork()).join();
+    }
+    if (message.directFromCpfpRefundTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.directFromCpfpRefundTxSigningJob, writer.uint32(42).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader4 ? input : new BinaryReader4(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseRenewNodeZeroTimelockSigningJob();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.nodeTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.refundTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.directNodeTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.directRefundTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.directFromCpfpRefundTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      nodeTxSigningJob: isSet3(object.nodeTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.nodeTxSigningJob) : void 0,
+      refundTxSigningJob: isSet3(object.refundTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.refundTxSigningJob) : void 0,
+      directNodeTxSigningJob: isSet3(object.directNodeTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.directNodeTxSigningJob) : void 0,
+      directRefundTxSigningJob: isSet3(object.directRefundTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.directRefundTxSigningJob) : void 0,
+      directFromCpfpRefundTxSigningJob: isSet3(object.directFromCpfpRefundTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.directFromCpfpRefundTxSigningJob) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.nodeTxSigningJob !== void 0) {
+      obj.nodeTxSigningJob = UserSignedTxSigningJob.toJSON(message.nodeTxSigningJob);
+    }
+    if (message.refundTxSigningJob !== void 0) {
+      obj.refundTxSigningJob = UserSignedTxSigningJob.toJSON(message.refundTxSigningJob);
+    }
+    if (message.directNodeTxSigningJob !== void 0) {
+      obj.directNodeTxSigningJob = UserSignedTxSigningJob.toJSON(message.directNodeTxSigningJob);
+    }
+    if (message.directRefundTxSigningJob !== void 0) {
+      obj.directRefundTxSigningJob = UserSignedTxSigningJob.toJSON(message.directRefundTxSigningJob);
+    }
+    if (message.directFromCpfpRefundTxSigningJob !== void 0) {
+      obj.directFromCpfpRefundTxSigningJob = UserSignedTxSigningJob.toJSON(message.directFromCpfpRefundTxSigningJob);
+    }
+    return obj;
+  },
+  create(base) {
+    return RenewNodeZeroTimelockSigningJob.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseRenewNodeZeroTimelockSigningJob();
+    message.nodeTxSigningJob = object.nodeTxSigningJob !== void 0 && object.nodeTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.nodeTxSigningJob) : void 0;
+    message.refundTxSigningJob = object.refundTxSigningJob !== void 0 && object.refundTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.refundTxSigningJob) : void 0;
+    message.directNodeTxSigningJob = object.directNodeTxSigningJob !== void 0 && object.directNodeTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.directNodeTxSigningJob) : void 0;
+    message.directRefundTxSigningJob = object.directRefundTxSigningJob !== void 0 && object.directRefundTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.directRefundTxSigningJob) : void 0;
+    message.directFromCpfpRefundTxSigningJob = object.directFromCpfpRefundTxSigningJob !== void 0 && object.directFromCpfpRefundTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.directFromCpfpRefundTxSigningJob) : void 0;
+    return message;
+  }
+};
 function createBaseRenewLeafResponse() {
   return { renewResult: void 0 };
 }
@@ -5015,6 +5170,9 @@ var RenewLeafResponse = {
       case "renewRefundTimelockResult":
         RenewRefundTimelockResult.encode(message.renewResult.renewRefundTimelockResult, writer.uint32(18).fork()).join();
         break;
+      case "renewNodeZeroTimelockResult":
+        RenewNodeZeroTimelockResult.encode(message.renewResult.renewNodeZeroTimelockResult, writer.uint32(26).fork()).join();
+        break;
     }
     return writer;
   },
@@ -5045,6 +5203,16 @@ var RenewLeafResponse = {
           };
           continue;
         }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.renewResult = {
+            $case: "renewNodeZeroTimelockResult",
+            renewNodeZeroTimelockResult: RenewNodeZeroTimelockResult.decode(reader, reader.uint32())
+          };
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -5061,6 +5229,9 @@ var RenewLeafResponse = {
       } : isSet3(object.renewRefundTimelockResult) ? {
         $case: "renewRefundTimelockResult",
         renewRefundTimelockResult: RenewRefundTimelockResult.fromJSON(object.renewRefundTimelockResult)
+      } : isSet3(object.renewNodeZeroTimelockResult) ? {
+        $case: "renewNodeZeroTimelockResult",
+        renewNodeZeroTimelockResult: RenewNodeZeroTimelockResult.fromJSON(object.renewNodeZeroTimelockResult)
       } : void 0
     };
   },
@@ -5070,6 +5241,10 @@ var RenewLeafResponse = {
       obj.renewNodeTimelockResult = RenewNodeTimelockResult.toJSON(message.renewResult.renewNodeTimelockResult);
     } else if (message.renewResult?.$case === "renewRefundTimelockResult") {
       obj.renewRefundTimelockResult = RenewRefundTimelockResult.toJSON(message.renewResult.renewRefundTimelockResult);
+    } else if (message.renewResult?.$case === "renewNodeZeroTimelockResult") {
+      obj.renewNodeZeroTimelockResult = RenewNodeZeroTimelockResult.toJSON(
+        message.renewResult.renewNodeZeroTimelockResult
+      );
     }
     return obj;
   },
@@ -5099,6 +5274,17 @@ var RenewLeafResponse = {
         }
         break;
       }
+      case "renewNodeZeroTimelockResult": {
+        if (object.renewResult?.renewNodeZeroTimelockResult !== void 0 && object.renewResult?.renewNodeZeroTimelockResult !== null) {
+          message.renewResult = {
+            $case: "renewNodeZeroTimelockResult",
+            renewNodeZeroTimelockResult: RenewNodeZeroTimelockResult.fromPartial(
+              object.renewResult.renewNodeZeroTimelockResult
+            )
+          };
+        }
+        break;
+      }
     }
     return message;
   }
@@ -5222,6 +5408,74 @@ var RenewRefundTimelockResult = {
     return message;
   }
 };
+function createBaseRenewNodeZeroTimelockResult() {
+  return { splitNode: void 0, node: void 0 };
+}
+var RenewNodeZeroTimelockResult = {
+  encode(message, writer = new BinaryWriter4()) {
+    if (message.splitNode !== void 0) {
+      TreeNode.encode(message.splitNode, writer.uint32(10).fork()).join();
+    }
+    if (message.node !== void 0) {
+      TreeNode.encode(message.node, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader4 ? input : new BinaryReader4(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseRenewNodeZeroTimelockResult();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.splitNode = TreeNode.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.node = TreeNode.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      splitNode: isSet3(object.splitNode) ? TreeNode.fromJSON(object.splitNode) : void 0,
+      node: isSet3(object.node) ? TreeNode.fromJSON(object.node) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.splitNode !== void 0) {
+      obj.splitNode = TreeNode.toJSON(message.splitNode);
+    }
+    if (message.node !== void 0) {
+      obj.node = TreeNode.toJSON(message.node);
+    }
+    return obj;
+  },
+  create(base) {
+    return RenewNodeZeroTimelockResult.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseRenewNodeZeroTimelockResult();
+    message.splitNode = object.splitNode !== void 0 && object.splitNode !== null ? TreeNode.fromPartial(object.splitNode) : void 0;
+    message.node = object.node !== void 0 && object.node !== null ? TreeNode.fromPartial(object.node) : void 0;
+    return message;
+  }
+};
 function createBaseNodeSignatureShares() {
   return {
     nodeId: "",
@@ -17976,7 +18230,11 @@ var BASE_CONFIG = {
   console: {
     otel: false
   },
-  events: {}
+  events: {},
+  optimizationOptions: {
+    auto: true,
+    multiplicity: 0
+  }
 };
 var LOCAL_WALLET_CONFIG = {
   ...BASE_CONFIG,
@@ -18187,10 +18445,12 @@ var WalletConfigService = class {
   getEvents() {
     return this.config.events;
   }
+  getOptimizationOptions() {
+    return this.config.optimizationOptions;
+  }
 };
 
 // src/services/coop-exit.ts
-import { Transaction as Transaction4 } from "@scure/btc-signer";
 import { uuidv7 as uuidv72 } from "uuidv7";
 
 // src/utils/bitcoin.ts
@@ -18345,6 +18605,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;
@@ -18353,9 +18614,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;
@@ -18365,63 +18626,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,
@@ -18431,7 +18637,10 @@ function createNodeTx({
     version: 3,
     allowUnknownOutputs: true
   });
-  nodeTx.addInput(parentOutPoint);
+  nodeTx.addInput({
+    ...parentOutPoint,
+    sequence
+  });
   if (applyFee) {
     nodeTx.addOutput({
       script: txOut.script,
@@ -18445,52 +18654,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,
@@ -18546,110 +18795,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) {
@@ -18668,6 +18916,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) {
@@ -18678,6 +18933,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",
@@ -18692,8 +18948,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() {
@@ -18706,19 +18962,13 @@ function getEphemeralAnchorOutput() {
 
 // src/services/transfer.ts
 import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1";
-import {
-  bytesToHex as bytesToHex4,
-  equalBytes,
-  hexToBytes as hexToBytes3,
-  numberToBytesBE
-} from "@noble/curves/utils";
+import { bytesToHex as bytesToHex4, equalBytes, numberToBytesBE } from "@noble/curves/utils";
 import { sha256 as sha2564 } from "@noble/hashes/sha2";
-import { Transaction as Transaction3 } from "@scure/btc-signer";
 import * as ecies from "eciesjs";
 import { uuidv7 } from "uuidv7";
 
 // src/utils/transfer_package.ts
-import { hexToBytes as hexToBytes2 } from "@noble/curves/utils";
+import { hexToBytes as hexToBytes3 } from "@noble/curves/utils";
 import { sha256 as sha2563 } from "@noble/hashes/sha2";
 function getTransferPackageSigningPayload(transferID, transferPackage) {
   const encryptedPayload = transferPackage.keyTweakPackage;
@@ -18727,7 +18977,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(";");
@@ -18742,13 +18992,6 @@ function getTransferPackageSigningPayload(transferID, transferPackage) {
 }
 
 // src/services/transfer.ts
-function getSigningJobProto(signingJob) {
-  return {
-    signingPublicKey: signingJob.signingPublicKey,
-    rawTx: signingJob.rawTx,
-    signingNonceCommitment: signingJob.signingNonceCommitment.commitment
-  };
-}
 var BaseTransferService = class {
   config;
   connectionManager;
@@ -19430,42 +19673,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: hexToBytes3(getTxId(nodeTx)),
-        index: 0
-      };
       let directNodeTx;
-      let directNodeOutPoint;
       if (leaf.leaf.directTx.length > 0) {
         directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
-        directNodeOutPoint = {
-          txid: hexToBytes3(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;
@@ -19678,71 +19906,127 @@ var TransferService = class extends BaseTransferService {
       throw new Error(`Error querying pending transfers by sender: ${error}`);
     }
   }
-  async refreshTimelockNodesInternal(node, parentNode, useTestUnilateralSequence) {
-    const signingJobs = [];
-    const parentNodeTx = getTxFromRawTxBytes(parentNode.nodeTx);
-    const parentNodeOutput = parentNodeTx.getOutput(0);
-    if (!parentNodeOutput) {
-      throw Error("Could not get parent node output");
+  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
+      });
     }
-    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"
+    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
       });
     }
-    let { nextSequence, nextDirectSequence } = getNextTransactionSequence(
-      currSequence,
-      true
+    return response.renewResult.renewNodeTimelockResult.node;
+  }
+  async createRenewRefundSigningJobs(node, parentNode) {
+    const signingJobs = [];
+    const parentTx = getTxFromRawTxBytes(parentNode.nodeTx);
+    const parentNodeOutput = getTxFromRawTxBytes(parentNode.nodeTx).getOutput(
+      0
     );
-    const output = {
+    if (!parentNodeOutput) {
+      throw new Error("Parent node output not found");
+    }
+    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({
@@ -19750,537 +20034,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: hexToBytes3(getTxId(cpfpNodeTx)),
-      index: 0
-    };
-    let newDirectRefundOutPoint;
-    if (newDirectNodeTx) {
-      newDirectRefundOutPoint = {
-        txid: hexToBytes3(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: hexToBytes3(getTxId(nodeTx)),
-      index: 0
-    };
-    const {
-      nextSequence: newNodeSequence,
-      nextDirectSequence: newDirectNodeSequence
-    } = getNextTransactionSequence(refundSequence);
-    const newNodeTx = new Transaction3({
-      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 Transaction3({
-        version: 3,
-        allowUnknownOutputs: true
-      });
-      newDirectNodeTx.addInput({
-        ...newNodeOutPoint,
-        sequence: newDirectNodeSequence
-      });
-      newDirectNodeTx.addOutput({
-        script: originalOutput.script,
-        amount: maybeApplyFee(originalOutput.amount)
-      });
-    }
-    const newCpfpRefundOutPoint = {
-      txid: hexToBytes3(getTxId(newNodeTx)),
-      index: 0
-    };
-    let newDirectRefundOutPoint;
-    if (newDirectNodeTx) {
-      newDirectRefundOutPoint = {
-        txid: hexToBytes3(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()
-    });
-    const nodeSig = await this.config.signer.aggregateFrost({
-      message: nodeSighash,
-      statechainSignatures: response.nodeTxSigningResult.signingResult?.signatureShares,
-      statechainPublicKeys: response.nodeTxSigningResult.signingResult?.publicKeys,
-      verifyingKey: response.nodeTxSigningResult.verifyingKey,
-      statechainCommitments: response.nodeTxSigningResult.signingResult?.signingNonceCommitments,
-      selfCommitment: newNodeSigningJob.signingNonceCommitment,
-      publicKey: signingPublicKey,
-      selfSignature: nodeUserSig,
-      adaptorPubKey: new Uint8Array()
+      verifyingKey: node.verifyingPublicKey
     });
-    let directNodeSig;
-    if (directNodeSighash && newDirectNodeSigningJob && response.directNodeTxSigningResult) {
-      const directNodeUserSig = await this.config.signer.signFrost({
-        message: directNodeSighash,
+    if (splitNodeDirectTx) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: splitNodeDirectTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "directSplit",
+        parentTxOut: unsignedParentNodeOutput,
+        leafId: node.id,
         keyDerivation,
-        publicKey: signingPublicKey,
-        verifyingKey: response.directNodeTxSigningResult.verifyingKey,
-        selfCommitment: newDirectNodeSigningJob.signingNonceCommitment,
-        statechainCommitments: response.directNodeTxSigningResult.signingResult?.signingNonceCommitments,
-        adaptorPubKey: new Uint8Array()
-      });
-      directNodeSig = await this.config.signer.aggregateFrost({
-        message: directNodeSighash,
-        statechainSignatures: response.directNodeTxSigningResult.signingResult?.signatureShares,
-        statechainPublicKeys: response.directNodeTxSigningResult.signingResult?.publicKeys,
-        verifyingKey: response.directNodeTxSigningResult.verifyingKey,
-        statechainCommitments: response.directNodeTxSigningResult.signingResult?.signingNonceCommitments,
-        selfCommitment: newDirectNodeSigningJob.signingNonceCommitment,
-        publicKey: signingPublicKey,
-        selfSignature: directNodeUserSig,
-        adaptorPubKey: new Uint8Array()
+        verifyingKey: node.verifyingPublicKey
       });
     }
-    const cpfpRefundUserSig = await this.config.signer.signFrost({
-      message: cpfpRefundSighash,
+    const splitNodeOutput = splitNodeTx.getOutput(0);
+    const splitNodeDirectOutput = splitNodeDirectTx.getOutput(0);
+    if (!splitNodeDirectOutput.amount || !splitNodeDirectOutput.script) {
+      throw new Error("Could not get split node output");
+    }
+    const unsignedSplitNodeOutput = {
+      script: splitNodeDirectOutput.script,
+      amount: splitNodeDirectOutput.amount
+    };
+    const { nodeTx: newNodeTx, directNodeTx: newDirectNodeTx } = createInitialTimelockNodeTx(splitNodeTx);
+    signingJobs.push({
+      signingPublicKey,
+      rawTx: newNodeTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "node",
+      parentTxOut: splitNodeOutput,
+      leafId: node.id,
       keyDerivation,
-      publicKey: signingPublicKey,
-      verifyingKey: response.refundTxSigningResult.verifyingKey,
-      selfCommitment: newCpfpRefundSigningJob.signingNonceCommitment,
-      statechainCommitments: response.refundTxSigningResult.signingResult?.signingNonceCommitments,
-      adaptorPubKey: new Uint8Array()
+      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()
-      });
-    }
-    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"
+        verifyingKey: node.verifyingPublicKey
       });
     }
-    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: hexToBytes3(getTxId(nodeTx)),
-      index: 0
-    };
-    let directRefundOutPoint;
-    if (directNodeTx) {
-      directRefundOutPoint = {
-        txid: hexToBytes3(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
     });
-    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 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
+        });
       }
-      const rawTx = getTxFromRawTxBytes(signingJob.rawTx);
-      const txOut = signingJob.parentTxOut;
-      const rawTxSighash = getSigHashFromTx(rawTx, 0, txOut);
-      const userSignature = await this.config.signer.signFrost({
-        message: rawTxSighash,
-        keyDerivation,
-        publicKey: signingPublicKey,
-        verifyingKey: signingResult.verifyingKey,
-        selfCommitment: signingJob.signingNonceCommitment,
-        statechainCommitments: signingResult.signingResult?.signingNonceCommitments,
-        adaptorPubKey: new Uint8Array()
-      });
-      const signature = await this.config.signer.aggregateFrost({
-        message: rawTxSighash,
-        statechainSignatures: signingResult.signingResult?.signatureShares,
-        statechainPublicKeys: signingResult.signingResult?.publicKeys,
-        verifyingKey: signingResult.verifyingKey,
-        statechainCommitments: signingResult.signingResult?.signingNonceCommitments,
-        selfCommitment: signingJob.signingNonceCommitment,
-        publicKey: signingPublicKey,
-        selfSignature: userSignature,
-        adaptorPubKey: new Uint8Array()
-      });
-      if (signingJob.type === "cpfp") {
-        cpfpRefundSignature = signature;
-      } else if (signingJob.type === "direct") {
-        directRefundSignature = signature;
-      } else if (signingJob.type === "directFromCpfp") {
-        directFromCpfpRefundSignature = signature;
+      return {
+        ...signingJob,
+        signingNonceCommitments
+      };
+    });
+    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
       }
+    });
+    if (response.renewResult?.$case !== "renewNodeZeroTimelockResult" || !response.renewResult?.renewNodeZeroTimelockResult.node) {
+      throw new ValidationError("Unexpected renew result", {
+        field: "renewResult",
+        value: response.renewResult
+      });
     }
-    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;
   }
 };
 
@@ -20322,71 +20368,6 @@ var CoopExitService = class extends BaseTransferService {
       directFromCpfpSignaturesMap
     };
   }
-  createConnectorRefundTransactions(sequence, directSequence, cpfpNodeOutPoint, directNodeOutPoint, connectorOutput, amountSats, receiverPubKey) {
-    const cpfpRefundTx = new Transaction4();
-    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 Transaction4();
-      directRefundTx.addInput({
-        txid: directNodeOutPoint.txid,
-        index: directNodeOutPoint.index,
-        sequence: directSequence
-      });
-      directRefundTx.addInput(connectorOutput);
-      directRefundTx.addOutput({
-        script: receiverScript,
-        amount: maybeApplyFee(amountSats)
-      });
-      directFromCpfpRefundTx = new Transaction4();
-      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(
@@ -20420,29 +20401,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();
@@ -20834,38 +20825,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: hexToBytes4(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: hexToBytes4(getTxId(cpfpRootTx)), index: 0 },
-      directInput: { txid: hexToBytes4(getTxId(directRootTx)), index: 0 },
-      amountSats: amount,
+    const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createInitialTimelockRefundTxs({
+      nodeTx: cpfpRootTx,
+      directNodeTx: directRootTx,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
     });
@@ -21157,22 +21128,12 @@ var DepositService = class {
         expected: "Output with script and amount"
       });
     }
-    const depositOutPoint = {
-      txid: hexToBytes4(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: hexToBytes4(getTxId(cpfpRootTx)), index: 0 },
-      amountSats: amount,
+    const { cpfpRefundTx } = createInitialTimelockRefundTxs({
+      nodeTx: cpfpRootTx,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
     });
@@ -27186,7 +27147,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";
@@ -27207,12 +27168,9 @@ if (isBun) {
 }
 var clientEnv = `js-spark-sdk/${packageVersion} ${baseEnvStr}`;
 
-// src/services/signing.ts
-import { hexToBytes as hexToBytes9 } from "@noble/curves/utils";
-
 // src/utils/htlc-transactions.ts
 import {
-  Transaction as Transaction6,
+  Transaction as Transaction4,
   Script,
   taprootListToTree,
   p2tr as p2tr3,
@@ -27300,7 +27258,7 @@ function createLightningHTLCTransaction({
     txid: hexToBytes8(getTxId(nodeTx)),
     index: 0
   };
-  const htlcTransaction = new Transaction6({
+  const htlcTransaction = new Transaction4({
     version: 3,
     allowUnknownOutputs: true
   });
@@ -27419,20 +27377,7 @@ var SigningService = class {
         });
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
-      const cpfpNodeOutPoint = {
-        txid: hexToBytes9(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", {
@@ -27442,20 +27387,21 @@ var SigningService = class {
         });
       }
       let directNodeTx;
-      let directNodeOutPoint;
       if (leaf.leaf.directTx.length > 0) {
         directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
-        directNodeOutPoint = {
-          txid: hexToBytes9(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()
       });
@@ -27471,7 +27417,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",
@@ -27496,16 +27443,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,
@@ -27632,6 +27569,35 @@ var SigningService = class {
       directFromCpfpLeafSigningJobs
     };
   }
+  async signSigningJobs(signingJobs) {
+    const userSignedTxSigningJobs = /* @__PURE__ */ new Map();
+    for (const signingJob of signingJobs) {
+      const rawTx = getTxFromRawTxBytes(signingJob.rawTx);
+      const txOut = signingJob.parentTxOut;
+      const rawTxSighash = getSigHashFromTx(rawTx, 0, txOut);
+      const userSignature = await this.config.signer.signFrost({
+        message: rawTxSighash,
+        keyDerivation: signingJob.keyDerivation,
+        publicKey: signingJob.signingPublicKey,
+        verifyingKey: signingJob.verifyingKey,
+        selfCommitment: signingJob.signingNonceCommitment,
+        statechainCommitments: signingJob.signingNonceCommitments,
+        adaptorPubKey: new Uint8Array()
+      });
+      const userSignedTxSigningJob = {
+        leafId: signingJob.leafId,
+        signingPublicKey: signingJob.signingPublicKey,
+        rawTx: rawTx.toBytes(),
+        signingNonceCommitment: signingJob.signingNonceCommitment.commitment,
+        signingCommitments: {
+          signingCommitments: signingJob.signingNonceCommitments
+        },
+        userSignature
+      };
+      userSignedTxSigningJobs.set(signingJob.type, userSignedTxSigningJob);
+    }
+    return userSignedTxSigningJobs;
+  }
 };
 
 // src/signer/signer.ts
@@ -27641,7 +27607,7 @@ import {
   bytesToHex as bytesToHex8,
   bytesToNumberBE as bytesToNumberBE7,
   equalBytes as equalBytes5,
-  hexToBytes as hexToBytes10
+  hexToBytes as hexToBytes9
 } from "@noble/curves/utils";
 import { sha256 as sha25610 } from "@noble/hashes/sha2";
 import { HDKey } from "@scure/bip32";
@@ -28295,7 +28261,7 @@ var DefaultSparkSigner = class {
   }
   async createSparkWalletFromSeed(seed, accountNumber) {
     if (typeof seed === "string") {
-      seed = hexToBytes10(seed);
+      seed = hexToBytes9(seed);
     }
     const {
       identityKey,
@@ -28434,14 +28400,14 @@ var TaprootSparkSigner = class extends DefaultSparkSigner {
 
 // src/tests/utils/test-faucet.ts
 import { schnorr as schnorr6, secp256k1 as secp256k112 } from "@noble/curves/secp256k1";
-import { bytesToHex as bytesToHex9, hexToBytes as hexToBytes11 } from "@noble/curves/utils";
+import { bytesToHex as bytesToHex9, hexToBytes as hexToBytes10 } from "@noble/curves/utils";
 import * as btc3 from "@scure/btc-signer";
-import { Address as Address3, OutScript as OutScript2, SigHash as SigHash2, Transaction as Transaction7 } from "@scure/btc-signer";
+import { Address as Address3, OutScript as OutScript2, SigHash as SigHash2, Transaction as Transaction5 } from "@scure/btc-signer";
 import { taprootTweakPrivKey as taprootTweakPrivKey2 } from "@scure/btc-signer/utils";
-var STATIC_FAUCET_KEY = hexToBytes11(
+var STATIC_FAUCET_KEY = hexToBytes10(
   "deadbeef1337cafe4242424242424242deadbeef1337cafe4242424242424242"
 );
-var STATIC_MINING_KEY = hexToBytes11(
+var STATIC_MINING_KEY = hexToBytes10(
   "1337cafe4242deadbeef4242424242421337cafe4242deadbeef424242424242"
 );
 var SATS_PER_BTC = 1e8;
@@ -28524,7 +28490,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       );
       await this.generateToAddress(1, address);
       const fundingTxRaw = await this.getRawTransaction(fundingTxid);
-      const fundingTx = Transaction7.fromRaw(hexToBytes11(fundingTxRaw.hex));
+      const fundingTx = Transaction5.fromRaw(hexToBytes10(fundingTxRaw.hex));
       for (let i = 0; i < fundingTx.outputsLength; i++) {
         const output = fundingTx.getOutput(i);
         if (!output.script || !output.amount) continue;
@@ -28555,7 +28521,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
         `Selected UTXO (${selectedUtxoAmountSats} sats) is too small to create even one faucet coin of ${COIN_AMOUNT} sats`
       );
     }
-    const splitTx = new Transaction7();
+    const splitTx = new Transaction5();
     splitTx.addInput({
       txid: selectedUtxo.txid,
       index: selectedUtxo.vout
@@ -28590,7 +28556,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       this.coins.push({
         key: STATIC_FAUCET_KEY,
         outpoint: {
-          txid: hexToBytes11(splitTxId),
+          txid: hexToBytes10(splitTxId),
           index: i
         },
         txout: signedSplitTx.getOutput(i)
@@ -28598,7 +28564,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     }
   }
   async sendFaucetCoinToP2WPKHAddress(pubKey) {
-    const sendToPubKeyTx = new Transaction7();
+    const sendToPubKeyTx = new Transaction5();
     const p2wpkhAddress = btc3.p2wpkh(pubKey, getNetwork(4 /* LOCAL */)).address;
     if (!p2wpkhAddress) {
       throw new Error("Invalid P2WPKH address");
@@ -28653,6 +28619,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: Headers3 } = getFetch();
@@ -28705,21 +28679,56 @@ 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 = secp256k112.utils.randomPrivateKey();
     const pubKey = secp256k112.getPublicKey(key);
     return getP2TRAddressFromPublicKey(pubKey, 4 /* LOCAL */);
   }
+  async getNewExternalWallet() {
+    const key = secp256k112.utils.randomPrivateKey();
+    const pubKey = secp256k112.getPublicKey(key);
+    return {
+      address: getP2TRAddressFromPublicKey(pubKey, 4 /* LOCAL */),
+      key,
+      pubKey
+    };
+  }
   async sendToAddress(address, amount, blocksToGenerate = 1) {
     const coin = await this.fund();
     if (!coin) {
       throw new Error("No coins available");
     }
-    const tx = new Transaction7();
+    const tx = new Transaction5();
     tx.addInput(coin.outpoint);
     const availableAmount = COIN_AMOUNT - FEE_AMOUNT;
     const destinationAddress = Address3(getNetwork(4 /* LOCAL */)).decode(
@@ -28814,75 +28823,6 @@ function chunkArray(arr, size) {
   return chunks;
 }
 
-// src/utils/optimize.ts
-var DENOMINATIONS = Array.from({ length: 28 }, (_, i) => 2 ** i);
-function assert(condition, message) {
-  if (!condition) {
-    throw new InternalValidationError(message || "Assertion failed");
-  }
-}
-function sum(arr) {
-  return arr.reduce((a, b) => a + b, 0);
-}
-function sorted(arr) {
-  return [...arr].sort((a, b) => a - b);
-}
-function equals(a, b) {
-  return a.length === b.length && a.every((val, index) => val === b[index]);
-}
-function greedyLeaves(amount) {
-  const leaves = [];
-  let remaining = amount;
-  for (let i = DENOMINATIONS.length - 1; i >= 0; i--) {
-    const leaf = DENOMINATIONS[i];
-    if (typeof leaf === "number" && leaf > 0) {
-      while (remaining >= leaf) {
-        remaining -= leaf;
-        leaves.push(leaf);
-      }
-    }
-  }
-  assert(sum(leaves) === amount, "greedy_leaves: sum mismatch");
-  return sorted(leaves);
-}
-var Swap = class {
-  inLeaves;
-  outLeaves;
-  constructor(inLeaves, outLeaves) {
-    this.inLeaves = [...inLeaves];
-    this.outLeaves = [...outLeaves];
-    assert(
-      sum(this.inLeaves) === sum(this.outLeaves),
-      "Swap in/out leaves must sum to same value for swap: " + this.toString()
-    );
-  }
-  toString() {
-    return `Swap(in=${JSON.stringify(this.inLeaves)}, out=${JSON.stringify(this.outLeaves)})`;
-  }
-};
-function maximizeUnilateralExit(inputLeaves, maxLeavesPerSwap = 64) {
-  const swaps = [];
-  let batch = [];
-  let leaves = sorted(inputLeaves);
-  while (leaves.length > 0) {
-    batch.push(leaves.shift());
-    const target = greedyLeaves(sum(batch));
-    if (batch.length >= maxLeavesPerSwap || target.length >= maxLeavesPerSwap) {
-      if (!equals(target, batch)) {
-        swaps.push(new Swap([...batch], target));
-      }
-      batch = [];
-    }
-  }
-  if (batch.length > 0) {
-    const target = greedyLeaves(sum(batch));
-    if (!equals(target, batch)) {
-      swaps.push(new Swap([...batch], target));
-    }
-  }
-  return swaps;
-}
-
 // src/utils/retry.ts
 var DEFAULT_RETRY_CONFIG = {
   maxAttempts: 5,
@@ -28959,6 +28899,199 @@ var SparkWalletEvent = {
   StreamReconnecting: "stream:reconnecting"
 };
 
+// src/utils/optimize.ts
+var DENOMINATIONS = Array.from({ length: 28 }, (_, i) => 2 ** i);
+function assert(condition, message) {
+  if (!condition) {
+    throw new InternalValidationError(message || "Assertion failed");
+  }
+}
+function sum(arr) {
+  return arr.reduce((a, b) => a + b, 0);
+}
+function sorted(arr) {
+  return [...arr].sort((a, b) => a - b);
+}
+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;
+  for (let i = DENOMINATIONS.length - 1; i >= 0; i--) {
+    const leaf = DENOMINATIONS[i];
+    if (typeof leaf === "number" && leaf > 0) {
+      while (remaining >= leaf) {
+        remaining -= leaf;
+        leaves.push(leaf);
+      }
+    }
+  }
+  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;
+  constructor(inLeaves, outLeaves) {
+    this.inLeaves = [...inLeaves];
+    this.outLeaves = [...outLeaves];
+    assert(
+      sum(this.inLeaves) === sum(this.outLeaves),
+      "Swap in/out leaves must sum to same value for swap: " + this.toString()
+    );
+  }
+  toString() {
+    return `Swap(in=${JSON.stringify(this.inLeaves)}, out=${JSON.stringify(this.outLeaves)})`;
+  }
+};
+function maximizeUnilateralExit(inputLeaves, maxLeavesPerSwap = 64) {
+  const swaps = [];
+  let batch = [];
+  let leaves = sorted(inputLeaves);
+  while (leaves.length > 0) {
+    batch.push(leaves.shift());
+    const target = greedyLeaves(sum(batch));
+    if (batch.length >= maxLeavesPerSwap || target.length >= maxLeavesPerSwap) {
+      if (!equals(target, batch)) {
+        swaps.push(new Swap([...batch], target));
+      }
+      batch = [];
+    }
+  }
+  if (batch.length > 0) {
+    const target = greedyLeaves(sum(batch));
+    if (!equals(target, batch)) {
+      swaps.push(new Swap([...batch], target));
+    }
+  }
+  return swaps;
+}
+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;
+          }
+        }
+      } else {
+        swaps.push(new Swap([...toGiveBatch], [...toReceiveBatch]));
+      }
+      toGiveBatch = [];
+      toReceiveBatch = [];
+    }
+  }
+  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
 var SparkWallet = class extends EventEmitter {
   config;
@@ -29063,16 +29196,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,
@@ -29248,19 +29378,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);
   }
@@ -29370,75 +29487,84 @@ var SparkWallet = class extends EventEmitter {
     }
     return nodes;
   }
-  areLeavesInefficient() {
-    const totalAmount = this.getInternalBalance();
-    if (this.leaves.length <= 1) {
-      return false;
+  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");
     }
-    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++;
-      }
-    }
-    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();
@@ -29555,7 +29681,7 @@ var SparkWallet = class extends EventEmitter {
         mnemonic = mnemonicOrSeed;
         seed = await this.config.signer.mnemonicToSeed(mnemonicOrSeed);
       } else {
-        seed = hexToBytes12(mnemonicOrSeed);
+        seed = hexToBytes11(mnemonicOrSeed);
       }
     }
     await this.initWalletFromSeed(seed, accountNumber);
@@ -29698,7 +29824,7 @@ var SparkWallet = class extends EventEmitter {
       directFromCpfpSignatureMap
     } = await this.transferService.startSwapSignRefund(
       leafKeyTweaks,
-      hexToBytes12(this.config.getSspIdentityPublicKey()),
+      hexToBytes11(this.config.getSspIdentityPublicKey()),
       new Date(Date.now() + 2 * 60 * 1e3)
     );
     try {
@@ -29913,7 +30039,7 @@ var SparkWallet = class extends EventEmitter {
           throw new Error(`Leaf not found for node ${nodeId}`);
         }
         const cpfpNodeTx = getTxFromRawTxBytes(node.nodeTx);
-        const cpfpRefundTxBytes = hexToBytes12(leaf.rawUnsignedRefundTransaction);
+        const cpfpRefundTxBytes = hexToBytes11(leaf.rawUnsignedRefundTransaction);
         const cpfpRefundTx = getTxFromRawTxBytes(cpfpRefundTxBytes);
         const cpfpSighash = getSigHashFromTx(
           cpfpRefundTx,
@@ -29922,7 +30048,7 @@ var SparkWallet = class extends EventEmitter {
         );
         const nodePublicKey = node.verifyingPublicKey;
         const taprootKey = computeTaprootKeyNoScript(nodePublicKey.slice(1));
-        const cpfpAdaptorSignatureBytes = hexToBytes12(
+        const cpfpAdaptorSignatureBytes = hexToBytes11(
           leaf.adaptorSignedSignature
         );
         applyAdaptorToSignature(
@@ -29933,7 +30059,7 @@ var SparkWallet = class extends EventEmitter {
         );
         if (leaf.directRawUnsignedRefundTransaction) {
           const directNodeTx = getTxFromRawTxBytes(node.directTx);
-          const directRefundTxBytes = hexToBytes12(
+          const directRefundTxBytes = hexToBytes11(
             leaf.directRawUnsignedRefundTransaction
           );
           const directRefundTx = getTxFromRawTxBytes(directRefundTxBytes);
@@ -29947,7 +30073,7 @@ var SparkWallet = class extends EventEmitter {
               `Direct adaptor signed signature missing for node ${nodeId}`
             );
           }
-          const directAdaptorSignatureBytes = hexToBytes12(
+          const directAdaptorSignatureBytes = hexToBytes11(
             leaf.directAdaptorSignedSignature
           );
           applyAdaptorToSignature(
@@ -29958,7 +30084,7 @@ var SparkWallet = class extends EventEmitter {
           );
         }
         if (leaf.directFromCpfpRawUnsignedRefundTransaction) {
-          const directFromCpfpRefundTxBytes = hexToBytes12(
+          const directFromCpfpRefundTxBytes = hexToBytes11(
             leaf.directFromCpfpRawUnsignedRefundTransaction
           );
           const directFromCpfpRefundTx = getTxFromRawTxBytes(
@@ -29974,7 +30100,7 @@ var SparkWallet = class extends EventEmitter {
               `Direct adaptor signed signature missing for node ${nodeId}`
             );
           }
-          const directFromCpfpAdaptorSignatureBytes = hexToBytes12(
+          const directFromCpfpAdaptorSignatureBytes = hexToBytes11(
             leaf.directFromCpfpAdaptorSignedSignature
           );
           applyAdaptorToSignature(
@@ -30021,8 +30147,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:", {
@@ -30416,7 +30541,7 @@ var SparkWallet = class extends EventEmitter {
         }
       );
     }
-    const tx = new Transaction8();
+    const tx = new Transaction6();
     tx.addInput({
       txid: depositTransactionId,
       index: outputIndex,
@@ -30456,7 +30581,7 @@ var SparkWallet = class extends EventEmitter {
     );
     const swapResponse = await sparkClient.initiate_static_deposit_utxo_refund({
       onChainUtxo: {
-        txid: hexToBytes12(depositTransactionId),
+        txid: hexToBytes11(depositTransactionId),
         vout: outputIndex,
         network: networkType
       },
@@ -30583,7 +30708,7 @@ var SparkWallet = class extends EventEmitter {
     creditAmountView.setUint32(0, lowerHalf, true);
     creditAmountView.setUint32(4, upperHalf, true);
     parts.push(new Uint8Array(creditAmountBuffer));
-    parts.push(hexToBytes12(sspSignature));
+    parts.push(hexToBytes11(sspSignature));
     const totalLength = parts.reduce((sum2, part) => sum2 + part.length, 0);
     const payload = new Uint8Array(totalLength);
     let offset = 0;
@@ -30687,26 +30812,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.
@@ -30848,6 +30954,9 @@ var SparkWallet = class extends EventEmitter {
         depositTx,
         vout
       });
+      await this.withLeaves(async () => {
+        this.leaves.push(...nodes2);
+      });
       return nodes2;
     });
     this.mutexes.delete(txid);
@@ -30977,7 +31086,7 @@ var SparkWallet = class extends EventEmitter {
     const [outcome] = await this.transferWithInvoice([
       {
         amountSats,
-        receiverIdentityPubkey: hexToBytes12(receiverAddress.identityPublicKey)
+        receiverIdentityPubkey: hexToBytes11(receiverAddress.identityPublicKey)
       }
     ]);
     if (!outcome) throw new Error("no transfer created");
@@ -31024,8 +31133,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}`
@@ -31068,7 +31176,7 @@ var SparkWallet = class extends EventEmitter {
                 transfer.id
               );
               if (pending) {
-                await this.claimTransfer({ transfer: pending, optimize: true });
+                await this.claimTransfer({ transfer: pending });
               }
             }
             return {
@@ -31118,75 +31226,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({
@@ -31204,7 +31282,18 @@ var SparkWallet = class extends EventEmitter {
       nodesMap.set(node.id, node);
     }
     const nodesToAdd = [];
-    for (const node of nodesToRefresh) {
+    for (const node of nodesToRenewNode) {
+      if (!node.parentNodeId) {
+        throw new Error(`node ${node.id} has no parent`);
+      }
+      const parentNode = nodesMap.get(node.parentNodeId);
+      if (!parentNode) {
+        throw new Error(`parent node ${node.parentNodeId} not found`);
+      }
+      const newNode = await this.transferService.renewNodeTxn(node, parentNode);
+      nodesToAdd.push(newNode);
+    }
+    for (const node of nodesToRenewRefund) {
       if (!node.parentNodeId) {
         throw new Error(`node ${node.id} has no parent`);
       }
@@ -31212,17 +31301,14 @@ var SparkWallet = class extends EventEmitter {
       if (!parentNode) {
         throw new Error(`parent node ${node.parentNodeId} not found`);
       }
-      const { nodes: nodes2 } = await this.transferService.refreshTimelockNodes(
+      const newNode = await this.transferService.renewRefundTxn(
         node,
         parentNode
       );
-      if (nodes2.length !== 1) {
-        throw new Error(`expected 1 node, got ${nodes2.length}`);
-      }
-      const newNode = nodes2[0];
-      if (!newNode) {
-        throw new Error("Failed to refresh timelock node");
-      }
+      nodesToAdd.push(newNode);
+    }
+    for (const node of nodesToRenewZeroTimelock) {
+      const newNode = await this.transferService.renewZeroTimelockNodeTxn(node);
       nodesToAdd.push(newNode);
     }
     this.updateLeaves(nodeIds, nodesToAdd);
@@ -31263,14 +31349,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(
@@ -31289,8 +31375,7 @@ var SparkWallet = class extends EventEmitter {
    */
   async claimTransfer({
     transfer,
-    emit,
-    optimize
+    emit
   }) {
     const onError = async (context) => {
       const error = context.error;
@@ -31335,12 +31420,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}`,
@@ -31373,7 +31453,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;
         })
@@ -31599,7 +31679,7 @@ var SparkWallet = class extends EventEmitter {
     const sparkFallbackAddress = decodedInvoice.fallbackAddress;
     const paymentHash = decodedInvoice.paymentHash;
     if (preferSpark) {
-      if (sparkFallbackAddress === void 0 || isValidSparkFallback(hexToBytes12(sparkFallbackAddress)) === false) {
+      if (sparkFallbackAddress === void 0 || isValidSparkFallback(hexToBytes11(sparkFallbackAddress)) === false) {
         console.warn(
           "No valid spark address found in invoice. Defaulting to lightning."
         );
@@ -31644,8 +31724,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,
@@ -31661,17 +31740,17 @@ var SparkWallet = class extends EventEmitter {
       const transferID = uuidv74();
       const startTransferRequest = await this.transferService.prepareTransferForLightning(
         leavesToSend,
-        hexToBytes12(this.config.getSspIdentityPublicKey()),
-        hexToBytes12(paymentHash),
+        hexToBytes11(this.config.getSspIdentityPublicKey()),
+        hexToBytes11(paymentHash),
         expiryTime,
         transferID
       );
       const swapResponse = await this.lightningService.swapNodesForPreimage({
         leaves: leavesToSend,
-        receiverIdentityPubkey: hexToBytes12(
+        receiverIdentityPubkey: hexToBytes11(
           this.config.getSspIdentityPublicKey()
         ),
-        paymentHash: hexToBytes12(paymentHash),
+        paymentHash: hexToBytes11(paymentHash),
         isInboundPayment: false,
         invoiceString: invoice,
         feeSats: feeEstimate,
@@ -31774,7 +31853,7 @@ var SparkWallet = class extends EventEmitter {
         }
         satsInvoices.push({
           amountSats: encodedAmount ?? Number(amount),
-          receiverIdentityPubkey: hexToBytes12(addressData.identityPublicKey),
+          receiverIdentityPubkey: hexToBytes11(addressData.identityPublicKey),
           sparkInvoice: invoice
         });
       } else if (fields.paymentType?.type === "tokens") {
@@ -31976,10 +32055,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,
@@ -32024,11 +32101,11 @@ var SparkWallet = class extends EventEmitter {
     const connectorOutputs = [];
     for (let i = 0; i < connectorTx.outputsLength - 1; i++) {
       connectorOutputs.push({
-        txid: hexToBytes12(connectorTxId),
+        txid: hexToBytes11(connectorTxId),
         index: i
       });
     }
-    const sspPubIdentityKey = hexToBytes12(this.config.getSspIdentityPublicKey());
+    const sspPubIdentityKey = hexToBytes11(this.config.getSspIdentityPublicKey());
     const transfer = await this.coopExitService.getConnectorRefundSignatures({
       leaves: leafKeyTweaks,
       exitTxId: coopExitTxId,
@@ -32065,8 +32142,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
@@ -32341,7 +32417,7 @@ var SparkWallet = class extends EventEmitter {
   async validateMessageWithIdentityKey(message, signature) {
     const hash = sha25611(message);
     if (typeof signature === "string") {
-      signature = hexToBytes12(signature);
+      signature = hexToBytes11(signature);
     }
     return this.config.signer.validateMessageWithIdentityKey(hash, signature);
   }
@@ -32354,7 +32430,7 @@ var SparkWallet = class extends EventEmitter {
    */
   async signTransaction(txHex, keyType = "auto-detect") {
     try {
-      const tx = Transaction8.fromRaw(hexToBytes12(txHex));
+      const tx = Transaction6.fromRaw(hexToBytes11(txHex));
       let publicKey;
       switch (keyType.toLowerCase()) {
         case "identity":
@@ -32561,15 +32637,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(
@@ -32605,89 +32672,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);
@@ -32842,8 +32826,7 @@ var SparkWallet = class extends EventEmitter {
       "getLightningReceiveRequest",
       "getLightningSendRequest",
       "getCoopExitRequest",
-      "checkTimelock",
-      "testOnly_expireTimelock"
+      "checkTimelock"
     ];
     methods.forEach((m) => this.wrapPublicSparkWalletMethodWithOtelSpan(m));
     this.initWallet = this.wrapWithOtelSpan(
@@ -33905,7 +33888,7 @@ function collectResponses(responses) {
 }
 
 // src/utils/unilateral-exit.ts
-import { bytesToHex as bytesToHex12, hexToBytes as hexToBytes13 } from "@noble/curves/utils";
+import { bytesToHex as bytesToHex12, hexToBytes as hexToBytes12 } from "@noble/curves/utils";
 import { ripemd160 } from "@noble/hashes/legacy";
 import { sha256 as sha25613 } from "@noble/hashes/sha2";
 import * as btc4 from "@scure/btc-signer";
@@ -33920,7 +33903,7 @@ function isEphemeralAnchorOutput(script, amount) {
 }
 async function constructUnilateralExitTxs(nodeHexStrings, sparkClient, network) {
   const result = [];
-  const nodes = nodeHexStrings.map((hex) => TreeNode.decode(hexToBytes13(hex)));
+  const nodes = nodeHexStrings.map((hex) => TreeNode.decode(hexToBytes12(hex)));
   const nodeMap = /* @__PURE__ */ new Map();
   for (const node of nodes) {
     nodeMap.set(node.id, node);
@@ -34009,7 +33992,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 = hexToBytes13(hex);
+      const nodeBytes = hexToBytes12(hex);
       const node = TreeNode.decode(nodeBytes);
       if (!node.id) {
         throw new Error(
@@ -34123,7 +34106,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
         usedUtxos,
         correctedParentTx
       } = constructFeeBumpTx(nodeTxHex, availableUtxos, feeRate, void 0);
-      const feeBumpTx = btc4.Transaction.fromPSBT(hexToBytes13(nodeFeeBumpPsbt));
+      const feeBumpTx = btc4.Transaction.fromPSBT(hexToBytes12(nodeFeeBumpPsbt));
       var feeBumpOut = feeBumpTx.outputsLength === 1 ? feeBumpTx.getOutput(0) : null;
       var feeBumpOutPubKey = null;
       for (const usedUtxo of usedUtxos) {
@@ -34178,7 +34161,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           void 0
         );
         const feeBumpTx2 = btc4.Transaction.fromPSBT(
-          hexToBytes13(refundFeeBump.feeBumpPsbt)
+          hexToBytes12(refundFeeBump.feeBumpPsbt)
         );
         var feeBumpOut = feeBumpTx2.outputsLength === 1 ? feeBumpTx2.getOutput(0) : null;
         var feeBumpOutPubKey = null;
@@ -34293,9 +34276,9 @@ function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
     if (!fundingUtxo) {
       throw new Error(`UTXO at index ${i} is undefined`);
     }
-    const pubKeyHash = hash160(hexToBytes13(fundingUtxo.publicKey));
+    const pubKeyHash = hash160(hexToBytes12(fundingUtxo.publicKey));
     const scriptToUse = new Uint8Array([0, 20, ...pubKeyHash]);
-    const providedScript = hexToBytes13(fundingUtxo.script);
+    const providedScript = hexToBytes12(fundingUtxo.script);
     if (bytesToHex12(scriptToUse) !== bytesToHex12(providedScript)) {
       throw new Error(
         `\u274C  Derived script doesn't match provided script for UTXO ${i + 1}.`
@@ -34423,7 +34406,6 @@ export {
   DIRECT_TIMELOCK_OFFSET,
   DefaultSparkSigner,
   HTLC_TIMELOCK_OFFSET,
-  INITIAL_DIRECT_SEQUENCE,
   INITIAL_SEQUENCE,
   InternalValidationError,
   LOGGER_NAMES,
@@ -34456,21 +34438,24 @@ export {
   constructFeeBumpTx,
   constructUnilateralExitFeeBumpPackages,
   constructUnilateralExitTxs,
-  createConnectorRefundTransactions,
-  createLeafNodeTx,
-  createNodeTx,
-  createNodeTxs,
-  createRefundTx,
-  createRefundTxs,
-  createRootTx,
+  createConnectorRefundTxs,
+  createCurrentTimelockRefundTxs,
+  createDecrementedTimelockNodeTx,
+  createDecrementedTimelockRefundTxs,
+  createInitialTimelockNodeTx,
+  createInitialTimelockRefundTxs,
+  createRootNodeTx,
   createSigningCommitment,
   createSigningNonce,
-  createSplitTx,
+  createTestUnilateralRefundTxs,
+  createTestUnilateralTimelockNodeTx,
+  createZeroTimelockNodeTx,
   decodeBech32mTokenIdentifier,
   decodeBytesToSigningCommitment,
   decodeBytesToSigningNonce,
   decodeSparkAddress,
   doesLeafNeedRefresh,
+  doesTxnNeedRenewed,
   encodeBech32mTokenIdentifier,
   encodeSigningCommitmentToBytes,
   encodeSigningNonceToBytes,
@@ -34508,12 +34493,14 @@ export {
   getTxFromRawTxHex,
   getTxId,
   getTxIdNoReverse,
+  hash160,
   isEphemeralAnchorOutput,
   isLegacySparkAddress,
   isSafeForNumber,
   isTxBroadcast,
   isValidPublicKey,
   isValidSparkAddress,
+  isZeroTimelock,
   lastKeyWithTarget,
   maybeApplyFee,
   modInverse,