@buildonspark/spark-sdk 0.1.43 → 0.1.45

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

@@ -23,7 +23,7 @@ import SspClient from "../graphql/client.js";
 import {
   BitcoinNetwork,
   ClaimStaticDepositOutput,
-  CoopExitFeeEstimatesOutput,
+  CoopExitFeeQuote,
   CoopExitRequest,
   ExitSpeed,
   LeavesSwapFeeEstimateOutput,
@@ -31,8 +31,8 @@ import {
   LightningReceiveRequest,
   LightningSendFeeEstimateInput,
   LightningSendRequest,
+  RequestCoopExitInput,
   StaticDepositQuoteOutput,
-  SwapLeaf,
   UserLeafInput,
 } from "../graphql/objects/index.js";
 import GraphQLTransferObj from "../graphql/objects/Transfer.js";
@@ -43,7 +43,6 @@ import {
   QueryNodesResponse,
   SigningJob,
   SubscribeToEventsResponse,
-  TokenTransactionWithStatus,
   Transfer,
   TransferStatus,
   TransferType,
@@ -102,7 +101,7 @@ import {
   SparkAddressFormat,
 } from "../address/index.js";
 import { isReactNative } from "../constants.js";
-import { networkToJSON } from "../proto/spark.js";
+import { Network as NetworkProto, networkToJSON } from "../proto/spark.js";
 import {
   decodeInvoice,
   getNetworkFromInvoice,
@@ -125,9 +124,12 @@ import type {
   InitWalletResponse,
   PayLightningInvoiceParams,
   SparkWalletProps,
-  TokenInfo,
+  TokenMetadata,
   TransferParams,
+  TokenBalanceMap,
 } from "./types.js";
+import { encodeHumanReadableTokenIdentifier } from "../utils/token-identifier.js";
+import { TokenTransactionWithStatus } from "../proto/spark_token.js";
 
 /**
  * The SparkWallet class is the primary interface for interacting with the Spark network.
@@ -164,6 +166,7 @@ export class SparkWallet extends EventEmitter {
   private streamController: AbortController | null = null;
 
   protected leaves: TreeNode[] = [];
+
   protected tokenOutputs: Map<string, OutputWithPreviousTransactionData[]> =
     new Map();
 
@@ -486,8 +489,7 @@ export class SparkWallet extends EventEmitter {
                 leaf.signingKeyshare.publicKey,
                 operatorLeaf.signingKeyshare.publicKey,
               ) ||
-              !equalBytes(leaf.nodeTx, operatorLeaf.nodeTx) ||
-              !equalBytes(leaf.refundTx, operatorLeaf.refundTx)
+              !equalBytes(leaf.nodeTx, operatorLeaf.nodeTx)
             ) {
               leavesToIgnore.add(nodeId);
             }
@@ -524,14 +526,40 @@ export class SparkWallet extends EventEmitter {
       .map(([_, node]) => node);
   }
 
-  private async selectLeaves(targetAmount: number): Promise<TreeNode[]> {
-    if (targetAmount <= 0) {
+  private async selectLeaves(
+    targetAmounts: number[],
+  ): Promise<Map<number, TreeNode[]>> {
+    if (targetAmounts.length === 0) {
+      throw new ValidationError("Target amounts must be non-empty", {
+        field: "targetAmounts",
+        value: targetAmounts,
+      });
+    }
+
+    if (targetAmounts.some((amount) => amount <= 0)) {
       throw new ValidationError("Target amount must be positive", {
-        field: "targetAmount",
-        value: targetAmount,
+        field: "targetAmounts",
+        value: targetAmounts,
       });
     }
 
+    const totalTargetAmount = targetAmounts.reduce(
+      (acc, amount) => acc + amount,
+      0,
+    );
+    const totalBalance = this.getInternalBalance();
+
+    if (totalTargetAmount > totalBalance) {
+      throw new ValidationError(
+        "Total target amount exceeds available balance",
+        {
+          field: "targetAmounts",
+          value: totalTargetAmount,
+          expected: `less than or equal to ${totalBalance}`,
+        },
+      );
+    }
+
     const leaves = await this.getLeaves();
     if (leaves.length === 0) {
       throw new ValidationError("No owned leaves found", {
@@ -541,37 +569,63 @@ export class SparkWallet extends EventEmitter {
 
     leaves.sort((a, b) => b.value - a.value);
 
-    let amount = 0;
-    let nodes: TreeNode[] = [];
-    for (const leaf of leaves) {
-      if (targetAmount - amount >= leaf.value) {
-        amount += leaf.value;
-        nodes.push(leaf);
-      }
-    }
+    const selectLeavesForTargets = (
+      targetAmounts: number[],
+      leaves: TreeNode[],
+    ) => {
+      const usedLeaves = new Set<string>();
+      const results: Map<number, TreeNode[]> = new Map();
+      let totalAmount = 0;
 
-    if (amount !== targetAmount) {
-      await this.requestLeavesSwap({ targetAmount });
+      for (const targetAmount of targetAmounts) {
+        const nodes: TreeNode[] = [];
+        let amount = 0;
 
-      amount = 0;
-      nodes = [];
-      const newLeaves = await this.getLeaves();
-      newLeaves.sort((a, b) => b.value - a.value);
-      for (const leaf of newLeaves) {
-        if (targetAmount - amount >= leaf.value) {
-          amount += leaf.value;
-          nodes.push(leaf);
+        for (const leaf of leaves) {
+          if (usedLeaves.has(leaf.id)) {
+            continue;
+          }
+
+          if (targetAmount - amount >= leaf.value) {
+            amount += leaf.value;
+            nodes.push(leaf);
+            usedLeaves.add(leaf.id);
+          }
         }
+
+        totalAmount += amount;
+        results.set(targetAmount, nodes);
       }
+
+      return {
+        results,
+        foundSelections: totalAmount === totalTargetAmount,
+      };
+    };
+
+    let { results, foundSelections } = selectLeavesForTargets(
+      targetAmounts,
+      leaves,
+    );
+
+    if (!foundSelections) {
+      const newLeaves = await this.requestLeavesSwap({ targetAmounts });
+
+      newLeaves.sort((a, b) => b.value - a.value);
+
+      ({ results, foundSelections } = selectLeavesForTargets(
+        targetAmounts,
+        newLeaves,
+      ));
     }
 
-    if (nodes.reduce((acc, leaf) => acc + leaf.value, 0) !== targetAmount) {
+    if (!foundSelections) {
       throw new Error(
-        `Failed to select leaves for target amount ${targetAmount}`,
+        `Failed to select leaves for target amount ${totalTargetAmount}`,
       );
     }
 
-    return nodes;
+    return results;
   }
 
   private async selectLeavesForSwap(targetAmount: number) {
@@ -853,32 +907,57 @@ export class SparkWallet extends EventEmitter {
    * @private
    */
   private async requestLeavesSwap({
-    targetAmount,
+    targetAmounts,
     leaves,
   }: {
-    targetAmount?: number;
+    targetAmounts?: number[];
     leaves?: TreeNode[];
-  }) {
-    if (targetAmount && targetAmount <= 0) {
-      throw new Error("targetAmount must be positive");
+  }): Promise<TreeNode[]> {
+    if (targetAmounts && targetAmounts.some((amount) => amount <= 0)) {
+      throw new Error("specified targetAmount must be positive");
     }
 
-    if (targetAmount && !Number.isSafeInteger(targetAmount)) {
+    if (
+      targetAmounts &&
+      targetAmounts.some((amount) => !Number.isSafeInteger(amount))
+    ) {
       throw new ValidationError("targetAmount must be less than 2^53", {
-        field: "targetAmount",
-        value: targetAmount,
+        field: "targetAmounts",
+        value: targetAmounts,
         expected: "smaller or equal to " + Number.MAX_SAFE_INTEGER,
       });
     }
 
     let leavesToSwap: TreeNode[];
-    if (targetAmount && leaves && leaves.length > 0) {
-      if (targetAmount < leaves.reduce((acc, leaf) => acc + leaf.value, 0)) {
+    const totalTargetAmount = targetAmounts?.reduce(
+      (acc, amount) => acc + amount,
+      0,
+    );
+
+    if (totalTargetAmount) {
+      const totalBalance = this.getInternalBalance();
+
+      if (totalTargetAmount > totalBalance) {
+        throw new ValidationError(
+          "Total target amount exceeds available balance",
+          {
+            field: "targetAmounts",
+            value: totalTargetAmount,
+            expected: `less than or equal to ${totalBalance}`,
+          },
+        );
+      }
+    }
+
+    if (totalTargetAmount && leaves && leaves.length > 0) {
+      if (
+        totalTargetAmount < leaves.reduce((acc, leaf) => acc + leaf.value, 0)
+      ) {
         throw new Error("targetAmount is less than the sum of leaves");
       }
       leavesToSwap = leaves;
-    } else if (targetAmount) {
-      leavesToSwap = await this.selectLeavesForSwap(targetAmount);
+    } else if (totalTargetAmount) {
+      leavesToSwap = await this.selectLeavesForSwap(totalTargetAmount);
     } else if (leaves && leaves.length > 0) {
       leavesToSwap = leaves;
     } else {
@@ -889,10 +968,10 @@ export class SparkWallet extends EventEmitter {
 
     const batches = chunkArray(leavesToSwap, 100);
 
-    const results: SwapLeaf[] = [];
+    const results: TreeNode[] = [];
     for (const batch of batches) {
-      const result = await this.processSwapBatch(batch, targetAmount);
-      results.push(...result.swapLeaves);
+      const result = await this.processSwapBatch(batch, targetAmounts);
+      results.push(...result);
     }
 
     return results;
@@ -903,8 +982,8 @@ export class SparkWallet extends EventEmitter {
    */
   private async processSwapBatch(
     leavesBatch: TreeNode[],
-    targetAmount?: number,
-  ): Promise<LeavesSwapRequest> {
+    targetAmounts?: number[],
+  ): Promise<TreeNode[]> {
     const leafKeyTweaks = await Promise.all(
       leavesBatch.map(async (leaf) => ({
         leaf,
@@ -981,9 +1060,10 @@ export class SparkWallet extends EventEmitter {
         userLeaves,
         adaptorPubkey,
         targetAmountSats:
-          targetAmount ||
+          targetAmounts?.reduce((acc, amount) => acc + amount, 0) ||
           leavesBatch.reduce((acc, leaf) => acc + leaf.value, 0),
         totalAmountSats: leavesBatch.reduce((acc, leaf) => acc + leaf.value, 0),
+        targetAmountSatsList: targetAmounts,
         // TODO: Request fee from SSP
         feeSats: 0,
         idempotencyKey: uuidv7(),
@@ -1051,13 +1131,24 @@ export class SparkWallet extends EventEmitter {
         leavesSwapRequestId: request.id,
       });
 
-      if (!completeResponse) {
+      if (!completeResponse || !completeResponse.inboundTransfer?.sparkId) {
         throw new Error("Failed to complete leaves swap");
       }
 
-      await this.claimTransfers(TransferType.COUNTER_SWAP);
+      const incomingTransfer = await this.transferService.queryTransfer(
+        completeResponse.inboundTransfer.sparkId,
+      );
 
-      return completeResponse;
+      if (!incomingTransfer) {
+        throw new Error("Failed to get incoming transfer");
+      }
+
+      return await this.claimTransfer({
+        transfer: incomingTransfer,
+        emit: false,
+        retryCount: 0,
+        optimize: false,
+      });
     } catch (e) {
       await this.cancelAllSenderInitiatedTransfers();
       throw new Error(`Failed to request leaves swap: ${e}`);
@@ -1093,32 +1184,6 @@ export class SparkWallet extends EventEmitter {
     };
   }
 
-  /**
-   * Gets the held token info for the wallet.
-   *
-   * @deprecated The information is returned in getBalance
-   */
-  public async getTokenInfo(): Promise<TokenInfo[]> {
-    console.warn("getTokenInfo is deprecated. Use getBalance instead.");
-
-    await this.syncTokenOutputs();
-
-    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)),
-      maxSupply: bytesToNumberBE(info.announcement!.maxSupply),
-    }));
-  }
-
   /**
    * Gets the current balance of the wallet.
    * You can use the forceRefetch option to synchronize your wallet and claim any
@@ -1126,24 +1191,21 @@ export class SparkWallet extends EventEmitter {
    *
    * @returns {Promise<Object>} Object containing:
    *   - balance: The wallet's current balance in satoshis
-   *   - tokenBalances: Map of token public keys to token balances and token info
+   *   - tokenBalances: Map of the human readable token identifier to token balances and token info
    */
   public async getBalance(): Promise<{
     balance: bigint;
-    tokenBalances: Map<string, { balance: bigint; tokenInfo: TokenInfo }>;
+    tokenBalances: TokenBalanceMap;
   }> {
     const leaves = await this.getLeaves(true);
     await this.syncTokenOutputs();
 
-    let tokenBalances: Map<string, { balance: bigint; tokenInfo: TokenInfo }>;
+    let tokenBalances: TokenBalanceMap;
 
     if (this.tokenOutputs.size !== 0) {
       tokenBalances = await this.getTokenBalance();
     } else {
-      tokenBalances = new Map<
-        string,
-        { balance: bigint; tokenInfo: TokenInfo }
-      >();
+      tokenBalances = new Map();
     }
 
     return {
@@ -1152,32 +1214,33 @@ export class SparkWallet extends EventEmitter {
     };
   }
 
-  private async getTokenBalance(): Promise<
-    Map<string, { balance: bigint; tokenInfo: TokenInfo }>
-  > {
-    const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
+  private async getTokenBalance(): Promise<TokenBalanceMap> {
+    const sparkTokenClient =
+      await this.connectionManager.createSparkTokenClient(
+        this.config.getCoordinatorAddress(),
+      );
 
-    // Get token info for all tokens
-    const tokenInfo = await lrc20Client.getTokenPubkeyInfo({
-      publicKeys: Array.from(this.tokenOutputs.keys()).map(hexToBytes),
+    const tokenMetadata = await sparkTokenClient.query_token_metadata({
+      issuerPublicKeys: Array.from(this.tokenOutputs.keys()).map(hexToBytes),
     });
+    const result: TokenBalanceMap = new Map();
 
-    const result = new Map<string, { balance: bigint; tokenInfo: TokenInfo }>();
-
-    for (const info of tokenInfo.tokenPubkeyInfos) {
-      const tokenPublicKey = bytesToHex(
-        info.announcement!.publicKey!.publicKey,
-      );
+    for (const metadata of tokenMetadata.tokenMetadata) {
+      const tokenPublicKey = bytesToHex(metadata.issuerPublicKey);
       const leaves = this.tokenOutputs.get(tokenPublicKey);
-
-      result.set(tokenPublicKey, {
+      const humanReadableTokenIdentifier = encodeHumanReadableTokenIdentifier({
+        tokenIdentifier: metadata.tokenIdentifier,
+        network: this.config.getNetworkType(),
+      });
+      result.set(humanReadableTokenIdentifier, {
         balance: leaves ? calculateAvailableTokenAmount(leaves) : BigInt(0),
-        tokenInfo: {
+        tokenMetadata: {
           tokenPublicKey,
-          tokenName: info.announcement!.name,
-          tokenSymbol: info.announcement!.symbol,
-          tokenDecimals: Number(bytesToNumberBE(info.announcement!.decimal)),
-          maxSupply: bytesToNumberBE(info.announcement!.maxSupply),
+          rawTokenIdentifier: metadata.tokenIdentifier,
+          tokenName: metadata.tokenName,
+          tokenTicker: metadata.tokenTicker,
+          decimals: metadata.decimals,
+          maxSupply: bytesToNumberBE(metadata.maxSupply),
         },
       });
     }
@@ -1750,16 +1813,60 @@ export class SparkWallet extends EventEmitter {
    * @returns {Promise<string[]>} The unused deposit addresses
    */
   public async getUnusedDepositAddresses(): Promise<string[]> {
+    return (await this.queryAllUnusedDepositAddresses({})).map(
+      (addr) => addr.depositAddress,
+    );
+  }
+
+  /**
+   * Gets all unused deposit addresses for the wallet.
+   *
+   * @param {Object} params - Parameters for querying unused deposit addresses
+   * @param {Uint8Array<ArrayBufferLike>} [params.identityPublicKey] - The identity public key
+   * @param {NetworkProto} [params.network] - The network
+   * @returns {Promise<DepositAddressQueryResult[]>} The unused deposit addresses
+   */
+  private async queryAllUnusedDepositAddresses({
+    identityPublicKey,
+    network,
+  }: {
+    identityPublicKey?: Uint8Array<ArrayBufferLike>;
+    network?: NetworkProto | undefined;
+  }): Promise<DepositAddressQueryResult[]> {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress(),
     );
-    return (
-      await sparkClient.query_unused_deposit_addresses({
-        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        network: NetworkToProto[this.config.getNetwork()],
-      })
-    ).depositAddresses.map((addr) => addr.depositAddress);
+
+    let limit = 100;
+    let offset = 0;
+    const pastOffsets = new Set<number>();
+    const depositAddresses: DepositAddressQueryResult[] = [];
+
+    while (offset >= 0) {
+      // Prevent infinite loop in case error with coordinator
+      if (pastOffsets.has(offset)) {
+        console.warn("Offset has already been seen, stopping");
+        break;
+      }
+
+      const response = await sparkClient.query_unused_deposit_addresses({
+        identityPublicKey:
+          identityPublicKey ??
+          (await this.config.signer.getIdentityPublicKey()),
+        network: network ?? NetworkToProto[this.config.getNetwork()],
+        limit,
+        offset,
+      });
+
+      depositAddresses.push(...response.depositAddresses);
+
+      pastOffsets.add(offset);
+      offset = response.offset;
+    }
+
+    return depositAddresses;
   }
+
   /**
    * Claims a deposit to the wallet.
    * Note that if you used advancedDeposit, you don't need to call this function.
@@ -1816,19 +1923,15 @@ export class SparkWallet extends EventEmitter {
       }
       const depositTx = getTxFromRawTxHex(txHex);
 
-      const sparkClient = await this.connectionManager.createSparkClient(
-        this.config.getCoordinatorAddress(),
-      );
-
       const unusedDepositAddresses: Map<string, DepositAddressQueryResult> =
         new Map(
           (
-            await sparkClient.query_unused_deposit_addresses({
+            await this.queryAllUnusedDepositAddresses({
               identityPublicKey:
                 await this.config.signer.getIdentityPublicKey(),
               network: NetworkToProto[this.config.getNetwork()],
             })
-          ).depositAddresses.map((addr) => [addr.depositAddress, addr]),
+          ).map((addr) => [addr.depositAddress, addr]),
         );
       let depositAddress: DepositAddressQueryResult | undefined;
       let vout = 0;
@@ -1888,17 +1991,15 @@ export class SparkWallet extends EventEmitter {
    */
   public async advancedDeposit(txHex: string) {
     const depositTx = getTxFromRawTxHex(txHex);
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress(),
-    );
+
     const unusedDepositAddresses: Map<string, DepositAddressQueryResult> =
       new Map(
         (
-          await sparkClient.query_unused_deposit_addresses({
+          await this.queryAllUnusedDepositAddresses({
             identityPublicKey: await this.config.signer.getIdentityPublicKey(),
             network: NetworkToProto[this.config.getNetwork()],
           })
-        ).depositAddresses.map((addr) => [addr.depositAddress, addr]),
+        ).map((addr) => [addr.depositAddress, addr]),
       );
 
     let vout = 0;
@@ -2023,7 +2124,9 @@ export class SparkWallet extends EventEmitter {
     );
 
     return await this.withLeaves(async () => {
-      let leavesToSend = await this.selectLeaves(amountSats);
+      let leavesToSend = (await this.selectLeaves([amountSats])).get(
+        amountSats,
+      )!;
 
       leavesToSend = await this.checkRefreshTimelockNodes(leavesToSend);
       leavesToSend = await this.checkExtendTimeLockNodes(leavesToSend);
@@ -2325,7 +2428,7 @@ export class SparkWallet extends EventEmitter {
         transfer.status !==
           TransferStatus.TRANSFER_STATUS_RECEIVER_KEY_TWEAKED &&
         transfer.status !==
-          TransferStatus.TRANSFER_STATUSR_RECEIVER_REFUND_SIGNED &&
+          TransferStatus.TRANSFER_STATUS_RECEIVER_REFUND_SIGNED &&
         transfer.status !==
           TransferStatus.TRANSFER_STATUS_RECEIVER_KEY_TWEAK_APPLIED
       ) {
@@ -2482,27 +2585,9 @@ export class SparkWallet extends EventEmitter {
           invoice.invoice.encodedInvoice,
         ).fallbackAddress;
 
-        if (
-          sparkFallbackAddress &&
-          isValidSparkFallback(hexToBytes(sparkFallbackAddress))
-        ) {
-          const invoiceIdentityPubkey = sparkFallbackAddress.slice(6); // remove the 3 byte header
-          const expectedIdentityPubkey =
-            receiverIdentityPubkey ?? (await this.getIdentityPublicKey());
-
-          if (invoiceIdentityPubkey !== expectedIdentityPubkey) {
-            throw new ValidationError(
-              "Mismatch between spark identity embedded in lightning invoice and designated recipient spark identity",
-              {
-                field: "sparkFallbackAddress",
-                value: invoiceIdentityPubkey,
-                expected: expectedIdentityPubkey,
-              },
-            );
-          }
-        } else {
+        if (!sparkFallbackAddress) {
           throw new ValidationError(
-            "No valid spark fallback address found in lightning invoice",
+            "No spark fallback address found in lightning invoice",
             {
               field: "sparkFallbackAddress",
               value: sparkFallbackAddress,
@@ -2510,6 +2595,20 @@ export class SparkWallet extends EventEmitter {
             },
           );
         }
+
+        const expectedIdentityPubkey =
+          receiverIdentityPubkey ?? (await this.getIdentityPublicKey());
+
+        if (sparkFallbackAddress !== expectedIdentityPubkey) {
+          throw new ValidationError(
+            "Mismatch between spark identity embedded in lightning invoice and designated recipient spark identity",
+            {
+              field: "sparkFallbackAddress",
+              value: sparkFallbackAddress,
+              expected: expectedIdentityPubkey,
+            },
+          );
+        }
       }
 
       return invoice;
@@ -2607,9 +2706,8 @@ export class SparkWallet extends EventEmitter {
           "No valid spark address found in invoice. Defaulting to lightning.",
         );
       } else {
-        const identityPublicKey = sparkFallbackAddress.slice(6); // remove the 3 byte header
         const receiverSparkAddress = encodeSparkAddress({
-          identityPublicKey,
+          identityPublicKey: sparkFallbackAddress,
           network: Network[invoiceNetwork] as NetworkType,
         });
         return await this.transfer({
@@ -2648,7 +2746,7 @@ export class SparkWallet extends EventEmitter {
         });
       }
 
-      let leaves = await this.selectLeaves(totalAmount);
+      let leaves = (await this.selectLeaves([totalAmount])).get(totalAmount)!;
 
       leaves = await this.checkRefreshTimelockNodes(leaves);
       leaves = await this.checkExtendTimeLockNodes(leaves);
@@ -2786,17 +2884,24 @@ export class SparkWallet extends EventEmitter {
    *
    * @param {Object} params - Parameters for the withdrawal
    * @param {string} params.onchainAddress - The Bitcoin address where the funds should be sent
-   * @param {number} [params.amountSats] - The amount in satoshis to withdraw. If not specified, attempts to withdraw all available funds
+   * @param {CoopExitFeeQuote} params.feeQuote - The fee quote for the withdrawal
+   * @param {ExitSpeed} params.exitSpeed - The exit speed chosen for the withdrawal
+   * @param {number} [params.amountSats] - The amount in satoshis to withdraw. If not specified, attempts to withdraw all available funds and deductFeeFromWithdrawalAmount is set to true.
+   * @param {boolean} [params.deductFeeFromWithdrawalAmount] - Controls how the withdrawal fee is handled. If true, the fee is deducted from the withdrawal amount (amountSats), meaning the recipient will receive amountSats minus the fee. If false, the fee is paid separately from the wallet balance, meaning the recipient will receive the full amountSats.
    * @returns {Promise<CoopExitRequest | null | undefined>} The withdrawal request details, or null/undefined if the request cannot be completed
    */
   public async withdraw({
     onchainAddress,
     exitSpeed,
+    feeQuote,
     amountSats,
+    deductFeeFromWithdrawalAmount = true,
   }: {
     onchainAddress: string;
     exitSpeed: ExitSpeed;
+    feeQuote: CoopExitFeeQuote;
     amountSats?: number;
+    deductFeeFromWithdrawalAmount?: boolean;
   }) {
     if (!Number.isSafeInteger(amountSats)) {
       throw new ValidationError("Sats amount must be less than 2^53", {
@@ -2806,7 +2911,13 @@ export class SparkWallet extends EventEmitter {
       });
     }
     return await this.withLeaves(async () => {
-      return await this.coopExit(onchainAddress, exitSpeed, amountSats);
+      return await this.coopExit(
+        onchainAddress,
+        feeQuote,
+        exitSpeed,
+        deductFeeFromWithdrawalAmount,
+        amountSats,
+      );
     });
   }
 
@@ -2820,7 +2931,9 @@ export class SparkWallet extends EventEmitter {
    */
   private async coopExit(
     onchainAddress: string,
+    feeEstimate: CoopExitFeeQuote,
     exitSpeed: ExitSpeed,
+    deductFeeFromWithdrawalAmount: boolean,
     targetAmountSats?: number,
   ) {
     if (!Number.isSafeInteger(targetAmountSats)) {
@@ -2831,53 +2944,46 @@ export class SparkWallet extends EventEmitter {
       });
     }
 
-    let leavesToSend: TreeNode[] = [];
-    if (targetAmountSats) {
-      leavesToSend = await this.selectLeaves(targetAmountSats);
-    } else {
-      leavesToSend = this.leaves.map((leaf) => ({
-        ...leaf,
-      }));
+    if (!targetAmountSats) {
+      deductFeeFromWithdrawalAmount = true;
     }
 
-    const sspClient = this.getSspClient();
-    const feeEstimate = await sspClient.getCoopExitFeeEstimate({
-      leafExternalIds: leavesToSend.map((leaf) => leaf.id),
-      withdrawalAddress: onchainAddress,
-    });
+    let fee: number | undefined;
+    switch (exitSpeed) {
+      case ExitSpeed.FAST:
+        fee =
+          (feeEstimate.l1BroadcastFeeFast?.originalValue || 0) +
+          (feeEstimate.userFeeFast?.originalValue || 0);
+        break;
+      case ExitSpeed.MEDIUM:
+        fee =
+          (feeEstimate.l1BroadcastFeeMedium?.originalValue || 0) +
+          (feeEstimate.userFeeMedium?.originalValue || 0);
+        break;
+      case ExitSpeed.SLOW:
+        fee =
+          (feeEstimate.l1BroadcastFeeSlow?.originalValue || 0) +
+          (feeEstimate.userFeeSlow?.originalValue || 0);
+        break;
+      default:
+        throw new ValidationError("Invalid exit speed", {
+          field: "exitSpeed",
+          value: exitSpeed,
+          expected: "FAST, MEDIUM, or SLOW",
+        });
+    }
 
-    if (feeEstimate) {
-      let fee: number | undefined;
-      switch (exitSpeed) {
-        case ExitSpeed.FAST:
-          fee =
-            (feeEstimate.speedFast?.l1BroadcastFee.originalValue || 0) +
-            (feeEstimate.speedFast?.userFee.originalValue || 0);
-          break;
-        case ExitSpeed.MEDIUM:
-          fee =
-            (feeEstimate.speedMedium?.l1BroadcastFee.originalValue || 0) +
-            (feeEstimate.speedMedium?.userFee.originalValue || 0);
-          break;
-        case ExitSpeed.SLOW:
-          fee =
-            (feeEstimate.speedSlow?.l1BroadcastFee.originalValue || 0) +
-            (feeEstimate.speedSlow?.userFee.originalValue || 0);
-          break;
-        default:
-          throw new ValidationError("Invalid exit speed", {
-            field: "exitSpeed",
-            value: exitSpeed,
-            expected: "FAST, MEDIUM, or SLOW",
-          });
-      }
+    let leavesToSendToSsp: TreeNode[] = [];
+    let leavesToSendToSE: TreeNode[] = [];
 
-      if (
-        fee !== undefined &&
-        fee > leavesToSend.reduce((acc, leaf) => acc + leaf.value, 0)
-      ) {
+    if (deductFeeFromWithdrawalAmount) {
+      leavesToSendToSsp = targetAmountSats
+        ? (await this.selectLeaves([targetAmountSats])).get(targetAmountSats)!
+        : this.leaves;
+
+      if (fee > leavesToSendToSsp.reduce((acc, leaf) => acc + leaf.value, 0)) {
         throw new ValidationError(
-          "The fee for the withdrawal is greater than the target amount",
+          "The fee for the withdrawal is greater than the target withdrawal amount",
           {
             field: "fee",
             value: fee,
@@ -2885,12 +2991,38 @@ export class SparkWallet extends EventEmitter {
           },
         );
       }
+    } else {
+      if (!targetAmountSats) {
+        throw new ValidationError(
+          "targetAmountSats is required when deductFeeFromWithdrawalAmount is false",
+          {
+            field: "targetAmountSats",
+            value: targetAmountSats,
+            expected: "defined when deductFeeFromWithdrawalAmount is false",
+          },
+        );
+      }
+
+      const leaves = await this.selectLeaves([targetAmountSats, fee]);
+
+      const leavesForTargetAmount = leaves.get(targetAmountSats);
+      const leavesForFee = leaves.get(fee);
+
+      if (!leavesForTargetAmount || !leavesForFee) {
+        throw new Error("Failed to select leaves for target amount and fee");
+      }
+
+      leavesToSendToSsp = leavesForTargetAmount;
+      leavesToSendToSE = leavesForFee;
     }
-    leavesToSend = await this.checkRefreshTimelockNodes(leavesToSend);
-    leavesToSend = await this.checkExtendTimeLockNodes(leavesToSend);
+
+    leavesToSendToSsp = await this.checkRefreshTimelockNodes(leavesToSendToSsp);
+    leavesToSendToSsp = await this.checkExtendTimeLockNodes(leavesToSendToSsp);
+    leavesToSendToSE = await this.checkRefreshTimelockNodes(leavesToSendToSE);
+    leavesToSendToSE = await this.checkExtendTimeLockNodes(leavesToSendToSE);
 
     const leafKeyTweaks = await Promise.all(
-      leavesToSend.map(async (leaf) => ({
+      [...leavesToSendToSE, ...leavesToSendToSsp].map(async (leaf) => ({
         leaf,
         signingPubKey: await this.config.signer.generatePublicKey(
           sha256(leaf.id),
@@ -2899,13 +3031,26 @@ export class SparkWallet extends EventEmitter {
       })),
     );
 
-    const coopExitRequest = await sspClient.requestCoopExit({
-      leafExternalIds: leavesToSend.map((leaf) => leaf.id),
+    const requestCoopExitParams: RequestCoopExitInput = {
+      leafExternalIds: leavesToSendToSsp.map((leaf) => leaf.id),
       withdrawalAddress: onchainAddress,
       idempotencyKey: uuidv7(),
       exitSpeed,
-      withdrawAll: true,
-    });
+      withdrawAll: deductFeeFromWithdrawalAmount,
+    };
+
+    if (!deductFeeFromWithdrawalAmount) {
+      requestCoopExitParams.feeQuoteId = feeEstimate.id;
+      requestCoopExitParams.feeLeafExternalIds = leavesToSendToSE.map(
+        (leaf) => leaf.id,
+      );
+    }
+
+    const sspClient = this.getSspClient();
+
+    const coopExitRequest = await sspClient.requestCoopExit(
+      requestCoopExitParams,
+    );
 
     if (!coopExitRequest?.rawConnectorTransaction) {
       throw new Error("Failed to request coop exit");
@@ -2952,15 +3097,15 @@ export class SparkWallet extends EventEmitter {
    * @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<CoopExitFeeEstimatesOutput | null>} Fee estimate for the withdrawal
+   * @returns {Promise<CoopExitFeeQuote | null>} Fee estimate for the withdrawal
    */
-  public async getWithdrawalFeeEstimate({
+  public async getWithdrawalFeeQuote({
     amountSats,
     withdrawalAddress,
   }: {
     amountSats: number;
     withdrawalAddress: string;
-  }): Promise<CoopExitFeeEstimatesOutput | null> {
+  }): Promise<CoopExitFeeQuote | null> {
     const sspClient = this.getSspClient();
 
     if (!Number.isSafeInteger(amountSats)) {
@@ -2971,12 +3116,12 @@ export class SparkWallet extends EventEmitter {
       });
     }
 
-    let leaves = await this.selectLeaves(amountSats);
+    let leaves = (await this.selectLeaves([amountSats])).get(amountSats)!;
 
     leaves = await this.checkRefreshTimelockNodes(leaves);
     leaves = await this.checkExtendTimeLockNodes(leaves);
 
-    const feeEstimate = await sspClient.getCoopExitFeeEstimate({
+    const feeEstimate = await sspClient.getCoopExitFeeQuote({
       leafExternalIds: leaves.map((leaf) => leaf.id),
       withdrawalAddress,
     });
@@ -3005,8 +3150,15 @@ export class SparkWallet extends EventEmitter {
    * @param {string} id - The ID of the transfer
    * @returns {Promise<Transfer | undefined>} The transfer
    */
-  public async getTransfer(id: string): Promise<Transfer | undefined> {
-    return await this.transferService.queryTransfer(id);
+  public async getTransfer(id: string): Promise<WalletTransfer | undefined> {
+    const transfer = await this.transferService.queryTransfer(id);
+    if (!transfer) {
+      return undefined;
+    }
+    return mapTransferToWalletTransfer(
+      transfer,
+      bytesToHex(await this.config.signer.getIdentityPublicKey()),
+    );
   }
 
   // ***** Token Flow *****
@@ -3021,10 +3173,9 @@ export class SparkWallet extends EventEmitter {
     this.tokenOutputs.clear();
 
     const unsortedTokenOutputs =
-      await this.tokenTransactionService.fetchOwnedTokenOutputs(
-        [await this.config.signer.getIdentityPublicKey()],
-        [],
-      );
+      await this.tokenTransactionService.fetchOwnedTokenOutputs({
+        ownerPublicKeys: [await this.config.signer.getIdentityPublicKey()],
+      });
 
     const filteredTokenOutputs = unsortedTokenOutputs.filter(
       (output) =>
@@ -3155,34 +3306,27 @@ export class SparkWallet extends EventEmitter {
    * Retrieves token transaction history for specified tokens owned by the wallet.
    * Can optionally filter by specific transaction hashes.
    *
-   * @param tokenPublicKeys - Array of token public keys to query transactions for
+   * @param ownerPublicKeys - Optional array of owner public keys to query transactions for
+   * @param issuerPublicKeys - Optional array of issuer public keys to query transactions for
    * @param tokenTransactionHashes - Optional array of specific transaction hashes to filter by
+   * @param tokenIdentifiers - Optional array of token identifiers to filter by
+   * @param outputIds - Optional array of output IDs to filter by
    * @returns Promise resolving to array of token transactions with their current status
    */
   public async queryTokenTransactions(
-    tokenPublicKeys: string[],
+    ownerPublicKeys?: string[],
+    issuerPublicKeys?: string[],
     tokenTransactionHashes?: string[],
+    tokenIdentifiers?: string[],
+    outputIds?: string[],
   ): Promise<TokenTransactionWithStatus[]> {
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress(),
-    );
-
-    let queryParams;
-    if (tokenTransactionHashes?.length) {
-      queryParams = {
-        tokenPublicKeys: tokenPublicKeys?.map(hexToBytes)!,
-        ownerPublicKeys: [hexToBytes(await this.getIdentityPublicKey())],
-        tokenTransactionHashes: tokenTransactionHashes.map(hexToBytes),
-      };
-    } else {
-      queryParams = {
-        tokenPublicKeys: tokenPublicKeys?.map(hexToBytes)!,
-        ownerPublicKeys: [hexToBytes(await this.getIdentityPublicKey())],
-      };
-    }
-
-    const response = await sparkClient.query_token_transactions(queryParams);
-    return response.tokenTransactionsWithStatus;
+    return this.tokenTransactionService.queryTokenTransactions({
+      ownerPublicKeys,
+      issuerPublicKeys,
+      tokenTransactionHashes,
+      tokenIdentifiers,
+      outputIds,
+    }) as Promise<TokenTransactionWithStatus[]>;
   }
 
   public async getTokenL1Address(): Promise<string> {