@buildonspark/spark-sdk 0.1.35 → 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;
+      }
+    }
   }
 
   /**
@@ -1199,7 +1209,7 @@ export class SparkWallet extends EventEmitter {
     return address.depositAddress.address;
   }
 
-  private async queryStaticDepositAddresses(): Promise<string[]> {
+  public async queryStaticDepositAddresses(): Promise<string[]> {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress(),
     );
@@ -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,
@@ -2149,7 +2181,10 @@ export class SparkWallet extends EventEmitter {
             const leafPubKey = leafPubKeyMap.get(leaf.leaf.id);
             if (leafPubKey) {
               leavesToClaim.push({
-                leaf: leaf.leaf,
+                leaf: {
+                  ...leaf.leaf,
+                  refundTx: leaf.intermediateRefundTx,
+                },
                 signingPubKey: leafPubKey,
                 newSigningPubKey: await this.config.signer.generatePublicKey(
                   sha256(leaf.leaf.id),
@@ -2164,8 +2199,6 @@ export class SparkWallet extends EventEmitter {
           leavesToClaim,
         );
 
-        this.leaves.push(...response.nodes);
-
         if (emit) {
           this.emit(
             "transfer:claimed",
@@ -2177,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,
@@ -2234,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);
@@ -2280,11 +2326,11 @@ export class SparkWallet extends EventEmitter {
    *
    * @param {Object} params - Parameters for the lightning invoice
    * @param {number} params.amountSats - Amount in satoshis
-   * @param {string} params.memo - Description for the invoice
+   * @param {string} [params.memo] - Description for the invoice. Should not be provided if the descriptionHash is provided.
    * @param {number} [params.expirySeconds] - Optional expiry time in seconds
    * @param {boolean} [params.includeSparkAddress] - Optional boolean signalling whether or not to include the spark address in the invoice
    * @param {string} [params.receiverIdentityPubkey] - Optional public key of the wallet receiving the lightning invoice. If not present, the receiver will be the creator of this request.
-   * @param {string} [params.descriptionHash] - Optional h tag of the invoice. This is the hash of a longer description to include in the lightning invoice. It is used in LNURL and UMA as the hash of the metadata.
+   * @param {string} [params.descriptionHash] - Optional h tag of the invoice. This is the hash of a longer description to include in the lightning invoice. It is used in LNURL and UMA as the hash of the metadata. This field is mutually exclusive with the memo field. Only one or the other should be provided.
    * @returns {Promise<LightningReceiveRequest>} BOLT11 encoded invoice
    */
   public async createLightningInvoice({
@@ -2337,6 +2383,17 @@ export class SparkWallet extends EventEmitter {
       });
     }
 
+    if (memo && descriptionHash) {
+      throw new ValidationError(
+        "Memo and descriptionHash cannot be provided together. Please provide only one.",
+        {
+          field: "memo",
+          value: memo,
+          expected: "Memo or descriptionHash",
+        },
+      );
+    }
+
     const requestLightningInvoice = async (
       amountSats: number,
       paymentHash: Uint8Array,
@@ -2510,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(
@@ -2741,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(
@@ -2828,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({
@@ -3128,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/dist/native/chunk-OVEXKBAZ.js

@@ -1,14 +0,0 @@
-require("react-native-get-random-values");
-
-// buffer.js
-import { Buffer } from "buffer";
-if (typeof globalThis.Buffer === "undefined") {
-  globalThis.Buffer = Buffer;
-}
-if (typeof global === "undefined") {
-  window.global = window.globalThis;
-}
-
-export {
-  Buffer
-};