@buildonspark/spark-sdk 0.1.43 → 0.1.45

package/src/spark-wallet/types.ts

@@ -1,6 +1,7 @@
 import type { Transaction } from "@scure/btc-signer";
 import { ConfigOptions } from "../services/wallet-config.js";
 import type { SparkSigner } from "../signer/signer.js";
+import { HumanReadableTokenIdentifier } from "../utils/token-identifier.js";
 
 export type CreateLightningInvoiceParams = {
   amountSats: number;
@@ -30,14 +31,49 @@ export type DepositParams = {
   vout: number;
 };
 
-export type TokenInfo = {
+/**
+ * Token metadata containing essential information about a token.
+ * This is the wallet's internal representation with JavaScript-friendly types.
+ *
+ * rawTokenIdentifier: This is the raw binary token identifier - This is used to encode the human readable token identifier.
+ *
+ * tokenPublicKey: This is the hex-encoded public key of the token issuer - Same as issuerPublicKey.
+ *
+ * @example
+ * ```typescript
+ * const tokenMetadata: TokenMetadata = {
+ *   rawTokenIdentifier: new Uint8Array([1, 2, 3]),
+ *   tokenPublicKey: "0348fbb...",
+ *   tokenName: "SparkToken",
+ *   tokenTicker: "SPK",
+ *   decimals: 8,
+ *   maxSupply: 1000000n
+ * };
+ * ```
+ */
+export type TokenMetadata = {
+  /** Raw binary token identifier - This is used to encode the human readable token identifier */
+  rawTokenIdentifier: Uint8Array;
+  /** Hex-encoded public key of the token issuer - Same as issuerPublicKey */
   tokenPublicKey: string;
+  /** Human-readable name of the token (e.g., SparkToken)*/
   tokenName: string;
-  tokenSymbol: string;
-  tokenDecimals: number;
+  /** Short ticker symbol for the token (e.g., "SPK") */
+  tokenTicker: string;
+  /** Number of decimal places for token amounts */
+  decimals: number;
+  /** Maximum supply of tokens that can ever be minted */
   maxSupply: bigint;
 };
 
+export type TokenBalanceMap = Map<
+  HumanReadableTokenIdentifier,
+  {
+    balance: bigint;
+    tokenMetadata: TokenMetadata;
+  }
+>;
+
 export type InitWalletResponse = {
   mnemonic?: string | undefined;
 };

package/src/tests/bolt11-spark.test.ts

@@ -62,7 +62,7 @@ describe("spark bolt11 invoice decoding", () => {
       "pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdpquwpc4curk03c9wlrswe78q4eyqc7d8d0xqzpuyk0sg5g70me25alkluzd2x62aysf2pyy8edtjeevuv4p2d5p76r4zkmneet7uvyakky2zr4cusd45tftc9c5fh0nnqpnl2jfll544esqchsrny";
     expect(() => {
       decodeInvoice(invoice);
-    }).toThrow('Letter "1" must be present between prefix and data only');
+    }).toThrow("Not a proper lightning payment request");
   });
 
   it("fails to decode malformed Bolt11 invoice - mixed case", () => {
@@ -73,20 +73,12 @@ describe("spark bolt11 invoice decoding", () => {
     }).toThrow("String must be lowercase or uppercase");
   });
 
-  it("fails to decode bolt11 invoice with invalid signature", () => {
-    const invoice =
-      "lnbc2500u1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdq5xysxxatsyp3k7enxv4jsxqzpusp5zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zygs9qrsgqwgt7mcn5yqw3yx0w94pswkpq6j9uh6xfqqqtsk4tnarugeektd4hg5975x9am52rz4qskukxdmjemg92vvqz8nvmsye63r5ykel43pgz7zq0g2";
-    expect(() => {
-      decodeInvoice(invoice);
-    }).toThrow("Invalid BOLT11 signature");
-  });
-
   it("fails to decode bolt11 invoice with invalid multiplier", () => {
     const invoice =
       "lnbc2500x1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdq5xysxxatsyp3k7enxv4jsxqzpusp5zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zygs9qrsgqrrzc4cvfue4zp3hggxp47ag7xnrlr8vgcmkjxk3j5jqethnumgkpqp23z9jclu3v0a7e0aruz366e9wqdykw6dxhdzcjjhldxq0w6wgqcnu43j";
     expect(() => {
       decodeInvoice(invoice);
-    }).toThrow("Invalid multiplier: x");
+    }).toThrow("Not a valid multiplier for the amount");
   });
 
   it("fails to decode bolt11 invoice with invalid submillisatoshi precision", () => {
@@ -94,7 +86,7 @@ describe("spark bolt11 invoice decoding", () => {
       "lnbc2500000001p1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdq5xysxxatsyp3k7enxv4jsxqzpusp5zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zygs9qrsgq0lzc236j96a95uv0m3umg28gclm5lqxtqqwk32uuk4k6673k6n5kfvx3d2h8s295fad45fdhmusm8sjudfhlf6dcsxmfvkeywmjdkxcp99202x";
     expect(() => {
       decodeInvoice(invoice);
-    }).toThrow("Invalid submillisatoshi precision");
+    }).toThrow("Amount is outside of valid range");
   });
 
   it("fails to decode bolt11 invoice with invalid payment secret", () => {
@@ -107,17 +99,17 @@ describe("spark bolt11 invoice decoding", () => {
 
   it("decodes a bolt11 invoice with spark address embedded", () => {
     const invoice =
-      "lnbc1pvjluezsp5zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zygspp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdpl2pkx2ctnv5sxxmmwwd5kgetjypeh2ursdae8g6twvus8g6rfwvs8qun0dfjkxaq9qrsgqfpml2dgykqjsjj0vxkcz9cuftlfhw5qs9720aqf4y0azyqggx29gz7gt7eadu5h5wqmn7ns8rju0ps0tk8jx70eg8jxek3usgsehql0ztdxmfjj58nqjky6w9wp324ctcnj9vnrgc8j9dpujfqjrc8lv9z4twr2pur2cgqujn2dx";
+      "lnbc13u1p5xalmkpp5z79uwgne7znz76plf0q4zxmh8t3wke6gsnm5kn67h4satpgflkmssp5azht5ywc5s4m40jf9h0nwlr959a34n72pns50lfm93zz8lvs7nqsxq9z0rgqnp4q0p92sfan5vj2a4f8q3gsfsy8qp60maeuxz858c5x0hvt5u0p0h9jr9yqtqd37k2ya0pv8pqeyjs4lklcexjyw600g9qqp62r4j0ph8fcmlfwqqqqzfv7u6g85qqqqqqqqqqthqq9qpz9cat0ndmwmfx036y9fxfhdufta3mn95ta9xw34ynlwg7euxjck85ysq0gfqqqqq7u6egqrhxk2qqn3qqcqzpgdq2w3jhxap3xv9qyyssqfahd64hu0lffl7cw2e4evu400s09yeupypvnfjvjjyq8rh05y9gzd3dqnmkvuyd9jszyhmdey75dujz8xaufgahsxkqktf3wxny8ghsqpk4mg8";
 
     const { amountMSats, fallbackAddress, paymentHash } =
       decodeInvoice(invoice);
 
-    expect(amountMSats).toBe(null);
+    expect(amountMSats).toBe(1300000n);
     expect(fallbackAddress).toBe(
-      "53504b0250949ec35b022e3895fd37750102f94fe813523fa220108328a81790bf67ade5",
+      "0222e3ab7cdbb76d267c7442a4c9bb7895f63b9968be94ce8d493fb91ecf0d2c58",
     );
     expect(paymentHash).toBe(
-      "0001020304050607080900010203040506070809000102030405060708090102",
+      "178bc72279f0a62f683f4bc1511b773ae2eb674884f74b4f5ebd61d58509fdb7",
     );
   });
 });

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

@@ -19,6 +19,22 @@ describe("deposit", () => {
     expect(depositAddress).toBeDefined();
   }, 30000);
 
+  it("should should query multiple deposit addresses", async () => {
+    const { wallet: sdk } = await SparkWalletTesting.initialize({
+      options: {
+        network: "LOCAL",
+      },
+    });
+
+    for (let i = 0; i < 105; i++) {
+      await sdk.getSingleUseDepositAddress();
+    }
+
+    const depositAddresses = await sdk.getUnusedDepositAddresses();
+
+    expect(depositAddresses).toHaveLength(105);
+  }, 30000);
+
   it("should generate a staticdeposit address", async () => {
     const { wallet: sdk } = await SparkWalletTesting.initialize({
       options: {

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

@@ -1,4 +1,5 @@
 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";
 
@@ -33,31 +34,94 @@ describe("SSP coop exit integration", () => {
 
     const withdrawalAddress = await faucet.getNewAddress();
 
-    const feeEstimate = await userWallet.getWithdrawalFeeEstimate({
+    const feeEstimate = await userWallet.getWithdrawalFeeQuote({
       amountSats: Number(DEPOSIT_AMOUNT),
       withdrawalAddress,
     });
 
     expect(feeEstimate).toBeDefined();
-    expect(feeEstimate?.speedFast?.l1BroadcastFee).toBeDefined();
-    expect(
-      feeEstimate?.speedFast?.l1BroadcastFee.originalValue,
-    ).toBeGreaterThan(0);
-    expect(feeEstimate?.speedFast?.userFee).toBeDefined();
-    expect(feeEstimate?.speedFast?.userFee.originalValue).toBeGreaterThan(0);
-
-    expect(feeEstimate?.speedMedium?.l1BroadcastFee).toBeDefined();
-    expect(
-      feeEstimate?.speedMedium?.l1BroadcastFee.originalValue,
-    ).toBeGreaterThan(0);
-    expect(feeEstimate?.speedMedium?.userFee).toBeDefined();
-    expect(feeEstimate?.speedMedium?.userFee.originalValue).toBeGreaterThan(0);
-
-    expect(feeEstimate?.speedSlow?.l1BroadcastFee).toBeDefined();
-    expect(
-      feeEstimate?.speedSlow?.l1BroadcastFee.originalValue,
-    ).toBeGreaterThan(0);
-    expect(feeEstimate?.speedSlow?.userFee).toBeDefined();
-    expect(feeEstimate?.speedSlow?.userFee.originalValue).toBeGreaterThan(0);
+    expect(feeEstimate?.l1BroadcastFeeFast).toBeDefined();
+    expect(feeEstimate?.l1BroadcastFeeFast.originalValue).toBeGreaterThan(0);
+    expect(feeEstimate?.userFeeFast).toBeDefined();
+    expect(feeEstimate?.userFeeFast.originalValue).toBeGreaterThan(0);
+
+    expect(feeEstimate?.l1BroadcastFeeMedium).toBeDefined();
+    expect(feeEstimate?.l1BroadcastFeeMedium.originalValue).toBeGreaterThan(0);
+    expect(feeEstimate?.userFeeMedium).toBeDefined();
+    expect(feeEstimate?.userFeeMedium.originalValue).toBeGreaterThan(0);
+
+    expect(feeEstimate?.l1BroadcastFeeSlow).toBeDefined();
+    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);
 });

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

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "@jest/globals";
+import { SparkWalletTesting } from "../../utils/spark-testing-wallet.js";
+import { BitcoinFaucet } from "../../utils/test-faucet.js";
+
+const DEPOSIT_AMOUNT = 10000n;
+
+describe("SSP swap", () => {
+  it("it should swap with the SSP before sending a transfer if the user does not have exact leaf 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);
+
+    // Wait for the transaction to be mined
+    await faucet.mineBlocks(6);
+
+    expect(signedTx).toBeDefined();
+
+    const transactionId = signedTx.id;
+
+    await userWallet.claimDeposit(transactionId);
+
+    const { balance } = await userWallet.getBalance();
+    expect(balance).toBe(DEPOSIT_AMOUNT);
+
+    const sparkAddress = await userWallet.getSparkAddress();
+
+    await userWallet.transfer({
+      amountSats: 8191,
+      receiverSparkAddress: sparkAddress,
+    });
+
+    const { balance: receiverBalance } = await userWallet.getBalance();
+    expect(receiverBalance).toBe(balance);
+  }, 60000);
+});