@dynamic-labs/spark 4.40.0 → 4.40.1

package/CHANGELOG.md

@@ -1,4 +1,10 @@
 
+### [4.40.1](https://github.com/dynamic-labs/dynamic-auth/compare/v4.40.0...v4.40.1) (2025-10-24)
+
+### Bug Fixes
+
+* add support for Keplr in-app browser redirect for cosmos chain ([#9770](https://github.com/dynamic-labs/dynamic-auth/issues/9770)) ([35652f3](https://github.com/dynamic-labs/dynamic-auth/commit/35652f3167a4e768f5d4c634ab1b4f127fd5076a))
+
 ## [4.40.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.39.0...v4.40.0) (2025-10-22)
 
 

package/package.cjs

@@ -3,6 +3,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "4.40.0";
+var version = "4.40.1";
 
 exports.version = version;

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.40.0";
+var version = "4.40.1";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/spark",
-  "version": "4.40.0",
+  "version": "4.40.1",
   "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -18,11 +18,12 @@
   },
   "homepage": "https://www.dynamic.xyz/",
   "dependencies": {
-    "@dynamic-labs/assert-package-version": "4.40.0",
-    "@dynamic-labs/types": "4.40.0",
-    "@dynamic-labs/utils": "4.40.0",
-    "@dynamic-labs/wallet-book": "4.40.0",
-    "@dynamic-labs/wallet-connector-core": "4.40.0"
+    "@dynamic-labs/assert-package-version": "4.40.1",
+    "sats-connect": "4.2.0",
+    "@dynamic-labs/types": "4.40.1",
+    "@dynamic-labs/utils": "4.40.1",
+    "@dynamic-labs/wallet-book": "4.40.1",
+    "@dynamic-labs/wallet-connector-core": "4.40.1"
   },
   "peerDependencies": {}
 }

package/src/connectors/SparkSatsConnectConnector/SparkSatsConnectConnector.cjs

@@ -0,0 +1,261 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var satsConnect = require('sats-connect');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var SparkWalletConnector = require('../SparkWalletConnector/SparkWalletConnector.cjs');
+
+/**
+ * Spark wallet connector implementation using sats-connect library.
+ *
+ * This connector enables integration with any wallet that supports the
+ * sats-connect Spark methods, providing a standardized interface for
+ * Spark Bitcoin operations including address management, balance queries,
+ * message signing, and token transfers.
+ *
+ * @example
+ * ```typescript
+ * const connector = new SparkSatsConnectConnector({
+ *   walletBook,
+ *   sparkNetworks
+ * });
+ *
+ * await connector.connect();
+ * const address = await connector.getAddress();
+ * const balance = await connector.getBalance();
+ * ```
+ */
+class SparkSatsConnectConnector extends SparkWalletConnector.SparkWalletConnector {
+    /**
+     * Creates a new Spark Sats Connect connector
+     * @param opts - Configuration options
+     */
+    constructor(opts) {
+        super(opts);
+        /** Human-readable connector name */
+        this.name = 'Spark Sats Connect';
+    }
+    /**
+     * Returns undefined since sats-connect uses a request-based API
+     * rather than a window provider pattern.
+     *
+     * The connector methods directly call sats-connect's request function
+     * instead of delegating to a provider object.
+     *
+     * @returns undefined as no provider object is needed
+     */
+    getProvider() {
+        // sats-connect doesn't use a window provider pattern like other wallets.
+        // Instead, it uses a direct request() API that works across all wallets
+        // that implement the sats-connect protocol.
+        return undefined;
+    }
+    /**
+     * Retrieves the current wallet address using sats-connect.
+     *
+     * Requests the Spark address from the connected wallet using the
+     * spark_getAddresses method.
+     *
+     * @returns The wallet address as a string, or undefined if unavailable
+     * @throws Error if the user cancels the request
+     */
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const response = yield satsConnect.request('spark_getAddresses', {});
+                if (response.status !== 'success') {
+                    throw response.error;
+                }
+                // Find the Spark address from the returned addresses
+                const sparkAddress = (_a = response.result.addresses) === null || _a === void 0 ? void 0 : _a.find((addr) => addr.purpose === satsConnect.AddressPurpose.Spark);
+                if (!sparkAddress) {
+                    throw new Error('No Spark address found in response');
+                }
+                return sparkAddress.address;
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('===SPARK=== [SparkSatsConnectConnector] Failed to get address', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Retrieves the public key for the Spark address.
+     *
+     * @returns The public key as a hex string
+     * @throws Error if the request fails
+     */
+    getPublicKey() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const response = yield satsConnect.request('spark_getAddresses', {});
+                if (response.status !== 'success') {
+                    throw response.error;
+                }
+                const sparkAddress = (_a = response.result.addresses) === null || _a === void 0 ? void 0 : _a.find((addr) => addr.purpose === satsConnect.AddressPurpose.Spark);
+                if (!(sparkAddress === null || sparkAddress === void 0 ? void 0 : sparkAddress.publicKey)) {
+                    throw new Error('No Spark public key found in response');
+                }
+                return sparkAddress.publicKey;
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('===SPARK=== [SparkSatsConnectConnector] Failed to get public key', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Retrieves the wallet balance using sats-connect.
+     *
+     * Gets the Spark Bitcoin balance in BTC (converted from satoshis).
+     *
+     * TODO: Add support for returning token balances in addition to BTC balance.
+     * The spark_getBalance method returns tokenBalances which we currently ignore.
+     *
+     * @returns The balance as a string in BTC, or undefined if unavailable
+     * @throws Error if the request fails
+     */
+    getBalance() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield satsConnect.request('spark_getBalance', undefined);
+                if (response.status !== 'success') {
+                    throw response.error;
+                }
+                // Convert satoshis to BTC using BigInt arithmetic to maintain precision
+                const balanceInSats = BigInt(response.result.balance);
+                const satoshisPerBtc = BigInt(100000000);
+                // Calculate whole BTC and remainder satoshis
+                const wholeBtc = balanceInSats / satoshisPerBtc;
+                const remainderSats = balanceInSats % satoshisPerBtc;
+                if (remainderSats === BigInt(0)) {
+                    return wholeBtc.toString();
+                }
+                const remainderStr = remainderSats.toString().padStart(8, '0');
+                let trimmedRemainder = remainderStr;
+                while (trimmedRemainder.endsWith('0') && trimmedRemainder.length > 1) {
+                    trimmedRemainder = trimmedRemainder.slice(0, -1);
+                }
+                return trimmedRemainder
+                    ? `${wholeBtc}.${trimmedRemainder}`
+                    : wholeBtc.toString();
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('===SPARK=== [SparkSatsConnectConnector] Failed to get balance', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Signs a message using sats-connect spark_signMessage method.
+     *
+     * @param message - The message to sign or signing request object
+     * @returns The signature as a string, or undefined if signing fails
+     * @throws Error if the request fails or user cancels
+     */
+    signMessage(message) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                // Extract message string from input
+                const messageToSign = typeof message === 'string' ? message : message.message;
+                if (!messageToSign) {
+                    throw new Error('Message is required for signing');
+                }
+                const response = yield satsConnect.request('spark_signMessage', {
+                    message: messageToSign,
+                });
+                if (response.status !== 'success') {
+                    throw response.error;
+                }
+                // Return the signature from the response
+                return response.result.signature;
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('===SPARK=== [SparkSatsConnectConnector] Failed to sign message', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Transfers Bitcoin to another Spark address using sats-connect.
+     *
+     * @param params - Transfer parameters
+     * @param params.receiverSparkAddress - The recipient's Spark address
+     * @param params.amountSats - Amount to transfer in satoshis
+     * @param params.isTaproot - Whether to use Taproot (currently ignored for sats-connect)
+     * @returns The transaction ID/hash
+     * @throws Error if the transfer fails or user cancels
+     */
+    transferBitcoin(params) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield satsConnect.request('spark_transfer', {
+                    amountSats: params.amountSats,
+                    receiverSparkAddress: params.receiverSparkAddress,
+                });
+                if (response.status !== 'success') {
+                    throw response.error;
+                }
+                return response.result.id;
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('===SPARK=== [SparkSatsConnectConnector] Failed to transfer Bitcoin', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Transfers tokens to another Spark address using sats-connect.
+     *
+     * @param params - Transfer parameters
+     * @param params.tokenPublicKey - The token's identifier (bech32m format)
+     * @param params.receiverSparkAddress - The recipient's Spark address
+     * @param params.tokenAmount - Amount of tokens to transfer
+     * @param params.isTaproot - Whether to use Taproot (currently ignored for sats-connect)
+     * @returns The transaction ID/hash
+     * @throws Error if the transfer fails or user cancels
+     */
+    transferTokens(params) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield satsConnect.request('spark_transferToken', {
+                    receiverSparkAddress: params.receiverSparkAddress,
+                    tokenAmount: params.tokenAmount,
+                    tokenIdentifier: params.tokenPublicKey,
+                });
+                if (response.status !== 'success') {
+                    throw response.error;
+                }
+                return response.result.id;
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('===SPARK=== [SparkSatsConnectConnector] Failed to transfer tokens', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Checks if the Spark wallet is installed in the browser.
+     *
+     * For sats-connect, we check if the library is available since it
+     * doesn't rely on a window provider pattern.
+     *
+     * @returns True if sats-connect is available
+     */
+    isInstalledOnBrowser() {
+        try {
+            // Check if sats-connect request function is available
+            return typeof satsConnect.request === 'function';
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+}
+
+exports.SparkSatsConnectConnector = SparkSatsConnectConnector;

package/src/connectors/SparkSatsConnectConnector/SparkSatsConnectConnector.d.ts

@@ -0,0 +1,122 @@
+import { SparkWalletConnector, SparkWalletConnectorOpts } from '../SparkWalletConnector';
+import type { ISparkProvider } from '../../types';
+/**
+ * Spark wallet connector implementation using sats-connect library.
+ *
+ * This connector enables integration with any wallet that supports the
+ * sats-connect Spark methods, providing a standardized interface for
+ * Spark Bitcoin operations including address management, balance queries,
+ * message signing, and token transfers.
+ *
+ * @example
+ * ```typescript
+ * const connector = new SparkSatsConnectConnector({
+ *   walletBook,
+ *   sparkNetworks
+ * });
+ *
+ * await connector.connect();
+ * const address = await connector.getAddress();
+ * const balance = await connector.getBalance();
+ * ```
+ */
+export declare class SparkSatsConnectConnector extends SparkWalletConnector {
+    /** Human-readable connector name */
+    name: string;
+    /**
+     * Creates a new Spark Sats Connect connector
+     * @param opts - Configuration options
+     */
+    constructor(opts: SparkWalletConnectorOpts);
+    /**
+     * Returns undefined since sats-connect uses a request-based API
+     * rather than a window provider pattern.
+     *
+     * The connector methods directly call sats-connect's request function
+     * instead of delegating to a provider object.
+     *
+     * @returns undefined as no provider object is needed
+     */
+    getProvider(): ISparkProvider | undefined;
+    /**
+     * Retrieves the current wallet address using sats-connect.
+     *
+     * Requests the Spark address from the connected wallet using the
+     * spark_getAddresses method.
+     *
+     * @returns The wallet address as a string, or undefined if unavailable
+     * @throws Error if the user cancels the request
+     */
+    getAddress(): Promise<string | undefined>;
+    /**
+     * Retrieves the public key for the Spark address.
+     *
+     * @returns The public key as a hex string
+     * @throws Error if the request fails
+     */
+    private getPublicKey;
+    /**
+     * Retrieves the wallet balance using sats-connect.
+     *
+     * Gets the Spark Bitcoin balance in BTC (converted from satoshis).
+     *
+     * TODO: Add support for returning token balances in addition to BTC balance.
+     * The spark_getBalance method returns tokenBalances which we currently ignore.
+     *
+     * @returns The balance as a string in BTC, or undefined if unavailable
+     * @throws Error if the request fails
+     */
+    getBalance(): Promise<string | undefined>;
+    /**
+     * Signs a message using sats-connect spark_signMessage method.
+     *
+     * @param message - The message to sign or signing request object
+     * @returns The signature as a string, or undefined if signing fails
+     * @throws Error if the request fails or user cancels
+     */
+    signMessage(message: string | {
+        message: string;
+        isTaproot?: boolean;
+    }): Promise<string | undefined>;
+    /**
+     * Transfers Bitcoin to another Spark address using sats-connect.
+     *
+     * @param params - Transfer parameters
+     * @param params.receiverSparkAddress - The recipient's Spark address
+     * @param params.amountSats - Amount to transfer in satoshis
+     * @param params.isTaproot - Whether to use Taproot (currently ignored for sats-connect)
+     * @returns The transaction ID/hash
+     * @throws Error if the transfer fails or user cancels
+     */
+    transferBitcoin(params: {
+        receiverSparkAddress: string;
+        amountSats: string | number;
+        isTaproot?: boolean;
+    }): Promise<string | undefined>;
+    /**
+     * Transfers tokens to another Spark address using sats-connect.
+     *
+     * @param params - Transfer parameters
+     * @param params.tokenPublicKey - The token's identifier (bech32m format)
+     * @param params.receiverSparkAddress - The recipient's Spark address
+     * @param params.tokenAmount - Amount of tokens to transfer
+     * @param params.isTaproot - Whether to use Taproot (currently ignored for sats-connect)
+     * @returns The transaction ID/hash
+     * @throws Error if the transfer fails or user cancels
+     */
+    transferTokens(params: {
+        tokenPublicKey: string;
+        receiverSparkAddress: string;
+        tokenAmount: number;
+        isTaproot?: boolean;
+    }): Promise<string | undefined>;
+    /**
+     * Checks if the Spark wallet is installed in the browser.
+     *
+     * For sats-connect, we check if the library is available since it
+     * doesn't rely on a window provider pattern.
+     *
+     * @returns True if sats-connect is available
+     */
+    isInstalledOnBrowser(): boolean;
+}

package/src/connectors/SparkSatsConnectConnector/SparkSatsConnectConnector.js

@@ -0,0 +1,257 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { request, AddressPurpose } from 'sats-connect';
+import { logger } from '@dynamic-labs/wallet-connector-core';
+import { SparkWalletConnector } from '../SparkWalletConnector/SparkWalletConnector.js';
+
+/**
+ * Spark wallet connector implementation using sats-connect library.
+ *
+ * This connector enables integration with any wallet that supports the
+ * sats-connect Spark methods, providing a standardized interface for
+ * Spark Bitcoin operations including address management, balance queries,
+ * message signing, and token transfers.
+ *
+ * @example
+ * ```typescript
+ * const connector = new SparkSatsConnectConnector({
+ *   walletBook,
+ *   sparkNetworks
+ * });
+ *
+ * await connector.connect();
+ * const address = await connector.getAddress();
+ * const balance = await connector.getBalance();
+ * ```
+ */
+class SparkSatsConnectConnector extends SparkWalletConnector {
+    /**
+     * Creates a new Spark Sats Connect connector
+     * @param opts - Configuration options
+     */
+    constructor(opts) {
+        super(opts);
+        /** Human-readable connector name */
+        this.name = 'Spark Sats Connect';
+    }
+    /**
+     * Returns undefined since sats-connect uses a request-based API
+     * rather than a window provider pattern.
+     *
+     * The connector methods directly call sats-connect's request function
+     * instead of delegating to a provider object.
+     *
+     * @returns undefined as no provider object is needed
+     */
+    getProvider() {
+        // sats-connect doesn't use a window provider pattern like other wallets.
+        // Instead, it uses a direct request() API that works across all wallets
+        // that implement the sats-connect protocol.
+        return undefined;
+    }
+    /**
+     * Retrieves the current wallet address using sats-connect.
+     *
+     * Requests the Spark address from the connected wallet using the
+     * spark_getAddresses method.
+     *
+     * @returns The wallet address as a string, or undefined if unavailable
+     * @throws Error if the user cancels the request
+     */
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const response = yield request('spark_getAddresses', {});
+                if (response.status !== 'success') {
+                    throw response.error;
+                }
+                // Find the Spark address from the returned addresses
+                const sparkAddress = (_a = response.result.addresses) === null || _a === void 0 ? void 0 : _a.find((addr) => addr.purpose === AddressPurpose.Spark);
+                if (!sparkAddress) {
+                    throw new Error('No Spark address found in response');
+                }
+                return sparkAddress.address;
+            }
+            catch (error) {
+                logger.error('===SPARK=== [SparkSatsConnectConnector] Failed to get address', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Retrieves the public key for the Spark address.
+     *
+     * @returns The public key as a hex string
+     * @throws Error if the request fails
+     */
+    getPublicKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const response = yield request('spark_getAddresses', {});
+                if (response.status !== 'success') {
+                    throw response.error;
+                }
+                const sparkAddress = (_a = response.result.addresses) === null || _a === void 0 ? void 0 : _a.find((addr) => addr.purpose === AddressPurpose.Spark);
+                if (!(sparkAddress === null || sparkAddress === void 0 ? void 0 : sparkAddress.publicKey)) {
+                    throw new Error('No Spark public key found in response');
+                }
+                return sparkAddress.publicKey;
+            }
+            catch (error) {
+                logger.error('===SPARK=== [SparkSatsConnectConnector] Failed to get public key', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Retrieves the wallet balance using sats-connect.
+     *
+     * Gets the Spark Bitcoin balance in BTC (converted from satoshis).
+     *
+     * TODO: Add support for returning token balances in addition to BTC balance.
+     * The spark_getBalance method returns tokenBalances which we currently ignore.
+     *
+     * @returns The balance as a string in BTC, or undefined if unavailable
+     * @throws Error if the request fails
+     */
+    getBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield request('spark_getBalance', undefined);
+                if (response.status !== 'success') {
+                    throw response.error;
+                }
+                // Convert satoshis to BTC using BigInt arithmetic to maintain precision
+                const balanceInSats = BigInt(response.result.balance);
+                const satoshisPerBtc = BigInt(100000000);
+                // Calculate whole BTC and remainder satoshis
+                const wholeBtc = balanceInSats / satoshisPerBtc;
+                const remainderSats = balanceInSats % satoshisPerBtc;
+                if (remainderSats === BigInt(0)) {
+                    return wholeBtc.toString();
+                }
+                const remainderStr = remainderSats.toString().padStart(8, '0');
+                let trimmedRemainder = remainderStr;
+                while (trimmedRemainder.endsWith('0') && trimmedRemainder.length > 1) {
+                    trimmedRemainder = trimmedRemainder.slice(0, -1);
+                }
+                return trimmedRemainder
+                    ? `${wholeBtc}.${trimmedRemainder}`
+                    : wholeBtc.toString();
+            }
+            catch (error) {
+                logger.error('===SPARK=== [SparkSatsConnectConnector] Failed to get balance', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Signs a message using sats-connect spark_signMessage method.
+     *
+     * @param message - The message to sign or signing request object
+     * @returns The signature as a string, or undefined if signing fails
+     * @throws Error if the request fails or user cancels
+     */
+    signMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Extract message string from input
+                const messageToSign = typeof message === 'string' ? message : message.message;
+                if (!messageToSign) {
+                    throw new Error('Message is required for signing');
+                }
+                const response = yield request('spark_signMessage', {
+                    message: messageToSign,
+                });
+                if (response.status !== 'success') {
+                    throw response.error;
+                }
+                // Return the signature from the response
+                return response.result.signature;
+            }
+            catch (error) {
+                logger.error('===SPARK=== [SparkSatsConnectConnector] Failed to sign message', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Transfers Bitcoin to another Spark address using sats-connect.
+     *
+     * @param params - Transfer parameters
+     * @param params.receiverSparkAddress - The recipient's Spark address
+     * @param params.amountSats - Amount to transfer in satoshis
+     * @param params.isTaproot - Whether to use Taproot (currently ignored for sats-connect)
+     * @returns The transaction ID/hash
+     * @throws Error if the transfer fails or user cancels
+     */
+    transferBitcoin(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield request('spark_transfer', {
+                    amountSats: params.amountSats,
+                    receiverSparkAddress: params.receiverSparkAddress,
+                });
+                if (response.status !== 'success') {
+                    throw response.error;
+                }
+                return response.result.id;
+            }
+            catch (error) {
+                logger.error('===SPARK=== [SparkSatsConnectConnector] Failed to transfer Bitcoin', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Transfers tokens to another Spark address using sats-connect.
+     *
+     * @param params - Transfer parameters
+     * @param params.tokenPublicKey - The token's identifier (bech32m format)
+     * @param params.receiverSparkAddress - The recipient's Spark address
+     * @param params.tokenAmount - Amount of tokens to transfer
+     * @param params.isTaproot - Whether to use Taproot (currently ignored for sats-connect)
+     * @returns The transaction ID/hash
+     * @throws Error if the transfer fails or user cancels
+     */
+    transferTokens(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield request('spark_transferToken', {
+                    receiverSparkAddress: params.receiverSparkAddress,
+                    tokenAmount: params.tokenAmount,
+                    tokenIdentifier: params.tokenPublicKey,
+                });
+                if (response.status !== 'success') {
+                    throw response.error;
+                }
+                return response.result.id;
+            }
+            catch (error) {
+                logger.error('===SPARK=== [SparkSatsConnectConnector] Failed to transfer tokens', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Checks if the Spark wallet is installed in the browser.
+     *
+     * For sats-connect, we check if the library is available since it
+     * doesn't rely on a window provider pattern.
+     *
+     * @returns True if sats-connect is available
+     */
+    isInstalledOnBrowser() {
+        try {
+            // Check if sats-connect request function is available
+            return typeof request === 'function';
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+}
+
+export { SparkSatsConnectConnector };

package/src/connectors/SparkSatsConnectConnector/index.d.ts

@@ -0,0 +1 @@
+export { SparkSatsConnectConnector } from './SparkSatsConnectConnector';

package/src/connectors/index.d.ts

@@ -1,2 +1,3 @@
-export * from './SparkWalletConnector';
 export * from './MagicEdenSparkConnector';
+export * from './SparkSatsConnectConnector';
+export * from './SparkWalletConnector';

package/src/consts.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const SATSCONNECT_FEATURE = 'sats-connect:';
+
+exports.SATSCONNECT_FEATURE = SATSCONNECT_FEATURE;

package/src/consts.d.ts

@@ -0,0 +1 @@
+export declare const SATSCONNECT_FEATURE = "sats-connect:";

package/src/consts.js

@@ -0,0 +1,4 @@
+'use client'
+const SATSCONNECT_FEATURE = 'sats-connect:';
+
+export { SATSCONNECT_FEATURE };

package/src/index.cjs

@@ -5,15 +5,13 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var assertPackageVersion = require('@dynamic-labs/assert-package-version');
 var _package = require('../package.cjs');
-require('../_virtual/_tslib.cjs');
-require('@dynamic-labs/wallet-connector-core');
-var SparkWallet = require('./wallet/SparkWallet.cjs');
-var MagicEdenSparkConnector = require('./connectors/MagicEdenSparkConnector/MagicEdenSparkConnector.cjs');
+var fetchSatsConnectConnectors = require('./utils/fetchSatsConnectConnectors/fetchSatsConnectConnectors.cjs');
 var isSparkWallet = require('./wallet/isSparkWallet/isSparkWallet.cjs');
+var SparkWallet = require('./wallet/SparkWallet.cjs');
 
 assertPackageVersion.assertPackageVersion('@dynamic-labs/spark', _package.version);
-const SparkWalletConnectors = () => [MagicEdenSparkConnector.MagicEdenSparkConnector];
+const SparkWalletConnectors = (props) => [...fetchSatsConnectConnectors.fetchSatsConnectConnectors(props)];
 
-exports.SparkWallet = SparkWallet.SparkWallet;
 exports.isSparkWallet = isSparkWallet.isSparkWallet;
+exports.SparkWallet = SparkWallet.SparkWallet;
 exports.SparkWalletConnectors = SparkWalletConnectors;

package/src/index.d.ts

@@ -1,6 +1,8 @@
-import { MagicEdenSparkConnector } from './connectors';
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
 export { type ISparkProvider } from './types';
 export { type SparkWalletConnector } from './connectors/SparkWalletConnector';
 export { isSparkWallet } from './wallet/isSparkWallet';
 export { SparkWallet } from './wallet/SparkWallet';
-export declare const SparkWalletConnectors: () => (typeof MagicEdenSparkConnector)[];
+export declare const SparkWalletConnectors: (props: {
+    walletBook: WalletBookSchema;
+}) => import("dist/packages/wallet-connector-core/src").WalletConnectorConstructor[];

package/src/index.js

@@ -1,13 +1,11 @@
 'use client'
 import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
 import { version } from '../package.js';
-import '../_virtual/_tslib.js';
-import '@dynamic-labs/wallet-connector-core';
-export { SparkWallet } from './wallet/SparkWallet.js';
-import { MagicEdenSparkConnector } from './connectors/MagicEdenSparkConnector/MagicEdenSparkConnector.js';
+import { fetchSatsConnectConnectors } from './utils/fetchSatsConnectConnectors/fetchSatsConnectConnectors.js';
 export { isSparkWallet } from './wallet/isSparkWallet/isSparkWallet.js';
+export { SparkWallet } from './wallet/SparkWallet.js';
 
 assertPackageVersion('@dynamic-labs/spark', version);
-const SparkWalletConnectors = () => [MagicEdenSparkConnector];
+const SparkWalletConnectors = (props) => [...fetchSatsConnectConnectors(props)];
 
 export { SparkWalletConnectors };

package/src/utils/fetchSatsConnectConnectors/fetchSatsConnectConnectors.cjs

@@ -0,0 +1,65 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var SparkSatsConnectConnector = require('../../connectors/SparkSatsConnectConnector/SparkSatsConnectConnector.cjs');
+var consts = require('../../consts.cjs');
+
+/**
+ * Checks if a wallet configuration supports sats-connect for Spark chain.
+ *
+ * A wallet is considered valid if it has:
+ * - An injected config for the 'spark' chain
+ * - The sats-connect feature included in wallet standard features
+ * - A valid provider ID
+ *
+ * @param wallet - The wallet configuration to check
+ * @returns true if the wallet supports sats-connect on Spark, false otherwise
+ */
+const isValidSatsConnectWallet = (wallet) => {
+    var _a;
+    return Boolean((_a = wallet.injectedConfig) === null || _a === void 0 ? void 0 : _a.find((config) => {
+        var _a, _b;
+        return config.chain === 'spark' &&
+            Array.isArray((_a = config.walletStandard) === null || _a === void 0 ? void 0 : _a.features) &&
+            config.walletStandard.features.includes(consts.SATSCONNECT_FEATURE) &&
+            ((_b = config.walletStandard) === null || _b === void 0 ? void 0 : _b.providerId);
+    }));
+};
+/**
+ * Fetches all Spark wallet connectors that support sats-connect from the wallet book.
+ *
+ * This function scans the wallet book for wallets with Spark chain configuration
+ * and sats-connect support, creating connector classes for each matching wallet.
+ *
+ * @param walletBook - The wallet book schema containing all wallet configurations
+ * @returns Array of wallet connector constructors for sats-connect enabled Spark wallets
+ *
+ * @example
+ * ```typescript
+ * const sparkConnectors = fetchSatsConnectConnectors({ walletBook });
+ * // Returns connectors for wallets like Xverse Spark
+ * ```
+ */
+const fetchSatsConnectConnectors = ({ walletBook, }) => {
+    var _a;
+    return Object.entries((_a = walletBook === null || walletBook === void 0 ? void 0 : walletBook.wallets) !== null && _a !== void 0 ? _a : {})
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        .filter(([_, wallet]) => isValidSatsConnectWallet(wallet))
+        .map(([key, wallet]) => {
+        const { shortName } = wallet;
+        const name = shortName || wallet.name;
+        return class extends SparkSatsConnectConnector.SparkSatsConnectConnector {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            constructor(props) {
+                super(Object.assign(Object.assign({}, props), { overrideKey: key, walletData: wallet }));
+                this.name = name;
+                this.overrideKey = key;
+            }
+        };
+    });
+};
+
+exports.fetchSatsConnectConnectors = fetchSatsConnectConnectors;
+exports.isValidSatsConnectWallet = isValidSatsConnectWallet;

package/src/utils/fetchSatsConnectConnectors/fetchSatsConnectConnectors.d.ts

@@ -0,0 +1,32 @@
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+/**
+ * Checks if a wallet configuration supports sats-connect for Spark chain.
+ *
+ * A wallet is considered valid if it has:
+ * - An injected config for the 'spark' chain
+ * - The sats-connect feature included in wallet standard features
+ * - A valid provider ID
+ *
+ * @param wallet - The wallet configuration to check
+ * @returns true if the wallet supports sats-connect on Spark, false otherwise
+ */
+export declare const isValidSatsConnectWallet: (wallet: WalletBookSchema['wallets'][string]) => boolean;
+/**
+ * Fetches all Spark wallet connectors that support sats-connect from the wallet book.
+ *
+ * This function scans the wallet book for wallets with Spark chain configuration
+ * and sats-connect support, creating connector classes for each matching wallet.
+ *
+ * @param walletBook - The wallet book schema containing all wallet configurations
+ * @returns Array of wallet connector constructors for sats-connect enabled Spark wallets
+ *
+ * @example
+ * ```typescript
+ * const sparkConnectors = fetchSatsConnectConnectors({ walletBook });
+ * // Returns connectors for wallets like Xverse Spark
+ * ```
+ */
+export declare const fetchSatsConnectConnectors: ({ walletBook, }: {
+    walletBook: WalletBookSchema;
+}) => WalletConnectorConstructor[];

package/src/utils/fetchSatsConnectConnectors/fetchSatsConnectConnectors.js

@@ -0,0 +1,60 @@
+'use client'
+import { SparkSatsConnectConnector } from '../../connectors/SparkSatsConnectConnector/SparkSatsConnectConnector.js';
+import { SATSCONNECT_FEATURE } from '../../consts.js';
+
+/**
+ * Checks if a wallet configuration supports sats-connect for Spark chain.
+ *
+ * A wallet is considered valid if it has:
+ * - An injected config for the 'spark' chain
+ * - The sats-connect feature included in wallet standard features
+ * - A valid provider ID
+ *
+ * @param wallet - The wallet configuration to check
+ * @returns true if the wallet supports sats-connect on Spark, false otherwise
+ */
+const isValidSatsConnectWallet = (wallet) => {
+    var _a;
+    return Boolean((_a = wallet.injectedConfig) === null || _a === void 0 ? void 0 : _a.find((config) => {
+        var _a, _b;
+        return config.chain === 'spark' &&
+            Array.isArray((_a = config.walletStandard) === null || _a === void 0 ? void 0 : _a.features) &&
+            config.walletStandard.features.includes(SATSCONNECT_FEATURE) &&
+            ((_b = config.walletStandard) === null || _b === void 0 ? void 0 : _b.providerId);
+    }));
+};
+/**
+ * Fetches all Spark wallet connectors that support sats-connect from the wallet book.
+ *
+ * This function scans the wallet book for wallets with Spark chain configuration
+ * and sats-connect support, creating connector classes for each matching wallet.
+ *
+ * @param walletBook - The wallet book schema containing all wallet configurations
+ * @returns Array of wallet connector constructors for sats-connect enabled Spark wallets
+ *
+ * @example
+ * ```typescript
+ * const sparkConnectors = fetchSatsConnectConnectors({ walletBook });
+ * // Returns connectors for wallets like Xverse Spark
+ * ```
+ */
+const fetchSatsConnectConnectors = ({ walletBook, }) => {
+    var _a;
+    return Object.entries((_a = walletBook === null || walletBook === void 0 ? void 0 : walletBook.wallets) !== null && _a !== void 0 ? _a : {})
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        .filter(([_, wallet]) => isValidSatsConnectWallet(wallet))
+        .map(([key, wallet]) => {
+        const { shortName } = wallet;
+        const name = shortName || wallet.name;
+        return class extends SparkSatsConnectConnector {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            constructor(props) {
+                super(Object.assign(Object.assign({}, props), { overrideKey: key, walletData: wallet }));
+                this.name = name;
+                this.overrideKey = key;
+            }
+        };
+    });
+};
+
+export { fetchSatsConnectConnectors, isValidSatsConnectWallet };

package/src/utils/fetchSatsConnectConnectors/index.d.ts

@@ -0,0 +1 @@
+export { fetchSatsConnectConnectors } from './fetchSatsConnectConnectors';

package/src/connectors/MagicEdenSparkConnector/MagicEdenSparkConnector.cjs

@@ -1,57 +0,0 @@
-'use client'
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _tslib = require('../../../_virtual/_tslib.cjs');
-var walletBook = require('@dynamic-labs/wallet-book');
-var utils = require('@dynamic-labs/utils');
-var SparkWalletConnector = require('../SparkWalletConnector/SparkWalletConnector.cjs');
-
-/**
- * Magic Eden Spark wallet connector implementation.
- *
- * Handles Magic Eden's specific interface requirements while leveraging
- * the base class's flexible type handling.
- */
-class MagicEdenSparkConnector extends SparkWalletConnector.SparkWalletConnector {
-    /**
-     * Creates a new Magic Eden Spark connector
-     * @param opts - Configuration options
-     */
-    constructor(opts) {
-        super(opts);
-        /** Human-readable connector name */
-        this.name = 'Magic Eden Spark';
-        /** Unique identifier for this connector type */
-        this.overrideKey = 'magicedenspark';
-    }
-    /**
-     * Returns the Magic Eden Spark provider from the window object
-     * @returns The SparkProvider instance, or undefined if not available
-     */
-    getProvider() {
-        const providers = utils.getProvidersFromWindow('magicEden.spark');
-        return providers[0];
-    }
-    /**
-     * Retrieves the wallet address with Magic Eden specific error handling
-     * @returns The wallet address as a string, or undefined if unavailable
-     */
-    getAddress() {
-        const _super = Object.create(null, {
-            getAddress: { get: () => super.getAddress }
-        });
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield _super.getAddress.call(this);
-            }
-            catch (error) {
-                walletBook.logger.warn('Failed to get address from Magic Eden Spark wallet:', error);
-                return undefined;
-            }
-        });
-    }
-}
-
-exports.MagicEdenSparkConnector = MagicEdenSparkConnector;

package/src/connectors/MagicEdenSparkConnector/MagicEdenSparkConnector.js

@@ -1,53 +0,0 @@
-'use client'
-import { __awaiter } from '../../../_virtual/_tslib.js';
-import { logger } from '@dynamic-labs/wallet-book';
-import { getProvidersFromWindow } from '@dynamic-labs/utils';
-import { SparkWalletConnector } from '../SparkWalletConnector/SparkWalletConnector.js';
-
-/**
- * Magic Eden Spark wallet connector implementation.
- *
- * Handles Magic Eden's specific interface requirements while leveraging
- * the base class's flexible type handling.
- */
-class MagicEdenSparkConnector extends SparkWalletConnector {
-    /**
-     * Creates a new Magic Eden Spark connector
-     * @param opts - Configuration options
-     */
-    constructor(opts) {
-        super(opts);
-        /** Human-readable connector name */
-        this.name = 'Magic Eden Spark';
-        /** Unique identifier for this connector type */
-        this.overrideKey = 'magicedenspark';
-    }
-    /**
-     * Returns the Magic Eden Spark provider from the window object
-     * @returns The SparkProvider instance, or undefined if not available
-     */
-    getProvider() {
-        const providers = getProvidersFromWindow('magicEden.spark');
-        return providers[0];
-    }
-    /**
-     * Retrieves the wallet address with Magic Eden specific error handling
-     * @returns The wallet address as a string, or undefined if unavailable
-     */
-    getAddress() {
-        const _super = Object.create(null, {
-            getAddress: { get: () => super.getAddress }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield _super.getAddress.call(this);
-            }
-            catch (error) {
-                logger.warn('Failed to get address from Magic Eden Spark wallet:', error);
-                return undefined;
-            }
-        });
-    }
-}
-
-export { MagicEdenSparkConnector };