@buildonspark/spark-sdk 0.2.2 → 0.2.4

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

@@ -88,14 +88,16 @@ import {
   NetworkType,
 } from "../utils/network.js";
 import { sumAvailableTokens } from "../utils/token-transactions.js";
-import { getNextTransactionSequence } from "../utils/transaction.js";
+import {
+  doesLeafNeedRefresh,
+  getCurrentTimelock,
+} from "../utils/transaction.js";
 
 import { LRCWallet } from "@buildonspark/lrc20-sdk";
 import { sha256 } from "@noble/hashes/sha2";
 import { EventEmitter } from "eventemitter3";
 import { isReactNative } from "../constants.js";
 import { Network as NetworkProto, networkToJSON } from "../proto/spark.js";
-import { TokenTransactionWithStatus } from "../proto/spark_token.js";
 import {
   decodeInvoice,
   getNetworkFromInvoice,
@@ -136,6 +138,11 @@ import type {
   TransferParams,
   UserTokenMetadata,
 } from "./types.js";
+import {
+  TokenTransactionWithStatus,
+  TokenMetadata,
+} from "../proto/spark_token.js";
+import { getFetch } from "../utils/fetch.js";
 
 /**
  * The SparkWallet class is the primary interface for interacting with the Spark network.
@@ -439,37 +446,43 @@ export class SparkWallet extends EventEmitter {
   }
 
   public async getLeaves(isBalanceCheck: boolean = false): Promise<TreeNode[]> {
-    const leaves = await this.queryNodes({
-      source: {
-        $case: "ownerIdentityPubkey",
-        ownerIdentityPubkey: await this.config.signer.getIdentityPublicKey(),
-      },
-      includeParents: false,
-      network: NetworkToProto[this.config.getNetwork()],
-    });
+    const operatorToLeaves = new Map<string, QueryNodesResponse>();
+    const ownerIdentityPubkey = await this.config.signer.getIdentityPublicKey();
+
+    let signingOperators = Object.entries(this.config.getSigningOperators());
+    if (isBalanceCheck) {
+      // If we're just checking the balance, we can just query the coordinator.
+      signingOperators = signingOperators.filter(
+        ([id, _]) => id === this.config.getCoordinatorIdentifier(),
+      );
+    }
+    await Promise.all(
+      signingOperators.map(async ([id, operator]) => {
+        const leaves = await this.queryNodes(
+          {
+            source: {
+              $case: "ownerIdentityPubkey",
+              ownerIdentityPubkey,
+            },
+            includeParents: false,
+            network: NetworkToProto[this.config.getNetwork()],
+          },
+          operator.address,
+        );
+        operatorToLeaves.set(id, leaves);
+      }),
+    );
 
+    const leaves = operatorToLeaves.get(
+      this.config.getCoordinatorIdentifier(),
+    )!;
     const leavesToIgnore: Set<string> = new Set();
-    // Query the leaf states from other operators.
-    // We'll ignore the leaves that are out of sync for now.
-    // Still include the leaves that are out of sync for balance check.
     if (!isBalanceCheck) {
-      for (const [id, operator] of Object.entries(
-        this.config.getSigningOperators(),
-      )) {
+      // Query the leaf states from other operators.
+      // We'll ignore the leaves that are out of sync for now.
+      // Still include the leaves that are out of sync for balance check.
+      for (const [id, operatorLeaves] of operatorToLeaves) {
         if (id !== this.config.getCoordinatorIdentifier()) {
-          const operatorLeaves = await this.queryNodes(
-            {
-              source: {
-                $case: "ownerIdentityPubkey",
-                ownerIdentityPubkey:
-                  await this.config.signer.getIdentityPublicKey(),
-              },
-              includeParents: false,
-              network: NetworkToProto[this.config.getNetwork()],
-            },
-            operator.address,
-          );
-
           // Loop over leaves returned by coordinator.
           // If the leaf is not present in the operator's leaves, we'll ignore it.
           // If the leaf is present, we'll check if the leaf is in sync with the operator's leaf.
@@ -499,17 +512,30 @@ export class SparkWallet extends EventEmitter {
       }
     }
 
-    const verifyKey = (
-      pubkey1: Uint8Array,
-      pubkey2: Uint8Array,
-      verifyingKey: Uint8Array,
-    ) => {
-      return equalBytes(addPublicKeys(pubkey1, pubkey2), verifyingKey);
-    };
+    const availableLeaves = Object.entries(leaves.nodes).filter(
+      ([_, node]) => node.status === "AVAILABLE",
+    );
 
-    for (const [id, leaf] of Object.entries(leaves.nodes)) {
+    for (const [id, leaf] of availableLeaves) {
       if (
-        !verifyKey(
+        leaf.parentNodeId &&
+        leaf.status === "AVAILABLE" &&
+        this.verifyKey(
+          await this.config.signer.getPublicKeyFromDerivation({
+            type: KeyDerivationType.LEAF,
+            path: leaf.parentNodeId,
+          }),
+          leaf.signingKeyshare?.publicKey ?? new Uint8Array(),
+          leaf.verifyingPublicKey,
+        )
+      ) {
+        this.transferLeavesToSelf([leaf], {
+          type: KeyDerivationType.LEAF,
+          path: leaf.parentNodeId,
+        });
+        leavesToIgnore.add(id);
+      } else if (
+        !this.verifyKey(
           await this.config.signer.getPublicKeyFromDerivation({
             type: KeyDerivationType.LEAF,
             path: leaf.id,
@@ -522,14 +548,33 @@ export class SparkWallet extends EventEmitter {
       }
     }
 
-    return Object.entries(leaves.nodes)
-      .filter(
-        ([_, node]) =>
-          node.status === "AVAILABLE" && !leavesToIgnore.has(node.id),
-      )
+    return availableLeaves
+      .filter(([_, node]) => !leavesToIgnore.has(node.id))
       .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,
+    verifyingKey: Uint8Array,
+  ): boolean {
+    return equalBytes(addPublicKeys(pubkey1, pubkey2), verifyingKey);
+  }
+
   private async selectLeaves(
     targetAmounts: number[],
   ): Promise<Map<number, TreeNode[]>> {
@@ -705,6 +750,8 @@ export class SparkWallet extends EventEmitter {
     leaves = await this.checkExtendTimeLockNodes(leaves);
 
     this.leaves = leaves;
+    this.checkExtendLeaves(leaves);
+
     this.optimizeLeaves().catch((e) => {
       console.error("Failed to optimize leaves", e);
     });
@@ -1000,26 +1047,80 @@ export class SparkWallet extends EventEmitter {
       })),
     );
 
-    const { transfer, signatureMap } =
-      await this.transferService.startSwapSignRefund(
-        leafKeyTweaks,
-        hexToBytes(this.config.getSspIdentityPublicKey()),
-        new Date(Date.now() + 2 * 60 * 1000),
-      );
+    const {
+      transfer,
+      signatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap,
+    } = await this.transferService.startSwapSignRefund(
+      leafKeyTweaks,
+      hexToBytes(this.config.getSspIdentityPublicKey()),
+      new Date(Date.now() + 2 * 60 * 1000),
+    );
+
     try {
       if (!transfer.leaves[0]?.leaf) {
+        console.error("[processSwapBatch] First leaf is missing");
         throw new Error("Failed to get leaf");
       }
 
-      const refundSignature = signatureMap.get(transfer.leaves[0].leaf.id);
-      if (!refundSignature) {
-        throw new Error("Failed to get refund signature");
+      const cpfpRefundSignature = signatureMap.get(transfer.leaves[0].leaf.id);
+      if (!cpfpRefundSignature) {
+        console.error(
+          "[processSwapBatch] Missing CPFP refund signature for first leaf",
+        );
+        throw new Error("Failed to get CPFP refund signature");
+      }
+
+      const directRefundSignature = directSignatureMap.get(
+        transfer.leaves[0].leaf.id,
+      );
+      if (!directRefundSignature) {
+        console.error(
+          "[processSwapBatch] Missing direct refund signature for first leaf",
+        );
+        throw new Error("Failed to get direct refund signature");
+      }
+
+      const directFromCpfpRefundSignature = directFromCpfpSignatureMap.get(
+        transfer.leaves[0].leaf.id,
+      );
+      if (!directFromCpfpRefundSignature) {
+        console.error(
+          "[processSwapBatch] Missing direct from CPFP refund signature for first leaf",
+        );
+        throw new Error("Failed to get direct from CPFP refund signature");
+      }
+
+      const {
+        adaptorPrivateKey: cpfpAdaptorPrivateKey,
+        adaptorSignature: cpfpAdaptorSignature,
+      } = generateAdaptorFromSignature(cpfpRefundSignature);
+
+      let directAdaptorPrivateKey: Uint8Array = new Uint8Array();
+      let directAdaptorSignature: Uint8Array = new Uint8Array();
+      let directFromCpfpAdaptorPrivateKey: Uint8Array = new Uint8Array();
+      let directFromCpfpAdaptorSignature: Uint8Array = new Uint8Array();
+
+      if (directRefundSignature.length > 0) {
+        const { adaptorPrivateKey, adaptorSignature } =
+          generateAdaptorFromSignature(directRefundSignature);
+
+        directAdaptorPrivateKey = adaptorPrivateKey;
+        directAdaptorSignature = adaptorSignature;
       }
 
-      const { adaptorPrivateKey, adaptorSignature } =
-        generateAdaptorFromSignature(refundSignature);
+      if (directFromCpfpRefundSignature.length > 0) {
+        const { adaptorPrivateKey, adaptorSignature } =
+          generateAdaptorFromSignature(directFromCpfpRefundSignature);
+        directFromCpfpAdaptorPrivateKey = adaptorPrivateKey;
+        directFromCpfpAdaptorSignature = adaptorSignature;
+      }
 
       if (!transfer.leaves[0].leaf) {
+        console.error(
+          "[processSwapBatch] First leaf missing when preparing user leaves",
+        );
         throw new Error("Failed to get leaf");
       }
 
@@ -1029,42 +1130,128 @@ export class SparkWallet extends EventEmitter {
         raw_unsigned_refund_transaction: bytesToHex(
           transfer.leaves[0].intermediateRefundTx,
         ),
-        adaptor_added_signature: bytesToHex(adaptorSignature),
+        direct_raw_unsigned_refund_transaction: bytesToHex(
+          transfer.leaves[0].intermediateDirectRefundTx,
+        ),
+        direct_from_cpfp_raw_unsigned_refund_transaction: bytesToHex(
+          transfer.leaves[0].intermediateDirectFromCpfpRefundTx,
+        ),
+        adaptor_added_signature: bytesToHex(cpfpAdaptorSignature),
+        direct_adaptor_added_signature: bytesToHex(directAdaptorSignature),
+        direct_from_cpfp_adaptor_added_signature: bytesToHex(
+          directFromCpfpAdaptorSignature,
+        ),
       });
 
       for (let i = 1; i < transfer.leaves.length; i++) {
         const leaf = transfer.leaves[i];
         if (!leaf?.leaf) {
+          console.error(`[processSwapBatch] Leaf ${i + 1} is missing`);
           throw new Error("Failed to get leaf");
         }
 
-        const refundSignature = signatureMap.get(leaf.leaf.id);
-        if (!refundSignature) {
-          throw new Error("Failed to get refund signature");
+        const cpfpRefundSignature = signatureMap.get(leaf.leaf.id);
+        if (!cpfpRefundSignature) {
+          console.error(
+            `[processSwapBatch] Missing CPFP refund signature for leaf ${i + 1}`,
+          );
+          throw new Error("Failed to get CPFP refund signature");
+        }
+
+        const directRefundSignature = directSignatureMap.get(leaf.leaf.id);
+        if (!directRefundSignature) {
+          console.error(
+            `[processSwapBatch] Missing direct refund signature for leaf ${i + 1}`,
+          );
+          throw new Error("Failed to get direct refund signature");
+        }
+
+        const directFromCpfpRefundSignature = directFromCpfpSignatureMap.get(
+          leaf.leaf.id,
+        );
+        if (!directFromCpfpRefundSignature) {
+          console.error(
+            `[processSwapBatch] Missing direct from CPFP refund signature for leaf ${i + 1}`,
+          );
+          throw new Error("Failed to get direct from CPFP refund signature");
         }
 
-        const signature = generateSignatureFromExistingAdaptor(
-          refundSignature,
-          adaptorPrivateKey,
+        const cpfpSignature = generateSignatureFromExistingAdaptor(
+          cpfpRefundSignature,
+          cpfpAdaptorPrivateKey,
         );
 
+        let directSignature: Uint8Array = new Uint8Array();
+        if (directRefundSignature.length > 0) {
+          directSignature = generateSignatureFromExistingAdaptor(
+            directRefundSignature,
+            directAdaptorPrivateKey,
+          );
+        }
+
+        let directFromCpfpSignature: Uint8Array = new Uint8Array();
+        if (directFromCpfpRefundSignature.length > 0) {
+          directFromCpfpSignature = generateSignatureFromExistingAdaptor(
+            directFromCpfpRefundSignature,
+            directFromCpfpAdaptorPrivateKey,
+          );
+        }
+
         userLeaves.push({
           leaf_id: leaf.leaf.id,
           raw_unsigned_refund_transaction: bytesToHex(
             leaf.intermediateRefundTx,
           ),
-          adaptor_added_signature: bytesToHex(signature),
+          direct_raw_unsigned_refund_transaction: bytesToHex(
+            leaf.intermediateDirectRefundTx,
+          ),
+          direct_from_cpfp_raw_unsigned_refund_transaction: bytesToHex(
+            leaf.intermediateDirectFromCpfpRefundTx,
+          ),
+          adaptor_added_signature: bytesToHex(cpfpSignature),
+          direct_adaptor_added_signature: bytesToHex(directSignature),
+          direct_from_cpfp_adaptor_added_signature: bytesToHex(
+            directFromCpfpSignature,
+          ),
         });
       }
 
       const sspClient = this.getSspClient();
-      const adaptorPubkey = bytesToHex(
-        secp256k1.getPublicKey(adaptorPrivateKey),
+      const cpfpAdaptorPubkey = bytesToHex(
+        secp256k1.getPublicKey(cpfpAdaptorPrivateKey),
       );
+      if (!cpfpAdaptorPubkey) {
+        throw new Error("Failed to generate CPFP adaptor pubkey");
+      }
+
+      let directAdaptorPubkey: string | undefined;
+      if (directAdaptorPrivateKey.length > 0) {
+        directAdaptorPubkey = bytesToHex(
+          secp256k1.getPublicKey(directAdaptorPrivateKey),
+        );
+      }
+
+      let directFromCpfpAdaptorPubkey: string | undefined;
+      if (directFromCpfpAdaptorPrivateKey.length > 0) {
+        directFromCpfpAdaptorPubkey = bytesToHex(
+          secp256k1.getPublicKey(directFromCpfpAdaptorPrivateKey),
+        );
+      }
+
       let request: LeavesSwapRequest | null | undefined = null;
+      const targetAmountSats =
+        targetAmounts?.reduce((acc, amount) => acc + amount, 0) ||
+        leavesBatch.reduce((acc, leaf) => acc + leaf.value, 0);
+      const totalAmountSats = leavesBatch.reduce(
+        (acc, leaf) => acc + leaf.value,
+        0,
+      );
+
       request = await sspClient.requestLeaveSwap({
         userLeaves,
-        adaptorPubkey,
+        adaptorPubkey: cpfpAdaptorPubkey,
+        directAdaptorPubkey: directAdaptorPubkey,
+        directFromCpfpAdaptorPubkey: directFromCpfpAdaptorPubkey,
         targetAmountSats:
           targetAmounts?.reduce((acc, amount) => acc + amount, 0) ||
           leavesBatch.reduce((acc, leaf) => acc + leaf.value, 0),
@@ -1076,6 +1263,7 @@ export class SparkWallet extends EventEmitter {
       });
 
       if (!request) {
+        console.error("[processSwapBatch] Leave swap request returned null");
         throw new Error("Failed to request leaves swap. No response returned.");
       }
 
@@ -1091,37 +1279,127 @@ export class SparkWallet extends EventEmitter {
       });
 
       if (Object.values(nodes.nodes).length !== request.swapLeaves.length) {
+        console.error("[processSwapBatch] Node count mismatch:", {
+          actual: Object.values(nodes.nodes).length,
+          expected: request.swapLeaves.length,
+        });
         throw new Error("Expected same number of nodes as swapLeaves");
       }
 
       for (const [nodeId, node] of Object.entries(nodes.nodes)) {
         if (!node.nodeTx) {
+          console.error(`[processSwapBatch] Node tx missing for ${nodeId}`);
           throw new Error(`Node tx not found for leaf ${nodeId}`);
         }
 
         if (!node.verifyingPublicKey) {
+          console.error(
+            `[processSwapBatch] Verifying public key missing for ${nodeId}`,
+          );
           throw new Error(`Node public key not found for leaf ${nodeId}`);
         }
 
         const leaf = request.swapLeaves.find((leaf) => leaf.leafId === nodeId);
         if (!leaf) {
+          console.error(`[processSwapBatch] Leaf not found for node ${nodeId}`);
           throw new Error(`Leaf not found for node ${nodeId}`);
         }
-
-        const nodeTx = getTxFromRawTxBytes(node.nodeTx);
-        const refundTxBytes = hexToBytes(leaf.rawUnsignedRefundTransaction);
-        const refundTx = getTxFromRawTxBytes(refundTxBytes);
-        const sighash = getSigHashFromTx(refundTx, 0, nodeTx.getOutput(0));
+        // Apply CPFP adaptor signature
+        const cpfpNodeTx = getTxFromRawTxBytes(node.nodeTx);
+        const cpfpRefundTxBytes = hexToBytes(leaf.rawUnsignedRefundTransaction);
+        const cpfpRefundTx = getTxFromRawTxBytes(cpfpRefundTxBytes);
+        const cpfpSighash = getSigHashFromTx(
+          cpfpRefundTx,
+          0,
+          cpfpNodeTx.getOutput(0),
+        );
 
         const nodePublicKey = node.verifyingPublicKey;
-
         const taprootKey = computeTaprootKeyNoScript(nodePublicKey.slice(1));
-        const adaptorSignatureBytes = hexToBytes(leaf.adaptorSignedSignature);
+        const cpfpAdaptorSignatureBytes = hexToBytes(
+          leaf.adaptorSignedSignature,
+        );
+        applyAdaptorToSignature(
+          taprootKey.slice(1),
+          cpfpSighash,
+          cpfpAdaptorSignatureBytes,
+          cpfpAdaptorPrivateKey,
+        );
+
+        // Apply direct adaptor signature
+
+        if (!leaf.directRawUnsignedRefundTransaction) {
+          throw new Error(
+            `Direct raw unsigned refund transaction missing for node ${nodeId}`,
+          );
+        }
+        if (!leaf.directAdaptorSignedSignature) {
+          throw new Error(
+            `Direct adaptor signed signature missing for node ${nodeId}`,
+          );
+        }
+
+        const directNodeTx = getTxFromRawTxBytes(node.directTx);
+
+        const directRefundTxBytes = hexToBytes(
+          leaf.directRawUnsignedRefundTransaction,
+        );
+
+        const directRefundTx = getTxFromRawTxBytes(directRefundTxBytes);
+
+        const directSighash = getSigHashFromTx(
+          directRefundTx,
+          0,
+          directNodeTx.getOutput(0),
+        );
+
+        if (!leaf.directFromCpfpAdaptorSignedSignature) {
+          throw new Error(
+            `Direct adaptor signed signature missing for node ${nodeId}`,
+          );
+        }
+
+        const directAdaptorSignatureBytes = hexToBytes(
+          leaf.directAdaptorSignedSignature,
+        );
+
+        applyAdaptorToSignature(
+          taprootKey.slice(1),
+          directSighash,
+          directAdaptorSignatureBytes,
+          directAdaptorPrivateKey,
+        );
+
+        if (!leaf.directRawUnsignedRefundTransaction) {
+          throw new Error(
+            `Direct raw unsigned refund transaction missing for node ${nodeId}`,
+          );
+        }
+        if (!leaf.directFromCpfpRawUnsignedRefundTransaction) {
+          throw new Error(
+            `Direct raw unsigned refund transaction missing for node ${nodeId}`,
+          );
+        }
+
+        const directFromCpfpRefundTxBytes = hexToBytes(
+          leaf.directFromCpfpRawUnsignedRefundTransaction,
+        );
+        const directFromCpfpRefundTx = getTxFromRawTxBytes(
+          directFromCpfpRefundTxBytes,
+        );
+        const directFromCpfpSighash = getSigHashFromTx(
+          directFromCpfpRefundTx,
+          0,
+          cpfpNodeTx.getOutput(0),
+        );
+        const directFromCpfpAdaptorSignatureBytes = hexToBytes(
+          leaf.directFromCpfpAdaptorSignedSignature,
+        );
         applyAdaptorToSignature(
           taprootKey.slice(1),
-          sighash,
-          adaptorSignatureBytes,
-          adaptorPrivateKey,
+          directFromCpfpSighash,
+          directFromCpfpAdaptorSignatureBytes,
+          directFromCpfpAdaptorPrivateKey,
         );
       }
 
@@ -1129,15 +1407,24 @@ export class SparkWallet extends EventEmitter {
         transfer,
         leafKeyTweaks,
         signatureMap,
+        directSignatureMap,
+        directFromCpfpSignatureMap,
       );
-
       const completeResponse = await sspClient.completeLeaveSwap({
-        adaptorSecretKey: bytesToHex(adaptorPrivateKey),
+        adaptorSecretKey: bytesToHex(cpfpAdaptorPrivateKey),
+        directAdaptorSecretKey: bytesToHex(directAdaptorPrivateKey),
+        directFromCpfpAdaptorSecretKey: bytesToHex(
+          directFromCpfpAdaptorPrivateKey,
+        ),
         userOutboundTransferExternalId: transfer.id,
         leavesSwapRequestId: request.id,
       });
 
       if (!completeResponse || !completeResponse.inboundTransfer?.sparkId) {
+        console.error(
+          "[processSwapBatch] Invalid complete response:",
+          completeResponse,
+        );
         throw new Error("Failed to complete leaves swap");
       }
 
@@ -1146,6 +1433,7 @@ export class SparkWallet extends EventEmitter {
       );
 
       if (!incomingTransfer) {
+        console.error("[processSwapBatch] No incoming transfer found");
         throw new Error("Failed to get incoming transfer");
       }
 
@@ -1156,6 +1444,11 @@ export class SparkWallet extends EventEmitter {
         optimize: false,
       });
     } catch (e) {
+      console.error("[processSwapBatch] Error details:", {
+        error: e,
+        message: (e as Error).message,
+        stack: (e as Error).stack,
+      });
       await this.cancelAllSenderInitiatedTransfers();
       throw new Error(`Failed to request leaves swap: ${e}`);
     }
@@ -1769,8 +2062,9 @@ export class SparkWallet extends EventEmitter {
       });
     }
 
+    const { fetch, Headers } = getFetch();
     const baseUrl = this.config.getElectrsUrl();
-    const headers: Record<string, string> = {};
+    const headers = new Headers();
 
     let txHex: string | undefined;
 
@@ -1783,7 +2077,7 @@ export class SparkWallet extends EventEmitter {
         const auth = btoa(
           `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`,
         );
-        headers["Authorization"] = `Basic ${auth}`;
+        headers.set("Authorization", `Basic ${auth}`);
       }
 
       const response = await fetch(`${baseUrl}/tx/${txid}/hex`, {
@@ -1940,8 +2234,9 @@ export class SparkWallet extends EventEmitter {
     }
 
     const nodes = await mutex.runExclusive(async () => {
+      const { fetch, Headers } = getFetch();
       const baseUrl = this.config.getElectrsUrl();
-      const headers: Record<string, string> = {};
+      const headers = new Headers();
 
       let txHex: string | undefined;
 
@@ -1954,7 +2249,7 @@ export class SparkWallet extends EventEmitter {
           const auth = btoa(
             `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`,
           );
-          headers["Authorization"] = `Basic ${auth}`;
+          headers.set("Authorization", `Basic ${auth}`);
         }
 
         const response = await fetch(`${baseUrl}/tx/${txid}/hex`, {
@@ -2251,10 +2546,16 @@ export class SparkWallet extends EventEmitter {
 
     for (const node of nodes) {
       const nodeTx = getTxFromRawTxBytes(node.nodeTx);
-      const { needRefresh } = getNextTransactionSequence(
-        nodeTx.getInput(0).sequence,
-      );
-      if (needRefresh) {
+      const sequence = nodeTx.getInput(0).sequence;
+      if (!sequence) {
+        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 {
@@ -2299,11 +2600,16 @@ export class SparkWallet extends EventEmitter {
 
     for (const node of nodes) {
       const refundTx = getTxFromRawTxBytes(node.refundTx);
-      const { needRefresh } = getNextTransactionSequence(
-        refundTx.getInput(0).sequence,
-        true,
-      );
-      if (needRefresh) {
+      const sequence = refundTx.getInput(0).sequence;
+      if (!sequence) {
+        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);
         nodeIds.push(node.id);
       } else {
@@ -2343,7 +2649,7 @@ export class SparkWallet extends EventEmitter {
       }
 
       const { nodes } = await this.transferService.refreshTimelockNodes(
-        [node],
+        node,
         parentNode,
       );
 
@@ -2408,6 +2714,9 @@ export class SparkWallet extends EventEmitter {
                 leaf: {
                   ...leaf.leaf,
                   refundTx: leaf.intermediateRefundTx,
+                  directRefundTx: leaf.intermediateDirectRefundTx,
+                  directFromCpfpRefundTx:
+                    leaf.intermediateDirectFromCpfpRefundTx,
                 },
                 keyDerivation: {
                   type: KeyDerivationType.ECIES,
@@ -2503,7 +2812,9 @@ export class SparkWallet extends EventEmitter {
         transfer.status !==
           TransferStatus.TRANSFER_STATUS_RECEIVER_REFUND_SIGNED &&
         transfer.status !==
-          TransferStatus.TRANSFER_STATUS_RECEIVER_KEY_TWEAK_APPLIED
+          TransferStatus.TRANSFER_STATUS_RECEIVER_KEY_TWEAK_APPLIED &&
+        transfer.status !==
+          TransferStatus.TRANSFER_STATUS_RECEIVER_KEY_TWEAK_LOCKED
       ) {
         continue;
       }
@@ -2857,6 +3168,8 @@ export class SparkWallet extends EventEmitter {
         swapResponse.transfer,
         leavesToSend,
         new Map(),
+        new Map(),
+        new Map(),
       );
 
       const sspResponse = await sspClient.requestLightningSend({
@@ -3405,12 +3718,16 @@ export class SparkWallet extends EventEmitter {
     tokenTransactionHashes,
     tokenIdentifiers,
     outputIds,
+    pageSize = 100,
+    offset = 0,
   }: {
     ownerPublicKeys?: string[];
     issuerPublicKeys?: string[];
     tokenTransactionHashes?: string[];
     tokenIdentifiers?: string[];
     outputIds?: string[];
+    pageSize?: number;
+    offset?: number;
   }): Promise<TokenTransactionWithStatus[]> {
     return this.tokenTransactionService.queryTokenTransactions({
       ownerPublicKeys,
@@ -3418,6 +3735,8 @@ export class SparkWallet extends EventEmitter {
       tokenTransactionHashes,
       tokenIdentifiers,
       outputIds,
+      pageSize,
+      offset,
     }) as Promise<TokenTransactionWithStatus[]>;
   }
 
@@ -3814,101 +4133,75 @@ export class SparkWallet extends EventEmitter {
         includeParents: true,
       });
 
-      const node = response.nodes[nodeId];
-      if (!node) {
+      let leaf = response.nodes[nodeId];
+      if (!leaf) {
         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,
-        });
+      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 parentNode = response.nodes[node.parentNodeId];
-      if (!parentNode) {
-        throw new ValidationError("Parent node not found", {
-          field: "parentNodeId",
-          value: node.parentNodeId,
-        });
-      }
+      const nodeTx = getTxFromRawTxBytes(leaf.nodeTx);
+      const refundTx = getTxFromRawTxBytes(leaf.refundTx);
 
-      // Call the transfer service to refresh the timelock
-      const result = await this.transferService.refreshTimelockNodes(
-        [node],
-        parentNode,
-      );
+      if (hasParentNode) {
+        const nodeTimelock = getCurrentTimelock(nodeTx.getInput(0).sequence);
+        if (nodeTimelock > 100) {
+          const expiredNodeTxLeaf =
+            await this.transferService.testonly_expireTimeLockNodeTx(
+              leaf,
+              parentNode,
+            );
 
-      // Update the local leaves if this node is in our wallet
-      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;
+          if (!expiredNodeTxLeaf.nodes[0]) {
+            throw new ValidationError("No expired node tx leaf", {
+              field: "expiredNodeTxLeaf",
+              value: expiredNodeTxLeaf,
+            });
+          }
+          leaf = expiredNodeTxLeaf.nodes[0];
         }
       }
-    } catch (error) {
-      throw new NetworkError(
-        "Failed to refresh timelock",
-        {
-          method: "refresh_timelock",
-        },
-        error as 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
-   */
-  public async testOnly_expireTimelockRefundTx(nodeId: string): Promise<void> {
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress(),
-    );
+      const refundTimelock = getCurrentTimelock(refundTx.getInput(0).sequence);
 
-    try {
-      // Get the node
-      const response = await sparkClient.query_nodes({
-        source: {
-          $case: "nodeIds",
-          nodeIds: {
-            nodeIds: [nodeId],
-          },
-        },
-        includeParents: false,
-      });
+      if (refundTimelock > 100) {
+        const expiredTxLeaf =
+          await this.transferService.testonly_expireTimeLockRefundtx(leaf);
 
-      const node = response.nodes[nodeId];
-      if (!node) {
-        throw new ValidationError("Node not found", {
-          field: "nodeId",
-          value: nodeId,
-        });
+        if (!expiredTxLeaf.nodes[0]) {
+          throw new ValidationError("No expired tx leaf", {
+            field: "expiredTxLeaf",
+            value: expiredTxLeaf,
+          });
+        }
+        leaf = expiredTxLeaf.nodes[0];
       }
 
-      // Call the transfer service to refresh the refund timelock
-      const result = await this.transferService.refreshTimelockRefundTx(node);
-
       // Update the local leaves if this node is in our wallet
-      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;
-        }
+      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 refund timelock",
+        "Failed to refresh timelock",
         {
-          method: "refresh_timelock_refund_tx",
+          method: "refresh_timelock",
         },
         error as Error,
       );