@buildonspark/spark-sdk 0.1.36 → 0.1.37

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

@@ -37,6 +37,8 @@ import {
 import {
   DepositAddressQueryResult,
   OutputWithPreviousTransactionData,
+  QueryNodesRequest,
+  QueryNodesResponse,
   SigningJob,
   SubscribeToEventsResponse,
   TokenTransactionWithStatus,
@@ -96,6 +98,7 @@ import {
   SparkAddressFormat,
 } from "../address/index.js";
 import { isReactNative } from "../constants.js";
+import { networkToJSON } from "../proto/spark.js";
 import {
   decodeInvoice,
   getNetworkFromInvoice,
@@ -121,7 +124,6 @@ import type {
   TokenInfo,
   TransferParams,
 } from "./types.js";
-import { networkToJSON } from "../proto/spark.js";
 
 /**
  * The SparkWallet class is the primary interface for interacting with the Spark network.
@@ -261,7 +263,11 @@ export class SparkWallet extends EventEmitter {
           event.transfer.transfer &&
           !equalBytes(senderIdentityPublicKey, receiverIdentityPublicKey)
         ) {
-          await this.claimTransfer(event.transfer.transfer, true);
+          await this.claimTransfer({
+            transfer: event.transfer.transfer,
+            emit: true,
+            optimize: true,
+          });
         }
       } else if (event?.$case === "deposit" && event.deposit.deposit) {
         const deposit = event.deposit.deposit;
@@ -427,10 +433,7 @@ export class SparkWallet extends EventEmitter {
   private async getLeaves(
     isBalanceCheck: boolean = false,
   ): Promise<TreeNode[]> {
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress(),
-    );
-    const leaves = await sparkClient.query_nodes({
+    const leaves = await this.queryNodes({
       source: {
         $case: "ownerIdentityPubkey",
         ownerIdentityPubkey: await this.config.signer.getIdentityPublicKey(),
@@ -448,18 +451,18 @@ export class SparkWallet extends EventEmitter {
         this.config.getSigningOperators(),
       )) {
         if (id !== this.config.getCoordinatorIdentifier()) {
-          const client = await this.connectionManager.createSparkClient(
+          const operatorLeaves = await this.queryNodes(
+            {
+              source: {
+                $case: "ownerIdentityPubkey",
+                ownerIdentityPubkey:
+                  await this.config.signer.getIdentityPublicKey(),
+              },
+              includeParents: false,
+              network: NetworkToProto[this.config.getNetwork()],
+            },
             operator.address,
           );
-          const operatorLeaves = await client.query_nodes({
-            source: {
-              $case: "ownerIdentityPubkey",
-              ownerIdentityPubkey:
-                await this.config.signer.getIdentityPublicKey(),
-            },
-            includeParents: false,
-            network: NetworkToProto[this.config.getNetwork()],
-          });
 
           // Loop over leaves returned by coordinator.
           // If the leaf is not present in the operator's leaves, we'll ignore it.
@@ -635,10 +638,14 @@ export class SparkWallet extends EventEmitter {
 
   private async syncWallet() {
     await this.syncTokenOutputs();
-    this.leaves = await this.getLeaves();
-    await this.config.signer.restoreSigningKeysFromLeafs(this.leaves);
-    await this.checkRefreshTimelockNodes();
-    await this.checkExtendTimeLockNodes();
+
+    let leaves = await this.getLeaves();
+    await this.config.signer.restoreSigningKeysFromLeafs(leaves);
+
+    leaves = await this.checkRefreshTimelockNodes(leaves);
+    leaves = await this.checkExtendTimeLockNodes(leaves);
+
+    this.leaves = leaves;
     this.optimizeLeaves().catch((e) => {
       console.error("Failed to optimize leaves", e);
     });
@@ -812,12 +819,6 @@ export class SparkWallet extends EventEmitter {
       });
     }
 
-    try {
-      await this.claimTransfers();
-    } catch (e) {
-      console.warn("Unabled to claim transfers.");
-    }
-
     let leavesToSwap: TreeNode[];
     if (targetAmount && leaves && leaves.length > 0) {
       if (targetAmount < leaves.reduce((acc, leaf) => acc + leaf.value, 0)) {
@@ -940,11 +941,7 @@ export class SparkWallet extends EventEmitter {
         throw new Error("Failed to request leaves swap. No response returned.");
       }
 
-      const sparkClient = await this.connectionManager.createSparkClient(
-        this.config.getCoordinatorAddress(),
-      );
-
-      const nodes = await sparkClient.query_nodes({
+      const nodes = await this.queryNodes({
         source: {
           $case: "nodeIds",
           nodeIds: {
@@ -973,7 +970,6 @@ export class SparkWallet extends EventEmitter {
           throw new Error(`Leaf not found for node ${nodeId}`);
         }
 
-        // @ts-ignore - We do a null check above
         const nodeTx = getTxFromRawTxBytes(node.nodeTx);
         const refundTxBytes = hexToBytes(leaf.rawUnsignedRefundTransaction);
         const refundTx = getTxFromRawTxBytes(refundTxBytes);
@@ -1163,7 +1159,21 @@ export class SparkWallet extends EventEmitter {
    * @returns {Promise<string>} A Bitcoin address for depositing funds
    */
   public async getStaticDepositAddress(): Promise<string> {
-    return await this.generateDepositAddress(true);
+    try {
+      return await this.generateDepositAddress(true);
+    } catch (error: any) {
+      if (error.message?.includes("static deposit address already exists")) {
+        // Query instead of checking error message in case error message changes.
+        const existingAddresses = await this.queryStaticDepositAddresses();
+        if (existingAddresses.length > 0 && existingAddresses[0]) {
+          return existingAddresses[0];
+        } else {
+          throw error;
+        }
+      } else {
+        throw error;
+      }
+    }
   }
 
   /**
@@ -1902,7 +1912,7 @@ export class SparkWallet extends EventEmitter {
 
     const resultNodes = !pendingTransfer
       ? []
-      : await this.claimTransfer(pendingTransfer);
+      : await this.claimTransfer({ transfer: pendingTransfer });
 
     const leavesToRemove = new Set(leaves.map((leaf) => leaf.id));
     this.leaves = [
@@ -1963,7 +1973,7 @@ export class SparkWallet extends EventEmitter {
     return await this.withLeaves(async () => {
       let leavesToSend = await this.selectLeaves(amountSats);
 
-      await this.checkRefreshTimelockNodes(leavesToSend);
+      leavesToSend = await this.checkRefreshTimelockNodes(leavesToSend);
       leavesToSend = await this.checkExtendTimeLockNodes(leavesToSend);
 
       const leafKeyTweaks = await Promise.all(
@@ -1990,7 +2000,10 @@ export class SparkWallet extends EventEmitter {
         const pendingTransfer =
           await this.transferService.queryTransfer(transactionId);
         if (pendingTransfer) {
-          await this.claimTransfer(pendingTransfer);
+          await this.claimTransfer({
+            transfer: pendingTransfer,
+            optimize: true,
+          });
         }
       }
 
@@ -2002,14 +2015,13 @@ export class SparkWallet extends EventEmitter {
   }
 
   private async checkExtendTimeLockNodes(
-    nodes?: TreeNode[],
+    nodes: TreeNode[],
   ): Promise<TreeNode[]> {
-    const nodesToCheck = nodes ?? this.leaves;
     const nodesToExtend: TreeNode[] = [];
     const nodeIds: string[] = [];
-    let resultNodes = [...nodesToCheck];
+    const validNodes: TreeNode[] = [];
 
-    for (const node of nodesToCheck) {
+    for (const node of nodes) {
       const nodeTx = getTxFromRawTxBytes(node.nodeTx);
       const { needRefresh } = getNextTransactionSequence(
         nodeTx.getInput(0).sequence,
@@ -2017,11 +2029,16 @@ export class SparkWallet extends EventEmitter {
       if (needRefresh) {
         nodesToExtend.push(node);
         nodeIds.push(node.id);
+      } else {
+        validNodes.push(node);
       }
     }
 
-    resultNodes = resultNodes.filter((node) => !nodesToExtend.includes(node));
+    if (nodesToExtend.length === 0) {
+      return validNodes;
+    }
 
+    const nodesToAdd: TreeNode[] = [];
     for (const node of nodesToExtend) {
       const signingPubKey = await this.config.signer.generatePublicKey(
         sha256(node.id),
@@ -2032,10 +2049,13 @@ export class SparkWallet extends EventEmitter {
       );
       this.leaves = this.leaves.filter((leaf) => leaf.id !== node.id);
       const newNodes = await this.transferLeavesToSelf(nodes, signingPubKey);
-      resultNodes.push(...newNodes);
+      nodesToAdd.push(...newNodes);
     }
 
-    return resultNodes;
+    this.updateLeaves(nodeIds, nodesToAdd);
+    validNodes.push(...nodesToAdd);
+
+    return validNodes;
   }
 
   /**
@@ -2045,11 +2065,14 @@ export class SparkWallet extends EventEmitter {
    * @returns {Promise<void>}
    * @private
    */
-  private async checkRefreshTimelockNodes(nodes?: TreeNode[]) {
+  private async checkRefreshTimelockNodes(
+    nodes: TreeNode[],
+  ): Promise<TreeNode[]> {
     const nodesToRefresh: TreeNode[] = [];
     const nodeIds: string[] = [];
+    const validNodes: TreeNode[] = [];
 
-    for (const node of nodes ?? this.leaves) {
+    for (const node of nodes) {
       const refundTx = getTxFromRawTxBytes(node.refundTx);
       const { needRefresh } = getNextTransactionSequence(
         refundTx.getInput(0).sequence,
@@ -2058,18 +2081,16 @@ export class SparkWallet extends EventEmitter {
       if (needRefresh) {
         nodesToRefresh.push(node);
         nodeIds.push(node.id);
+      } else {
+        validNodes.push(node);
       }
     }
 
     if (nodesToRefresh.length === 0) {
-      return;
+      return validNodes;
     }
 
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress(),
-    );
-
-    const nodesResp = await sparkClient.query_nodes({
+    const nodesResp = await this.queryNodes({
       source: {
         $case: "nodeIds",
         nodeIds: {
@@ -2085,6 +2106,7 @@ export class SparkWallet extends EventEmitter {
       nodesMap.set(node.id, node);
     }
 
+    const nodesToAdd: TreeNode[] = [];
     for (const node of nodesToRefresh) {
       if (!node.parentNodeId) {
         throw new Error(`node ${node.id} has no parent`);
@@ -2110,9 +2132,13 @@ export class SparkWallet extends EventEmitter {
         throw new Error("Failed to refresh timelock node");
       }
 
-      this.leaves = this.leaves.filter((leaf) => leaf.id !== node.id);
-      this.leaves.push(newNode);
+      nodesToAdd.push(newNode);
     }
+
+    this.updateLeaves(nodeIds, nodesToAdd);
+    validNodes.push(...nodesToAdd);
+
+    return validNodes;
   }
 
   /**
@@ -2121,16 +2147,22 @@ export class SparkWallet extends EventEmitter {
    * @param {Transfer} transfer - The transfer to claim
    * @returns {Promise<Object>} The claim result
    */
-  private async claimTransfer(
-    transfer: Transfer,
-    emit: boolean = false,
-    retryCount: number = 0,
-  ) {
+  private async claimTransfer({
+    transfer,
+    emit,
+    retryCount,
+    optimize,
+  }: {
+    transfer: Transfer;
+    emit?: boolean;
+    retryCount?: number;
+    optimize?: boolean;
+  }) {
     const MAX_RETRIES = 5;
     const BASE_DELAY_MS = 1000;
     const MAX_DELAY_MS = 10000;
 
-    if (retryCount > 0) {
+    if (retryCount && retryCount > 0) {
       const delayMs = Math.min(
         BASE_DELAY_MS * Math.pow(2, retryCount - 1),
         MAX_DELAY_MS,
@@ -2167,8 +2199,6 @@ export class SparkWallet extends EventEmitter {
           leavesToClaim,
         );
 
-        this.leaves.push(...response.nodes);
-
         if (emit) {
           this.emit(
             "transfer:claimed",
@@ -2180,15 +2210,28 @@ export class SparkWallet extends EventEmitter {
         return response.nodes;
       });
 
-      await this.checkRefreshTimelockNodes(result);
+      result = await this.checkRefreshTimelockNodes(result);
       result = await this.checkExtendTimeLockNodes(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();
+      }
+
       return result;
     } catch (error) {
-      if (retryCount < MAX_RETRIES) {
-        this.claimTransfer(transfer, emit, retryCount + 1);
+      if (retryCount && retryCount < MAX_RETRIES) {
+        this.claimTransfer({
+          transfer,
+          emit,
+          retryCount: retryCount + 1,
+          optimize,
+        });
         return [];
-      } else if (retryCount > 0) {
+      } else if (retryCount) {
         console.warn(
           "Failed to claim transfer. Please try reinitializing your wallet in a few minutes. Transfer ID: " +
             transfer.id,
@@ -2237,7 +2280,7 @@ export class SparkWallet extends EventEmitter {
         continue;
       }
       promises.push(
-        this.claimTransfer(transfer, emit)
+        this.claimTransfer({ transfer, emit, optimize: true })
           .then(() => transfer.id)
           .catch((error) => {
             console.warn(`Failed to claim transfer ${transfer.id}:`, error);
@@ -2524,7 +2567,7 @@ export class SparkWallet extends EventEmitter {
 
       let leaves = await this.selectLeaves(totalAmount);
 
-      await this.checkRefreshTimelockNodes(leaves);
+      leaves = await this.checkRefreshTimelockNodes(leaves);
       leaves = await this.checkExtendTimeLockNodes(leaves);
 
       const leavesToSend = await Promise.all(
@@ -2755,7 +2798,7 @@ export class SparkWallet extends EventEmitter {
         );
       }
     }
-    await this.checkRefreshTimelockNodes(leavesToSend);
+    leavesToSend = await this.checkRefreshTimelockNodes(leavesToSend);
     leavesToSend = await this.checkExtendTimeLockNodes(leavesToSend);
 
     const leafKeyTweaks = await Promise.all(
@@ -2842,7 +2885,7 @@ export class SparkWallet extends EventEmitter {
 
     let leaves = await this.selectLeaves(amountSats);
 
-    await this.checkRefreshTimelockNodes(leaves);
+    leaves = await this.checkRefreshTimelockNodes(leaves);
     leaves = await this.checkExtendTimeLockNodes(leaves);
 
     const feeEstimate = await sspClient.getCoopExitFeeEstimate({
@@ -3142,4 +3185,51 @@ export class SparkWallet extends EventEmitter {
       }
     }, 10000);
   }
+
+  private async updateLeaves(
+    leavesToRemove: string[],
+    leavesToAdd: TreeNode[],
+  ) {
+    const leavesToRemoveSet = new Set(leavesToRemove);
+    this.leaves = this.leaves.filter((leaf) => !leavesToRemoveSet.has(leaf.id));
+    this.leaves.push(...leavesToAdd);
+  }
+
+  private async queryNodes(
+    baseRequest: Omit<QueryNodesRequest, "limit" | "offset">,
+    sparkClientAddress?: string,
+    pageSize: number = 100,
+  ): Promise<QueryNodesResponse> {
+    const address = sparkClientAddress ?? this.config.getCoordinatorAddress();
+    const aggregatedNodes: {
+      [key: string]: QueryNodesResponse["nodes"][string];
+    } = {};
+    let offset = 0;
+
+    while (true) {
+      const sparkClient =
+        await this.connectionManager.createSparkClient(address);
+
+      const response = await sparkClient.query_nodes({
+        ...baseRequest,
+        limit: pageSize,
+        offset,
+      });
+
+      /* Merge nodes from this page. If user is sending or receiving payments results can shift
+         accross pages, potentially causing duplicates. Dedupe by node id: */
+      Object.assign(aggregatedNodes, response.nodes ?? {});
+
+      /* If we received fewer nodes than requested, this was the last page. */
+      const received = Object.keys(response.nodes ?? {}).length;
+      if (received < pageSize) {
+        return {
+          nodes: aggregatedNodes,
+          offset: response.offset,
+        } as QueryNodesResponse;
+      }
+
+      offset += pageSize;
+    }
+  }
 }

package/src/tests/integration/deposit.test.ts

@@ -33,6 +33,11 @@ describe("deposit", () => {
     // Verify that static deposit addresses don't appear in unused deposit addresses
     const unusedDepositAddresses = await sdk.getUnusedDepositAddresses();
     expect(unusedDepositAddresses).toHaveLength(0);
+
+    // Check that the same static deposit address is returned a second time.
+    const secondDepositAddress = await sdk.getStaticDepositAddress();
+    expect(secondDepositAddress).toBeDefined();
+    expect(secondDepositAddress).toEqual(depositAddress);
   }, 30000);
 
   it("should create a tree root", async () => {

package/src/tests/integration/ssp/static_deposit.test.ts

@@ -86,5 +86,9 @@ describe.skip("SSP static deposit address integration", () => {
 
     const { balance: balance2 } = await userWallet.getBalance();
     expect(balance2).toBe(BigInt(quoteAmount + quoteAmount2));
+
+    // Get transfers should include static deposit transfers.
+    const transfers = await userWallet.getTransfers();
+    expect(transfers.transfers.length).toBe(2);
   }, 60000);
 });

package/src/tests/spark-wallet/queryNodes.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, beforeEach, jest } from "@jest/globals";
+import { SparkWallet } from "../../spark-wallet/spark-wallet.js";
+import type { ConnectionManager } from "../../services/connection.js";
+
+/** Helper subclass to expose the private `queryNodes` method for testing. */
+class TestSparkWallet extends SparkWallet {
+  public constructor() {
+    super();
+  }
+
+  /** Expose the private `queryNodes` method as public for tests. */
+  public async queryNodesPublic(
+    ...args: Parameters<SparkWallet["queryNodes"]>
+  ) {
+    return (this as any).queryNodes(...args);
+  }
+
+  /** Replace the internally-created ConnectionManager with a mocked version. */
+  public setConnectionManager(manager: any) {
+    this.connectionManager = manager;
+  }
+}
+
+describe("queryNodes pagination", () => {
+  let wallet: TestSparkWallet;
+  let createSparkClientMock: jest.Mock;
+
+  beforeEach(() => {
+    const pageSize = 2;
+    const paginatedResponses: Record<number, unknown> = {
+      0: {
+        nodes: {
+          n1: { id: "n1" },
+          n2: { id: "n2" },
+        },
+        offset: 0,
+      },
+      2: {
+        nodes: {
+          n2: { id: "n2" },
+          n3: { id: "n3" },
+        },
+        offset: 2,
+      },
+      4: {
+        nodes: {},
+        offset: 4,
+      },
+    };
+
+    // `query_nodes` implementation returns the matching response for the current offset.
+    const queryNodesStub = jest.fn(async ({ offset }: { offset: number }) => {
+      return paginatedResponses[offset] ?? { nodes: {}, offset };
+    });
+
+    // Mock `createSparkClient` so that each call returns an object containing the stub.
+    createSparkClientMock = jest.fn(async () => ({
+      query_nodes: queryNodesStub,
+    }));
+
+    // Mock ConnectionManager housing the mocked factory.
+    const connectionManagerMock = {
+      createSparkClient: createSparkClientMock,
+    };
+
+    wallet = new TestSparkWallet();
+    wallet.setConnectionManager(connectionManagerMock);
+  });
+
+  it("aggregates all pages and removes duplicates", async () => {
+    const result = await wallet.queryNodesPublic(
+      { includeParents: false } as any,
+      undefined,
+      2,
+    );
+
+    // Expect three unique nodes in the final aggregation.
+    expect(Object.keys(result.nodes)).toHaveLength(3);
+    expect(Object.keys(result.nodes)).toEqual(
+      expect.arrayContaining(["n1", "n2", "n3"]),
+    );
+
+    // Ensure we kept the last offset from the mocked response.
+    expect(result.offset).toBe(4);
+
+    // `createSparkClient` must have been invoked once per page (3 times).
+    expect(createSparkClientMock).toHaveBeenCalledTimes(3);
+  });
+});

package/android/build/.transforms/040d8fa2b9716b9d83b2ee652456153b/results.bin

@@ -1 +0,0 @@
-o/classes

package/android/build/.transforms/2d0f5d3b1e10a4215d771884270da0bd/results.bin

@@ -1 +0,0 @@
-o/classes

package/android/build/.transforms/54700a025e43a95050ec1055d0701a4f/results.bin

@@ -1 +0,0 @@
-o/bundleLibRuntimeToDirDebug