@dynamic-labs/spark 4.30.0

package/src/connectors/SparkWalletConnector/SparkWalletConnector.cjs

@@ -0,0 +1,247 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var provider = require('../../utils/provider.cjs');
+var address = require('../../utils/address.cjs');
+var SparkWallet = require('../../wallet/SparkWallet.cjs');
+
+/**
+ * Abstract base class for all Spark wallet connectors.
+ *
+ * Provides complete Dynamic SDK wallet connector implementation for Spark wallets.
+ * Concrete connectors only need to implement `getProvider()`.
+ */
+class SparkWalletConnector extends walletConnectorCore.WalletConnectorBase {
+    /**
+     * Creates a new Spark wallet connector
+     * @param opts - Configuration options
+     */
+    constructor(opts) {
+        super(opts);
+        /** The wallet class to instantiate */
+        this.ChainWallet = SparkWallet.SparkWallet;
+        /** Human-readable connector name */
+        this.name = 'Spark';
+        /** Unique identifier for this connector type */
+        this.overrideKey = 'injectedspark';
+        /** The blockchain this connector supports */
+        this.connectedChain = 'SPARK';
+        /** All supported blockchain types */
+        this.supportedChains = ['SPARK'];
+        this.sparkNetworks = opts.sparkNetworks || [];
+    }
+    /**
+     * Establishes a connection to the Spark wallet
+     * @throws {Error} If no Spark provider is available
+     */
+    connect() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const provider$1 = provider.assertProvider(this.getProvider(), 'Spark');
+            if (provider$1.connect) {
+                yield provider$1.connect();
+            }
+        });
+    }
+    /**
+     * Ends the current wallet session
+     */
+    endSession() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const provider$1 = provider.assertProvider(this.getProvider(), 'Spark');
+                if (provider$1 === null || provider$1 === void 0 ? void 0 : provider$1.disconnect) {
+                    yield provider$1.disconnect();
+                }
+                this.emit('disconnect');
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('Failed to disconnect Spark wallet:', error);
+            }
+        });
+    }
+    /**
+     * Retrieves the current wallet address
+     * @returns The wallet address as a string, or undefined if unavailable
+     */
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const provider$1 = provider.assertProvider(this.getProvider(), 'Spark');
+                if (provider$1.getAddress) {
+                    const addressResult = yield provider$1.getAddress();
+                    const address$1 = address.extractAddress(addressResult);
+                    if (address$1) {
+                        return address$1;
+                    }
+                }
+                throw new Error('No address available from Spark provider');
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('Failed to get Spark address:', error);
+                return undefined;
+            }
+        });
+    }
+    /**
+     * Gets the current network chain ID
+     * @returns The network chain ID as a string (defaults to mainnet '301')
+     */
+    getNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            // MagicEden and XVerse are only supporting mainnet at the moment
+            // This should be expanded is anyone ever supports testnet or regtest
+            // We can detect netowrk using addresses in the future if we want
+            return '301';
+        });
+    }
+    /**
+     * Returns all enabled Spark networks for this connector
+     * @returns Array of GenericNetwork configurations
+     */
+    getEnabledNetworks() {
+        return this.sparkNetworks;
+    }
+    /**
+     * Attempts to switch to a different network
+     * @note Spark wallets do not support dynamic network switching
+     */
+    switchNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            walletConnectorCore.logger.warn('Spark wallet does not support dynamic network switching');
+        });
+    }
+    /**
+     * Gets block explorer URLs for the current network
+     * @returns Array of block explorer URLs (defaults to mempool.space)
+     */
+    getBlockExplorerUrlsForCurrentNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const chainId = yield this.getNetwork();
+                const networkConfig = this.sparkNetworks.find((n) => n.chainId === chainId);
+                return (networkConfig === null || networkConfig === void 0 ? void 0 : networkConfig.blockExplorerUrls) || ['https://mempool.space/'];
+            }
+            catch (error) {
+                walletConnectorCore.logger.warn('Failed to get block explorer URLs, using default:', error);
+                return ['https://mempool.space/'];
+            }
+        });
+    }
+    /**
+     * Signs a message using the connected wallet
+     * @param message - The message to sign or signing request object
+     * @returns The signature as a string, or undefined if signing fails
+     */
+    signMessage(message) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                if (!message) {
+                    throw new Error('Message is required for signing');
+                }
+                const provider$1 = provider.assertProvider(this.getProvider(), 'Spark');
+                if (!provider$1.signMessage) {
+                    throw new Error('Message signing not supported by Spark provider');
+                }
+                // Extract message and isTaproot with defaults
+                const messageToSign = typeof message === 'string' ? message : message.message;
+                const isTaproot = typeof message === 'object' ? (_a = message.isTaproot) !== null && _a !== void 0 ? _a : false : false;
+                const result = yield provider$1.signMessage({
+                    isTaproot,
+                    message: messageToSign,
+                });
+                // Handle different return formats
+                if (result && typeof result === 'object' && 'signature' in result) {
+                    return result.signature;
+                }
+                if (typeof result === 'string') {
+                    return result;
+                }
+                throw new Error('Unexpected signature format from provider');
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('Failed to sign message with Spark wallet:', error);
+                throw new Error(`Failed to sign message with Spark wallet: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    /**
+     * Signs a message using Taproot protocol
+     * @param message - The message to sign
+     * @returns Promise resolving to signature result
+     */
+    signMessageWithTaproot(message) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.signMessage({
+                isTaproot: true, // Always use Taproot for this method
+                message: message,
+            });
+        });
+    }
+    /**
+     * Transfers Bitcoin to another Spark address
+     * @param params - Transfer parameters
+     * @returns Promise resolving to transaction hash
+     */
+    transferBitcoin(params) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const provider$1 = provider.assertProvider(this.getProvider(), 'Spark');
+                if (!provider$1.transferBitcoin) {
+                    throw new Error('Bitcoin transfer not supported by Spark provider');
+                }
+                const txHash = yield provider$1.transferBitcoin(params);
+                return txHash;
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('Failed to transfer Bitcoin using Spark wallet:', error);
+                throw new Error(`Failed to transfer Bitcoin using Spark wallet: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    /**
+     * Transfers tokens to another Spark address
+     * @param params - Transfer parameters
+     * @returns Promise resolving to transaction hash
+     */
+    transferTokens(params) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const provider$1 = provider.assertProvider(this.getProvider(), 'Spark');
+                if (!provider$1.transferTokens) {
+                    throw new Error('Token transfer not supported by Spark provider');
+                }
+                const txHash = yield provider$1.transferTokens(params);
+                return txHash;
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('Failed to transfer tokens using Spark wallet:', error);
+                throw new Error(`Failed to transfer tokens using Spark wallet: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    /**
+     * Proves ownership of a wallet address by signing a message
+     * @param address - The address to prove ownership of
+     * @param messageToSign - The message to sign for authentication
+     * @returns The signature as a string, or undefined if authentication fails
+     */
+    proveOwnership(_address, messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.signMessage(messageToSign);
+        });
+    }
+    /**
+     * Checks if the Spark wallet is installed in the browser
+     * @returns True if a provider is available, false otherwise
+     */
+    isInstalledOnBrowser() {
+        return Boolean(this.getProvider());
+    }
+}
+
+exports.SparkWalletConnector = SparkWalletConnector;

package/src/connectors/SparkWalletConnector/SparkWalletConnector.d.ts

@@ -0,0 +1,128 @@
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import { Chain, WalletConnectorBase, WalletMetadata } from '@dynamic-labs/wallet-connector-core';
+import { GenericNetwork } from '@dynamic-labs/types';
+import type { ISparkProvider } from '../../types';
+import { SparkWallet } from '../../wallet/SparkWallet';
+/**
+ * Configuration options for Spark wallet connectors
+ */
+export type SparkWalletConnectorOpts = {
+    /** Wallet book schema for metadata */
+    walletBook: WalletBookSchema;
+    /** Optional wallet metadata */
+    metadata?: WalletMetadata;
+    /** Custom Spark networks configuration */
+    sparkNetworks?: GenericNetwork[];
+};
+/**
+ * Abstract base class for all Spark wallet connectors.
+ *
+ * Provides complete Dynamic SDK wallet connector implementation for Spark wallets.
+ * Concrete connectors only need to implement `getProvider()`.
+ */
+export declare abstract class SparkWalletConnector extends WalletConnectorBase<typeof SparkWallet> {
+    /** The wallet class to instantiate */
+    ChainWallet: typeof SparkWallet;
+    /** Human-readable connector name */
+    name: string;
+    /** Unique identifier for this connector type */
+    overrideKey: string;
+    /** The blockchain this connector supports */
+    connectedChain: Chain;
+    /** All supported blockchain types */
+    supportedChains: Chain[];
+    /** Available Spark networks for this connector */
+    protected sparkNetworks: GenericNetwork[];
+    /**
+     * Creates a new Spark wallet connector
+     * @param opts - Configuration options
+     */
+    constructor(opts: SparkWalletConnectorOpts);
+    /**
+     * Establishes a connection to the Spark wallet
+     * @throws {Error} If no Spark provider is available
+     */
+    connect(): Promise<void>;
+    /**
+     * Ends the current wallet session
+     */
+    endSession(): Promise<void>;
+    /**
+     * Retrieves the current wallet address
+     * @returns The wallet address as a string, or undefined if unavailable
+     */
+    getAddress(): Promise<string | undefined>;
+    /**
+     * Gets the current network chain ID
+     * @returns The network chain ID as a string (defaults to mainnet '301')
+     */
+    getNetwork(): Promise<string | undefined>;
+    /**
+     * Returns all enabled Spark networks for this connector
+     * @returns Array of GenericNetwork configurations
+     */
+    getEnabledNetworks(): GenericNetwork[];
+    /**
+     * Attempts to switch to a different network
+     * @note Spark wallets do not support dynamic network switching
+     */
+    switchNetwork(): Promise<void>;
+    /**
+     * Gets block explorer URLs for the current network
+     * @returns Array of block explorer URLs (defaults to mempool.space)
+     */
+    getBlockExplorerUrlsForCurrentNetwork(): Promise<string[]>;
+    /**
+     * Signs a message using the connected wallet
+     * @param message - The message to sign or signing request object
+     * @returns The signature as a string, or undefined if signing fails
+     */
+    signMessage(message: string | {
+        message: string;
+        isTaproot?: boolean;
+    }): Promise<string | undefined>;
+    /**
+     * Signs a message using Taproot protocol
+     * @param message - The message to sign
+     * @returns Promise resolving to signature result
+     */
+    signMessageWithTaproot(message: string): Promise<string | undefined>;
+    /**
+     * Transfers Bitcoin to another Spark address
+     * @param params - Transfer parameters
+     * @returns Promise resolving to transaction hash
+     */
+    transferBitcoin(params: {
+        receiverSparkAddress: string;
+        amountSats: bigint;
+        isTaproot?: boolean;
+    }): Promise<string | undefined>;
+    /**
+     * Transfers tokens to another Spark address
+     * @param params - Transfer parameters
+     * @returns Promise resolving to transaction hash
+     */
+    transferTokens(params: {
+        tokenPublicKey: string;
+        receiverSparkAddress: string;
+        tokenAmount: number;
+        isTaproot?: boolean;
+    }): Promise<string | undefined>;
+    /**
+     * Proves ownership of a wallet address by signing a message
+     * @param address - The address to prove ownership of
+     * @param messageToSign - The message to sign for authentication
+     * @returns The signature as a string, or undefined if authentication fails
+     */
+    proveOwnership(_address: string, messageToSign: string): Promise<string | undefined>;
+    /**
+     * Checks if the Spark wallet is installed in the browser
+     * @returns True if a provider is available, false otherwise
+     */
+    isInstalledOnBrowser(): boolean;
+    /**
+     * Abstract method that concrete connectors must implement
+     * @returns The Spark provider instance, or undefined if not available
+     */
+    abstract getProvider(): ISparkProvider | undefined;
+}

package/src/connectors/SparkWalletConnector/SparkWalletConnector.js

@@ -0,0 +1,243 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { WalletConnectorBase, logger } from '@dynamic-labs/wallet-connector-core';
+import { assertProvider } from '../../utils/provider.js';
+import { extractAddress } from '../../utils/address.js';
+import { SparkWallet } from '../../wallet/SparkWallet.js';
+
+/**
+ * Abstract base class for all Spark wallet connectors.
+ *
+ * Provides complete Dynamic SDK wallet connector implementation for Spark wallets.
+ * Concrete connectors only need to implement `getProvider()`.
+ */
+class SparkWalletConnector extends WalletConnectorBase {
+    /**
+     * Creates a new Spark wallet connector
+     * @param opts - Configuration options
+     */
+    constructor(opts) {
+        super(opts);
+        /** The wallet class to instantiate */
+        this.ChainWallet = SparkWallet;
+        /** Human-readable connector name */
+        this.name = 'Spark';
+        /** Unique identifier for this connector type */
+        this.overrideKey = 'injectedspark';
+        /** The blockchain this connector supports */
+        this.connectedChain = 'SPARK';
+        /** All supported blockchain types */
+        this.supportedChains = ['SPARK'];
+        this.sparkNetworks = opts.sparkNetworks || [];
+    }
+    /**
+     * Establishes a connection to the Spark wallet
+     * @throws {Error} If no Spark provider is available
+     */
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = assertProvider(this.getProvider(), 'Spark');
+            if (provider.connect) {
+                yield provider.connect();
+            }
+        });
+    }
+    /**
+     * Ends the current wallet session
+     */
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const provider = assertProvider(this.getProvider(), 'Spark');
+                if (provider === null || provider === void 0 ? void 0 : provider.disconnect) {
+                    yield provider.disconnect();
+                }
+                this.emit('disconnect');
+            }
+            catch (error) {
+                logger.error('Failed to disconnect Spark wallet:', error);
+            }
+        });
+    }
+    /**
+     * Retrieves the current wallet address
+     * @returns The wallet address as a string, or undefined if unavailable
+     */
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const provider = assertProvider(this.getProvider(), 'Spark');
+                if (provider.getAddress) {
+                    const addressResult = yield provider.getAddress();
+                    const address = extractAddress(addressResult);
+                    if (address) {
+                        return address;
+                    }
+                }
+                throw new Error('No address available from Spark provider');
+            }
+            catch (error) {
+                logger.error('Failed to get Spark address:', error);
+                return undefined;
+            }
+        });
+    }
+    /**
+     * Gets the current network chain ID
+     * @returns The network chain ID as a string (defaults to mainnet '301')
+     */
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // MagicEden and XVerse are only supporting mainnet at the moment
+            // This should be expanded is anyone ever supports testnet or regtest
+            // We can detect netowrk using addresses in the future if we want
+            return '301';
+        });
+    }
+    /**
+     * Returns all enabled Spark networks for this connector
+     * @returns Array of GenericNetwork configurations
+     */
+    getEnabledNetworks() {
+        return this.sparkNetworks;
+    }
+    /**
+     * Attempts to switch to a different network
+     * @note Spark wallets do not support dynamic network switching
+     */
+    switchNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.warn('Spark wallet does not support dynamic network switching');
+        });
+    }
+    /**
+     * Gets block explorer URLs for the current network
+     * @returns Array of block explorer URLs (defaults to mempool.space)
+     */
+    getBlockExplorerUrlsForCurrentNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const chainId = yield this.getNetwork();
+                const networkConfig = this.sparkNetworks.find((n) => n.chainId === chainId);
+                return (networkConfig === null || networkConfig === void 0 ? void 0 : networkConfig.blockExplorerUrls) || ['https://mempool.space/'];
+            }
+            catch (error) {
+                logger.warn('Failed to get block explorer URLs, using default:', error);
+                return ['https://mempool.space/'];
+            }
+        });
+    }
+    /**
+     * Signs a message using the connected wallet
+     * @param message - The message to sign or signing request object
+     * @returns The signature as a string, or undefined if signing fails
+     */
+    signMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                if (!message) {
+                    throw new Error('Message is required for signing');
+                }
+                const provider = assertProvider(this.getProvider(), 'Spark');
+                if (!provider.signMessage) {
+                    throw new Error('Message signing not supported by Spark provider');
+                }
+                // Extract message and isTaproot with defaults
+                const messageToSign = typeof message === 'string' ? message : message.message;
+                const isTaproot = typeof message === 'object' ? (_a = message.isTaproot) !== null && _a !== void 0 ? _a : false : false;
+                const result = yield provider.signMessage({
+                    isTaproot,
+                    message: messageToSign,
+                });
+                // Handle different return formats
+                if (result && typeof result === 'object' && 'signature' in result) {
+                    return result.signature;
+                }
+                if (typeof result === 'string') {
+                    return result;
+                }
+                throw new Error('Unexpected signature format from provider');
+            }
+            catch (error) {
+                logger.error('Failed to sign message with Spark wallet:', error);
+                throw new Error(`Failed to sign message with Spark wallet: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    /**
+     * Signs a message using Taproot protocol
+     * @param message - The message to sign
+     * @returns Promise resolving to signature result
+     */
+    signMessageWithTaproot(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signMessage({
+                isTaproot: true, // Always use Taproot for this method
+                message: message,
+            });
+        });
+    }
+    /**
+     * Transfers Bitcoin to another Spark address
+     * @param params - Transfer parameters
+     * @returns Promise resolving to transaction hash
+     */
+    transferBitcoin(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const provider = assertProvider(this.getProvider(), 'Spark');
+                if (!provider.transferBitcoin) {
+                    throw new Error('Bitcoin transfer not supported by Spark provider');
+                }
+                const txHash = yield provider.transferBitcoin(params);
+                return txHash;
+            }
+            catch (error) {
+                logger.error('Failed to transfer Bitcoin using Spark wallet:', error);
+                throw new Error(`Failed to transfer Bitcoin using Spark wallet: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    /**
+     * Transfers tokens to another Spark address
+     * @param params - Transfer parameters
+     * @returns Promise resolving to transaction hash
+     */
+    transferTokens(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const provider = assertProvider(this.getProvider(), 'Spark');
+                if (!provider.transferTokens) {
+                    throw new Error('Token transfer not supported by Spark provider');
+                }
+                const txHash = yield provider.transferTokens(params);
+                return txHash;
+            }
+            catch (error) {
+                logger.error('Failed to transfer tokens using Spark wallet:', error);
+                throw new Error(`Failed to transfer tokens using Spark wallet: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    /**
+     * Proves ownership of a wallet address by signing a message
+     * @param address - The address to prove ownership of
+     * @param messageToSign - The message to sign for authentication
+     * @returns The signature as a string, or undefined if authentication fails
+     */
+    proveOwnership(_address, messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signMessage(messageToSign);
+        });
+    }
+    /**
+     * Checks if the Spark wallet is installed in the browser
+     * @returns True if a provider is available, false otherwise
+     */
+    isInstalledOnBrowser() {
+        return Boolean(this.getProvider());
+    }
+}
+
+export { SparkWalletConnector };

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

@@ -0,0 +1 @@
+export * from './SparkWalletConnector';

package/src/connectors/index.d.ts

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

package/src/index.cjs

@@ -0,0 +1,19 @@
+'use client'
+'use strict';
+
+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 isSparkWallet = require('./wallet/isSparkWallet/isSparkWallet.cjs');
+
+assertPackageVersion.assertPackageVersion('@dynamic-labs/spark', _package.version);
+const SparkWalletConnectors = () => [MagicEdenSparkConnector.MagicEdenSparkConnector];
+
+exports.SparkWallet = SparkWallet.SparkWallet;
+exports.isSparkWallet = isSparkWallet.isSparkWallet;
+exports.SparkWalletConnectors = SparkWalletConnectors;

package/src/index.d.ts

@@ -0,0 +1,6 @@
+import { MagicEdenSparkConnector } from './connectors';
+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)[];

package/src/index.js

@@ -0,0 +1,13 @@
+'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';
+export { isSparkWallet } from './wallet/isSparkWallet/isSparkWallet.js';
+
+assertPackageVersion('@dynamic-labs/spark', version);
+const SparkWalletConnectors = () => [MagicEdenSparkConnector];
+
+export { SparkWalletConnectors };