@buildonspark/spark-sdk 0.1.38 → 0.1.40

package/dist/{chunk-7WRK6WNJ.js → chunk-LHT4QTFK.js}

@@ -2,9 +2,7 @@ import {
   Lrc20ConnectionManager
 } from "./chunk-FWQPAPXK.js";
 import {
-  TokenTransactionService
-} from "./chunk-W3EC5XSA.js";
-import {
+  DEFAULT_FEE_SATS,
   computeTaprootKeyNoScript,
   createRefundTx,
   getEphemeralAnchorOutput,
@@ -19,10 +17,7 @@ import {
   getTxFromRawTxHex,
   getTxId,
   proofOfPossessionMessageHashForDepositAddress
-} from "./chunk-E5SL7XTO.js";
-import {
-  calculateAvailableTokenAmount
-} from "./chunk-57XLH3ZR.js";
+} from "./chunk-ED3ZAFDI.js";
 import {
   mapTransferToWalletTransfer,
   mapTreeNodeToWalletLeaf
@@ -41,26 +36,29 @@ import {
   LightningReceiveRequestFromJson,
   LightningSendRequestFromJson
 } from "./chunk-S7KD6DDL.js";
+import {
+  TokenTransactionService
+} from "./chunk-5MNQB2T4.js";
+import {
+  calculateAvailableTokenAmount
+} from "./chunk-57XLH3ZR.js";
 import {
   decodeSparkAddress,
   encodeSparkAddress
-} from "./chunk-LIP2K6KR.js";
+} from "./chunk-2CDJZQN4.js";
 import {
   WalletConfigService
-} from "./chunk-DI7QXUQJ.js";
+} from "./chunk-W2VXS35Y.js";
 import {
   LRC_WALLET_NETWORK,
   LRC_WALLET_NETWORK_TYPE,
   Network,
   NetworkToProto,
   getNetwork
-} from "./chunk-VJTDG4BQ.js";
+} from "./chunk-HK6LPV6Z.js";
 import {
   ELECTRS_CREDENTIALS
 } from "./chunk-ZUVYYR5T.js";
-import {
-  BitcoinNetwork_default
-} from "./chunk-HMLOC6TE.js";
 import {
   addPublicKeys,
   applyAdaptorToSignature,
@@ -72,12 +70,11 @@ import {
   getCrypto
 } from "./chunk-MGPRLH6Q.js";
 import {
-  ConnectionManager
-} from "./chunk-RGWBSZIO.js";
+  BitcoinNetwork_default
+} from "./chunk-HMLOC6TE.js";
 import {
-  SendLeafKeyTweaks,
-  networkToJSON
-} from "./chunk-C5LTJBI7.js";
+  ConnectionManager
+} from "./chunk-I4JI6TYN.js";
 import {
   isReactNative
 } from "./chunk-HKAKEKCE.js";
@@ -88,6 +85,10 @@ import {
   RPCError,
   ValidationError
 } from "./chunk-TWF35O6M.js";
+import {
+  SendLeafKeyTweaks,
+  networkToJSON
+} from "./chunk-C5LTJBI7.js";
 import {
   Buffer
 } from "./chunk-MVRQ5US7.js";
@@ -1058,6 +1059,32 @@ var BaseTransferService = class {
     }
     return updatedTransfer;
   }
+  async deliverTransferPackage(transfer, leaves, refundSignatureMap) {
+    const keyTweakInputMap = await this.prepareSendTransferKeyTweaks(
+      transfer.id,
+      transfer.receiverIdentityPublicKey,
+      leaves,
+      refundSignatureMap
+    );
+    const transferPackage = await this.prepareTransferPackage(
+      transfer.id,
+      keyTweakInputMap,
+      leaves,
+      transfer.receiverIdentityPublicKey
+    );
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    const response = await sparkClient.finalize_transfer_with_transfer_package({
+      transferId: transfer.id,
+      ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+      transferPackage
+    });
+    if (!response.transfer) {
+      throw new ValidationError("No transfer response from operator");
+    }
+    return response.transfer;
+  }
   async sendTransferWithKeyTweaks(leaves, receiverIdentityPubkey) {
     const transferID = uuidv7();
     const keyTweakInputMap = await this.prepareSendTransferKeyTweaks(
@@ -1815,9 +1842,20 @@ var TransferService = class extends BaseTransferService {
       if (!input) {
         throw Error("Could not fetch tx input");
       }
-      const newTx = new Transaction({ allowUnknownOutputs: true });
-      for (let j = 0; j < nodeTx.outputsLength; j++) {
-        newTx.addOutput(nodeTx.getOutput(j));
+      const newTx = new Transaction({ version: 3, allowUnknownOutputs: true });
+      const originalOutput = nodeTx.getOutput(0);
+      if (!originalOutput) {
+        throw Error("Could not get original output");
+      }
+      newTx.addOutput({
+        script: originalOutput.script,
+        amount: originalOutput.amount
+      });
+      for (let j = 1; j < nodeTx.outputsLength; j++) {
+        const additionalOutput = nodeTx.getOutput(j);
+        if (additionalOutput) {
+          newTx.addOutput(additionalOutput);
+        }
       }
       if (i === 0) {
         const currSequence = input.sequence;
@@ -1844,9 +1882,23 @@ var TransferService = class extends BaseTransferService {
       throw Error("leaf does not have refund tx");
     }
     const refundTx = getTxFromRawTxBytes(leaf?.refundTx);
-    const newRefundTx = new Transaction({ allowUnknownOutputs: true });
-    for (let j = 0; j < refundTx.outputsLength; j++) {
-      newRefundTx.addOutput(refundTx.getOutput(j));
+    const newRefundTx = new Transaction({
+      version: 3,
+      allowUnknownOutputs: true
+    });
+    const originalRefundOutput = refundTx.getOutput(0);
+    if (!originalRefundOutput) {
+      throw Error("Could not get original refund output");
+    }
+    newRefundTx.addOutput({
+      script: originalRefundOutput.script,
+      amount: originalRefundOutput.amount
+    });
+    for (let j = 1; j < refundTx.outputsLength; j++) {
+      const additionalOutput = refundTx.getOutput(j);
+      if (additionalOutput) {
+        newRefundTx.addOutput(additionalOutput);
+      }
     }
     const refundTxInput = refundTx.getInput(0);
     if (!refundTxInput) {
@@ -1955,10 +2007,11 @@ var TransferService = class extends BaseTransferService {
       nodeTxSignature: leafSignature,
       refundTxSignature: refundSignature
     });
-    return await sparkClient.finalize_node_signatures({
+    const result = await sparkClient.finalize_node_signatures({
       intent: 3 /* REFRESH */,
       nodeSignatures
     });
+    return result;
   }
   async extendTimelock(node, signingPubKey) {
     const nodeTx = getTxFromRawTxBytes(node.nodeTx);
@@ -1969,9 +2022,20 @@ var TransferService = class extends BaseTransferService {
       index: 0
     };
     const { nextSequence: newNodeSequence } = getNextTransactionSequence(refundSequence);
-    const newNodeTx = new Transaction({ allowUnknownOutputs: true });
+    const newNodeTx = new Transaction({
+      version: 3,
+      allowUnknownOutputs: true
+    });
     newNodeTx.addInput({ ...newNodeOutPoint, sequence: newNodeSequence });
-    newNodeTx.addOutput(nodeTx.getOutput(0));
+    const originalOutput = nodeTx.getOutput(0);
+    if (!originalOutput) {
+      throw Error("Could not get original node output");
+    }
+    newNodeTx.addOutput({
+      script: originalOutput.script,
+      amount: originalOutput.amount
+      // feeReducedAmount,
+    });
     newNodeTx.addOutput(getEphemeralAnchorOutput());
     const newRefundOutPoint = {
       txid: hexToBytes(getTxId(newNodeTx)),
@@ -1985,11 +2049,16 @@ var TransferService = class extends BaseTransferService {
       initialSequence(),
       newRefundOutPoint,
       amountSats,
+      // feeReducedRefundAmount,
       signingPubKey,
       this.config.getNetwork()
     );
     const nodeSighash = getSigHashFromTx(newNodeTx, 0, nodeTx.getOutput(0));
-    const refundSighash = getSigHashFromTx(newRefundTx, 0, nodeTx.getOutput(0));
+    const refundSighash = getSigHashFromTx(
+      newRefundTx,
+      0,
+      newNodeTx.getOutput(0)
+    );
     const newNodeSigningJob = {
       signingPublicKey: signingPubKey,
       rawTx: newNodeTx.toBytes(),
@@ -2063,6 +2132,94 @@ var TransferService = class extends BaseTransferService {
       ]
     });
   }
+  async refreshTimelockRefundTx(node, signingPubKey) {
+    const nodeTx = getTxFromRawTxBytes(node.nodeTx);
+    const refundTx = getTxFromRawTxBytes(node.refundTx);
+    const currSequence = refundTx.getInput(0).sequence || 0;
+    const { nextSequence } = getNextTransactionSequence(currSequence);
+    const newRefundTx = new Transaction({
+      version: 3,
+      allowUnknownOutputs: true
+    });
+    const originalRefundOutput = refundTx.getOutput(0);
+    if (!originalRefundOutput) {
+      throw Error("Could not get original refund output");
+    }
+    newRefundTx.addOutput({
+      script: originalRefundOutput.script,
+      amount: originalRefundOutput.amount
+    });
+    for (let j = 1; j < refundTx.outputsLength; j++) {
+      const additionalOutput = refundTx.getOutput(j);
+      if (additionalOutput) {
+        newRefundTx.addOutput(additionalOutput);
+      }
+    }
+    const refundTxInput = refundTx.getInput(0);
+    if (!refundTxInput) {
+      throw Error("refund tx doesn't have input");
+    }
+    newRefundTx.addInput({
+      ...refundTxInput,
+      sequence: nextSequence
+    });
+    const refundSigningJob = {
+      signingPublicKey: signingPubKey,
+      rawTx: newRefundTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
+    };
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    const response = await sparkClient.refresh_timelock({
+      leafId: node.id,
+      ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+      signingJobs: [refundSigningJob]
+    });
+    if (response.signingResults.length !== 1) {
+      throw Error(
+        `Expected 1 signing result, got ${response.signingResults.length}`
+      );
+    }
+    const signingResult = response.signingResults[0];
+    if (!signingResult || !refundSigningJob.signingNonceCommitment) {
+      throw Error("Signing result or nonce commitment does not exist");
+    }
+    const rawTx = getTxFromRawTxBytes(refundSigningJob.rawTx);
+    const txOut = nodeTx.getOutput(0);
+    const rawTxSighash = getSigHashFromTx(rawTx, 0, txOut);
+    const userSignature = await this.config.signer.signFrost({
+      message: rawTxSighash,
+      privateAsPubKey: signingPubKey,
+      publicKey: signingPubKey,
+      verifyingKey: signingResult.verifyingKey,
+      selfCommitment: refundSigningJob.signingNonceCommitment,
+      statechainCommitments: signingResult.signingResult?.signingNonceCommitments,
+      adaptorPubKey: new Uint8Array()
+    });
+    const signature = await this.config.signer.aggregateFrost({
+      message: rawTxSighash,
+      statechainSignatures: signingResult.signingResult?.signatureShares,
+      statechainPublicKeys: signingResult.signingResult?.publicKeys,
+      verifyingKey: signingResult.verifyingKey,
+      statechainCommitments: signingResult.signingResult?.signingNonceCommitments,
+      selfCommitment: refundSigningJob.signingNonceCommitment,
+      publicKey: signingPubKey,
+      selfSignature: userSignature,
+      adaptorPubKey: new Uint8Array()
+    });
+    const result = await sparkClient.finalize_node_signatures({
+      intent: 3 /* REFRESH */,
+      nodeSignatures: [
+        {
+          nodeId: node.id,
+          nodeTxSignature: new Uint8Array(),
+          refundTxSignature: signature
+        }
+      ]
+    });
+    return result;
+  }
 };
 
 // src/services/coop-exit.ts
@@ -2349,7 +2506,7 @@ var DepositService = class {
     depositTx,
     vout
   }) {
-    const rootTx = new Transaction3();
+    const rootTx = new Transaction3({ version: 3 });
     const output = depositTx.getOutput(vout);
     if (!output) {
       throw new ValidationError("Invalid deposit transaction output", {
@@ -2367,17 +2524,19 @@ var DepositService = class {
         expected: "Output with script and amount"
       });
     }
+    let outputAmount = amount;
     rootTx.addInput({
       txid: getTxId(depositTx),
       index: vout
     });
     rootTx.addOutput({
       script,
-      amount
+      amount: outputAmount
     });
+    rootTx.addOutput(getEphemeralAnchorOutput());
     const rootNonceCommitment = await this.config.signer.getRandomSigningCommitment();
     const rootTxSighash = getSigHashFromTx(rootTx, 0, output);
-    const refundTx = new Transaction3();
+    const refundTx = new Transaction3({ version: 3 });
     const sequence = 1 << 30 | INITIAL_TIME_LOCK2;
     refundTx.addInput({
       txid: getTxId(rootTx),
@@ -2392,10 +2551,11 @@ var DepositService = class {
     const refundPkScript = btc.OutScript.encode(refundAddress);
     refundTx.addOutput({
       script: refundPkScript,
-      amount
+      amount: outputAmount
     });
+    refundTx.addOutput(getEphemeralAnchorOutput());
     const refundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const refundTxSighash = getSigHashFromTx(refundTx, 0, output);
+    const refundTxSighash = getSigHashFromTx(refundTx, 0, rootTx.getOutput(0));
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
@@ -2968,6 +3128,12 @@ import { hexToBytes as hexToBytes4 } from "@noble/curves/abstract/utils";
 import { sha256 as sha2566 } from "@noble/hashes/sha2";
 import { Address as Address2, OutScript as OutScript2, Transaction as Transaction4 } from "@scure/btc-signer";
 var INITIAL_TIME_LOCK3 = 2e3;
+function maybeApplyFee2(amount) {
+  if (amount > BigInt(DEFAULT_FEE_SATS)) {
+    return amount - BigInt(DEFAULT_FEE_SATS);
+  }
+  return amount;
+}
 var TreeCreationService = class {
   config;
   connectionManager;
@@ -3166,7 +3332,7 @@ var TreeCreationService = class {
       refundTxSigningJob: void 0,
       children: []
     };
-    const tx = new Transaction4();
+    const tx = new Transaction4({ version: 3 });
     tx.addInput({
       txid: getTxId(parentTx),
       index: vout
@@ -3178,6 +3344,7 @@ var TreeCreationService = class {
     tx.addOutput({
       script: parentTxOut.script,
       amount: parentTxOut.amount
+      // maybeApplyFee(parentTxOut.amount),
     });
     tx.addOutput(getEphemeralAnchorOutput());
     const signingNonceCommitment = await this.config.signer.getRandomSigningCommitment();
@@ -3194,7 +3361,7 @@ var TreeCreationService = class {
       refundTxSigningJob: void 0,
       children: []
     };
-    const childTx = new Transaction4();
+    const childTx = new Transaction4({ version: 3 });
     childTx.addInput({
       txid: getTxId(tx),
       index: 0,
@@ -3203,6 +3370,7 @@ var TreeCreationService = class {
     childTx.addOutput({
       script: parentTxOut.script,
       amount: parentTxOut.amount
+      // maybeApplyFee(parentTxOut.amount),
     });
     childTx.addOutput(getEphemeralAnchorOutput());
     const childSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
@@ -3213,7 +3381,7 @@ var TreeCreationService = class {
     };
     childCreationNode.nodeTxSigningCommitment = childSigningNonceCommitment;
     childCreationNode.nodeTxSigningJob = childSigningJob;
-    const refundTx = new Transaction4();
+    const refundTx = new Transaction4({ version: 3 });
     refundTx.addInput({
       txid: getTxId(childTx),
       index: 0,
@@ -3229,8 +3397,9 @@ var TreeCreationService = class {
     const refundPkScript = OutScript2.encode(refundAddress);
     refundTx.addOutput({
       script: refundPkScript,
-      amount: parentTxOut.amount
+      amount: maybeApplyFee2(parentTxOut.amount)
     });
+    refundTx.addOutput(getEphemeralAnchorOutput());
     const refundSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
     const refundSigningJob = {
       signingPublicKey: node.signingPublicKey,
@@ -3247,7 +3416,7 @@ var TreeCreationService = class {
     if (!parentTxOutput?.script || !parentTxOutput?.amount) {
       throw new Error("parentTxOutput is undefined");
     }
-    const rootNodeTx = new Transaction4();
+    const rootNodeTx = new Transaction4({ version: 3 });
     rootNodeTx.addInput({
       txid: getTxId(parentTx),
       index: vout
@@ -3262,10 +3431,10 @@ var TreeCreationService = class {
       rootNodeTx.addOutput({
         script: childPkScript,
         amount: parentTxOutput.amount / 2n
+        // feeAdjustedAmount / 2n,
       });
     }
-    const anchor = getEphemeralAnchorOutput();
-    rootNodeTx.addOutput(anchor);
+    rootNodeTx.addOutput(getEphemeralAnchorOutput());
     const rootNodeSigningCommitment = await this.config.signer.getRandomSigningCommitment();
     const rootNodeSigningJob = {
       signingPublicKey: root.signingPublicKey,
@@ -4476,7 +4645,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
           adaptorPrivateKey
         );
       }
-      await this.transferService.sendTransferTweakKey(
+      await this.transferService.deliverTransferPackage(
         transfer,
         leafKeyTweaks,
         signatureMap
@@ -6161,6 +6330,112 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     }
     return this.config.signer.validateMessageWithIdentityKey(hash, signature);
   }
+  /**
+   * Signs a transaction with wallet keys.
+   *
+   * @param {string} txHex - The transaction hex to sign
+   * @param {string} keyType - The type of key to use for signing ("identity", "deposit", or "auto-detect")
+   * @returns {Promise<string>} The signed transaction hex
+   */
+  async signTransaction(txHex, keyType = "auto-detect") {
+    try {
+      const tx = Transaction6.fromRaw(hexToBytes7(txHex));
+      let publicKey;
+      switch (keyType.toLowerCase()) {
+        case "identity":
+          publicKey = await this.config.signer.getIdentityPublicKey();
+          break;
+        case "deposit":
+          publicKey = await this.config.signer.getDepositSigningKey();
+          break;
+        case "auto-detect":
+        default:
+          const detectedKey = await this.detectKeyForTransaction(tx);
+          if (detectedKey) {
+            publicKey = detectedKey.publicKey;
+          } else {
+            publicKey = await this.config.signer.getIdentityPublicKey();
+          }
+          break;
+      }
+      let inputsSigned = 0;
+      for (let i = 0; i < tx.inputsLength; i++) {
+        const input = tx.getInput(i);
+        if (!input?.witnessUtxo?.script) {
+          continue;
+        }
+        const script = input.witnessUtxo.script;
+        if (script.length === 1 && script[0] === 81) {
+          continue;
+        }
+        const identityScript = getP2TRScriptFromPublicKey(
+          publicKey,
+          this.config.getNetwork()
+        );
+        if (bytesToHex4(script) === bytesToHex4(identityScript)) {
+          try {
+            this.config.signer.signTransactionIndex(tx, i, publicKey);
+            inputsSigned++;
+          } catch (error) {
+            throw new ValidationError(`Failed to sign input ${i}: ${error}`, {
+              field: "input",
+              value: i
+            });
+          }
+        }
+      }
+      if (inputsSigned === 0) {
+        throw new Error(
+          "No inputs were signed. Check that the transaction contains inputs controlled by this wallet."
+        );
+      }
+      tx.finalize();
+      const signedTxHex = tx.hex;
+      return signedTxHex;
+    } catch (error) {
+      console.error("\u274C Error signing transaction:", error);
+      throw error;
+    }
+  }
+  /**
+   * Helper method to auto-detect which key should be used for signing a transaction.
+   */
+  async detectKeyForTransaction(tx) {
+    try {
+      const identityPubKey = await this.config.signer.getIdentityPublicKey();
+      const depositPubKey = await this.config.signer.getDepositSigningKey();
+      for (let i = 0; i < tx.inputsLength; i++) {
+        const input = tx.getInput(i);
+        if (input?.witnessUtxo?.script) {
+          const script = input.witnessUtxo.script;
+          const identityScript = getP2TRScriptFromPublicKey(
+            identityPubKey,
+            this.config.getNetwork()
+          );
+          const depositScript = getP2TRScriptFromPublicKey(
+            depositPubKey,
+            this.config.getNetwork()
+          );
+          if (bytesToHex4(script) === bytesToHex4(identityScript)) {
+            return {
+              publicKey: identityPubKey,
+              keyType: "identity"
+            };
+          }
+          if (bytesToHex4(script) === bytesToHex4(depositScript)) {
+            return {
+              publicKey: depositPubKey,
+              keyType: "deposit"
+            };
+          }
+        }
+      }
+      return null;
+    } catch (error) {
+      console.warn("Error during key auto-detection:", error);
+      return null;
+    }
+  }
   /**
    * Get a Lightning receive request by ID.
    *
@@ -6191,6 +6466,246 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     const sspClient = this.getSspClient();
     return await sspClient.getCoopExitRequest(id);
   }
+  /**
+   * Check the remaining timelock on a given node.
+   *
+   * @param {string} nodeId - The ID of the node to check
+   * @returns {Promise<{nodeTimelock: number, refundTimelock: number}>} The remaining timelocks in blocks for both node and refund transactions
+   */
+  async checkTimelock(nodeId) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    try {
+      const response = await sparkClient.query_nodes({
+        source: {
+          $case: "nodeIds",
+          nodeIds: {
+            nodeIds: [nodeId]
+          }
+        },
+        includeParents: false,
+        network: NetworkToProto[this.config.getNetwork()]
+      });
+      const node = response.nodes[nodeId];
+      if (!node) {
+        throw new ValidationError("Node not found", {
+          field: "nodeId",
+          value: nodeId
+        });
+      }
+      const isRootNode = !node.parentNodeId;
+      if (!node.nodeTx || node.nodeTx.length === 0) {
+        throw new ValidationError(
+          `Node transaction data is missing or empty for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "nodeTx",
+            value: node.nodeTx?.length || 0
+          }
+        );
+      }
+      if (!node.refundTx || node.refundTx.length === 0) {
+        throw new ValidationError(
+          `Refund transaction data is missing or empty for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "refundTx",
+            value: node.refundTx?.length || 0
+          }
+        );
+      }
+      let nodeTx, refundTx;
+      try {
+        nodeTx = getTxFromRawTxBytes(node.nodeTx);
+      } catch (error) {
+        throw new ValidationError(
+          `Failed to parse node transaction for ${isRootNode ? "root" : "non-root"} node: ${error instanceof Error ? error.message : String(error)}`,
+          {
+            field: "nodeTx",
+            value: node.nodeTx.length
+          }
+        );
+      }
+      try {
+        refundTx = getTxFromRawTxBytes(node.refundTx);
+      } catch (error) {
+        throw new ValidationError(
+          `Failed to parse refund transaction for ${isRootNode ? "root" : "non-root"} node: ${error instanceof Error ? error.message : String(error)}`,
+          {
+            field: "refundTx",
+            value: node.refundTx.length
+          }
+        );
+      }
+      const nodeInput = nodeTx.getInput(0);
+      if (!nodeInput) {
+        throw new ValidationError(
+          `Node transaction has no inputs for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "nodeInput",
+            value: nodeTx.inputsLength
+          }
+        );
+      }
+      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(
+          `Refund transaction has no inputs for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "refundInput",
+            value: refundTx.inputsLength
+          }
+        );
+      }
+      if (!refundInput.sequence) {
+        throw new ValidationError(
+          `Refund transaction has no sequence for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "sequence",
+            value: refundInput.sequence
+          }
+        );
+      }
+      const nodeTimelock = nodeInput.sequence & 65535;
+      const refundTimelock = refundInput.sequence & 65535;
+      return {
+        nodeTimelock,
+        refundTimelock
+      };
+    } catch (error) {
+      throw new NetworkError(
+        `Failed to check timelock for node ${nodeId}`,
+        {
+          method: "query_nodes"
+        },
+        error
+      );
+    }
+  }
+  /**
+   * 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
+      });
+      const node = response.nodes[nodeId];
+      if (!node) {
+        throw new ValidationError("Node not found", {
+          field: "nodeId",
+          value: nodeId
+        });
+      }
+      if (!node.parentNodeId) {
+        throw new ValidationError("Node has no parent", {
+          field: "parentNodeId",
+          value: node.parentNodeId
+        });
+      }
+      const parentNode = response.nodes[node.parentNodeId];
+      if (!parentNode) {
+        throw new ValidationError("Parent node not found", {
+          field: "parentNodeId",
+          value: node.parentNodeId
+        });
+      }
+      const signingPubKey = await this.config.signer.generatePublicKey(
+        sha2567(node.id)
+      );
+      const result = await this.transferService.refreshTimelockNodes(
+        [node],
+        parentNode,
+        signingPubKey
+      );
+      const leafIndex = this.leaves.findIndex((leaf) => leaf.id === node.id);
+      if (leafIndex !== -1 && result.nodes.length > 0) {
+        const newNode = result.nodes[0];
+        if (newNode) {
+          this.leaves[leafIndex] = newNode;
+        }
+      }
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to refresh timelock",
+        {
+          method: "refresh_timelock"
+        },
+        error
+      );
+    }
+  }
+  /**
+   * Refresh the timelock of a specific node's refund transaction only.
+   *
+   * @param {string} nodeId - The ID of the node whose refund transaction to refresh
+   * @returns {Promise<void>} Promise that resolves when the refund timelock is refreshed
+   */
+  async testOnly_expireTimelockRefundTx(nodeId) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    try {
+      const response = await sparkClient.query_nodes({
+        source: {
+          $case: "nodeIds",
+          nodeIds: {
+            nodeIds: [nodeId]
+          }
+        },
+        includeParents: false
+      });
+      const node = response.nodes[nodeId];
+      if (!node) {
+        throw new ValidationError("Node not found", {
+          field: "nodeId",
+          value: nodeId
+        });
+      }
+      const signingPubKey = await this.config.signer.generatePublicKey(
+        sha2567(node.id)
+      );
+      const result = await this.transferService.refreshTimelockRefundTx(
+        node,
+        signingPubKey
+      );
+      const leafIndex = this.leaves.findIndex((leaf) => leaf.id === node.id);
+      if (leafIndex !== -1 && result.nodes.length > 0) {
+        const newNode = result.nodes[0];
+        if (newNode) {
+          this.leaves[leafIndex] = newNode;
+        }
+      }
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to refresh refund timelock",
+        {
+          method: "refresh_timelock_refund_tx"
+        },
+        error
+      );
+    }
+  }
   cleanup() {
     if (this.claimTransfersInterval) {
       clearInterval(this.claimTransfersInterval);