@buildonspark/spark-sdk 0.3.8 → 0.4.0

package/src/spark-wallet/spark-wallet.ts

@@ -1,4 +1,4 @@
-import { isNode, isObject, mapCurrencyAmount } from "@lightsparkdev/core";
+import { isObject, mapCurrencyAmount } from "@lightsparkdev/core";
 import { secp256k1 } from "@noble/curves/secp256k1";
 import {
   bytesToHex,
@@ -46,7 +46,6 @@ import {
   SigningJob,
   SubscribeToEventsResponse,
   Transfer,
-  TransferEvent,
   TransferStatus,
   TransferType,
   TreeNode,
@@ -87,10 +86,7 @@ import {
   NetworkType,
 } from "../utils/network.js";
 import { sumAvailableTokens } from "../utils/token-transactions.js";
-import {
-  doesLeafNeedRefresh,
-  getCurrentTimelock,
-} from "../utils/transaction.js";
+import { doesTxnNeedRenewed, isZeroTimelock } from "../utils/transaction.js";
 
 import { sha256 } from "@noble/hashes/sha2";
 import { trace, Tracer } from "@opentelemetry/api";
@@ -128,7 +124,6 @@ import {
 import { chunkArray } from "../utils/chunkArray.js";
 import { getFetch } from "../utils/fetch.js";
 import { addPublicKeys } from "../utils/keys.js";
-import { maximizeUnilateralExit } from "../utils/optimize.js";
 import { RetryContext, withRetry } from "../utils/retry.js";
 import {
   Bech32mTokenIdentifier,
@@ -156,6 +151,7 @@ import type {
   UserTokenMetadata,
 } from "./types.js";
 import { SparkWalletEvent } from "./types.js";
+import { optimize, shouldOptimize } from "../utils/optimize.js";
 
 /**
  * The SparkWallet class is the primary interface for interacting with the Spark network.
@@ -303,16 +299,15 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
           await this.claimTransfer({
             transfer: event.transfer.transfer,
             emit: true,
-            optimize: true,
           });
         }
       } else if (isDepositStreamEvent(event)) {
         const deposit = event.deposit.deposit;
-        const newLeaf = await this.transferService.extendTimelock(deposit);
-        await this.transferLeavesToSelf(newLeaf.nodes, {
-          type: KeyDerivationType.LEAF,
-          path: deposit.id,
+
+        await this.withLeaves(async () => {
+          this.leaves.push(deposit);
         });
+
         this.emit(
           SparkWalletEvent.DepositConfirmed,
           deposit.id,
@@ -531,20 +526,6 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
       .map(([_, node]) => node);
   }
 
-  private async checkExtendLeaves(leaves: TreeNode[]): Promise<void> {
-    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: KeyDerivationType.LEAF,
-            path: leaf.id,
-          });
-        }
-      }
-    });
-  }
-
   private verifyKey(
     pubkey1: Uint8Array,
     pubkey2: Uint8Array,
@@ -687,76 +668,101 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     return nodes;
   }
 
-  private areLeavesInefficient() {
-    const totalAmount = this.getInternalBalance();
-
-    if (this.leaves.length <= 1) {
-      return false;
+  public async *optimizeLeaves(
+    multiplicity: number | undefined = undefined,
+  ): AsyncGenerator<
+    {
+      step: number;
+      total: number;
+      controller: AbortController;
+    },
+    void,
+    void
+  > {
+    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);
+    if (
+      this.optimizationInProgress ||
+      !shouldOptimize(
+        this.leaves.map((leaf) => leaf.value),
+        multiplicityValue,
+      )
+    ) {
+      return;
+    }
 
-    let remainingAmount = totalAmount;
-    let optimalLeavesLength = 0;
+    const controller = new AbortController();
+    const release = await this.leavesMutex.acquire();
+    try {
+      this.optimizationInProgress = true;
 
-    for (let i = nextLowerPowerOfTwo; i >= 0; i--) {
-      const denomination = 2 ** i;
-      while (remainingAmount >= denomination) {
-        remainingAmount -= denomination;
-        optimalLeavesLength++;
+      this.leaves = await this.getLeaves();
+      const swaps = optimize(
+        this.leaves.map((leaf) => leaf.value),
+        multiplicityValue,
+      );
+      if (swaps.length === 0) {
+        return;
       }
-    }
-
-    return this.leaves.length > optimalLeavesLength * 5;
-  }
 
-  private async optimizeLeaves() {
-    if (this.optimizationInProgress || !this.areLeavesInefficient()) {
-      return;
-    }
+      yield {
+        step: 0,
+        total: swaps.length,
+        controller,
+      };
 
-    await this.withLeaves(async () => {
-      this.optimizationInProgress = true;
-      try {
-        this.leaves = await this.getLeaves();
-        const swaps = maximizeUnilateralExit(
-          this.leaves.map((leaf) => leaf.value),
-        );
+      // Build a map from the denomination to the indices
+      const valueToNodes = new Map<number, TreeNode[]>();
+      this.leaves.forEach((leaf) => {
+        if (!valueToNodes.has(leaf.value)) {
+          valueToNodes.set(leaf.value, []);
+        }
+        valueToNodes.get(leaf.value)!.push(leaf);
+      });
 
-        // Build a map from the denomination to the nodes
-        const valueToNodes = new Map<number, TreeNode[]>();
-        this.leaves.forEach((leaf) => {
-          if (!valueToNodes.has(leaf.value)) {
-            valueToNodes.set(leaf.value, []);
-          }
-          valueToNodes.get(leaf.value)!.push(leaf);
-        });
+      // Select the leaves to send for each swap.
+      for (const swap of swaps) {
+        if (controller.signal.aborted) {
+          break;
+        }
 
-        // Select the leaves to send for each swap.
-        for (const swap of swaps) {
-          const leavesToSend: TreeNode[] = [];
-          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`,
-              );
-            }
+        const leavesToSend: TreeNode[] = [];
+        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;
+        // TODO: Parallelize this.
+        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();
+    }
   }
 
   private async syncWallet() {
@@ -764,15 +770,15 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
 
     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()) {
+        // run all optimizer steps, do nothing with them
+      }
+    }
   }
 
   private async withLeaves<T>(operation: () => Promise<T>): Promise<T> {
@@ -1473,7 +1479,6 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
       return await this.claimTransfer({
         transfer: incomingTransfer,
         emit: false,
-        optimize: false,
       });
     } catch (e) {
       console.error("[processSwapBatch] Error details:", {
@@ -2333,29 +2338,7 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
       depositTx,
       vout,
     });
-
-    const resultingNodes: TreeNode[] = [];
-    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: KeyDerivationType.LEAF,
-              path: node.id,
-            });
-            resultingNodes.push(...transfer);
-          } else {
-            resultingNodes.push(n);
-          }
-        }
-      } else {
-        resultingNodes.push(node);
-      }
-    }
-
-    return resultingNodes;
+    return res.nodes;
   }
 
   /**
@@ -2528,6 +2511,10 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
         vout,
       });
 
+      await this.withLeaves(async () => {
+        this.leaves.push(...nodes);
+      });
+
       return nodes;
     });
 
@@ -2637,6 +2624,7 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
       : await this.claimTransfer({ transfer: pendingTransfer });
 
     const leavesToRemove = new Set(leaves.map((leaf) => leaf.id));
+
     this.leaves = [
       ...this.leaves.filter((leaf) => !leavesToRemove.has(leaf.id)),
       ...resultNodes,
@@ -2735,8 +2723,7 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
               `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(
@@ -2787,7 +2774,7 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
                 transfer.id,
               );
               if (pending) {
-                await this.claimTransfer({ transfer: pending, optimize: true });
+                await this.claimTransfer({ transfer: pending });
               }
             }
             return {
@@ -2842,87 +2829,55 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     };
   }
 
-  private async checkExtendTimeLockNodes(
-    nodes: TreeNode[],
-  ): Promise<TreeNode[]> {
-    const nodesToExtend: TreeNode[] = [];
+  private async checkRenewLeaves(nodes: TreeNode[]): Promise<TreeNode[]> {
+    const nodesToRenewNode: TreeNode[] = [];
+    const nodesToRenewRefund: TreeNode[] = [];
+    const nodesToRenewZeroTimelock: TreeNode[] = [];
+
     const nodeIds: string[] = [];
     const validNodes: TreeNode[] = [];
 
     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 === undefined) {
         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: TreeNode[] = [];
-    for (const node of nodesToExtend) {
-      const { nodes } = await this.transferService.extendTimelock(node);
-      this.leaves = this.leaves.filter((leaf) => leaf.id !== node.id);
-      const newNodes = await this.transferLeavesToSelf(nodes, {
-        type: KeyDerivationType.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
-   */
-  private async checkRefreshTimelockNodes(
-    nodes: TreeNode[],
-  ): Promise<TreeNode[]> {
-    const nodesToRefresh: TreeNode[] = [];
-    const nodeIds: string[] = [];
-    const validNodes: TreeNode[] = [];
-
-    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;
     }
 
@@ -2943,7 +2898,7 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     }
 
     const nodesToAdd: TreeNode[] = [];
-    for (const node of nodesToRefresh) {
+    for (const node of nodesToRenewNode) {
       if (!node.parentNodeId) {
         throw new Error(`node ${node.id} has no parent`);
       }
@@ -2953,20 +2908,29 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
         throw new Error(`parent node ${node.parentNodeId} not found`);
       }
 
-      const { nodes } = await this.transferService.refreshTimelockNodes(
-        node,
-        parentNode,
-      );
+      const newNode = await this.transferService.renewNodeTxn(node, parentNode);
+      nodesToAdd.push(newNode);
+    }
 
-      if (nodes.length !== 1) {
-        throw new Error(`expected 1 node, got ${nodes.length}`);
+    for (const node of nodesToRenewRefund) {
+      if (!node.parentNodeId) {
+        throw new Error(`node ${node.id} has no parent`);
       }
 
-      const newNode = nodes[0];
-      if (!newNode) {
-        throw new Error("Failed to refresh timelock node");
+      const parentNode = nodesMap.get(node.parentNodeId);
+      if (!parentNode) {
+        throw new Error(`parent node ${node.parentNodeId} not found`);
       }
 
+      const newNode = await this.transferService.renewRefundTxn(
+        node,
+        parentNode,
+      );
+      nodesToAdd.push(newNode);
+    }
+
+    for (const node of nodesToRenewZeroTimelock) {
+      const newNode = await this.transferService.renewZeroTimelockNodeTxn(node);
       nodesToAdd.push(newNode);
     }
 
@@ -3020,17 +2984,20 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     result: TreeNode[],
     transfer: Transfer,
     emit?: boolean,
-    optimize?: boolean,
   ): Promise<TreeNode[]> {
-    result = await this.checkRefreshTimelockNodes(result);
-    result = await this.checkExtendTimeLockNodes(result);
+    result = await this.checkRenewLeaves(result);
 
     const existingIds = new Set(this.leaves.map((leaf) => leaf.id));
     const uniqueResults = result.filter((node) => !existingIds.has(node.id));
     this.leaves.push(...uniqueResults);
 
-    if (optimize && transfer.type !== TransferType.COUNTER_SWAP) {
-      await this.optimizeLeaves();
+    if (
+      this.config.getOptimizationOptions().auto &&
+      transfer.type !== TransferType.COUNTER_SWAP
+    ) {
+      for await (const _ of this.optimizeLeaves()) {
+        // run all optimizer steps, do nothing with them
+      }
     }
 
     if (emit) {
@@ -3053,11 +3020,9 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
   private async claimTransfer({
     transfer,
     emit,
-    optimize,
   }: {
     transfer: Transfer;
     emit?: boolean;
-    optimize?: boolean;
   }) {
     const onError = async (
       context: RetryContext<TreeNode[], Transfer>,
@@ -3115,12 +3080,7 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
         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}`,
@@ -3169,7 +3129,7 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
         continue;
       }
       promises.push(
-        this.claimTransfer({ transfer, emit, optimize: true })
+        this.claimTransfer({ transfer, emit })
           .then(() => transfer.id)
           .catch((error) => {
             console.warn(`Failed to claim transfer ${transfer.id}:`, error);
@@ -3509,8 +3469,7 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
         selectedLeaves,
         `no leaves for ${totalAmount}`,
       );
-      leaves = await this.checkRefreshTimelockNodes(leaves);
-      leaves = await this.checkExtendTimeLockNodes(leaves);
+      leaves = await this.checkRenewLeaves(leaves);
 
       const leavesToSend: LeafKeyTweak[] = await Promise.all(
         leaves.map(async (leaf) => ({
@@ -3914,10 +3873,8 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
       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: LeafKeyTweak[] = await Promise.all(
       [...leavesToSendToSE, ...leavesToSendToSsp].map(async (leaf) => ({
@@ -4024,8 +3981,7 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
       `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),
@@ -4661,16 +4617,6 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
         );
       }
 
-      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(
@@ -4711,104 +4657,6 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     }
   }
 
-  /**
-   * 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
-   */
-  public async testOnly_expireTimelock(nodeId: string): Promise<void> {
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress(),
-    );
-
-    try {
-      // First, get the node and its parent
-      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) {
-        // skip node timelock check
-      } 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];
-      }
-
-      // Update the local leaves if this node is in our wallet
-      const leafIndex = this.leaves.findIndex((leaf) => leaf.id === leaf.id);
-      if (leafIndex !== -1) {
-        this.leaves[leafIndex] = leaf;
-      }
-    } catch (error) {
-      throw new NetworkError(
-        "Failed to refresh timelock",
-        {
-          method: "refresh_timelock",
-        },
-        error as Error,
-      );
-    }
-  }
-
   private cleanup() {
     if (this.claimTransfersInterval) {
       clearInterval(this.claimTransfersInterval);
@@ -5012,7 +4860,6 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
       "getLightningSendRequest",
       "getCoopExitRequest",
       "checkTimelock",
-      "testOnly_expireTimelock",
     ] as const;
 
     methods.forEach((m) => this.wrapPublicSparkWalletMethodWithOtelSpan(m));