@buildonspark/spark-sdk 0.3.8 → 0.4.0

package/dist/bare/index.cjs

@@ -1228,7 +1228,6 @@ __export(index_exports, {
   DIRECT_TIMELOCK_OFFSET: () => DIRECT_TIMELOCK_OFFSET,
   DefaultSparkSigner: () => DefaultSparkSigner,
   HTLC_TIMELOCK_OFFSET: () => HTLC_TIMELOCK_OFFSET,
-  INITIAL_DIRECT_SEQUENCE: () => INITIAL_DIRECT_SEQUENCE,
   INITIAL_SEQUENCE: () => INITIAL_SEQUENCE,
   InternalValidationError: () => InternalValidationError,
   LOGGER_NAMES: () => LOGGER_NAMES,
@@ -1261,21 +1260,24 @@ __export(index_exports, {
   constructFeeBumpTx: () => constructFeeBumpTx,
   constructUnilateralExitFeeBumpPackages: () => constructUnilateralExitFeeBumpPackages,
   constructUnilateralExitTxs: () => constructUnilateralExitTxs,
-  createConnectorRefundTransactions: () => createConnectorRefundTransactions,
-  createLeafNodeTx: () => createLeafNodeTx,
-  createNodeTx: () => createNodeTx,
-  createNodeTxs: () => createNodeTxs,
-  createRefundTx: () => createRefundTx,
-  createRefundTxs: () => createRefundTxs,
-  createRootTx: () => createRootTx,
+  createConnectorRefundTxs: () => createConnectorRefundTxs,
+  createCurrentTimelockRefundTxs: () => createCurrentTimelockRefundTxs,
+  createDecrementedTimelockNodeTx: () => createDecrementedTimelockNodeTx,
+  createDecrementedTimelockRefundTxs: () => createDecrementedTimelockRefundTxs,
+  createInitialTimelockNodeTx: () => createInitialTimelockNodeTx,
+  createInitialTimelockRefundTxs: () => createInitialTimelockRefundTxs,
+  createRootNodeTx: () => createRootNodeTx,
   createSigningCommitment: () => createSigningCommitment,
   createSigningNonce: () => createSigningNonce,
-  createSplitTx: () => createSplitTx,
+  createTestUnilateralRefundTxs: () => createTestUnilateralRefundTxs,
+  createTestUnilateralTimelockNodeTx: () => createTestUnilateralTimelockNodeTx,
+  createZeroTimelockNodeTx: () => createZeroTimelockNodeTx,
   decodeBech32mTokenIdentifier: () => decodeBech32mTokenIdentifier,
   decodeBytesToSigningCommitment: () => decodeBytesToSigningCommitment,
   decodeBytesToSigningNonce: () => decodeBytesToSigningNonce,
   decodeSparkAddress: () => decodeSparkAddress,
   doesLeafNeedRefresh: () => doesLeafNeedRefresh,
+  doesTxnNeedRenewed: () => doesTxnNeedRenewed,
   encodeBech32mTokenIdentifier: () => encodeBech32mTokenIdentifier,
   encodeSigningCommitmentToBytes: () => encodeSigningCommitmentToBytes,
   encodeSigningNonceToBytes: () => encodeSigningNonceToBytes,
@@ -1313,12 +1315,14 @@ __export(index_exports, {
   getTxFromRawTxHex: () => getTxFromRawTxHex,
   getTxId: () => getTxId,
   getTxIdNoReverse: () => getTxIdNoReverse,
+  hash160: () => hash160,
   isEphemeralAnchorOutput: () => isEphemeralAnchorOutput,
   isLegacySparkAddress: () => isLegacySparkAddress,
   isSafeForNumber: () => isSafeForNumber,
   isTxBroadcast: () => isTxBroadcast,
   isValidPublicKey: () => isValidPublicKey,
   isValidSparkAddress: () => isValidSparkAddress,
+  isZeroTimelock: () => isZeroTimelock,
   lastKeyWithTarget: () => lastKeyWithTarget,
   maybeApplyFee: () => maybeApplyFee,
   modInverse: () => modInverse,
@@ -1502,7 +1506,7 @@ var import_secp256k114 = require("@noble/curves/secp256k1");
 var import_utils24 = require("@noble/curves/utils");
 var import_bip392 = require("@scure/bip39");
 var import_english2 = require("@scure/bip39/wordlists/english");
-var import_btc_signer7 = require("@scure/btc-signer");
+var import_btc_signer5 = require("@scure/btc-signer");
 var import_async_mutex = require("async-mutex");
 var import_uuidv75 = require("uuidv7");
 
@@ -5949,6 +5953,12 @@ var RenewLeafRequest = {
           writer.uint32(26).fork()
         ).join();
         break;
+      case "renewNodeZeroTimelockSigningJob":
+        RenewNodeZeroTimelockSigningJob.encode(
+          message.signingJobs.renewNodeZeroTimelockSigningJob,
+          writer.uint32(34).fork()
+        ).join();
+        break;
     }
     return writer;
   },
@@ -5986,6 +5996,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;
@@ -6003,6 +6023,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
     };
   },
@@ -6019,6 +6044,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;
   },
@@ -6051,6 +6080,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;
   }
@@ -6325,6 +6365,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 import_wire4.BinaryWriter()) {
+    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 import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(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 };
 }
@@ -6337,6 +6496,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;
   },
@@ -6367,6 +6529,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;
@@ -6383,6 +6555,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
     };
   },
@@ -6392,6 +6567,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;
   },
@@ -6421,6 +6600,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;
   }
@@ -6544,6 +6734,74 @@ var RenewRefundTimelockResult = {
     return message;
   }
 };
+function createBaseRenewNodeZeroTimelockResult() {
+  return { splitNode: void 0, node: void 0 };
+}
+var RenewNodeZeroTimelockResult = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    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 import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(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: "",
@@ -19298,7 +19556,11 @@ var BASE_CONFIG = {
   console: {
     otel: false
   },
-  events: {}
+  events: {},
+  optimizationOptions: {
+    auto: true,
+    multiplicity: 0
+  }
 };
 var LOCAL_WALLET_CONFIG = {
   ...BASE_CONFIG,
@@ -19509,10 +19771,12 @@ var WalletConfigService = class {
   getEvents() {
     return this.config.events;
   }
+  getOptimizationOptions() {
+    return this.config.optimizationOptions;
+  }
 };
 
 // src/services/coop-exit.ts
-var import_btc_signer3 = require("@scure/btc-signer");
 var import_uuidv72 = require("uuidv7");
 
 // src/utils/bitcoin.ts
@@ -19667,6 +19931,7 @@ function getTxEstimatedVbytesSizeByNumberOfInputsOutputs(numInputs, numOutputs)
 }
 
 // src/utils/transaction.ts
+var import_utils3 = require("@noble/hashes/utils");
 var import_btc_signer = require("@scure/btc-signer");
 var INITIAL_TIMELOCK = 2e3;
 var TEST_UNILATERAL_TIMELOCK = 100;
@@ -19675,9 +19940,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;
@@ -19687,63 +19952,8 @@ function maybeApplyFee(amount) {
   }
   return amount;
 }
-function createRootTx(depositOutPoint, depositTxOut) {
-  const cpfpRootTx = new import_btc_signer.Transaction({
-    version: 3,
-    allowUnknownOutputs: true
-  });
-  cpfpRootTx.addInput(depositOutPoint);
-  cpfpRootTx.addOutput(depositTxOut);
-  cpfpRootTx.addOutput(getEphemeralAnchorOutput());
-  const directRootTx = new import_btc_signer.Transaction({
-    version: 3,
-    allowUnknownOutputs: true
-  });
-  directRootTx.addInput(depositOutPoint);
-  directRootTx.addOutput({
-    script: depositTxOut.script,
-    amount: maybeApplyFee(depositTxOut.amount ?? 0n)
-  });
-  return [cpfpRootTx, directRootTx];
-}
-function createSplitTx(parentOutPoint, childTxOuts) {
-  const cpfpSplitTx = new import_btc_signer.Transaction({
-    version: 3,
-    allowUnknownOutputs: true
-  });
-  cpfpSplitTx.addInput(parentOutPoint);
-  for (const txOut of childTxOuts) {
-    cpfpSplitTx.addOutput(txOut);
-  }
-  cpfpSplitTx.addOutput(getEphemeralAnchorOutput());
-  const directSplitTx = new import_btc_signer.Transaction({
-    version: 3,
-    allowUnknownOutputs: true
-  });
-  directSplitTx.addInput(parentOutPoint);
-  let totalOutputAmount = 0n;
-  for (const txOut of childTxOuts) {
-    totalOutputAmount += txOut.amount ?? 0n;
-  }
-  if (totalOutputAmount > BigInt(DEFAULT_FEE_SATS)) {
-    const feeRatio = Number(DEFAULT_FEE_SATS) / Number(totalOutputAmount);
-    for (const txOut of childTxOuts) {
-      const adjustedAmount = BigInt(
-        Math.floor(Number(txOut.amount ?? 0n) * (1 - feeRatio))
-      );
-      directSplitTx.addOutput({
-        script: txOut.script,
-        amount: adjustedAmount
-      });
-    }
-  } else {
-    for (const txOut of childTxOuts) {
-      directSplitTx.addOutput(txOut);
-    }
-  }
-  return [cpfpSplitTx, directSplitTx];
-}
 function createNodeTx({
+  sequence,
   txOut,
   parentOutPoint,
   applyFee,
@@ -19753,7 +19963,10 @@ function createNodeTx({
     version: 3,
     allowUnknownOutputs: true
   });
-  nodeTx.addInput(parentOutPoint);
+  nodeTx.addInput({
+    ...parentOutPoint,
+    sequence
+  });
   if (applyFee) {
     nodeTx.addOutput({
       script: txOut.script,
@@ -19767,52 +19980,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: (0, import_utils3.hexToBytes)(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 import_btc_signer.Transaction({
-    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 import_btc_signer.Transaction({
-    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,
@@ -19868,110 +20121,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: (0, import_utils3.hexToBytes)(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: (0, import_utils3.hexToBytes)(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 import_btc_signer.Transaction({
-    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 import_btc_signer.Transaction({
-    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 import_btc_signer.Transaction({
-    version: 3,
-    allowUnknownOutputs: true
-  });
-  directFromCpfpTx.addInput({
-    ...cpfpNodeOutPoint,
-    sequence
-  });
-  directFromCpfpTx.addInput(connectorOutput);
-  directFromCpfpTx.addOutput({
-    script: receiverScript,
-    amount: outputAmount
-  });
-  return [cpfpRefundTx, directRefundTx, directFromCpfpTx];
+  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) {
@@ -19990,6 +20242,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) {
@@ -20000,6 +20259,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",
@@ -20014,8 +20274,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() {
@@ -20028,14 +20288,13 @@ function getEphemeralAnchorOutput() {
 
 // src/services/transfer.ts
 var import_secp256k12 = require("@noble/curves/secp256k1");
-var import_utils4 = require("@noble/curves/utils");
+var import_utils5 = require("@noble/curves/utils");
 var import_sha24 = require("@noble/hashes/sha2");
-var import_btc_signer2 = require("@scure/btc-signer");
 var ecies = __toESM(require("eciesjs"), 1);
 var import_uuidv7 = require("uuidv7");
 
 // src/utils/transfer_package.ts
-var import_utils3 = require("@noble/curves/utils");
+var import_utils4 = require("@noble/curves/utils");
 var import_sha23 = require("@noble/hashes/sha2");
 function getTransferPackageSigningPayload(transferID, transferPackage) {
   const encryptedPayload = transferPackage.keyTweakPackage;
@@ -20044,7 +20303,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 = (0, import_utils3.hexToBytes)(transferID.replaceAll("-", ""));
+  let message = (0, import_utils4.hexToBytes)(transferID.replaceAll("-", ""));
   for (const pair of pairs) {
     const keyPart = encoder.encode(pair.key + ":");
     const separator = encoder.encode(";");
@@ -20059,13 +20318,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;
@@ -20412,7 +20664,7 @@ var BaseTransferService = class {
   }
   async prepareSendTransferKeyTweaks(transferID, receiverIdentityPubkey, leaves, cpfpRefundSignatureMap, directRefundSignatureMap, directFromCpfpRefundSignatureMap) {
     const receiverEciesPubKey = ecies.PublicKey.fromHex(
-      (0, import_utils4.bytesToHex)(receiverIdentityPubkey)
+      (0, import_utils5.bytesToHex)(receiverIdentityPubkey)
     );
     const leavesTweaksMap = /* @__PURE__ */ new Map();
     for (const leaf of leaves) {
@@ -20453,7 +20705,7 @@ var BaseTransferService = class {
         throw new Error(`Share not found for operator ${operator.id}`);
       }
       const pubkeyTweak = import_secp256k12.secp256k1.getPublicKey(
-        (0, import_utils4.numberToBytesBE)(share.share, 32),
+        (0, import_utils5.numberToBytesBE)(share.share, 32),
         true
       );
       pubkeySharesTweak.set(identifier, pubkeyTweak);
@@ -20478,7 +20730,7 @@ var BaseTransferService = class {
       leafTweaksMap.set(identifier, {
         leafId: leaf.leaf.id,
         secretShareTweak: {
-          secretShare: (0, import_utils4.numberToBytesBE)(share.share, 32),
+          secretShare: (0, import_utils5.numberToBytesBE)(share.share, 32),
           proofs: share.proofs
         },
         pubkeySharesTweak: Object.fromEntries(pubkeySharesTweak),
@@ -20501,7 +20753,7 @@ var BaseTransferService = class {
     return void 0;
   }
   compareTransfers(transfer1, transfer2) {
-    return transfer1.id === transfer2.id && (0, import_utils4.equalBytes)(
+    return transfer1.id === transfer2.id && (0, import_utils5.equalBytes)(
       transfer1.senderIdentityPublicKey,
       transfer2.senderIdentityPublicKey
     ) && transfer1.status === transfer2.status && transfer1.totalValue === transfer2.totalValue && transfer1.expiryTime?.getTime() === transfer2.expiryTime?.getTime() && transfer1.leaves.length === transfer2.leaves.length;
@@ -20747,42 +20999,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: (0, import_utils4.hexToBytes)(getTxId(nodeTx)),
-        index: 0
-      };
       let directNodeTx;
-      let directNodeOutPoint;
       if (leaf.leaf.directTx.length > 0) {
         directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
-        directNodeOutPoint = {
-          txid: (0, import_utils4.hexToBytes)(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;
@@ -20890,7 +21127,7 @@ var TransferService = class extends BaseTransferService {
         throw new Error(`Share not found for operator ${operator.id}`);
       }
       const pubkeyTweak = import_secp256k12.secp256k1.getPublicKey(
-        (0, import_utils4.numberToBytesBE)(share.share, 32)
+        (0, import_utils5.numberToBytesBE)(share.share, 32)
       );
       pubkeySharesTweak.set(identifier, pubkeyTweak);
     }
@@ -20903,7 +21140,7 @@ var TransferService = class extends BaseTransferService {
       leafTweaksMap.set(identifier, {
         leafId: leaf.leaf.id,
         secretShareTweak: {
-          secretShare: (0, import_utils4.numberToBytesBE)(share.share, 32),
+          secretShare: (0, import_utils5.numberToBytesBE)(share.share, 32),
           proofs: share.proofs
         },
         pubkeySharesTweak: Object.fromEntries(pubkeySharesTweak)
@@ -20995,71 +21232,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({
@@ -21067,537 +21360,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: (0, import_utils4.hexToBytes)(getTxId(cpfpNodeTx)),
-      index: 0
-    };
-    let newDirectRefundOutPoint;
-    if (newDirectNodeTx) {
-      newDirectRefundOutPoint = {
-        txid: (0, import_utils4.hexToBytes)(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: (0, import_utils4.hexToBytes)(getTxId(nodeTx)),
-      index: 0
-    };
-    const {
-      nextSequence: newNodeSequence,
-      nextDirectSequence: newDirectNodeSequence
-    } = getNextTransactionSequence(refundSequence);
-    const newNodeTx = new import_btc_signer2.Transaction({
-      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 import_btc_signer2.Transaction({
-        version: 3,
-        allowUnknownOutputs: true
-      });
-      newDirectNodeTx.addInput({
-        ...newNodeOutPoint,
-        sequence: newDirectNodeSequence
-      });
-      newDirectNodeTx.addOutput({
-        script: originalOutput.script,
-        amount: maybeApplyFee(originalOutput.amount)
-      });
-    }
-    const newCpfpRefundOutPoint = {
-      txid: (0, import_utils4.hexToBytes)(getTxId(newNodeTx)),
-      index: 0
-    };
-    let newDirectRefundOutPoint;
-    if (newDirectNodeTx) {
-      newDirectRefundOutPoint = {
-        txid: (0, import_utils4.hexToBytes)(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()
-    });
-    const cpfpRefundSig = await this.config.signer.aggregateFrost({
-      message: cpfpRefundSighash,
-      statechainSignatures: response.refundTxSigningResult.signingResult?.signatureShares,
-      statechainPublicKeys: response.refundTxSigningResult.signingResult?.publicKeys,
-      verifyingKey: response.refundTxSigningResult.verifyingKey,
-      statechainCommitments: response.refundTxSigningResult.signingResult?.signingNonceCommitments,
-      selfCommitment: newCpfpRefundSigningJob.signingNonceCommitment,
-      publicKey: signingPublicKey,
-      selfSignature: cpfpRefundUserSig,
-      adaptorPubKey: new Uint8Array()
+      verifyingKey: node.verifyingPublicKey
     });
-    let directRefundSig;
-    if (directRefundSighash && newDirectRefundSigningJob && response.directRefundTxSigningResult) {
-      const directRefundUserSig = await this.config.signer.signFrost({
-        message: directRefundSighash,
-        keyDerivation,
-        publicKey: signingPublicKey,
-        verifyingKey: response.directRefundTxSigningResult.verifyingKey,
-        selfCommitment: newDirectRefundSigningJob.signingNonceCommitment,
-        statechainCommitments: response.directRefundTxSigningResult.signingResult?.signingNonceCommitments,
-        adaptorPubKey: new Uint8Array()
-      });
-      directRefundSig = await this.config.signer.aggregateFrost({
-        message: directRefundSighash,
-        statechainSignatures: response.directRefundTxSigningResult.signingResult?.signatureShares,
-        statechainPublicKeys: response.directRefundTxSigningResult.signingResult?.publicKeys,
-        verifyingKey: response.directRefundTxSigningResult.verifyingKey,
-        statechainCommitments: response.directRefundTxSigningResult.signingResult?.signingNonceCommitments,
-        selfCommitment: newDirectRefundSigningJob.signingNonceCommitment,
-        publicKey: signingPublicKey,
-        selfSignature: directRefundUserSig,
-        adaptorPubKey: new Uint8Array()
-      });
-    }
-    let directFromCpfpRefundSig;
-    if (directFromCpfpRefundSighash && newDirectFromCpfpRefundSigningJob && response.directFromCpfpRefundTxSigningResult) {
-      const directFromCpfpRefundUserSig = await this.config.signer.signFrost({
-        message: directFromCpfpRefundSighash,
+    if (newDirectNodeTx) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: newDirectNodeTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "directNode",
+        parentTxOut: splitNodeOutput,
+        leafId: node.id,
         keyDerivation,
-        publicKey: signingPublicKey,
-        verifyingKey: response.directFromCpfpRefundTxSigningResult.verifyingKey,
-        selfCommitment: newDirectFromCpfpRefundSigningJob.signingNonceCommitment,
-        statechainCommitments: response.directFromCpfpRefundTxSigningResult.signingResult?.signingNonceCommitments,
-        adaptorPubKey: new Uint8Array()
-      });
-      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: (0, import_utils4.hexToBytes)(getTxId(nodeTx)),
-      index: 0
-    };
-    let directRefundOutPoint;
-    if (directNodeTx) {
-      directRefundOutPoint = {
-        txid: (0, import_utils4.hexToBytes)(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;
   }
 };
 
@@ -21639,71 +21694,6 @@ var CoopExitService = class extends BaseTransferService {
       directFromCpfpSignaturesMap
     };
   }
-  createConnectorRefundTransactions(sequence, directSequence, cpfpNodeOutPoint, directNodeOutPoint, connectorOutput, amountSats, receiverPubKey) {
-    const cpfpRefundTx = new import_btc_signer3.Transaction();
-    if (!cpfpNodeOutPoint.txid || cpfpNodeOutPoint.index === void 0) {
-      throw new ValidationError("Invalid CPFP node outpoint", {
-        field: "cpfpNodeOutPoint",
-        value: { txid: cpfpNodeOutPoint.txid, index: cpfpNodeOutPoint.index },
-        expected: "Both txid and index must be defined"
-      });
-    }
-    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 import_btc_signer3.Transaction();
-      directRefundTx.addInput({
-        txid: directNodeOutPoint.txid,
-        index: directNodeOutPoint.index,
-        sequence: directSequence
-      });
-      directRefundTx.addInput(connectorOutput);
-      directRefundTx.addOutput({
-        script: receiverScript,
-        amount: maybeApplyFee(amountSats)
-      });
-      directFromCpfpRefundTx = new import_btc_signer3.Transaction();
-      directFromCpfpRefundTx.addInput({
-        txid: cpfpNodeOutPoint.txid,
-        index: cpfpNodeOutPoint.index,
-        sequence: directSequence
-      });
-      directFromCpfpRefundTx.addInput(connectorOutput);
-      directFromCpfpRefundTx.addOutput({
-        script: receiverScript,
-        amount: maybeApplyFee(amountSats)
-      });
-    }
-    return {
-      cpfpRefundTx,
-      directRefundTx,
-      directFromCpfpRefundTx
-    };
-  }
   async signCoopExitRefunds(leaves, exitTxId, connectorOutputs, receiverPubKey, transferId) {
     if (leaves.length !== connectorOutputs.length) {
       throw new ValidationError(
@@ -21737,29 +21727,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();
@@ -21865,13 +21865,13 @@ var CoopExitService = class extends BaseTransferService {
 // src/services/deposit.ts
 var import_secp256k14 = require("@noble/curves/secp256k1");
 var import_sha26 = require("@noble/hashes/sha2");
-var import_utils6 = require("@noble/hashes/utils");
-var import_btc_signer4 = require("@scure/btc-signer");
-var import_utils7 = require("@scure/btc-signer/utils");
+var import_utils7 = require("@noble/hashes/utils");
+var import_btc_signer2 = require("@scure/btc-signer");
+var import_utils8 = require("@scure/btc-signer/utils");
 
 // src/utils/keys.ts
 var import_secp256k13 = require("@noble/curves/secp256k1");
-var import_utils5 = require("@noble/curves/utils");
+var import_utils6 = require("@noble/curves/utils");
 function addPublicKeys(a, b) {
   if (a.length !== 33 || b.length !== 33) {
     throw new ValidationError("Public keys must be 33 bytes", {
@@ -21928,7 +21928,7 @@ function addPrivateKeys(a, b) {
   const privA = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(a);
   const privB = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(b);
   const sum2 = (privA + privB) % import_secp256k13.secp256k1.CURVE.n;
-  return (0, import_utils5.numberToBytesBE)(sum2, 32);
+  return (0, import_utils6.numberToBytesBE)(sum2, 32);
 }
 function subtractPrivateKeys(a, b) {
   if (a.length !== 32 || b.length !== 32) {
@@ -21941,7 +21941,7 @@ function subtractPrivateKeys(a, b) {
   const privA = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(a);
   const privB = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(b);
   const sum2 = (import_secp256k13.secp256k1.CURVE.n - privB + privA) % import_secp256k13.secp256k1.CURVE.n;
-  return (0, import_utils5.numberToBytesBE)(sum2, 32);
+  return (0, import_utils6.numberToBytesBE)(sum2, 32);
 }
 function sumOfPrivateKeys(keys) {
   return keys.reduce((sum2, key) => {
@@ -22008,7 +22008,7 @@ var DepositService = class {
       operatorPubkey,
       address.address
     );
-    const taprootKey = (0, import_btc_signer4.p2tr)(
+    const taprootKey = (0, import_btc_signer2.p2tr)(
       operatorPubkey.slice(1, 33),
       void 0,
       getNetwork(this.config.getNetwork())
@@ -22032,7 +22032,7 @@ var DepositService = class {
       if (operator.identifier === this.config.getCoordinatorIdentifier() && !verifyCoordinatorProof) {
         continue;
       }
-      const operatorPubkey2 = (0, import_utils6.hexToBytes)(operator.identityPublicKey);
+      const operatorPubkey2 = (0, import_utils7.hexToBytes)(operator.identityPublicKey);
       const operatorSig = address.depositAddressProof.addressSignatures[operator.identifier];
       if (!operatorSig) {
         throw new ValidationError("Operator signature not found", {
@@ -22151,38 +22151,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: (0, import_utils6.hexToBytes)(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: (0, import_utils6.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
-      directInput: { txid: (0, import_utils6.hexToBytes)(getTxId(directRootTx)), index: 0 },
-      amountSats: amount,
+    const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createInitialTimelockRefundTxs({
+      nodeTx: cpfpRootTx,
+      directNodeTx: directRootTx,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
     });
@@ -22311,7 +22291,7 @@ var DepositService = class {
         }
       );
     }
-    if (!(0, import_utils7.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+    if (!(0, import_utils8.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
       throw new ValidationError("Verifying key mismatch", {
         field: "verifyingKey",
         value: treeResp.rootNodeSignatureShares.verifyingKey,
@@ -22474,22 +22454,12 @@ var DepositService = class {
         expected: "Output with script and amount"
       });
     }
-    const depositOutPoint = {
-      txid: (0, import_utils6.hexToBytes)(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: (0, import_utils6.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
-      amountSats: amount,
+    const { cpfpRefundTx } = createInitialTimelockRefundTxs({
+      nodeTx: cpfpRootTx,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
     });
@@ -22558,7 +22528,7 @@ var DepositService = class {
         }
       );
     }
-    if (!(0, import_utils7.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+    if (!(0, import_utils8.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
       throw new ValidationError("Verifying key mismatch", {
         field: "verifyingKey",
         value: treeResp.rootNodeSignatureShares.verifyingKey,
@@ -22634,7 +22604,7 @@ var DepositService = class {
 
 // src/services/lightning.ts
 var import_secp256k15 = require("@noble/curves/secp256k1");
-var import_utils8 = require("@noble/curves/utils");
+var import_utils9 = require("@noble/curves/utils");
 var import_sha27 = require("@noble/hashes/sha2");
 var import_uuidv73 = require("uuidv7");
 
@@ -22719,8 +22689,8 @@ var LightningService = class {
   }) {
     const crypto = getCrypto();
     const randBytes = crypto.getRandomValues(new Uint8Array(32));
-    const preimage = (0, import_utils8.numberToBytesBE)(
-      (0, import_utils8.bytesToNumberBE)(randBytes) % import_secp256k15.secp256k1.CURVE.n,
+    const preimage = (0, import_utils9.numberToBytesBE)(
+      (0, import_utils9.bytesToNumberBE)(randBytes) % import_secp256k15.secp256k1.CURVE.n,
       32
     );
     return await this.createLightningInvoiceWithPreImage({
@@ -22775,12 +22745,12 @@ var LightningService = class {
         const sparkClient = await this.connectionManager.createSparkClient(
           operator.address
         );
-        const userIdentityPublicKey = receiverIdentityPubkey ? (0, import_utils8.hexToBytes)(receiverIdentityPubkey) : await this.config.signer.getIdentityPublicKey();
+        const userIdentityPublicKey = receiverIdentityPubkey ? (0, import_utils9.hexToBytes)(receiverIdentityPubkey) : await this.config.signer.getIdentityPublicKey();
         try {
           await sparkClient.store_preimage_share({
             paymentHash,
             preimageShare: {
-              secretShare: (0, import_utils8.numberToBytesBE)(share.share, 32),
+              secretShare: (0, import_utils9.numberToBytesBE)(share.share, 32),
               proofs: share.proofs
             },
             threshold: this.config.getThreshold(),
@@ -22997,14 +22967,14 @@ var LightningService = class {
 };
 
 // src/services/token-transactions.ts
-var import_utils12 = require("@noble/curves/utils");
-var import_utils13 = require("@noble/hashes/utils");
+var import_utils13 = require("@noble/curves/utils");
+var import_utils14 = require("@noble/hashes/utils");
 
 // src/utils/address.ts
 var import_wire5 = require("@bufbuild/protobuf/wire");
 var import_secp256k16 = require("@noble/curves/secp256k1");
-var import_utils9 = require("@noble/curves/utils");
-var import_utils10 = require("@noble/hashes/utils");
+var import_utils10 = require("@noble/curves/utils");
+var import_utils11 = require("@noble/hashes/utils");
 var import_base3 = require("@scure/base");
 var import_uuidv74 = require("uuidv7");
 
@@ -23196,7 +23166,7 @@ function encodeSparkAddress(payload) {
 function encodeSparkAddressWithSignature(payload, signature) {
   try {
     isValidPublicKey(payload.identityPublicKey);
-    const identityPublicKey = (0, import_utils10.hexToBytes)(payload.identityPublicKey);
+    const identityPublicKey = (0, import_utils11.hexToBytes)(payload.identityPublicKey);
     let sparkInvoiceFields;
     if (payload.sparkInvoiceFields) {
       validateSparkInvoiceFields(payload.sparkInvoiceFields);
@@ -23240,8 +23210,8 @@ function decodeSparkAddress(address, network) {
     const decoded = bech32mDecode(address);
     const payload = SparkAddress.decode(import_base3.bech32m.fromWords(decoded.words));
     const { identityPublicKey, sparkInvoiceFields, signature } = payload;
-    const identityPubkeyHex = (0, import_utils10.bytesToHex)(identityPublicKey);
-    const signatureHex = signature ? (0, import_utils10.bytesToHex)(signature) : void 0;
+    const identityPubkeyHex = (0, import_utils11.bytesToHex)(identityPublicKey);
+    const signatureHex = signature ? (0, import_utils11.bytesToHex)(signature) : void 0;
     isValidPublicKey(identityPubkeyHex);
     return {
       identityPublicKey: identityPubkeyHex,
@@ -23251,10 +23221,10 @@ function decodeSparkAddress(address, network) {
         id: import_uuidv74.UUID.ofInner(sparkInvoiceFields.id).toString(),
         paymentType: sparkInvoiceFields.paymentType ? sparkInvoiceFields.paymentType.$case === "tokensPayment" ? {
           type: "tokens",
-          tokenIdentifier: sparkInvoiceFields.paymentType.tokensPayment.tokenIdentifier ? (0, import_utils10.bytesToHex)(
+          tokenIdentifier: sparkInvoiceFields.paymentType.tokensPayment.tokenIdentifier ? (0, import_utils11.bytesToHex)(
             sparkInvoiceFields.paymentType.tokensPayment.tokenIdentifier
           ) : void 0,
-          amount: sparkInvoiceFields.paymentType.tokensPayment.amount ? (0, import_utils9.bytesToNumberBE)(
+          amount: sparkInvoiceFields.paymentType.tokensPayment.amount ? (0, import_utils10.bytesToNumberBE)(
             sparkInvoiceFields.paymentType.tokensPayment.amount
           ) : void 0
         } : sparkInvoiceFields.paymentType.$case === "satsPayment" ? {
@@ -23262,7 +23232,7 @@ function decodeSparkAddress(address, network) {
           amount: sparkInvoiceFields.paymentType.satsPayment.amount
         } : void 0 : void 0,
         memo: sparkInvoiceFields.memo,
-        senderPublicKey: sparkInvoiceFields.senderPublicKey ? (0, import_utils10.bytesToHex)(sparkInvoiceFields.senderPublicKey) : void 0,
+        senderPublicKey: sparkInvoiceFields.senderPublicKey ? (0, import_utils11.bytesToHex)(sparkInvoiceFields.senderPublicKey) : void 0,
         expiryTime: sparkInvoiceFields.expiryTime
       },
       signature: signatureHex
@@ -23363,7 +23333,7 @@ function validateSparkInvoiceFields(sparkInvoiceFields) {
   }
   if (senderPublicKey) {
     try {
-      isValidPublicKey((0, import_utils10.bytesToHex)(senderPublicKey));
+      isValidPublicKey((0, import_utils11.bytesToHex)(senderPublicKey));
     } catch (error) {
       throw new ValidationError(
         "Invalid sender public key",
@@ -23414,7 +23384,7 @@ function validateSparkInvoiceFields(sparkInvoiceFields) {
             value: tokensAmount
           });
         }
-        const tokensAmountBigInt = (0, import_utils9.bytesToNumberBE)(tokensAmount);
+        const tokensAmountBigInt = (0, import_utils10.bytesToNumberBE)(tokensAmount);
         if (tokensAmountBigInt < 0 || tokensAmountBigInt > MAX_UINT128) {
           throw new ValidationError(
             "Asset amount must be between 0 and MAX_UINT128",
@@ -27705,11 +27675,11 @@ function validateTokenTransaction(finalTokenTransaction, partialTokenTransaction
 }
 
 // src/utils/token-transactions.ts
-var import_utils11 = require("@noble/curves/utils");
+var import_utils12 = require("@noble/curves/utils");
 function sumAvailableTokens(outputs) {
   try {
     return outputs.reduce(
-      (sum2, output) => sum2 + BigInt((0, import_utils11.bytesToNumberBE)(output.output.tokenAmount)),
+      (sum2, output) => sum2 + BigInt((0, import_utils12.bytesToNumberBE)(output.output.tokenAmount)),
       BigInt(0)
     );
   } catch (error) {
@@ -27740,7 +27710,7 @@ function filterTokenBalanceForTokenIdentifier(tokenBalances, tokenIdentifier) {
   }
   const tokenIdentifierBytes = decodeBech32mTokenIdentifier(tokenIdentifier).tokenIdentifier;
   const tokenBalance = [...tokenBalances.entries()].find(
-    ([, info]) => (0, import_utils11.equalBytes)(info.tokenMetadata.rawTokenIdentifier, tokenIdentifierBytes)
+    ([, info]) => (0, import_utils12.equalBytes)(info.tokenMetadata.rawTokenIdentifier, tokenIdentifierBytes)
   );
   if (!tokenBalance) {
     return {
@@ -27834,14 +27804,14 @@ var TokenTransactionService = class {
       }
       if (receiverAddress.sparkInvoiceFields) {
         return {
-          receiverPublicKey: (0, import_utils13.hexToBytes)(receiverAddress.identityPublicKey),
+          receiverPublicKey: (0, import_utils14.hexToBytes)(receiverAddress.identityPublicKey),
           rawTokenIdentifier,
           tokenAmount: transfer.tokenAmount,
           sparkInvoice: transfer.receiverSparkAddress
         };
       }
       return {
-        receiverPublicKey: (0, import_utils13.hexToBytes)(receiverAddress.identityPublicKey),
+        receiverPublicKey: (0, import_utils14.hexToBytes)(receiverAddress.identityPublicKey),
         rawTokenIdentifier,
         tokenAmount: transfer.tokenAmount
       };
@@ -27871,7 +27841,7 @@ var TokenTransactionService = class {
       (output) => ({
         ownerPublicKey: output.receiverPublicKey,
         tokenIdentifier: output.rawTokenIdentifier,
-        tokenAmount: (0, import_utils12.numberToBytesBE)(output.tokenAmount, 16)
+        tokenAmount: (0, import_utils13.numberToBytesBE)(output.tokenAmount, 16)
       })
     );
     if (availableTokenAmount > totalRequestedAmount) {
@@ -27880,7 +27850,7 @@ var TokenTransactionService = class {
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
         tokenIdentifier: firstTokenIdentifierBytes,
-        tokenAmount: (0, import_utils12.numberToBytesBE)(changeAmount, 16)
+        tokenAmount: (0, import_utils13.numberToBytesBE)(changeAmount, 16)
       });
     }
     return {
@@ -27907,7 +27877,7 @@ var TokenTransactionService = class {
     for (const [_, operator] of Object.entries(
       this.config.getSigningOperators()
     )) {
-      operatorKeys.push((0, import_utils13.hexToBytes)(operator.identityPublicKey));
+      operatorKeys.push((0, import_utils14.hexToBytes)(operator.identityPublicKey));
     }
     return operatorKeys;
   }
@@ -27924,7 +27894,7 @@ var TokenTransactionService = class {
       finalTokenTransactionHash,
       signingOperators
     );
-    return (0, import_utils12.bytesToHex)(finalTokenTransactionHash);
+    return (0, import_utils13.bytesToHex)(finalTokenTransactionHash);
   }
   async startTokenTransaction(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const sparkClient = await this.connectionManager.createSparkTokenClient(
@@ -28099,10 +28069,10 @@ var TokenTransactionService = class {
       });
     }
     for (const ownerPublicKey of ownerPublicKeys) {
-      isValidPublicKey((0, import_utils12.bytesToHex)(ownerPublicKey));
+      isValidPublicKey((0, import_utils13.bytesToHex)(ownerPublicKey));
     }
     for (const issuerPublicKey of issuerPublicKeys) {
-      isValidPublicKey((0, import_utils12.bytesToHex)(issuerPublicKey));
+      isValidPublicKey((0, import_utils13.bytesToHex)(issuerPublicKey));
     }
     for (const tokenIdentifier of tokenIdentifiers) {
       if (tokenIdentifier.length !== 32) {
@@ -28170,8 +28140,8 @@ var TokenTransactionService = class {
       this.config.getCoordinatorAddress()
     );
     let queryParams = {
-      issuerPublicKeys: issuerPublicKeys?.map(import_utils13.hexToBytes),
-      ownerPublicKeys: ownerPublicKeys?.map(import_utils13.hexToBytes),
+      issuerPublicKeys: issuerPublicKeys?.map(import_utils14.hexToBytes),
+      ownerPublicKeys: ownerPublicKeys?.map(import_utils14.hexToBytes),
       tokenIdentifiers: tokenIdentifiers?.map((identifier) => {
         const { tokenIdentifier } = decodeBech32mTokenIdentifier(
           identifier,
@@ -28179,7 +28149,7 @@ var TokenTransactionService = class {
         );
         return tokenIdentifier;
       }),
-      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils13.hexToBytes),
+      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils14.hexToBytes),
       outputIds: outputIds || [],
       limit: pageSize,
       offset
@@ -28214,7 +28184,7 @@ var TokenTransactionService = class {
       });
     }
     const exactMatch = tokenOutputs.find(
-      (item) => (0, import_utils12.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
+      (item) => (0, import_utils13.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
     );
     if (exactMatch) {
       return [exactMatch];
@@ -28225,7 +28195,7 @@ var TokenTransactionService = class {
     for (const outputWithPreviousTransactionData of tokenOutputs) {
       if (remainingAmount <= 0n) break;
       selectedOutputs.push(outputWithPreviousTransactionData);
-      remainingAmount -= (0, import_utils12.bytesToNumberBE)(
+      remainingAmount -= (0, import_utils13.bytesToNumberBE)(
         outputWithPreviousTransactionData.output.tokenAmount
       );
     }
@@ -28240,14 +28210,14 @@ var TokenTransactionService = class {
   sortTokenOutputsByStrategy(tokenOutputs, strategy) {
     if (strategy === "SMALL_FIRST") {
       tokenOutputs.sort((a, b) => {
-        const amountA = (0, import_utils12.bytesToNumberBE)(a.output.tokenAmount);
-        const amountB = (0, import_utils12.bytesToNumberBE)(b.output.tokenAmount);
+        const amountA = (0, import_utils13.bytesToNumberBE)(a.output.tokenAmount);
+        const amountB = (0, import_utils13.bytesToNumberBE)(b.output.tokenAmount);
         return amountA < amountB ? -1 : amountA > amountB ? 1 : 0;
       });
     } else {
       tokenOutputs.sort((a, b) => {
-        const amountA = (0, import_utils12.bytesToNumberBE)(a.output.tokenAmount);
-        const amountB = (0, import_utils12.bytesToNumberBE)(b.output.tokenAmount);
+        const amountA = (0, import_utils13.bytesToNumberBE)(a.output.tokenAmount);
+        const amountB = (0, import_utils13.bytesToNumberBE)(b.output.tokenAmount);
         return amountB < amountA ? -1 : amountB > amountA ? 1 : 0;
       });
     }
@@ -28255,7 +28225,7 @@ var TokenTransactionService = class {
   // Helper function for deciding if the signer public key is the identity public key
   async signMessageWithKey(message, publicKey) {
     const tokenSignatures = this.config.getTokenSignatures();
-    if ((0, import_utils12.bytesToHex)(publicKey) === (0, import_utils12.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
+    if ((0, import_utils13.bytesToHex)(publicKey) === (0, import_utils13.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
       if (tokenSignatures === "SCHNORR") {
         return await this.config.signer.signSchnorrWithIdentityKey(message);
       } else {
@@ -28264,8 +28234,8 @@ var TokenTransactionService = class {
     } else {
       throw new ValidationError("Invalid public key", {
         field: "publicKey",
-        value: (0, import_utils12.bytesToHex)(publicKey),
-        expected: (0, import_utils12.bytesToHex)(await this.config.signer.getIdentityPublicKey())
+        value: (0, import_utils13.bytesToHex)(publicKey),
+        expected: (0, import_utils13.bytesToHex)(await this.config.signer.getIdentityPublicKey())
       });
     }
   }
@@ -28284,7 +28254,7 @@ var TokenTransactionService = class {
         }
         const payload = {
           finalTokenTransactionHash,
-          operatorIdentityPublicKey: (0, import_utils13.hexToBytes)(operator.identityPublicKey)
+          operatorIdentityPublicKey: (0, import_utils14.hexToBytes)(operator.identityPublicKey)
         };
         const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
         const ownerSignature = await this.signMessageWithKey(
@@ -28306,7 +28276,7 @@ var TokenTransactionService = class {
         }
         const payload = {
           finalTokenTransactionHash,
-          operatorIdentityPublicKey: (0, import_utils13.hexToBytes)(operator.identityPublicKey)
+          operatorIdentityPublicKey: (0, import_utils14.hexToBytes)(operator.identityPublicKey)
         };
         const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
         const ownerSignature = await this.signMessageWithKey(
@@ -28322,7 +28292,7 @@ var TokenTransactionService = class {
         for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
           const payload = {
             finalTokenTransactionHash,
-            operatorIdentityPublicKey: (0, import_utils13.hexToBytes)(operator.identityPublicKey)
+            operatorIdentityPublicKey: (0, import_utils14.hexToBytes)(operator.identityPublicKey)
           };
           const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
           let ownerSignature;
@@ -28339,7 +28309,7 @@ var TokenTransactionService = class {
       }
       inputTtxoSignaturesPerOperator.push({
         ttxoSignatures,
-        operatorIdentityPublicKey: (0, import_utils13.hexToBytes)(operator.identityPublicKey)
+        operatorIdentityPublicKey: (0, import_utils14.hexToBytes)(operator.identityPublicKey)
       });
     }
     return inputTtxoSignaturesPerOperator;
@@ -28349,22 +28319,22 @@ var TokenTransactionService = class {
 // src/utils/adaptor-signature.ts
 var import_modular = require("@noble/curves/abstract/modular");
 var import_secp256k17 = require("@noble/curves/secp256k1");
-var import_utils14 = require("@noble/curves/utils");
+var import_utils15 = require("@noble/curves/utils");
 function generateSignatureFromExistingAdaptor(signature, adaptorPrivateKeyBytes) {
   const { r, s } = parseSignature(signature);
-  const sBigInt = (0, import_utils14.bytesToNumberBE)(s);
-  const tBigInt = (0, import_utils14.bytesToNumberBE)(adaptorPrivateKeyBytes);
+  const sBigInt = (0, import_utils15.bytesToNumberBE)(s);
+  const tBigInt = (0, import_utils15.bytesToNumberBE)(adaptorPrivateKeyBytes);
   const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k17.secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...(0, import_utils14.numberToBytesBE)(newS, 32)]);
+  const newSignature = new Uint8Array([...r, ...(0, import_utils15.numberToBytesBE)(newS, 32)]);
   return newSignature;
 }
 function generateAdaptorFromSignature(signature) {
   const adaptorPrivateKey = import_secp256k17.secp256k1.utils.randomPrivateKey();
   const { r, s } = parseSignature(signature);
-  const sBigInt = (0, import_utils14.bytesToNumberBE)(s);
-  const tBigInt = (0, import_utils14.bytesToNumberBE)(adaptorPrivateKey);
+  const sBigInt = (0, import_utils15.bytesToNumberBE)(s);
+  const tBigInt = (0, import_utils15.bytesToNumberBE)(adaptorPrivateKey);
   const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k17.secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...(0, import_utils14.numberToBytesBE)(newS, 32)]);
+  const newSignature = new Uint8Array([...r, ...(0, import_utils15.numberToBytesBE)(newS, 32)]);
   return {
     adaptorSignature: newSignature,
     adaptorPrivateKey
@@ -28381,10 +28351,10 @@ function validateOutboundAdaptorSignature(pubkey, hash, signature, adaptorPubkey
 }
 function applyAdaptorToSignature(pubkey, hash, signature, adaptorPrivateKeyBytes) {
   const { r, s } = parseSignature(signature);
-  const sBigInt = (0, import_utils14.bytesToNumberBE)(s);
-  const adaptorPrivateKey = (0, import_utils14.bytesToNumberBE)(adaptorPrivateKeyBytes);
+  const sBigInt = (0, import_utils15.bytesToNumberBE)(s);
+  const adaptorPrivateKey = (0, import_utils15.bytesToNumberBE)(adaptorPrivateKeyBytes);
   const newS = (0, import_modular.mod)(sBigInt + adaptorPrivateKey, import_secp256k17.secp256k1.CURVE.n);
-  const newSig = new Uint8Array([...r, ...(0, import_utils14.numberToBytesBE)(newS, 32)]);
+  const newSig = new Uint8Array([...r, ...(0, import_utils15.numberToBytesBE)(newS, 32)]);
   try {
     if (import_secp256k17.schnorr.verify(newSig, hash, pubkey)) {
       return newSig;
@@ -28393,7 +28363,7 @@ function applyAdaptorToSignature(pubkey, hash, signature, adaptorPrivateKeyBytes
     console.error("[applyAdaptorToSignature] Addition verification failed:", e);
   }
   const altS = (0, import_modular.mod)(sBigInt - adaptorPrivateKey, import_secp256k17.secp256k1.CURVE.n);
-  const altSig = new Uint8Array([...r, ...(0, import_utils14.numberToBytesBE)(altS, 32)]);
+  const altSig = new Uint8Array([...r, ...(0, import_utils15.numberToBytesBE)(altS, 32)]);
   try {
     if (import_secp256k17.schnorr.verify(altSig, hash, pubkey)) {
       return altSig;
@@ -28410,7 +28380,7 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   if (hash.length !== 32) {
     throw new Error(`wrong size for message (got ${hash.length}, want 32)`);
   }
-  const pubKey = import_secp256k17.schnorr.utils.lift_x((0, import_utils14.bytesToNumberBE)(pubKeyBytes));
+  const pubKey = import_secp256k17.schnorr.utils.lift_x((0, import_utils15.bytesToNumberBE)(pubKeyBytes));
   pubKey.assertValidity();
   const { r, s } = parseSignature(signature);
   const commitmenet = import_secp256k17.schnorr.utils.taggedHash(
@@ -28422,9 +28392,9 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   if (commitmenet.length > 32) {
     throw new Error("hash of (r || P || m) too big");
   }
-  const e = (0, import_modular.mod)((0, import_utils14.bytesToNumberBE)(commitmenet), import_secp256k17.secp256k1.CURVE.n);
+  const e = (0, import_modular.mod)((0, import_utils15.bytesToNumberBE)(commitmenet), import_secp256k17.secp256k1.CURVE.n);
   const negE = (0, import_modular.mod)(-e, import_secp256k17.secp256k1.CURVE.n);
-  const sG = import_secp256k17.secp256k1.Point.BASE.multiplyUnsafe((0, import_utils14.bytesToNumberBE)(s));
+  const sG = import_secp256k17.secp256k1.Point.BASE.multiplyUnsafe((0, import_utils15.bytesToNumberBE)(s));
   const eP = pubKey.multiplyUnsafe(negE);
   const R = sG.add(eP);
   if (R.is0()) {
@@ -28440,7 +28410,7 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   if (newR.y % 2n !== 0n) {
     throw new Error("calculated R y-value is odd");
   }
-  const rNum = (0, import_utils14.bytesToNumberBE)(r);
+  const rNum = (0, import_utils15.bytesToNumberBE)(r);
   if (newR.toAffine().x !== rNum) {
     throw new Error("calculated R point was not given R");
   }
@@ -28461,15 +28431,15 @@ function parseSignature(signature) {
   }
   const r = signature.slice(0, 32);
   const s = signature.slice(32, 64);
-  if ((0, import_utils14.bytesToNumberBE)(r) >= import_secp256k17.secp256k1.CURVE.Fp.ORDER) {
+  if ((0, import_utils15.bytesToNumberBE)(r) >= import_secp256k17.secp256k1.CURVE.Fp.ORDER) {
     throw new ValidationError("Invalid signature: r >= field prime", {
-      rValue: (0, import_utils14.bytesToNumberBE)(r),
+      rValue: (0, import_utils15.bytesToNumberBE)(r),
       fieldPrime: import_secp256k17.secp256k1.CURVE.Fp.ORDER
     });
   }
-  if ((0, import_utils14.bytesToNumberBE)(s) >= import_secp256k17.secp256k1.CURVE.n) {
+  if ((0, import_utils15.bytesToNumberBE)(s) >= import_secp256k17.secp256k1.CURVE.n) {
     throw new ValidationError("Invalid signature: s >= group order", {
-      sValue: (0, import_utils14.bytesToNumberBE)(s),
+      sValue: (0, import_utils15.bytesToNumberBE)(s),
       groupOrder: import_secp256k17.secp256k1.CURVE.n
     });
   }
@@ -28492,7 +28462,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";
@@ -28513,13 +28483,10 @@ if (isBun) {
 }
 var clientEnv = `js-spark-sdk/${packageVersion} ${baseEnvStr}`;
 
-// src/services/signing.ts
-var import_utils16 = require("@noble/curves/utils");
-
 // src/utils/htlc-transactions.ts
-var import_btc_signer5 = require("@scure/btc-signer");
+var import_btc_signer3 = require("@scure/btc-signer");
 var import_secp256k18 = require("@noble/curves/secp256k1");
-var import_utils15 = require("@noble/curves/utils");
+var import_utils16 = require("@noble/curves/utils");
 var PUB_KEY_BYTES = "0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0";
 function numsPoint() {
   const withdrawalPubKeyPoint = import_secp256k18.secp256k1.Point.fromHex(PUB_KEY_BYTES);
@@ -28597,10 +28564,10 @@ function createLightningHTLCTransaction({
     outAmount = maybeApplyFee(outAmount);
   }
   const input = {
-    txid: (0, import_utils15.hexToBytes)(getTxId(nodeTx)),
+    txid: (0, import_utils16.hexToBytes)(getTxId(nodeTx)),
     index: 0
   };
-  const htlcTransaction = new import_btc_signer5.Transaction({
+  const htlcTransaction = new import_btc_signer3.Transaction({
     version: 3,
     allowUnknownOutputs: true
   });
@@ -28639,12 +28606,12 @@ function createHTLCTaprootAddress({
   );
   const hashLockLeaf = { leafVersion: 192, script: hashLockScript };
   const sequenceLockLeaf = { leafVersion: 192, script: sequenceLockScript };
-  const scriptTree = (0, import_btc_signer5.taprootListToTree)([hashLockLeaf, sequenceLockLeaf]);
-  const p2trScript = (0, import_btc_signer5.p2tr)(numsKey, scriptTree, network, true).script;
+  const scriptTree = (0, import_btc_signer3.taprootListToTree)([hashLockLeaf, sequenceLockLeaf]);
+  const p2trScript = (0, import_btc_signer3.p2tr)(numsKey, scriptTree, network, true).script;
   return p2trScript;
 }
 function createHashLockScript(hash, pubkey) {
-  const result = import_btc_signer5.Script.encode([
+  const result = import_btc_signer3.Script.encode([
     "SHA256",
     hash,
     "EQUALVERIFY",
@@ -28654,8 +28621,8 @@ function createHashLockScript(hash, pubkey) {
   return result;
 }
 function createSequenceLockScript(sequence, sequenceLockDestinationPubkey) {
-  const result = import_btc_signer5.Script.encode([
-    (0, import_btc_signer5.ScriptNum)().encode(BigInt(sequence)),
+  const result = import_btc_signer3.Script.encode([
+    (0, import_btc_signer3.ScriptNum)().encode(BigInt(sequence)),
     "CHECKSEQUENCEVERIFY",
     "DROP",
     sequenceLockDestinationPubkey.slice(1, 33),
@@ -28719,20 +28686,7 @@ var SigningService = class {
         });
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
-      const cpfpNodeOutPoint = {
-        txid: (0, import_utils16.hexToBytes)(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", {
@@ -28742,20 +28696,21 @@ var SigningService = class {
         });
       }
       let directNodeTx;
-      let directNodeOutPoint;
       if (leaf.leaf.directTx.length > 0) {
         directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
-        directNodeOutPoint = {
-          txid: (0, import_utils16.hexToBytes)(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()
       });
@@ -28771,7 +28726,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",
@@ -28796,16 +28752,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,
@@ -28932,6 +28878,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
@@ -29731,7 +29706,7 @@ var TaprootSparkSigner = class extends DefaultSparkSigner {
 var import_secp256k113 = require("@noble/curves/secp256k1");
 var import_utils21 = require("@noble/curves/utils");
 var btc3 = __toESM(require("@scure/btc-signer"), 1);
-var import_btc_signer6 = require("@scure/btc-signer");
+var import_btc_signer4 = require("@scure/btc-signer");
 var import_utils22 = require("@scure/btc-signer/utils");
 var STATIC_FAUCET_KEY = (0, import_utils21.hexToBytes)(
   "deadbeef1337cafe4242424242424242deadbeef1337cafe4242424242424242"
@@ -29819,7 +29794,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       );
       await this.generateToAddress(1, address);
       const fundingTxRaw = await this.getRawTransaction(fundingTxid);
-      const fundingTx = import_btc_signer6.Transaction.fromRaw((0, import_utils21.hexToBytes)(fundingTxRaw.hex));
+      const fundingTx = import_btc_signer4.Transaction.fromRaw((0, import_utils21.hexToBytes)(fundingTxRaw.hex));
       for (let i = 0; i < fundingTx.outputsLength; i++) {
         const output = fundingTx.getOutput(i);
         if (!output.script || !output.amount) continue;
@@ -29850,7 +29825,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 import_btc_signer6.Transaction();
+    const splitTx = new import_btc_signer4.Transaction();
     splitTx.addInput({
       txid: selectedUtxo.txid,
       index: selectedUtxo.vout
@@ -29893,7 +29868,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     }
   }
   async sendFaucetCoinToP2WPKHAddress(pubKey) {
-    const sendToPubKeyTx = new import_btc_signer6.Transaction();
+    const sendToPubKeyTx = new import_btc_signer4.Transaction();
     const p2wpkhAddress = btc3.p2wpkh(pubKey, getNetwork(4 /* LOCAL */)).address;
     if (!p2wpkhAddress) {
       throw new Error("Invalid P2WPKH address");
@@ -29929,7 +29904,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     const sighash = unsignedTx.preimageWitnessV1(
       0,
       new Array(unsignedTx.inputsLength).fill(script),
-      import_btc_signer6.SigHash.DEFAULT,
+      import_btc_signer4.SigHash.DEFAULT,
       new Array(unsignedTx.inputsLength).fill(fundingTxOut.amount)
     );
     const merkleRoot = new Uint8Array();
@@ -29948,6 +29923,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();
@@ -30000,27 +29983,62 @@ 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 = import_secp256k113.secp256k1.utils.randomPrivateKey();
     const pubKey = import_secp256k113.secp256k1.getPublicKey(key);
     return getP2TRAddressFromPublicKey(pubKey, 4 /* LOCAL */);
   }
+  async getNewExternalWallet() {
+    const key = import_secp256k113.secp256k1.utils.randomPrivateKey();
+    const pubKey = import_secp256k113.secp256k1.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 import_btc_signer6.Transaction();
+    const tx = new import_btc_signer4.Transaction();
     tx.addInput(coin.outpoint);
     const availableAmount = COIN_AMOUNT - FEE_AMOUNT;
-    const destinationAddress = (0, import_btc_signer6.Address)(getNetwork(4 /* LOCAL */)).decode(
+    const destinationAddress = (0, import_btc_signer4.Address)(getNetwork(4 /* LOCAL */)).decode(
       address
     );
-    const destinationScript = import_btc_signer6.OutScript.encode(destinationAddress);
+    const destinationScript = import_btc_signer4.OutScript.encode(destinationAddress);
     tx.addOutput({
       script: destinationScript,
       amount
@@ -30109,75 +30127,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,
@@ -30254,6 +30203,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 import_eventemitter3.EventEmitter {
   config;
@@ -30358,16 +30500,13 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
         if (event.transfer.transfer && !(0, import_utils24.equalBytes)(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,
@@ -30543,19 +30682,6 @@ var SparkWallet = class extends import_eventemitter3.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 (0, import_utils24.equalBytes)(addPublicKeys(pubkey1, pubkey2), verifyingKey);
   }
@@ -30665,75 +30791,84 @@ var SparkWallet = class extends import_eventemitter3.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();
@@ -31316,8 +31451,7 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
       }
       return await this.claimTransfer({
         transfer: incomingTransfer,
-        emit: false,
-        optimize: false
+        emit: false
       });
     } catch (e) {
       console.error("[processSwapBatch] Error details:", {
@@ -31711,16 +31845,16 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
         }
       );
     }
-    const tx = new import_btc_signer7.Transaction();
+    const tx = new import_btc_signer5.Transaction();
     tx.addInput({
       txid: depositTransactionId,
       index: outputIndex,
       witnessScript: new Uint8Array()
     });
-    const addressDecoded = (0, import_btc_signer7.Address)(getNetwork(network)).decode(
+    const addressDecoded = (0, import_btc_signer5.Address)(getNetwork(network)).decode(
       destinationAddress
     );
-    const outputScript = import_btc_signer7.OutScript.encode(addressDecoded);
+    const outputScript = import_btc_signer5.OutScript.encode(addressDecoded);
     tx.addOutput({
       script: outputScript,
       amount: BigInt(creditAmountSats)
@@ -31904,8 +32038,8 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
       if (!output) {
         continue;
       }
-      const parsedScript = import_btc_signer7.OutScript.decode(output.script);
-      const address = (0, import_btc_signer7.Address)(getNetwork(this.config.getNetwork())).encode(
+      const parsedScript = import_btc_signer5.OutScript.decode(output.script);
+      const address = (0, import_btc_signer5.Address)(getNetwork(this.config.getNetwork())).encode(
         parsedScript
       );
       if (staticDepositAddresses.has(address)) {
@@ -31982,26 +32116,7 @@ var SparkWallet = class extends import_eventemitter3.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.
@@ -32110,8 +32225,8 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
         if (!output) {
           continue;
         }
-        const parsedScript = import_btc_signer7.OutScript.decode(output.script);
-        const address = (0, import_btc_signer7.Address)(getNetwork(this.config.getNetwork())).encode(
+        const parsedScript = import_btc_signer5.OutScript.decode(output.script);
+        const address = (0, import_btc_signer5.Address)(getNetwork(this.config.getNetwork())).encode(
           parsedScript
         );
         if (unusedDepositAddresses.has(address)) {
@@ -32143,6 +32258,9 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
         depositTx,
         vout
       });
+      await this.withLeaves(async () => {
+        this.leaves.push(...nodes2);
+      });
       return nodes2;
     });
     this.mutexes.delete(txid);
@@ -32171,8 +32289,8 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
       if (!output) {
         continue;
       }
-      const parsedScript = import_btc_signer7.OutScript.decode(output.script);
-      const address = (0, import_btc_signer7.Address)(getNetwork(this.config.getNetwork())).encode(
+      const parsedScript = import_btc_signer5.OutScript.decode(output.script);
+      const address = (0, import_btc_signer5.Address)(getNetwork(this.config.getNetwork())).encode(
         parsedScript
       );
       const unusedDepositAddress = unusedDepositAddresses.get(address);
@@ -32319,8 +32437,7 @@ var SparkWallet = class extends import_eventemitter3.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}`
@@ -32363,7 +32480,7 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
                 transfer.id
               );
               if (pending) {
-                await this.claimTransfer({ transfer: pending, optimize: true });
+                await this.claimTransfer({ transfer: pending });
               }
             }
             return {
@@ -32413,75 +32530,45 @@ var SparkWallet = class extends import_eventemitter3.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({
@@ -32499,7 +32586,18 @@ var SparkWallet = class extends import_eventemitter3.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`);
       }
@@ -32507,17 +32605,14 @@ var SparkWallet = class extends import_eventemitter3.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);
@@ -32558,14 +32653,14 @@ var SparkWallet = class extends import_eventemitter3.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(
@@ -32584,8 +32679,7 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
    */
   async claimTransfer({
     transfer,
-    emit,
-    optimize
+    emit
   }) {
     const onError = async (context) => {
       const error = context.error;
@@ -32630,12 +32724,7 @@ var SparkWallet = class extends import_eventemitter3.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}`,
@@ -32668,7 +32757,7 @@ var SparkWallet = class extends import_eventemitter3.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;
         })
@@ -32939,8 +33028,7 @@ var SparkWallet = class extends import_eventemitter3.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,
@@ -33271,10 +33359,8 @@ var SparkWallet = class extends import_eventemitter3.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,
@@ -33360,8 +33446,7 @@ var SparkWallet = class extends import_eventemitter3.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
@@ -33649,7 +33734,7 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
    */
   async signTransaction(txHex, keyType = "auto-detect") {
     try {
-      const tx = import_btc_signer7.Transaction.fromRaw((0, import_utils24.hexToBytes)(txHex));
+      const tx = import_btc_signer5.Transaction.fromRaw((0, import_utils24.hexToBytes)(txHex));
       let publicKey;
       switch (keyType.toLowerCase()) {
         case "identity":
@@ -33856,15 +33941,6 @@ var SparkWallet = class extends import_eventemitter3.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(
@@ -33900,89 +33976,6 @@ var SparkWallet = class extends import_eventemitter3.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);
@@ -34137,8 +34130,7 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
       "getLightningReceiveRequest",
       "getLightningSendRequest",
       "getCoopExitRequest",
-      "checkTimelock",
-      "testOnly_expireTimelock"
+      "checkTimelock"
     ];
     methods.forEach((m) => this.wrapPublicSparkWalletMethodWithOtelSpan(m));
     this.initWallet = this.wrapWithOtelSpan(
@@ -35718,7 +35710,6 @@ setFetch(sparkBareFetch, Headers2);
   DIRECT_TIMELOCK_OFFSET,
   DefaultSparkSigner,
   HTLC_TIMELOCK_OFFSET,
-  INITIAL_DIRECT_SEQUENCE,
   INITIAL_SEQUENCE,
   InternalValidationError,
   LOGGER_NAMES,
@@ -35751,21 +35742,24 @@ setFetch(sparkBareFetch, Headers2);
   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,
@@ -35803,12 +35797,14 @@ setFetch(sparkBareFetch, Headers2);
   getTxFromRawTxHex,
   getTxId,
   getTxIdNoReverse,
+  hash160,
   isEphemeralAnchorOutput,
   isLegacySparkAddress,
   isSafeForNumber,
   isTxBroadcast,
   isValidPublicKey,
   isValidSparkAddress,
+  isZeroTimelock,
   lastKeyWithTarget,
   maybeApplyFee,
   modInverse,