@buildonspark/spark-sdk 0.3.6 → 0.3.7

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

@@ -14,6 +14,7 @@ import { Mutex } from "async-mutex";
 import { uuidv7 } from "uuidv7";
 import {
   ConfigurationError,
+  InternalValidationError,
   NetworkError,
   NotImplementedError,
   RPCError,
@@ -106,7 +107,7 @@ import {
   isValidSparkFallback,
 } from "../services/bolt11-spark.js";
 import { SigningService } from "../services/signing.js";
-import { SparkSigner } from "../signer/signer.js";
+import { DefaultSparkSigner, SparkSigner } from "../signer/signer.js";
 import { KeyDerivation, KeyDerivationType } from "../signer/types.js";
 import { BitcoinFaucet } from "../tests/utils/test-faucet.js";
 import {
@@ -125,6 +126,7 @@ 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,
@@ -193,9 +195,10 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
 
   private tracer: Tracer | null = null;
 
-  constructor(options?: ConfigOptions, signer?: SparkSigner) {
+  constructor(options?: ConfigOptions, signerArg?: SparkSigner) {
     super();
 
+    const signer = signerArg || this.buildSigner();
     this.config = new WalletConfigService(options, signer);
     this.connectionManager = this.buildConnectionManager(this.config);
     this.signingService = new SigningService(this.config);
@@ -263,6 +266,10 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     return this.sspClient;
   }
 
+  protected buildSigner() {
+    return new DefaultSparkSigner();
+  }
+
   protected buildConnectionManager(config: WalletConfigService) {
     return new ConnectionManager(config);
   }
@@ -744,9 +751,40 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     await this.withLeaves(async () => {
       this.optimizationInProgress = true;
       try {
-        if (this.leaves.length > 0) {
-          await this.requestLeavesSwap({ leaves: this.leaves });
+        this.leaves = await this.getLeaves();
+        const swaps = maximizeUnilateralExit(
+          this.leaves.map((leaf) => leaf.value),
+        );
+
+        // 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) {
+          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;
@@ -1430,6 +1468,14 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
         directSignatureMap,
         directFromCpfpSignatureMap,
       );
+
+      // At this point the leaves are considered outgoing.
+      // Remove them from internal state so we don't select them again
+      const leavesToRemove = new Set(leavesBatch.map((leaf) => leaf.id));
+      this.leaves = [
+        ...this.leaves.filter((leaf) => !leavesToRemove.has(leaf.id)),
+      ];
+
       const completeResponse = await sspClient.completeLeaveSwap({
         adaptorSecretKey: bytesToHex(cpfpAdaptorPrivateKey),
         directAdaptorSecretKey: bytesToHex(directAdaptorPrivateKey),
@@ -3537,14 +3583,14 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
 
       const sspResponse = await sspClient.requestLightningSend({
         encodedInvoice: invoice,
-        idempotencyKey: uuidv7(),
         amountSats: isZeroAmountInvoice ? amountSatsToSend! : undefined,
+        userOutboundTransferExternalId: swapResponse.transfer.id,
       });
 
       if (!sspResponse) {
         throw new Error("Failed to contact SSP");
       }
-      // test
+
       const leavesToRemove = new Set(leavesToSend.map((leaf) => leaf.leaf.id));
       this.leaves = this.leaves.filter((leaf) => !leavesToRemove.has(leaf.id));
 
@@ -3912,12 +3958,14 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
       })),
     );
 
+    const transferId = uuidv7();
+
     const requestCoopExitParams: RequestCoopExitInput = {
       leafExternalIds: leavesToSendToSsp.map((leaf) => leaf.id),
       withdrawalAddress: onchainAddress,
-      idempotencyKey: uuidv7(),
       exitSpeed,
       withdrawAll: deductFeeFromWithdrawalAmount,
+      userOutboundTransferExternalId: transferId,
     };
 
     if (!deductFeeFromWithdrawalAmount) {
@@ -3962,11 +4010,11 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
       exitTxId: coopExitTxId,
       connectorOutputs,
       receiverPubKey: sspPubIdentityKey,
+      transferId,
     });
 
     const completeResponse = await sspClient.completeCoopExit({
       userOutboundTransferExternalId: transfer.transfer.id,
-      coopExitRequestId: coopExitRequest.id,
     });
 
     return completeResponse;
@@ -4887,7 +4935,6 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     const consoleOptions = wallet.config.getConsoleOptions();
     const spanProcessors: SpanProcessor[] = [];
     if (consoleOptions.otel) {
-      console.log("OpenTelemetry client logging enabled.");
       spanProcessors.push(new SimpleSpanProcessor(new ConsoleSpanExporter()));
     }
     const traceUrls = this.getOtelTraceUrls();

package/src/tests/integration/coop-exit.test.ts

@@ -156,11 +156,13 @@ describe.each(walletTypes)("coop exit", ({ name, Signer, createTree }) => {
       newKeyDerivation: newLeafDerivationPath,
     };
 
+    const transferId = uuidv7();
     const senderTransfer = await coopExitService.getConnectorRefundSignatures({
       leaves: [transferNode],
       exitTxId: hexToBytes(getTxIdNoReverse(exitTx)),
       connectorOutputs,
       receiverPubKey: hexToBytes(sspPubkey),
+      transferId,
     });
 
     const receiverTransfer = await sspTransferService.queryTransfer(

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

@@ -24,6 +24,7 @@ import {
 import { getTestWalletConfig, walletTypes } from "../test-utils.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "../utils/test-faucet.js";
+import { DefaultSparkSigner } from "../../signer/signer.js";
 
 async function cleanUp() {
   const config = getTestWalletConfig();
@@ -33,7 +34,10 @@ async function cleanUp() {
   );
   const paymentHash = sha256(preimage);
 
-  const configService = new WalletConfigService(config);
+  const configService = new WalletConfigService(
+    config,
+    new DefaultSparkSigner(),
+  );
   const connectionManager = new ConnectionManagerNodeJS(configService);
   for (const operator of Object.values(config.signingOperators!)) {
     const client = await connectionManager.createMockClient(operator!.address);

package/src/tests/integration/ssp/coop-exit-validation.test.ts

@@ -1,12 +1,11 @@
-import { Transaction } from "@scure/btc-signer";
+import { expect } from "@jest/globals";
+import { ValidationError } from "../../../errors/types.js";
+import { ExitSpeed } from "../../../types/index.js";
+import { getNewAddress } from "../../utils/regtest-test-faucet.js";
 import {
   initTestingWallet,
   SparkWalletTesting,
 } from "../../utils/spark-testing-wallet.js";
-import { expect } from "@jest/globals";
-import { ExitSpeed } from "../../../types/index.js";
-import { ValidationError } from "../../../errors/types.js";
-import { getNewAddress } from "../../utils/regtest-test-faucet.js";
 
 const DEPOSIT_AMOUNT = 50_000n;
 
@@ -200,7 +199,7 @@ describe("SSP coop exit basic validation", () => {
         exitSpeed: ExitSpeed.FAST,
         deductFeeFromWithdrawalAmount: true,
       }),
-    ).rejects.toThrow("Not enough leaves to swap for the target amount");
+    ).rejects.toThrow("Total target amount exceeds available balance");
   }, 600000);
 
   // it("should correctly update balance after successful withdrawal", async () => {

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

@@ -46,18 +46,20 @@ describe("SSP static deposit address integration", () => {
         vout!,
       );
 
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-
       const quoteAmount = quote!.creditAmountSats;
       const sspSignature = quote!.signature;
 
-      await userWallet.claimStaticDeposit({
-        transactionId,
-        creditAmountSats: quoteAmount,
-        sspSignature,
-        outputIndex: vout!,
-      });
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await retryUntilSuccess(
+        async () =>
+          await userWallet.claimStaticDeposit({
+            transactionId,
+            creditAmountSats: quoteAmount,
+            sspSignature,
+            outputIndex: vout!,
+          }),
+      );
+
+      await waitForClaim({ wallet: userWallet });
       const { balance } = await userWallet.getBalance();
       expect(balance).toBe(BigInt(quoteAmount));
 
@@ -79,7 +81,7 @@ describe("SSP static deposit address integration", () => {
         creditAmountSats: quoteAmount2,
         sspSignature: sspSignature2,
       });
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await waitForClaim({ wallet: userWallet });
       const { balance: balance2 } = await userWallet.getBalance();
       expect(balance2).toBe(BigInt(quoteAmount + quoteAmount2));
 
@@ -99,7 +101,7 @@ describe("SSP static deposit address integration", () => {
         transactionId: transactionId3,
         maxFee: 1000,
       });
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await waitForClaim({ wallet: userWallet });
       const { balance: balance3 } = await userWallet.getBalance();
       expect(balance3).toBe(BigInt(quoteAmount + quoteAmount2 + quoteAmount3));
       // Get transfers should include static deposit transfers.
@@ -203,18 +205,20 @@ describe("SSP static deposit address integration", () => {
         vout!,
       );
 
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-
       const quoteAmount = quote!.creditAmountSats;
       const sspSignature = quote!.signature;
 
-      await userWallet.claimStaticDeposit({
-        transactionId,
-        creditAmountSats: quoteAmount,
-        sspSignature,
-        outputIndex: vout!,
-      });
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await retryUntilSuccess(
+        async () =>
+          await userWallet.claimStaticDeposit({
+            transactionId,
+            creditAmountSats: quoteAmount,
+            sspSignature,
+            outputIndex: vout!,
+          }),
+      );
+
+      await waitForClaim({ wallet: userWallet });
       const { balance } = await userWallet.getBalance();
       expect(balance).toBe(BigInt(quoteAmount));
 
@@ -231,12 +235,15 @@ describe("SSP static deposit address integration", () => {
         await userWallet.getClaimStaticDepositQuote(transactionId2);
       const quoteAmount2 = quote2!.creditAmountSats;
       const sspSignature2 = quote2!.signature;
-      await userWallet.claimStaticDeposit({
-        transactionId: transactionId2,
-        creditAmountSats: quoteAmount2,
-        sspSignature: sspSignature2,
-      });
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await retryUntilSuccess(
+        async () =>
+          await userWallet.claimStaticDeposit({
+            transactionId: transactionId2,
+            creditAmountSats: quoteAmount2,
+            sspSignature: sspSignature2,
+          }),
+      );
+      await waitForClaim({ wallet: userWallet });
       const { balance: balance2 } = await userWallet.getBalance();
       expect(balance2).toBe(BigInt(quoteAmount + quoteAmount2));
 
@@ -252,11 +259,14 @@ describe("SSP static deposit address integration", () => {
       const quote3 =
         await userWallet.getClaimStaticDepositQuote(transactionId3);
       const quoteAmount3 = quote3!.creditAmountSats;
-      await userWallet.claimStaticDepositWithMaxFee({
-        transactionId: transactionId3,
-        maxFee: 1000,
-      });
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await retryUntilSuccess(
+        async () =>
+          await userWallet.claimStaticDepositWithMaxFee({
+            transactionId: transactionId3,
+            maxFee: 1000,
+          }),
+      );
+      await waitForClaim({ wallet: userWallet });
       const { balance: balance3 } = await userWallet.getBalance();
       expect(balance3).toBe(BigInt(quoteAmount + quoteAmount2 + quoteAmount3));
       // Get transfers should include static deposit transfers.
@@ -533,7 +543,7 @@ describe("SSP static deposit address integration", () => {
         creditAmountSats: quote.creditAmountSats,
         sspSignature: quote.signature,
       });
-      await new Promise((resolve) => setTimeout(resolve, 40000));
+      await waitForClaim({ wallet: aliceWallet });
 
       const { balance } = await aliceWallet.getBalance();
 
@@ -619,7 +629,7 @@ describe("SSP static deposit address integration", () => {
         outputIndex: vout!,
       });
 
-      await new Promise((resolve) => setTimeout(resolve, 30000));
+      await waitForClaim({ wallet: userWallet });
 
       expect(outputs).toBeDefined();
 
@@ -669,7 +679,7 @@ describe("SSP static deposit address integration", () => {
         outputIndex: vout!,
       });
 
-      await new Promise((resolve) => setTimeout(resolve, 30000));
+      await waitForClaim({ wallet: userWallet });
 
       console.log("Fetching wallet balance after claim...");
       const { balance } = await userWallet.getBalance();
@@ -686,7 +696,7 @@ describe("SSP static deposit address integration", () => {
 
       expect(transfer).toBeDefined();
 
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await waitForClaim({ wallet: userWallet });
 
       // Try to refund the deposit after claiming and transfer
       console.log("Attempting refund of claimed deposit...");

package/src/tests/optimize.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "@jest/globals";
+import {
+  greedyLeaves,
+  swapMinimizingLeaves,
+  maximizeUnilateralExit,
+  minimizeTransferSwap,
+  Swap,
+} from "../utils/optimize.js";
+
+describe("keys", () => {
+  it("test greedyLeaves", () => {
+    expect(greedyLeaves(0)).toEqual([]);
+    expect(greedyLeaves(1)).toEqual([1]);
+    expect(greedyLeaves(100)).toEqual([4, 32, 64]);
+    expect(greedyLeaves(255)).toEqual([1, 2, 4, 8, 16, 32, 64, 128]);
+    expect(greedyLeaves(256)).toEqual([256]);
+  });
+
+  it("test swapMinimizingLeaves", () => {
+    expect(swapMinimizingLeaves(0)).toEqual([]);
+    expect(swapMinimizingLeaves(1)).toEqual([1]);
+    expect(swapMinimizingLeaves(100)).toEqual([1, 1, 2, 4, 4, 8, 16, 32, 32]);
+    expect(swapMinimizingLeaves(255)).toEqual([1, 2, 4, 8, 16, 32, 64, 128]);
+    expect(swapMinimizingLeaves(256)).toEqual([1, 1, 2, 4, 8, 16, 32, 64, 128]);
+  });
+
+  it("test maximizeUnilateralExit", () => {
+    expect(maximizeUnilateralExit([100, 64, 28, 1, 1])).toEqual([
+      new Swap([1, 1, 28, 64, 100], [2, 64, 128]),
+    ]);
+    expect(maximizeUnilateralExit([1, 1, 1, 1, 1, 1, 1, 1], 2)).toEqual([
+      new Swap([1, 1], [2]),
+      new Swap([1, 1], [2]),
+      new Swap([1, 1], [2]),
+      new Swap([1, 1], [2]),
+    ]);
+  });
+
+  it("test minimizeTransferSwap", () => {
+    expect(minimizeTransferSwap([8])).toEqual([new Swap([8], [1, 1, 2, 4])]);
+    expect(minimizeTransferSwap([100])).toEqual([
+      new Swap([100], [1, 1, 2, 4, 4, 8, 16, 32, 32]),
+    ]);
+  });
+});

package/src/tests/token-outputs.test.ts

@@ -1,4 +1,4 @@
-import { numberToBytesBE } from "@noble/curves/utils";
+import { numberToBytesBE, bytesToNumberBE } from "@noble/curves/utils";
 import { ValidationError } from "../errors/types.js";
 import { OutputWithPreviousTransactionData } from "../proto/spark.js";
 import { WalletConfigService } from "../services/config.js";
@@ -17,6 +17,18 @@ describe("select token outputs", () => {
     );
   });
 
+  // Helper to access the private sorting method
+  const sortTokenOutputsByStrategy = (
+    tokenOutputs: OutputWithPreviousTransactionData[],
+    strategy: "SMALL_FIRST" | "LARGE_FIRST",
+  ) => {
+    // TypeScript bracket notation to access private method
+    (tokenTransactionService as any)["sortTokenOutputsByStrategy"](
+      tokenOutputs,
+      strategy,
+    );
+  };
+
   const createMockTokenOutput = (
     id: string,
     tokenAmount: bigint,
@@ -191,4 +203,51 @@ describe("select token outputs", () => {
       // Total: 600n >= 600n
     });
   });
+
+  describe("sorting with large amounts", () => {
+    it("should sort correctly when all amounts are above 2^60", () => {
+      const base = 2n ** 60n;
+      const amounts = [
+        base + 5000n,
+        base + 100n,
+        base + 1n,
+        base + 10000n,
+        base + 500n,
+      ];
+
+      const tokenOutputs = amounts.map((amount, i) =>
+        createMockTokenOutput(`output${i}`, amount),
+      );
+
+      // SMALL_FIRST
+      const smallFirstSorted = [...tokenOutputs];
+      sortTokenOutputsByStrategy(smallFirstSorted, "SMALL_FIRST");
+
+      const smallFirstAmounts = smallFirstSorted.map((o) =>
+        bytesToNumberBE(o.output!.tokenAmount!),
+      );
+      expect(smallFirstAmounts).toEqual([
+        base + 1n,
+        base + 100n,
+        base + 500n,
+        base + 5000n,
+        base + 10000n,
+      ]);
+
+      // LARGE_FIRST
+      const largeFirstSorted = [...tokenOutputs];
+      sortTokenOutputsByStrategy(largeFirstSorted, "LARGE_FIRST");
+
+      const largeFirstAmounts = largeFirstSorted.map((o) =>
+        bytesToNumberBE(o.output!.tokenAmount!),
+      );
+      expect(largeFirstAmounts).toEqual([
+        base + 10000n,
+        base + 5000n,
+        base + 500n,
+        base + 100n,
+        base + 1n,
+      ]);
+    });
+  });
 });

package/src/tests/utils/test-faucet.ts

@@ -42,9 +42,9 @@ export class BitcoinFaucet {
   private lock: Promise<void> = Promise.resolve();
 
   private constructor(
-    private url: string = "http://127.0.0.1:8332",
-    private username: string = "testutil",
-    private password: string = "testutilpassword",
+    private url: string,
+    private username: string,
+    private password: string,
   ) {
     this.miningAddress = getP2TRAddressFromPublicKey(
       secp256k1.getPublicKey(STATIC_MINING_KEY),
@@ -52,12 +52,16 @@ export class BitcoinFaucet {
     );
   }
 
-  static getInstance(
-    url: string = "http://127.0.0.1:8332",
-    username: string = "testutil",
-    password: string = "testutilpassword",
-  ): BitcoinFaucet {
+  static getInstance(): BitcoinFaucet {
     if (!BitcoinFaucet.instance) {
+      const url =
+        process.env.BITCOIN_RPC_URL ||
+        (process.env.MINIKUBE_IP
+          ? `http://${process.env.MINIKUBE_IP}:8332`
+          : "http://127.0.0.1:8332");
+      const username = process.env.BITCOIN_RPC_USER || "testutil";
+      const password = process.env.BITCOIN_RPC_PASSWORD || "testutilpassword";
+
       BitcoinFaucet.instance = new BitcoinFaucet(url, username, password);
     }
     return BitcoinFaucet.instance;