@buildonspark/spark-sdk 0.0.11 → 0.0.13

package/dist/spark-sdk.d.ts

@@ -1,9 +1,11 @@
+import { CoopExitFeeEstimateInput, CoopExitFeeEstimateOutput, LeavesSwapRequest, LightningReceiveFeeEstimateInput, LightningReceiveFeeEstimateOutput, LightningSendFeeEstimateInput, LightningSendFeeEstimateOutput } from "./graphql/objects/index.js";
 import { LeafWithPreviousTransactionData, QueryAllTransfersResponse, Transfer, TreeNode } from "./proto/spark.js";
-import { ConfigOptions, WalletConfigService } from "./services/config.js";
+import { WalletConfigService } from "./services/config.js";
 import { ConnectionManager } from "./services/connection.js";
 import { TransferService } from "./services/transfer.js";
-import { NetworkType } from "./utils/network.js";
+import { ConfigOptions } from "./services/wallet-config.js";
 import { LRC20WalletApiConfig, LRCWallet } from "@buildonspark/lrc20-sdk";
+import { SparkSigner } from "./signer/signer.js";
 export type CreateLightningInvoiceParams = {
     amountSats: number;
     memo: string;
@@ -12,19 +14,19 @@ export type CreateLightningInvoiceParams = {
 export type PayLightningInvoiceParams = {
     invoice: string;
 };
-export type SendTransferParams = {
-    amount?: number;
-    leaves?: TreeNode[];
-    receiverPubKey: string;
-    expiryTime?: Date;
+export type TransferParams = {
+    amountSats: number;
+    receiverSparkAddress: string;
 };
 export type InitWalletResponse = {
-    balance: bigint;
-    tokenBalance: Map<string, {
-        balance: bigint;
-    }>;
     mnemonic?: string | undefined;
 };
+export interface SparkWalletProps {
+    mnemonicOrSeed?: Uint8Array | string;
+    signer?: SparkSigner;
+    options?: ConfigOptions;
+    lrc20WalletApiConfig?: LRC20WalletApiConfig;
+}
 /**
  * The SparkWallet class is the primary interface for interacting with the Spark network.
  * It provides methods for creating and managing wallets, handling deposits, executing transfers,
@@ -47,7 +49,11 @@ export declare class SparkWallet {
     private wasmModule;
     protected leaves: TreeNode[];
     protected tokenLeaves: Map<string, LeafWithPreviousTransactionData[]>;
-    constructor(network: NetworkType, configOptions?: ConfigOptions);
+    protected constructor(options?: ConfigOptions, signer?: SparkSigner);
+    static create({ mnemonicOrSeed, signer, options, lrc20WalletApiConfig, }: SparkWalletProps): Promise<{
+        mnemonic?: string | undefined;
+        wallet: SparkWallet;
+    }>;
     private initWasm;
     private initializeWallet;
     private getLeaves;
@@ -57,7 +63,6 @@ export declare class SparkWallet {
     private optimizeLeaves;
     private syncWallet;
     private withLeaves;
-    private isInitialized;
     /**
      * Gets the identity public key of the wallet.
      *
@@ -84,9 +89,9 @@ export declare class SparkWallet {
      *   - mnemonic: The mnemonic if one was generated (undefined for raw seed)
      *   - balance: The wallet's initial balance in satoshis
      *   - tokenBalance: Map of token balances and leaf counts
+     * @private
      */
-    initWallet(mnemonicOrSeed?: Uint8Array | string, enableLRC20Wallet?: boolean, lrc20WalletApiConfig?: LRC20WalletApiConfig): Promise<InitWalletResponse>;
-    private initWalletFromMnemonic;
+    protected initWallet(mnemonicOrSeed?: Uint8Array | string, lrc20WalletApiConfig?: LRC20WalletApiConfig): Promise<InitWalletResponse | undefined>;
     /**
      * Initializes a wallet from a seed.
      *
@@ -102,9 +107,11 @@ export declare class SparkWallet {
      * @param {number} [params.targetAmount] - Target amount for the swap
      * @param {TreeNode[]} [params.leaves] - Specific leaves to swap
      * @returns {Promise<Object>} The completed swap response
-     * @private
      */
-    private requestLeavesSwap;
+    requestLeavesSwap({ targetAmount, leaves, }: {
+        targetAmount?: number;
+        leaves?: TreeNode[];
+    }): Promise<LeavesSwapRequest>;
     /**
      * Gets all transfers for the wallet.
      *
@@ -112,7 +119,7 @@ export declare class SparkWallet {
      * @param {number} [offset=0] - Offset for pagination
      * @returns {Promise<QueryAllTransfersResponse>} Response containing the list of transfers
      */
-    getAllTransfers(limit?: number, offset?: number): Promise<QueryAllTransfersResponse>;
+    getTransfers(limit?: number, offset?: number): Promise<QueryAllTransfersResponse>;
     /**
      * Gets the current balance of the wallet.
      * You can use the forceRefetch option to synchronize your wallet and claim any
@@ -153,15 +160,19 @@ export declare class SparkWallet {
      * @private
      */
     private finalizeDeposit;
-    claimDeposit(txid: string): Promise<TreeNode[] | undefined>;
     /**
-     * Queries the mempool for transactions associated with an address.
+     * Gets all unused deposit addresses for the wallet.
      *
-     * @param {string} address - The address to query
-     * @returns {Promise<{depositTx: Transaction, vout: number} | null>} Transaction details or null if none found
-     * @private
+     * @returns {Promise<string[]>} The unused deposit addresses
+     */
+    getUnusedDepositAddresses(): Promise<string[]>;
+    /**
+     * Claims a deposit to the wallet.
+     *
+     * @param {string} txid - The transaction ID of the deposit
+     * @returns {Promise<TreeNode[] | undefined>} The nodes resulting from the deposit
      */
-    private queryMempoolTxs;
+    claimDeposit(txid: string): Promise<TreeNode[] | undefined>;
     /**
      * Transfers deposit to self to claim ownership.
      *
@@ -174,45 +185,39 @@ export declare class SparkWallet {
     /**
      * Sends a transfer to another Spark user.
      *
-     * @param {Object} params - Parameters for the transfer
+     * @param {TransferParams} params - Parameters for the transfer
      * @param {string} params.receiverSparkAddress - The recipient's Spark address
      * @param {number} params.amountSats - Amount to send in satoshis
      * @returns {Promise<Transfer>} The completed transfer details
      */
-    sendSparkTransfer({ receiverSparkAddress, amountSats, }: {
-        receiverSparkAddress: string;
-        amountSats: number;
-    }): Promise<Transfer>;
+    transfer({ amountSats, receiverSparkAddress }: TransferParams): Promise<Transfer>;
     /**
-     * Internal method to send a transfer.
+     * Internal method to refresh timelock nodes.
      *
-     * @param {SendTransferParams} params - Parameters for the transfer
-     * @returns {Promise<Transfer>} The completed transfer details
+     * @param {string} nodeId - The optional ID of the node to refresh. If not provided, all nodes will be checked.
+     * @returns {Promise<void>}
      * @private
      */
-    private _sendTransfer;
+    private refreshTimelockNodes;
     /**
-     * Internal method to refresh timelock nodes.
+     * Gets all pending transfers.
      *
-     * @param {string} nodeId - The optional ID of the node to refresh. If not provided, all nodes will be checked.
-     * @returns {Promise<void>}
+     * @returns {Promise<Transfer[]>} The pending transfers
      */
-    refreshTimelockNodes(nodeId?: string): Promise<void>;
+    getPendingTransfers(): Promise<Transfer[]>;
     /**
      * Claims a specific transfer.
      *
      * @param {Transfer} transfer - The transfer to claim
      * @returns {Promise<Object>} The claim result
-     * @private
      */
-    private claimTransfer;
+    claimTransfer(transfer: Transfer): Promise<TreeNode[]>;
     /**
      * Claims all pending transfers.
      *
      * @returns {Promise<boolean>} True if any transfers were claimed
-     * @private
      */
-    private claimTransfers;
+    claimTransfers(): Promise<boolean>;
     /**
      * Cancels all sender-initiated transfers.
      *
@@ -243,17 +248,15 @@ export declare class SparkWallet {
      *
      * @param {LightningReceiveFeeEstimateInput} params - Input parameters for fee estimation
      * @returns {Promise<LightningReceiveFeeEstimateOutput | null>} Fee estimate for receiving Lightning payments
-     * @private
      */
-    private getLightningReceiveFeeEstimate;
+    getLightningReceiveFeeEstimate({ amountSats, network, }: LightningReceiveFeeEstimateInput): Promise<LightningReceiveFeeEstimateOutput | null>;
     /**
      * Gets fee estimate for sending Lightning payments.
      *
      * @param {LightningSendFeeEstimateInput} params - Input parameters for fee estimation
      * @returns {Promise<LightningSendFeeEstimateOutput | null>} Fee estimate for sending Lightning payments
-     * @private
      */
-    private getLightningSendFeeEstimate;
+    getLightningSendFeeEstimate({ encodedInvoice, }: LightningSendFeeEstimateInput): Promise<LightningSendFeeEstimateOutput | null>;
     /**
      * Generates a deposit address for a tree.
      *
@@ -303,9 +306,8 @@ export declare class SparkWallet {
      *
      * @param {CoopExitFeeEstimateInput} params - Input parameters for fee estimation
      * @returns {Promise<CoopExitFeeEstimateOutput | null>} Fee estimate for the withdrawal
-     * @private
      */
-    private getCoopExitFeeEstimate;
+    getCoopExitFeeEstimate({ leafExternalIds, withdrawalAddress, }: CoopExitFeeEstimateInput): Promise<CoopExitFeeEstimateOutput | null>;
     /**
      * Synchronizes token leaves for the wallet.
      *

package/dist/spark-sdk.js

@@ -13,7 +13,6 @@ import { DepositService } from "./services/deposit.js";
 import { LightningService } from "./services/lightning.js";
 import { TokenTransactionService } from "./services/token-transactions.js";
 import { TransferService } from "./services/transfer.js";
-import * as bip39 from "@scure/bip39";
 import { validateMnemonic } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english";
 import { Mutex } from "async-mutex";
@@ -30,20 +29,6 @@ import { broadcastL1Withdrawal } from "./services/lrc20.js";
 import { getMasterHDKeyFromSeed } from "./utils/index.js";
 // Add this constant at the file level
 const MAX_TOKEN_LEAVES = 100;
-class LeafOperationError extends Error {
-    cause;
-    constructor(message, cause) {
-        super(message);
-        this.cause = cause;
-        this.name = "LeafOperationError";
-    }
-}
-class LeafOperationTimeoutError extends LeafOperationError {
-    constructor(message) {
-        super(message);
-        this.name = "LeafOperationTimeoutError";
-    }
-}
 /**
  * The SparkWallet class is the primary interface for interacting with the Spark network.
  * It provides methods for creating and managing wallets, handling deposits, executing transfers,
@@ -66,8 +51,8 @@ export class SparkWallet {
     wasmModule = null;
     leaves = [];
     tokenLeaves = new Map();
-    constructor(network, configOptions) {
-        this.config = new WalletConfigService(Network[network], configOptions);
+    constructor(options, signer) {
+        this.config = new WalletConfigService(options, signer);
         this.connectionManager = new ConnectionManager(this.config);
         this.depositService = new DepositService(this.config, this.connectionManager);
         this.transferService = new TransferService(this.config, this.connectionManager);
@@ -76,6 +61,14 @@ export class SparkWallet {
         this.lightningService = new LightningService(this.config, this.connectionManager);
         this.coopExitService = new CoopExitService(this.config, this.connectionManager);
     }
+    static async create({ mnemonicOrSeed, signer, options, lrc20WalletApiConfig, }) {
+        const wallet = new SparkWallet(options, signer);
+        const initResponse = await wallet.initWallet(mnemonicOrSeed, lrc20WalletApiConfig);
+        return {
+            wallet,
+            ...initResponse,
+        };
+    }
     async initWasm() {
         try {
             this.wasmModule = await initWasm();
@@ -85,13 +78,9 @@ export class SparkWallet {
         }
     }
     async initializeWallet(identityPublicKey) {
-        await this.connectionManager.createClients();
         this.sspClient = new SspClient(identityPublicKey);
-        await Promise.all([
-            this.initWasm(),
-            // Hacky but do this to store the deposit signing key in the signer
-            this.config.signer.getDepositSigningKey(),
-        ]);
+        await this.connectionManager.createClients();
+        await this.initWasm();
         await this.syncWallet();
     }
     async getLeaves() {
@@ -195,8 +184,8 @@ export class SparkWallet {
     async syncWallet() {
         await Promise.all([this.claimTransfers(), this.syncTokenLeaves()]);
         this.leaves = await this.getLeaves();
-        await this.refreshTimelockNodes();
         await this.config.signer.restoreSigningKeysFromLeafs(this.leaves);
+        await this.refreshTimelockNodes();
         this.optimizeLeaves().catch((e) => {
             console.error("Failed to optimize leaves", e);
         });
@@ -210,9 +199,6 @@ export class SparkWallet {
             release();
         }
     }
-    isInitialized() {
-        return this.sspClient !== null && this.wasmModule !== null;
-    }
     /**
      * Gets the identity public key of the wallet.
      *
@@ -243,33 +229,28 @@ export class SparkWallet {
      *   - mnemonic: The mnemonic if one was generated (undefined for raw seed)
      *   - balance: The wallet's initial balance in satoshis
      *   - tokenBalance: Map of token balances and leaf counts
+     * @private
      */
-    async initWallet(mnemonicOrSeed, enableLRC20Wallet = true, lrc20WalletApiConfig) {
+    async initWallet(mnemonicOrSeed, lrc20WalletApiConfig) {
         const returnMnemonic = !mnemonicOrSeed;
+        let mnemonic;
         if (!mnemonicOrSeed) {
             mnemonicOrSeed = await this.config.signer.generateMnemonic();
         }
+        let seed;
         if (typeof mnemonicOrSeed !== "string") {
-            mnemonicOrSeed = bytesToHex(mnemonicOrSeed);
-        }
-        let mnemonic;
-        if (validateMnemonic(mnemonicOrSeed, wordlist)) {
-            mnemonic = mnemonicOrSeed;
-            await this.initWalletFromMnemonic(mnemonicOrSeed);
+            seed = mnemonicOrSeed;
         }
         else {
-            await this.initWalletFromSeed(mnemonicOrSeed);
-        }
-        const balance = this.leaves.reduce((acc, leaf) => acc + BigInt(leaf.value), 0n);
-        const tokenBalance = await this.getAllTokenBalances();
-        if (enableLRC20Wallet) {
-            let seed;
-            if (typeof mnemonicOrSeed === "string") {
-                seed = await bip39.mnemonicToSeed(mnemonicOrSeed);
+            if (validateMnemonic(mnemonicOrSeed, wordlist)) {
+                seed = await this.config.signer.mnemonicToSeed(mnemonicOrSeed);
             }
             else {
-                seed = mnemonicOrSeed;
+                seed = hexToBytes(mnemonicOrSeed);
             }
+        }
+        await this.initWalletFromSeed(seed);
+        if (lrc20WalletApiConfig) {
             const network = this.config.getNetwork();
             const masterPrivateKey = getMasterHDKeyFromSeed(seed, network == Network.REGTEST ? 0 : 1).privateKey;
             this.lrc20Wallet = new LRCWallet(bytesToHex(masterPrivateKey), LRC_WALLET_NETWORK[network], LRC_WALLET_NETWORK_TYPE[network], lrc20WalletApiConfig);
@@ -277,19 +258,9 @@ export class SparkWallet {
         if (returnMnemonic) {
             return {
                 mnemonic,
-                balance,
-                tokenBalance,
             };
         }
-        return {
-            balance,
-            tokenBalance,
-        };
-    }
-    async initWalletFromMnemonic(mnemonic) {
-        const identityPublicKey = await this.config.signer.createSparkWalletFromMnemonic(mnemonic, this.config.getNetwork());
-        await this.initializeWallet(identityPublicKey);
-        return identityPublicKey;
+        return;
     }
     /**
      * Initializes a wallet from a seed.
@@ -310,7 +281,6 @@ export class SparkWallet {
      * @param {number} [params.targetAmount] - Target amount for the swap
      * @param {TreeNode[]} [params.leaves] - Specific leaves to swap
      * @returns {Promise<Object>} The completed swap response
-     * @private
      */
     async requestLeavesSwap({ targetAmount, leaves, }) {
         if (targetAmount && targetAmount <= 0) {
@@ -338,7 +308,7 @@ export class SparkWallet {
             signingPubKey: await this.config.signer.generatePublicKey(sha256(leaf.id)),
             newSigningPubKey: await this.config.signer.generatePublicKey(),
         })));
-        const { transfer, signatureMap } = await this.transferService.sendTransferSignRefund(leafKeyTweaks, await this.config.signer.getSspIdentityPublicKey(this.config.getNetwork()), new Date(Date.now() + 10 * 60 * 1000));
+        const { transfer, signatureMap } = await this.transferService.sendTransferSignRefund(leafKeyTweaks, await this.config.signer.getSspIdentityPublicKey(this.config.getNetwork()), new Date(Date.now() + 2 * 60 * 1000));
         try {
             if (!transfer.leaves[0]?.leaf) {
                 throw new Error("Failed to get leaf");
@@ -445,7 +415,7 @@ export class SparkWallet {
      * @param {number} [offset=0] - Offset for pagination
      * @returns {Promise<QueryAllTransfersResponse>} Response containing the list of transfers
      */
-    async getAllTransfers(limit = 20, offset = 0) {
+    async getTransfers(limit = 20, offset = 0) {
         return await this.transferService.queryAllTransfers(limit, offset);
     }
     /**
@@ -518,6 +488,23 @@ export class SparkWallet {
         });
         return await this.transferDepositToSelf(response.nodes, signingPubKey);
     }
+    /**
+     * Gets all unused deposit addresses for the wallet.
+     *
+     * @returns {Promise<string[]>} The unused deposit addresses
+     */
+    async getUnusedDepositAddresses() {
+        const sparkClient = await this.connectionManager.createSparkClient(this.config.getCoordinatorAddress());
+        return (await sparkClient.query_unused_deposit_addresses({
+            identityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        })).depositAddresses.map((addr) => addr.depositAddress);
+    }
+    /**
+     * Claims a deposit to the wallet.
+     *
+     * @param {string} txid - The transaction ID of the deposit
+     * @returns {Promise<TreeNode[] | undefined>} The nodes resulting from the deposit
+     */
     async claimDeposit(txid) {
         const baseUrl = this.config.getNetwork() === Network.REGTEST
             ? "https://regtest-mempool.dev.dev.sparkinfra.net/api"
@@ -567,47 +554,6 @@ export class SparkWallet {
         });
         return nodes;
     }
-    /**
-     * Queries the mempool for transactions associated with an address.
-     *
-     * @param {string} address - The address to query
-     * @returns {Promise<{depositTx: Transaction, vout: number} | null>} Transaction details or null if none found
-     * @private
-     */
-    async queryMempoolTxs(address) {
-        const network = getNetworkFromAddress(address) || this.config.getNetwork();
-        const baseUrl = network === BitcoinNetwork.REGTEST
-            ? "https://regtest-mempool.dev.dev.sparkinfra.net/api"
-            : "https://mempool.space/docs/api";
-        const auth = btoa("spark-sdk:mCMk1JqlBNtetUNy");
-        const headers = {
-            "Content-Type": "application/json",
-        };
-        if (network === BitcoinNetwork.REGTEST) {
-            headers["Authorization"] = `Basic ${auth}`;
-        }
-        const response = await fetch(`${baseUrl}/address/${address}/txs`, {
-            headers,
-        });
-        const addressTxs = await response.json();
-        if (addressTxs && addressTxs.length > 0) {
-            const latestTx = addressTxs[0];
-            const outputIndex = latestTx.vout.findIndex((output) => output.scriptpubkey_address === address);
-            if (outputIndex === -1) {
-                return null;
-            }
-            const txResponse = await fetch(`${baseUrl}/tx/${latestTx.txid}/hex`, {
-                headers,
-            });
-            const txHex = await txResponse.text();
-            const depositTx = getTxFromRawTxHex(txHex);
-            return {
-                depositTx,
-                vout: outputIndex,
-            };
-        }
-        return null;
-    }
     /**
      * Transfers deposit to self to claim ownership.
      *
@@ -622,7 +568,7 @@ export class SparkWallet {
             signingPubKey,
             newSigningPubKey: await this.config.signer.generatePublicKey(),
         })));
-        await this.transferService.sendTransfer(leafKeyTweaks, await this.config.signer.getIdentityPublicKey(), new Date(Date.now() + 10 * 60 * 1000));
+        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
@@ -634,55 +580,32 @@ export class SparkWallet {
     /**
      * Sends a transfer to another Spark user.
      *
-     * @param {Object} params - Parameters for the transfer
+     * @param {TransferParams} params - Parameters for the transfer
      * @param {string} params.receiverSparkAddress - The recipient's Spark address
      * @param {number} params.amountSats - Amount to send in satoshis
      * @returns {Promise<Transfer>} The completed transfer details
      */
-    async sendSparkTransfer({ receiverSparkAddress, amountSats, }) {
+    async transfer({ amountSats, receiverSparkAddress }) {
         return await this.withLeaves(async () => {
-            return await this._sendTransfer({
-                receiverPubKey: receiverSparkAddress,
-                amount: amountSats,
-            });
+            const leavesToSend = await this.selectLeaves(amountSats);
+            await this.refreshTimelockNodes();
+            const leafKeyTweaks = await Promise.all(leavesToSend.map(async (leaf) => ({
+                leaf,
+                signingPubKey: await this.config.signer.generatePublicKey(sha256(leaf.id)),
+                newSigningPubKey: await this.config.signer.generatePublicKey(),
+            })));
+            const transfer = await this.transferService.sendTransfer(leafKeyTweaks, hexToBytes(receiverSparkAddress));
+            const leavesToRemove = new Set(leavesToSend.map((leaf) => leaf.id));
+            this.leaves = this.leaves.filter((leaf) => !leavesToRemove.has(leaf.id));
+            return transfer;
         });
     }
-    /**
-     * Internal method to send a transfer.
-     *
-     * @param {SendTransferParams} params - Parameters for the transfer
-     * @returns {Promise<Transfer>} The completed transfer details
-     * @private
-     */
-    async _sendTransfer({ amount, receiverPubKey, leaves, expiryTime = new Date(Date.now() + 10 * 60 * 1000), }) {
-        let leavesToSend = [];
-        if (leaves) {
-            leavesToSend = leaves.map((leaf) => ({
-                ...leaf,
-            }));
-        }
-        else if (amount) {
-            leavesToSend = await this.selectLeaves(amount);
-        }
-        else {
-            throw new Error("Must provide amount or leaves");
-        }
-        await this.refreshTimelockNodes();
-        const leafKeyTweaks = await Promise.all(leavesToSend.map(async (leaf) => ({
-            leaf,
-            signingPubKey: await this.config.signer.generatePublicKey(sha256(leaf.id)),
-            newSigningPubKey: await this.config.signer.generatePublicKey(),
-        })));
-        const transfer = await this.transferService.sendTransfer(leafKeyTweaks, hexToBytes(receiverPubKey), expiryTime);
-        const leavesToRemove = new Set(leavesToSend.map((leaf) => leaf.id));
-        this.leaves = this.leaves.filter((leaf) => !leavesToRemove.has(leaf.id));
-        return transfer;
-    }
     /**
      * Internal method to refresh timelock nodes.
      *
      * @param {string} nodeId - The optional ID of the node to refresh. If not provided, all nodes will be checked.
      * @returns {Promise<void>}
+     * @private
      */
     async refreshTimelockNodes(nodeId) {
         const nodesToRefresh = [];
@@ -747,12 +670,19 @@ export class SparkWallet {
             this.leaves.push(newNode);
         }
     }
+    /**
+     * Gets all pending transfers.
+     *
+     * @returns {Promise<Transfer[]>} The pending transfers
+     */
+    async getPendingTransfers() {
+        return (await this.transferService.queryPendingTransfers()).transfers;
+    }
     /**
      * Claims a specific transfer.
      *
      * @param {Transfer} transfer - The transfer to claim
      * @returns {Promise<Object>} The claim result
-     * @private
      */
     async claimTransfer(transfer) {
         return await this.claimTransferMutex.runExclusive(async () => {
@@ -780,7 +710,6 @@ export class SparkWallet {
      * Claims all pending transfers.
      *
      * @returns {Promise<boolean>} True if any transfers were claimed
-     * @private
      */
     async claimTransfers() {
         const transfers = await this.transferService.queryPendingTransfers();
@@ -805,10 +734,12 @@ export class SparkWallet {
      * @private
      */
     async cancelAllSenderInitiatedTransfers() {
-        const transfers = await this.transferService.queryPendingTransfersBySender();
-        for (const transfer of transfers.transfers) {
-            if (transfer.status === TransferStatus.TRANSFER_STATUS_SENDER_INITIATED) {
-                await this.transferService.cancelSendTransfer(transfer);
+        for (const operator of Object.values(this.config.getSigningOperators())) {
+            const transfers = await this.transferService.queryPendingTransfersBySender(operator.address);
+            for (const transfer of transfers.transfers) {
+                if (transfer.status === TransferStatus.TRANSFER_STATUS_SENDER_INITIATED) {
+                    await this.transferService.cancelSendTransfer(transfer, operator.address);
+                }
             }
         }
     }
@@ -908,7 +839,6 @@ export class SparkWallet {
      *
      * @param {LightningReceiveFeeEstimateInput} params - Input parameters for fee estimation
      * @returns {Promise<LightningReceiveFeeEstimateOutput | null>} Fee estimate for receiving Lightning payments
-     * @private
      */
     async getLightningReceiveFeeEstimate({ amountSats, network, }) {
         if (!this.sspClient) {
@@ -921,7 +851,6 @@ export class SparkWallet {
      *
      * @param {LightningSendFeeEstimateInput} params - Input parameters for fee estimation
      * @returns {Promise<LightningSendFeeEstimateOutput | null>} Fee estimate for sending Lightning payments
-     * @private
      */
     async getLightningSendFeeEstimate({ encodedInvoice, }) {
         if (!this.sspClient) {
@@ -1032,7 +961,6 @@ export class SparkWallet {
      *
      * @param {CoopExitFeeEstimateInput} params - Input parameters for fee estimation
      * @returns {Promise<CoopExitFeeEstimateOutput | null>} Fee estimate for the withdrawal
-     * @private
      */
     async getCoopExitFeeEstimate({ leafExternalIds, withdrawalAddress, }) {
         if (!this.sspClient) {