@buildonspark/spark-sdk 0.0.20 → 0.0.22

package/src/graphql/queries/UserRequest.ts

@@ -0,0 +1,10 @@
+import { FRAGMENT as UserRequestFragment } from "../objects/UserRequest.js";
+
+export const UserRequest = `
+  query UserRequest($request_id: ID!) {
+    user_request(request_id: $request_id) {
+      ...UserRequestFragment
+    }
+  }
+  ${UserRequestFragment}
+`;

package/src/services/lightning.ts

@@ -7,6 +7,7 @@ import { secp256k1 } from "@noble/curves/secp256k1";
 import { TransactionInput } from "@scure/btc-signer/psbt";
 import { sha256 } from "@scure/btc-signer/utils";
 import { decode } from "light-bolt11-decoder";
+import LightningReceiveRequest from "../graphql/objects/LightningReceiveRequest.js";
 import {
   GetSigningCommitmentsResponse,
   InitiatePreimageSwapRequest_Reason,
@@ -38,7 +39,7 @@ export type CreateLightningInvoiceParams = {
     amountSats: number,
     paymentHash: Uint8Array,
     memo?: string,
-  ) => Promise<string | undefined>;
+  ) => Promise<LightningReceiveRequest | null>;
   amountSats: number;
   memo?: string;
 };
@@ -71,7 +72,7 @@ export class LightningService {
     invoiceCreator,
     amountSats,
     memo,
-  }: CreateLightningInvoiceParams): Promise<string> {
+  }: CreateLightningInvoiceParams): Promise<LightningReceiveRequest> {
     const randBytes = crypto.getRandomValues(new Uint8Array(32));
     const preimage = numberToBytesBE(
       bytesToNumberBE(randBytes) % secp256k1.CURVE.n,
@@ -90,7 +91,7 @@ export class LightningService {
     amountSats,
     memo,
     preimage,
-  }: CreateLightningInvoiceWithPreimageParams): Promise<string> {
+  }: CreateLightningInvoiceWithPreimageParams): Promise<LightningReceiveRequest> {
     const paymentHash = sha256(preimage);
     const invoice = await invoiceCreator(amountSats, paymentHash, memo);
     if (!invoice) {
@@ -124,7 +125,7 @@ export class LightningService {
               proofs: share.proofs,
             },
             threshold: this.config.getThreshold(),
-            invoiceString: invoice,
+            invoiceString: invoice.invoice.encodedEnvoice,
             userIdentityPublicKey:
               await this.config.signer.getIdentityPublicKey(),
           });

package/src/services/transfer.ts

@@ -1056,7 +1056,7 @@ export class TransferService extends BaseTransferService {
     });
   }
 
-  private async extendTimelock(node: TreeNode, signingPubKey: Uint8Array) {
+  async extendTimelock(node: TreeNode, signingPubKey: Uint8Array) {
     const nodeTx = getTxFromRawTxBytes(node.nodeTx);
     const refundTx = getTxFromRawTxBytes(node.refundTx);
 

package/src/spark-sdk.ts

@@ -1,7 +1,7 @@
 import {
   bytesToHex,
-  hexToBytes,
   bytesToNumberBE,
+  hexToBytes,
 } from "@noble/curves/abstract/utils";
 import { secp256k1 } from "@noble/curves/secp256k1";
 import { Address, OutScript, Transaction } from "@scure/btc-signer";
@@ -11,14 +11,16 @@ import { decode } from "light-bolt11-decoder";
 import SspClient from "./graphql/client.js";
 import {
   BitcoinNetwork,
-  CoopExitFeeEstimateInput,
   CoopExitFeeEstimateOutput,
+  CoopExitRequest,
   LeavesSwapFeeEstimateOutput,
   LeavesSwapRequest,
   LightningReceiveFeeEstimateInput,
   LightningReceiveFeeEstimateOutput,
+  LightningReceiveRequest,
   LightningSendFeeEstimateInput,
   LightningSendFeeEstimateOutput,
+  LightningSendRequest,
   UserLeafInput,
 } from "./graphql/objects/index.js";
 import {
@@ -38,11 +40,14 @@ import { LightningService } from "./services/lightning.js";
 import { TokenTransactionService } from "./services/token-transactions.js";
 import { LeafKeyTweak, TransferService } from "./services/transfer.js";
 import { ConfigOptions } from "./services/wallet-config.js";
-
+import {
+  createLrc20ConnectionManager,
+  ILrc20ConnectionManager,
+  Lrc20SparkClient,
+} from "@buildonspark/lrc20-sdk/grpc";
 import { validateMnemonic } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english";
 import { Mutex } from "async-mutex";
-import bitcoin from "bitcoinjs-lib";
 import {
   DepositAddressTree,
   TreeCreationService,
@@ -103,6 +108,14 @@ type DepositParams = {
   vout: number;
 };
 
+export type TokenInfo = {
+  tokenPublicKey: string;
+  tokenName: string;
+  tokenSymbol: string;
+  tokenDecimals: number;
+  tokenSupply: bigint;
+}
+
 export type InitWalletResponse = {
   mnemonic?: string | undefined;
 };
@@ -122,6 +135,7 @@ export class SparkWallet {
   protected config: WalletConfigService;
 
   protected connectionManager: ConnectionManager;
+  protected lrc20ConnectionManager: ILrc20ConnectionManager;
   protected lrc20Wallet: LRCWallet | undefined;
 
   private depositService: DepositService;
@@ -137,6 +151,8 @@ export class SparkWallet {
   private sspClient: SspClient | null = null;
   private wasmModule: InitOutput | null = null;
 
+  private mutexes: Map<string, Mutex> = new Map();
+
   private pendingWithdrawnLeafIds: string[] = [];
 
   protected leaves: TreeNode[] = [];
@@ -146,6 +162,7 @@ export class SparkWallet {
   protected constructor(options?: ConfigOptions, signer?: SparkSigner) {
     this.config = new WalletConfigService(options, signer);
     this.connectionManager = new ConnectionManager(this.config);
+    this.lrc20ConnectionManager = createLrc20ConnectionManager(this.config.getLrc20Address());
     this.depositService = new DepositService(
       this.config,
       this.connectionManager,
@@ -172,7 +189,7 @@ export class SparkWallet {
     );
   }
 
-  public static async intialize({
+  public static async initialize({
     mnemonicOrSeed,
     signer,
     options,
@@ -326,7 +343,7 @@ export class SparkWallet {
     this.leaves = await this.getLeaves();
     await this.config.signer.restoreSigningKeysFromLeafs(this.leaves);
     await this.refreshTimelockNodes();
-
+    await this.extendTimeLockNodes();
     this.optimizeLeaves().catch((e) => {
       console.error("Failed to optimize leaves", e);
     });
@@ -670,6 +687,25 @@ export class SparkWallet {
     return await this.transferService.queryAllTransfers(limit, offset);
   }
 
+  public async getTokenInfo(): Promise<TokenInfo[]> {
+    await this.syncTokenLeaves();
+
+    const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
+    const { balance, tokenBalances } = await this.getBalance();
+    
+    const tokenInfo = await lrc20Client.getTokenPubkeyInfo({
+      publicKeys: Array.from(tokenBalances.keys()).map(hexToBytes)
+    });
+
+    return tokenInfo.tokenPubkeyInfos.map((info) => ({
+      tokenPublicKey: bytesToHex(info.announcement!.publicKey!.publicKey),
+      tokenName: info.announcement!.name,
+      tokenSymbol: info.announcement!.symbol,
+      tokenDecimals: Number(bytesToNumberBE(info.announcement!.decimal)),
+      tokenSupply: bytesToNumberBE(info.totalSupply),
+    }));
+  }
+
   /**
    * Gets the current balance of the wallet.
    * You can use the forceRefetch option to synchronize your wallet and claim any
@@ -776,71 +812,84 @@ export class SparkWallet {
    * @returns {Promise<TreeNode[] | undefined>} The nodes resulting from the deposit
    */
   public async claimDeposit(txid: string) {
-    const baseUrl =
-      this.config.getNetwork() === Network.REGTEST
-        ? "https://regtest-mempool.dev.dev.sparkinfra.net/api"
-        : "https://mempool.space/api";
-    const auth = btoa("spark-sdk:mCMk1JqlBNtetUNy");
-
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-    };
-
-    if (this.config.getNetwork() === Network.REGTEST) {
-      headers["Authorization"] = `Basic ${auth}`;
+    let mutex = this.mutexes.get(txid);
+    if (!mutex) {
+      mutex = new Mutex();
+      this.mutexes.set(txid, mutex);
     }
 
-    const response = await fetch(`${baseUrl}/tx/${txid}/hex`, {
-      headers,
-    });
+    const nodes = await mutex.runExclusive(async () => {
+      const baseUrl =
+        this.config.getNetwork() === Network.REGTEST
+          ? "https://regtest-mempool.dev.dev.sparkinfra.net/api"
+          : "https://mempool.space/api";
+      const auth = btoa("spark-sdk:mCMk1JqlBNtetUNy");
 
-    const txHex = await response.text();
-    if (!/^[0-9A-Fa-f]+$/.test(txHex)) {
-      throw new Error("Transaction not found");
-    }
-    const depositTx = getTxFromRawTxHex(txHex);
+      const headers: Record<string, string> = {
+        "Content-Type": "application/json",
+      };
 
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress(),
-    );
+      if (this.config.getNetwork() === Network.REGTEST) {
+        headers["Authorization"] = `Basic ${auth}`;
+      }
 
-    const unusedDepositAddresses: Map<string, DepositAddressQueryResult> =
-      new Map(
-        (
-          await sparkClient.query_unused_deposit_addresses({
-            identityPublicKey: await this.config.signer.getIdentityPublicKey(),
-          })
-        ).depositAddresses.map((addr) => [addr.depositAddress, addr]),
-      );
+      const response = await fetch(`${baseUrl}/tx/${txid}/hex`, {
+        headers,
+      });
 
-    let depositAddress: DepositAddressQueryResult | undefined;
-    let vout = 0;
-    for (let i = 0; i < depositTx.outputsLength; i++) {
-      const output = depositTx.getOutput(i);
-      if (!output) {
-        continue;
+      const txHex = await response.text();
+      if (!/^[0-9A-Fa-f]+$/.test(txHex)) {
+        throw new Error("Transaction not found");
       }
-      const parsedScript = OutScript.decode(output.script!);
-      const address = Address(getNetwork(this.config.getNetwork())).encode(
-        parsedScript,
+      const depositTx = getTxFromRawTxHex(txHex);
+
+      const sparkClient = await this.connectionManager.createSparkClient(
+        this.config.getCoordinatorAddress(),
       );
-      if (unusedDepositAddresses.has(address)) {
-        vout = i;
-        depositAddress = unusedDepositAddresses.get(address);
-        break;
+
+      const unusedDepositAddresses: Map<string, DepositAddressQueryResult> =
+        new Map(
+          (
+            await sparkClient.query_unused_deposit_addresses({
+              identityPublicKey:
+                await this.config.signer.getIdentityPublicKey(),
+            })
+          ).depositAddresses.map((addr) => [addr.depositAddress, addr]),
+        );
+
+      let depositAddress: DepositAddressQueryResult | undefined;
+      let vout = 0;
+      for (let i = 0; i < depositTx.outputsLength; i++) {
+        const output = depositTx.getOutput(i);
+        if (!output) {
+          continue;
+        }
+        const parsedScript = OutScript.decode(output.script!);
+        const address = Address(getNetwork(this.config.getNetwork())).encode(
+          parsedScript,
+        );
+        if (unusedDepositAddresses.has(address)) {
+          vout = i;
+          depositAddress = unusedDepositAddresses.get(address);
+          break;
+        }
+      }
+      if (!depositAddress) {
+        return [];
       }
-    }
-    if (!depositAddress) {
-      throw new Error("Deposit address not found");
-    }
 
-    const nodes = await this.finalizeDeposit({
-      signingPubKey: depositAddress.userSigningPublicKey,
-      verifyingKey: depositAddress.verifyingPublicKey,
-      depositTx,
-      vout,
+      const nodes = await this.finalizeDeposit({
+        signingPubKey: depositAddress.userSigningPublicKey,
+        verifyingKey: depositAddress.verifyingPublicKey,
+        depositTx,
+        vout,
+      });
+
+      return nodes;
     });
 
+    this.mutexes.delete(txid);
+
     return nodes;
   }
 
@@ -864,18 +913,12 @@ export class SparkWallet {
       })),
     );
 
-    await this.transferService.sendTransfer(
+    const transfer = await this.transferService.sendTransfer(
       leafKeyTweaks,
       await this.config.signer.getIdentityPublicKey(),
     );
 
-    const pendingTransfers = await this.transferService.queryPendingTransfers();
-    if (pendingTransfers.transfers.length > 0) {
-      // @ts-ignore - We check the length, so the first element is guaranteed to exist
-      return (await this.claimTransfer(pendingTransfers.transfers[0])).nodes;
-    }
-
-    return;
+    return await this.claimTransfer(transfer);
   }
   // ***** Transfer Flow *****
 
@@ -892,6 +935,7 @@ export class SparkWallet {
       const leavesToSend = await this.selectLeaves(amountSats);
 
       await this.refreshTimelockNodes();
+      await this.extendTimeLockNodes();
 
       const leafKeyTweaks = await Promise.all(
         leavesToSend.map(async (leaf) => ({
@@ -915,6 +959,29 @@ export class SparkWallet {
     });
   }
 
+  private async extendTimeLockNodes() {
+    const nodesToExtend: TreeNode[] = [];
+    const nodeIds: string[] = [];
+
+    for (const node of this.leaves) {
+      const nodeTx = getTxFromRawTxBytes(node.nodeTx);
+      const { nextSequence } = getNextTransactionSequence(
+        nodeTx.getInput(0).sequence,
+      );
+      if (nextSequence <= 0) {
+        nodesToExtend.push(node);
+        nodeIds.push(node.id);
+      }
+    }
+
+    for (const node of nodesToExtend) {
+      await this.transferService.extendTimelock(
+        node,
+        await this.config.signer.generatePublicKey(sha256(node.id)),
+      );
+    }
+  }
+
   /**
    * Internal method to refresh timelock nodes.
    *
@@ -1048,6 +1115,7 @@ export class SparkWallet {
 
       this.leaves.push(...response.nodes);
       await this.refreshTimelockNodes();
+      await this.extendTimeLockNodes();
 
       return response.nodes;
     });
@@ -1112,13 +1180,13 @@ export class SparkWallet {
    * @param {number} params.amountSats - Amount in satoshis
    * @param {string} params.memo - Description for the invoice
    * @param {number} [params.expirySeconds] - Optional expiry time in seconds
-   * @returns {Promise<string>} BOLT11 encoded invoice
+   * @returns {Promise<LightningReceiveRequest>} BOLT11 encoded invoice
    */
   public async createLightningInvoice({
     amountSats,
     memo,
     expirySeconds = 60 * 60 * 24 * 30,
-  }: CreateLightningInvoiceParams) {
+  }: CreateLightningInvoiceParams): Promise<LightningReceiveRequest> {
     if (!this.sspClient) {
       throw new Error("SSP client not initialized");
     }
@@ -1144,14 +1212,16 @@ export class SparkWallet {
         memo,
       });
 
-      return invoice?.invoice.encodedEnvoice;
+      return invoice;
     };
 
-    return this.lightningService!.createLightningInvoice({
+    const invoice = await this.lightningService!.createLightningInvoice({
       amountSats,
       memo,
       invoiceCreator: requestLightningInvoice,
     });
+
+    return invoice;
   }
 
   /**
@@ -1191,6 +1261,8 @@ export class SparkWallet {
       const leaves = await this.selectLeaves(amountSats);
 
       await this.refreshTimelockNodes();
+      await this.extendTimeLockNodes();
+
       const leavesToSend = await Promise.all(
         leaves.map(async (leaf) => ({
           leaf,
@@ -1346,21 +1418,21 @@ export class SparkWallet {
    *
    * @param {Object} params - Parameters for the withdrawal
    * @param {string} params.onchainAddress - The Bitcoin address where the funds should be sent
-   * @param {number} [params.targetAmountSats] - The amount in satoshis to withdraw. If not specified, attempts to withdraw all available funds
+   * @param {number} [params.amountSats] - The amount in satoshis to withdraw. If not specified, attempts to withdraw all available funds
    * @returns {Promise<CoopExitRequest | null | undefined>} The withdrawal request details, or null/undefined if the request cannot be completed
    */
   public async withdraw({
     onchainAddress,
-    targetAmountSats,
+    amountSats,
   }: {
     onchainAddress: string;
-    targetAmountSats?: number;
+    amountSats?: number;
   }) {
-    if (targetAmountSats && targetAmountSats < 10000) {
+    if (amountSats && amountSats < 10000) {
       throw new Error("The minimum amount for a withdrawal is 10000 sats");
     }
     return await this.withLeaves(async () => {
-      return await this.coopExit(onchainAddress, targetAmountSats);
+      return await this.coopExit(onchainAddress, amountSats);
     });
   }
 
@@ -1446,19 +1518,30 @@ export class SparkWallet {
   /**
    * Gets fee estimate for cooperative exit (on-chain withdrawal).
    *
-   * @param {CoopExitFeeEstimateInput} params - Input parameters for fee estimation
+   * @param {Object} params - Input parameters for fee estimation
+   * @param {number} params.amountSats - The amount in satoshis to withdraw
+   * @param {string} params.withdrawalAddress - The Bitcoin address where the funds should be sent
    * @returns {Promise<CoopExitFeeEstimateOutput | null>} Fee estimate for the withdrawal
    */
   public async getCoopExitFeeEstimate({
-    leafExternalIds,
+    amountSats,
     withdrawalAddress,
-  }: CoopExitFeeEstimateInput): Promise<CoopExitFeeEstimateOutput | null> {
+  }: {
+    amountSats: number;
+    withdrawalAddress: string;
+  }): Promise<CoopExitFeeEstimateOutput | null> {
     if (!this.sspClient) {
       throw new Error("SSP client not initialized");
     }
 
+    if (amountSats < 10000) {
+      throw new Error("The minimum amount for a withdrawal is 10000 sats");
+    }
+
+    const leaves = await this.selectLeaves(amountSats);
+
     return await this.sspClient.getCoopExitFeeEstimate({
-      leafExternalIds,
+      leafExternalIds: leaves.map((leaf) => leaf.id),
       withdrawalAddress,
     });
   }
@@ -1757,25 +1840,67 @@ export class SparkWallet {
       return;
     }
   }
-}
 
-/**
- * Utility function to determine the network from a Bitcoin address.
- *
- * @param {string} address - The Bitcoin address
- * @returns {BitcoinNetwork | null} The detected network or null if not detected
- */
-function getNetworkFromAddress(address: string) {
-  try {
-    const decoded = bitcoin.address.fromBech32(address);
-    // HRP (human-readable part) determines the network
-    if (decoded.prefix === "bc") {
-      return BitcoinNetwork.MAINNET;
-    } else if (decoded.prefix === "bcrt") {
-      return BitcoinNetwork.REGTEST;
+  /**
+   * Signs a message with the identity key.
+   *
+   * @param {string} message - Unhashed message to sign
+   * @param {boolean} [compact] - Whether to use compact encoding. If false, the message will be encoded as DER.
+   * @returns {Promise<string>} The signed message
+   */
+  public async signMessage(
+    message: string,
+    compact?: boolean,
+  ): Promise<string> {
+    const hash = sha256(message);
+    return bytesToHex(
+      await this.config.signer.signMessageWithIdentityKey(hash, compact),
+    );
+  }
+
+  /**
+   * Get a Lightning receive request by ID.
+   *
+   * @param {string} id - The ID of the Lightning receive request
+   * @returns {Promise<LightningReceiveRequest | null>} The Lightning receive request
+   */
+  public async getLightningReceiveRequest(
+    id: string,
+  ): Promise<LightningReceiveRequest | null> {
+    if (!this.sspClient) {
+      throw new Error("SSP client not initialized");
     }
-  } catch (err) {
-    throw new Error("Invalid Bitcoin address");
+
+    return await this.sspClient.getLightningReceiveRequest(id);
+  }
+
+  /**
+   * Get a Lightning send request by ID.
+   *
+   * @param {string} id - The ID of the Lightning send request
+   * @returns {Promise<LightningSendRequest | null>} The Lightning send request
+   */
+  public async getLightningSendRequest(
+    id: string,
+  ): Promise<LightningSendRequest | null> {
+    if (!this.sspClient) {
+      throw new Error("SSP client not initialized");
+    }
+
+    return await this.sspClient.getLightningSendRequest(id);
+  }
+
+  /**
+   * Get a coop exit request by ID.
+   *
+   * @param {string} id - The ID of the coop exit request
+   * @returns {Promise<CoopExitRequest | null>} The coop exit request
+   */
+  public async getCoopExitRequest(id: string): Promise<CoopExitRequest | null> {
+    if (!this.sspClient) {
+      throw new Error("SSP client not initialized");
+    }
+
+    return await this.sspClient.getCoopExitRequest(id);
   }
-  return null;
 }

package/src/tests/adaptor-signature.test.ts

@@ -16,7 +16,7 @@ describe("adaptor signature", () => {
     async () => {
       let failures = 0;
 
-      const { wallet } = await SparkWalletTesting.intialize({
+      const { wallet } = await SparkWalletTesting.initialize({
         options: {
           network: "LOCAL",
         },

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

@@ -41,7 +41,7 @@ describe("coop exit", () => {
       };
 
       // Setup user with leaves
-      const { wallet: userWallet } = await SparkWalletTesting.intialize({
+      const { wallet: userWallet } = await SparkWalletTesting.initialize({
         options,
       });
 
@@ -66,7 +66,7 @@ describe("coop exit", () => {
       );
 
       // Setup ssp
-      const { wallet: sspWallet } = await SparkWalletTesting.intialize({
+      const { wallet: sspWallet } = await SparkWalletTesting.initialize({
         options,
       });
       const sspPubkey = await sspWallet.getIdentityPublicKey();

package/src/tests/deposit.test.ts

@@ -15,7 +15,7 @@ describe("deposit", () => {
     async () => {
       const mnemonic =
         "raise benefit echo client clutch short pyramid grass fall core slogan boil device plastic drastic discover decide penalty middle appear medal elbow original income";
-      const { wallet: sdk } = await SparkWalletTesting.intialize({
+      const { wallet: sdk } = await SparkWalletTesting.initialize({
         options: {
           network: "LOCAL",
         },
@@ -39,7 +39,7 @@ describe("deposit", () => {
 
       const coin = await faucet.fund();
 
-      const { wallet: sdk } = await SparkWalletTesting.intialize({
+      const { wallet: sdk } = await SparkWalletTesting.initialize({
         options: {
           network: "LOCAL",
         },