@buildonspark/spark-sdk 0.2.5 → 0.2.6

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

@@ -0,0 +1,233 @@
+import { Transaction } from "@scure/btc-signer";
+import {
+  initWallet,
+  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;
+
+describe("SSP coop exit basic validation", () => {
+  let userWallet!: SparkWalletTesting;
+  let withdrawalAddress: string;
+  let quoteAmount: number;
+
+  beforeAll(async () => {
+    const { wallet, depositAddress, signedTx, vout, faucet } = await initWallet(
+      DEPOSIT_AMOUNT,
+      "LOCAL",
+    );
+
+    // Wait for the transaction to be mined
+    await new Promise((resolve) => setTimeout(resolve, 30000));
+
+    expect(signedTx).toBeDefined();
+
+    const transactionId = signedTx.id;
+
+    userWallet = wallet;
+
+    console.log("Fetching claim quote for static deposit...");
+    const quote = await userWallet.getClaimStaticDepositQuote(
+      transactionId,
+      vout!,
+    );
+
+    quoteAmount = quote!.creditAmountSats;
+    const sspSignature = quote!.signature;
+
+    console.log("Attempting to claim static deposit...");
+    await userWallet.claimStaticDeposit({
+      transactionId,
+      creditAmountSats: quoteAmount,
+      sspSignature,
+      outputIndex: vout!,
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 30000));
+
+    const { balance } = await userWallet.getBalance();
+    expect(balance).toBe(BigInt(quoteAmount));
+
+    withdrawalAddress = await getNewAddress();
+  }, 600000);
+
+  it("should fail when amountSats is zero", async () => {
+    const { balance } = await userWallet.getBalance();
+    expect(balance).toBe(BigInt(quoteAmount));
+
+    await expect(
+      userWallet.getWithdrawalFeeQuote({
+        amountSats: 0,
+        withdrawalAddress,
+      }),
+    ).rejects.toThrow("Target amount must be positive");
+  }, 600000);
+
+  it("should fail when amountSats is negative", async () => {
+    await expect(
+      userWallet.getWithdrawalFeeQuote({
+        amountSats: -1,
+        withdrawalAddress,
+      }),
+    ).rejects.toThrow("Target amount must be positive");
+  }, 600000);
+
+  it("should fail when amountSats exceeds Number.MAX_SAFE_INTEGER", async () => {
+    await expect(
+      userWallet.getWithdrawalFeeQuote({
+        amountSats: Number.MAX_SAFE_INTEGER + 1,
+        withdrawalAddress,
+      }),
+    ).rejects.toThrow("Sats amount must be less than 2^53");
+  }, 600000);
+
+  it("should fail when amountSats exceeds available balance", async () => {
+    const { balance } = await userWallet.getBalance();
+    expect(balance).toBe(BigInt(quoteAmount));
+
+    await expect(
+      userWallet.getWithdrawalFeeQuote({
+        amountSats: Number(balance) + 1,
+        withdrawalAddress,
+      }),
+    ).rejects.toThrow("Total target amount exceeds available balance");
+  }, 600000);
+
+  it("should fail when withdrawalAddress is invalid", async () => {
+    await expect(
+      userWallet.getWithdrawalFeeQuote({
+        amountSats: 1000,
+        withdrawalAddress: "invalid address",
+      }),
+    ).rejects.toThrow("Invalid address provided");
+  }, 600000);
+
+  it("should succeed when valid params are provided", async () => {
+    const feeQuote = await userWallet.getWithdrawalFeeQuote({
+      amountSats: 5000,
+      withdrawalAddress,
+    });
+
+    expect(feeQuote).toBeDefined();
+  }, 600000);
+
+  it("should fail when withdrawalAddress is missing", async () => {
+    await expect(
+      userWallet.getWithdrawalFeeQuote({
+        amountSats: 1000,
+        withdrawalAddress: "" as unknown as string,
+      }),
+    ).rejects.toThrow("Invalid address provided");
+  }, 600000);
+
+  it("should fail when amountSats is not a number", async () => {
+    await expect(
+      userWallet.getWithdrawalFeeQuote({
+        amountSats: "1000" as unknown as number,
+        withdrawalAddress,
+      }),
+    ).rejects.toThrow("Sats amount must be less than 2^53");
+  }, 600000);
+
+  it("should fail if deductFeeFromWithdrawalAmount is true and amount is too small", async () => {
+    const feeQuote = await userWallet.getWithdrawalFeeQuote({
+      amountSats: 100,
+      withdrawalAddress,
+    });
+
+    await expect(
+      userWallet.withdraw({
+        amountSats: 100, // Fails if amount is less than the fee.
+        onchainAddress: withdrawalAddress,
+        feeQuote: feeQuote!,
+        exitSpeed: ExitSpeed.FAST,
+        deductFeeFromWithdrawalAmount: true,
+      }),
+    ).rejects.toMatchObject({
+      name: ValidationError.name,
+      message: expect.stringContaining(
+        "The fee for the withdrawal is greater than the target withdrawal amount",
+      ),
+      context: expect.objectContaining({
+        field: "fee",
+        expected: "less than or equal to the target amount",
+      }),
+    });
+  }, 600000);
+
+  it("should fail with invalid exitSpeed", async () => {
+    const feeQuote = await userWallet.getWithdrawalFeeQuote({
+      amountSats: 5000,
+      withdrawalAddress,
+    });
+
+    await expect(
+      userWallet.withdraw({
+        amountSats: 5000,
+        onchainAddress: withdrawalAddress,
+        feeQuote: feeQuote!,
+        exitSpeed: "INVALID" as ExitSpeed,
+        deductFeeFromWithdrawalAmount: false,
+      }),
+    ).rejects.toMatchObject({
+      name: ValidationError.name,
+      message: expect.stringContaining("Invalid exit speed"),
+      context: expect.objectContaining({
+        field: "exitSpeed",
+        value: "INVALID" as ExitSpeed,
+        expected: "FAST, MEDIUM, or SLOW",
+      }),
+    });
+  }, 600000);
+
+  it("should fail if fee exceeds available balance (without deduction)", async () => {
+    await new Promise((resolve) => setTimeout(resolve, 40000));
+
+    const initialBalance = (await userWallet.getBalance()).balance;
+
+    const feeQuote = await userWallet.getWithdrawalFeeQuote({
+      amountSats: Number(initialBalance),
+      withdrawalAddress,
+    });
+
+    await expect(
+      userWallet.withdraw({
+        amountSats: Number(initialBalance) + 1,
+        onchainAddress: withdrawalAddress,
+        feeQuote: feeQuote!,
+        exitSpeed: ExitSpeed.FAST,
+        deductFeeFromWithdrawalAmount: true,
+      }),
+    ).rejects.toThrow("Not enough leaves to swap for the target amount");
+  }, 600000);
+
+  // it("should correctly update balance after successful withdrawal", async () => {
+  //   const initialBalance = (await userWallet.getBalance()).balance;
+
+  //   const feeQuote = await userWallet.getWithdrawalFeeQuote({
+  //     amountSats: 3000,
+  //     withdrawalAddress,
+  //   });
+
+  //   const result = await userWallet.withdraw({
+  //     amountSats: 3000,
+  //     onchainAddress: withdrawalAddress,
+  //     feeQuote: feeQuote!,
+  //     exitSpeed: ExitSpeed.SLOW,
+  //     deductFeeFromWithdrawalAmount: false,
+  //   });
+
+  //   await new Promise((resolve) => setTimeout(resolve, 30000));
+
+  //   const finalBalance = (await userWallet.getBalance()).balance;
+  //   const fee =
+  //     (result?.l1BroadcastFee?.originalValue ?? 0) +
+  //     (result?.fee?.originalValue ?? 0);
+
+  //   expect(finalBalance).toBe(initialBalance - 3000n - BigInt(fee));
+  // }, 600000);
+});

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

@@ -1,41 +1,61 @@
 import { describe, expect, it } from "@jest/globals";
 import { ExitSpeed } from "../../../types/index.js";
-import { SparkWalletTesting } from "../../utils/spark-testing-wallet.js";
-import { BitcoinFaucet } from "../../utils/test-faucet.js";
+import {
+  initWallet,
+  SparkWalletTesting,
+} from "../../utils/spark-testing-wallet.js";
+import { getNewAddress } from "../../utils/regtest-test-faucet.js";
+import { ValidationError } from "../../../index.node.js";
 
-const DEPOSIT_AMOUNT = 10_000n;
+export const DEPOSIT_AMOUNT = 30_000n;
 
 describe("SSP coop exit integration", () => {
-  it("should estimate coop exit fee", async () => {
-    const faucet = BitcoinFaucet.getInstance();
-
-    const { wallet: userWallet } = await SparkWalletTesting.initialize(
-      {
-        options: {
-          network: "LOCAL",
-        },
-      },
-      false,
+  let userWallet!: SparkWalletTesting;
+  let withdrawalAddress: string;
+  let quoteAmount: number;
+
+  beforeEach(async () => {
+    const { wallet, depositAddress, signedTx, vout, faucet } = await initWallet(
+      DEPOSIT_AMOUNT,
+      "LOCAL",
     );
 
-    const depositAddress = await userWallet.getSingleUseDepositAddress();
-    expect(depositAddress).toBeDefined();
+    // Wait for the transaction to be mined
+    await new Promise((resolve) => setTimeout(resolve, 30000));
 
-    const signedTx = await faucet.sendToAddress(depositAddress, DEPOSIT_AMOUNT);
     expect(signedTx).toBeDefined();
-    await faucet.mineBlocks(6);
 
-    await userWallet.claimDeposit(signedTx.id);
+    const transactionId = signedTx.id;
 
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    userWallet = wallet;
 
-    const { balance } = await userWallet.getBalance();
-    expect(balance).toBe(DEPOSIT_AMOUNT);
+    console.log("Fetching claim quote for static deposit...");
+    const quote = await userWallet.getClaimStaticDepositQuote(
+      transactionId,
+      vout!,
+    );
 
-    const withdrawalAddress = await faucet.getNewAddress();
+    quoteAmount = quote!.creditAmountSats;
+    const sspSignature = quote!.signature;
+
+    console.log("Attempting to claim static deposit...");
+    await userWallet.claimStaticDeposit({
+      transactionId,
+      creditAmountSats: quoteAmount,
+      sspSignature,
+      outputIndex: vout!,
+    });
 
+    await new Promise((resolve) => setTimeout(resolve, 30000));
+
+    const { balance } = await userWallet.getBalance();
+    expect(balance).toBe(BigInt(quoteAmount));
+
+    withdrawalAddress = await getNewAddress();
+  }, 600000);
+  it("should estimate coop exit fee", async () => {
     const feeEstimate = await userWallet.getWithdrawalFeeQuote({
-      amountSats: Number(DEPOSIT_AMOUNT),
+      amountSats: Number(quoteAmount),
       withdrawalAddress,
     });
 
@@ -54,74 +74,73 @@ describe("SSP coop exit integration", () => {
     expect(feeEstimate?.l1BroadcastFeeSlow.originalValue).toBeGreaterThan(0);
     expect(feeEstimate?.userFeeSlow).toBeDefined();
     expect(feeEstimate?.userFeeSlow.originalValue).toBeGreaterThan(0);
-  }, 60000);
-
-  it.skip("should complete coop exit without deducting fees from withdrawal amount", async () => {
-    const faucet = BitcoinFaucet.getInstance();
-
-    const { wallet: userWallet } = await SparkWalletTesting.initialize(
-      {
-        options: {
-          network: "LOCAL",
-        },
-      },
-      false,
-    );
-
-    const depositAddress = await userWallet.getSingleUseDepositAddress();
-    expect(depositAddress).toBeDefined();
-
-    const signedTx = await faucet.sendToAddress(depositAddress, DEPOSIT_AMOUNT);
-    expect(signedTx).toBeDefined();
-    await faucet.mineBlocks(6);
-
-    await userWallet.claimDeposit(signedTx.id);
-
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-
-    const { balance } = await userWallet.getBalance();
-    expect(balance).toBe(DEPOSIT_AMOUNT);
-
-    const withdrawalAddress = await faucet.getNewAddress();
-
-    const feeQuote = await userWallet.getWithdrawalFeeQuote({
-      amountSats: 5000,
-      withdrawalAddress,
-    });
-
-    expect(feeQuote).toBeDefined();
-
-    const coopExit = await userWallet.withdraw({
-      amountSats: 5000,
-      onchainAddress: withdrawalAddress,
-      feeQuote: feeQuote!,
-      exitSpeed: ExitSpeed.FAST,
-      deductFeeFromWithdrawalAmount: false,
-    });
-
-    const fee =
-      (coopExit?.l1BroadcastFee?.originalValue ?? 0) +
-      (coopExit?.fee?.originalValue ?? 0);
-
-    expect(fee).toBeGreaterThan(0);
-
-    const { balance: balanceAfter } = await userWallet.getBalance();
-
-    expect(balanceAfter).toBe(DEPOSIT_AMOUNT - 5000n - BigInt(fee));
-    expect(coopExit).toBeDefined();
-    expect(coopExit?.coopExitTxid).toBeDefined();
-
-    await faucet.mineBlocks(6);
-
-    const deposit = await userWallet.claimDeposit(coopExit!.coopExitTxid);
-
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-
-    expect(deposit).toBeDefined();
-    expect(deposit?.reduce((acc, leaf) => acc + leaf.value, 0)).toBe(5000);
-
-    const { balance: balance2 } = await userWallet.getBalance();
-
-    expect(balance2).toBe(DEPOSIT_AMOUNT - BigInt(fee));
-  }, 60000);
+  }, 600000);
+
+  // it("should complete coop exit without deducting fees from withdrawal amount", async () => {
+  //   const { balance } = await userWallet.getBalance();
+  //   expect(balance).toBe(BigInt(quoteAmount));
+
+  //   const feeQuote = await userWallet.getWithdrawalFeeQuote({
+  //     amountSats: 5000,
+  //     withdrawalAddress,
+  //   });
+
+  //   expect(feeQuote).toBeDefined();
+
+  //   const coopExit = await userWallet.withdraw({
+  //     amountSats: 5000,
+  //     onchainAddress: withdrawalAddress,
+  //     feeQuote: feeQuote!,
+  //     exitSpeed: ExitSpeed.FAST,
+  //     deductFeeFromWithdrawalAmount: false,
+  //   });
+
+  //   const fee =
+  //     (coopExit?.l1BroadcastFee?.originalValue ?? 0) +
+  //     (coopExit?.fee?.originalValue ?? 0);
+
+  //   expect(fee).toBeGreaterThan(0);
+
+  //   const { balance: balanceAfter } = await userWallet.getBalance();
+
+  //   expect(balanceAfter).toBe(balance - 5000n - BigInt(fee));
+  //   expect(coopExit).toBeDefined();
+  //   expect(coopExit?.coopExitTxid).toBeDefined();
+  // }, 600000);
+
+  // it("CoopExit with spent leaves", async () => {
+  //   const { balance } = await userWallet.getBalance();
+
+  //   const feeQuote = await userWallet.getWithdrawalFeeQuote({
+  //     amountSats: Number(balance),
+  //     withdrawalAddress,
+  //   });
+
+  //   expect(feeQuote).toBeDefined();
+
+  //   const coopExit = await userWallet.withdraw({
+  //     amountSats: Number(balance),
+  //     onchainAddress: withdrawalAddress,
+  //     feeQuote: feeQuote!,
+  //     exitSpeed: ExitSpeed.FAST,
+  //     deductFeeFromWithdrawalAmount: true,
+  //   });
+
+  //   expect(coopExit).toBeDefined();
+  //   expect(coopExit?.coopExitTxid).toBeDefined();
+
+  //   const sparkAddress = await userWallet.getSparkAddress();
+  //   await expect(
+  //     userWallet.transfer({
+  //       amountSats: Number(balance),
+  //       receiverSparkAddress: sparkAddress,
+  //     }),
+  //   ).rejects.toMatchObject({
+  //     name: ValidationError.name,
+  //     message: expect.stringContaining("No owned leaves found"),
+  //     context: expect.objectContaining({
+  //       field: "leaves",
+  //     }),
+  //   });
+  // }, 600000);
 });

package/src/tests/integration/ssp/static-deposit-validation.test.ts

@@ -0,0 +1,145 @@
+import {
+  initWallet,
+  SparkWalletTesting,
+} from "../../utils/spark-testing-wallet.js";
+import { sha256 } from "@noble/hashes/sha2";
+import { bytesToHex } from "@noble/hashes/utils";
+import { BitcoinFaucet } from "../../utils/test-faucet.js";
+
+const DEPOSIT_AMOUNT = 10000n;
+
+describe("SSP static deposit validation tests", () => {
+  // it("should reject claiming deposits with insufficient confirmation", async () => {
+  //   const faucet = BitcoinFaucet.getInstance();
+
+  //   const { wallet: userWallet } = await SparkWalletTesting.initialize(
+  //     {
+  //       options: {
+  //         network: "LOCAL",
+  //       },
+  //     },
+  //     false,
+  //   );
+
+  //   const depositAddress = await userWallet.getStaticDepositAddress();
+  //   expect(depositAddress).toBeDefined();
+
+  //   const signedTx = await faucet.sendToAddress(
+  //     depositAddress,
+  //     DEPOSIT_AMOUNT,
+  //     0,
+  //   );
+
+  //   expect(signedTx).toBeDefined();
+  //   const transactionId = signedTx.id;
+
+  //   await expect(
+  //     userWallet.getClaimStaticDepositQuote(transactionId),
+  //   ).rejects.toThrow("Transaction not found");
+
+  //   const vout = await (userWallet as any).getDepositTransactionVout(
+  //     transactionId,
+  //   );
+
+  //   expect(transactionId).toBeDefined();
+
+  //   await new Promise((resolve) => setTimeout(resolve, 30000));
+
+  //   const quote = await userWallet.getClaimStaticDepositQuote(
+  //     transactionId,
+  //     vout!,
+  //   );
+
+  //   expect(quote).toBeDefined();
+  // }, 600000);
+
+  it("should validate static deposit request parameters", async () => {
+    const {
+      wallet: userWallet,
+      depositAddress,
+      signedTx,
+      vout,
+      faucet,
+    } = await initWallet(DEPOSIT_AMOUNT, "LOCAL");
+
+    await new Promise((resolve) => setTimeout(resolve, 30000));
+
+    expect(signedTx).toBeDefined();
+
+    const transactionId = signedTx.id;
+
+    // Invalid transaction ID
+    await expect(
+      userWallet.getClaimStaticDepositQuote("invalid-txid", vout!),
+    ).rejects.toThrow("Invalid transaction ID:");
+
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+
+    // Valid transaction ID but not same as signedTx.id
+    await expect(
+      userWallet.getClaimStaticDepositQuote(
+        bytesToHex(sha256("invalid-txid")),
+        vout!,
+      ),
+    ).rejects.toThrow("Transaction not found");
+
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+
+    // Missing output index
+    await expect(
+      userWallet.getClaimStaticDepositQuote(transactionId, vout! + 10),
+    ).rejects.toThrow("UTXO is spent or not found.");
+
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+
+    // Valid quote request for control
+    const quote = await userWallet.getClaimStaticDepositQuote(
+      transactionId,
+      vout!,
+    );
+    expect(quote).toBeDefined();
+    console.log(
+      "Static deposit quote validation passed for correct parameters.",
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 10000));
+
+    // Invalid claim: missing signature
+    await expect(
+      userWallet.claimStaticDeposit({
+        transactionId,
+        creditAmountSats: quote!.creditAmountSats,
+        outputIndex: vout!,
+        sspSignature: "",
+      }),
+    ).rejects.toThrow(
+      'Request ClaimStaticDeposit failed. [{"message":"Something went wrong."',
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 10000));
+
+    // Invalid claim: invalid credit amount
+    await expect(
+      userWallet.claimStaticDeposit({
+        transactionId,
+        creditAmountSats: quote!.creditAmountSats + 1000,
+        outputIndex: vout!,
+        sspSignature: quote!.signature,
+      }),
+    ).rejects.toThrow(
+      "The utxo amount is not enough to cover the claim amount",
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 10000));
+
+    // Invalid claim: wrong output index
+    await expect(
+      userWallet.claimStaticDeposit({
+        transactionId,
+        creditAmountSats: quote!.creditAmountSats,
+        outputIndex: vout! + 10,
+        sspSignature: quote!.signature,
+      }),
+    ).rejects.toThrow("UTXO is spent or not found.");
+  }, 600000);
+});