@dynamic-labs/stellar 4.59.1 → 4.59.2

package/src/connectors/StellarWalletConnector/StellarWalletConnector.js

@@ -0,0 +1,347 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { Horizon } from '@stellar/stellar-sdk';
+import { Logger } from '@dynamic-labs/logger';
+import { DynamicError } from '@dynamic-labs/utils';
+import { WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
+import { StellarWallet } from '../../wallet/StellarWallet.js';
+import { getNetworkFromAddress } from '../../utils/getNetworkFromAddress.js';
+import { StellarLocalStorageCache } from '../../StellarLocalStorageCache.js';
+
+/**
+ * Abstract base class for all Stellar wallet connectors.
+ *
+ * This class provides the common functionality needed by all
+ * Stellar wallet implementations. It handles connection management,
+ * network operations, and transaction signing.
+ */
+class StellarWalletConnector extends WalletConnectorBase {
+    constructor(name, opts) {
+        var _a;
+        super({
+            metadata: opts.metadata,
+            walletBook: opts.walletBook,
+        });
+        this.name = 'Stellar';
+        this.ChainWallet = StellarWallet;
+        this.connectedChain = 'STELLAR';
+        this.supportedChains = ['STELLAR'];
+        /** Connection state */
+        this.isConnecting = false;
+        /** Flag to track if connection was cancelled by disconnect */
+        this.connectionCancelled = false;
+        this.name = name;
+        this.logger = new Logger(this.name);
+        this.stellarNetworks = (_a = opts.stellarNetworks) !== null && _a !== void 0 ? _a : [];
+        this.overrideKey = this.key;
+        this.cache = new StellarLocalStorageCache(this.overrideKey);
+    }
+    getEnabledNetworks() {
+        return this.stellarNetworks;
+    }
+    getSelectedNetwork() {
+        var _a;
+        return (_a = this.stellarNetworks) === null || _a === void 0 ? void 0 : _a[0];
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddress();
+            if (!address) {
+                return undefined;
+            }
+            if (!this.stellarNetworks.length) {
+                return undefined;
+            }
+            const network = yield getNetworkFromAddress(address, this.stellarNetworks[0]);
+            if (!network) {
+                return undefined;
+            }
+            this.selectedNetwork = this.stellarNetworks.find((n) => n.chainId.toString() === network);
+            return network;
+        });
+    }
+    /**
+     * Checks if the provider is already connected.
+     */
+    isProviderConnected() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.getProvider();
+            if (!provider) {
+                return false;
+            }
+            // Check if provider has an isConnected property (not part of IStellarProvider but some wallets have it)
+            const providerWithConnection = provider;
+            if (typeof providerWithConnection.isConnected === 'boolean') {
+                return providerWithConnection.isConnected;
+            }
+            // Some providers have isConnected as a method
+            if (typeof providerWithConnection.isConnected === 'function') {
+                return providerWithConnection.isConnected();
+            }
+            // If we have a cached public key, assume connected
+            return Boolean(this.connectedPublicKey);
+        });
+    }
+    /**
+     * Connects to the Stellar wallet.
+     */
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Avoid unnecessary connection attempts
+            if (this.isConnecting) {
+                this.logger.debug('[connect] Connection already in progress');
+                return;
+            }
+            // Check if already connected
+            if (yield this.isProviderConnected()) {
+                this.logger.debug('[connect] Provider already connected');
+                return;
+            }
+            this.isConnecting = true;
+            this.connectionCancelled = false;
+            this.logger.debug('[connect] Attempting to connect');
+            try {
+                const provider = this.getProvider();
+                if (!provider) {
+                    throw new DynamicError('No Stellar provider found');
+                }
+                const publicKey = yield provider.connect();
+                // Check if disconnect was called while we were waiting for provider.connect()
+                // This prevents a race condition where disconnect() clears state but connect()
+                // subsequently sets connectedPublicKey
+                if (this.connectionCancelled) {
+                    this.logger.debug('[connect] Connection cancelled by disconnect');
+                    return;
+                }
+                this.connectedPublicKey = publicKey;
+                this.logger.debug('[connect] Connected successfully');
+            }
+            catch (error) {
+                this.logger.error('[connect] Connection failed:', error);
+                throw new DynamicError('Failed to connect to Stellar wallet');
+            }
+            finally {
+                this.isConnecting = false;
+            }
+        });
+    }
+    /**
+     * Disconnects from the wallet.
+     */
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.debug('[disconnect] Disconnecting');
+            // Cancel any ongoing connection attempt to prevent race condition
+            // where connect() might set connectedPublicKey after we clear it
+            if (this.isConnecting) {
+                this.logger.debug('[disconnect] Cancelling ongoing connection attempt');
+                this.connectionCancelled = true;
+                this.isConnecting = false;
+            }
+            const provider = this.getProvider();
+            if (!provider) {
+                // Still clear state even if no provider
+                this.connectedPublicKey = undefined;
+                this.getAddressPromise = undefined;
+                yield this.cache.clearConnectedAcccounts();
+                return;
+            }
+            try {
+                yield provider.disconnect();
+            }
+            catch (error) {
+                this.logger.debug('[disconnect] Disconnect not supported or failed:', error);
+            }
+            // Clear all cached state
+            this.connectedPublicKey = undefined;
+            this.getAddressPromise = undefined;
+            yield this.cache.clearConnectedAcccounts();
+        });
+    }
+    /**
+     * Signs a Stellar transaction XDR.
+     */
+    signTransaction(transactionXdr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.getProvider();
+            if (!provider) {
+                throw new DynamicError('No Stellar provider found');
+            }
+            return provider.sign(transactionXdr);
+        });
+    }
+    /**
+     * Signs a message.
+     */
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.getProvider();
+            if (!provider) {
+                return undefined;
+            }
+            return provider.signMessage(messageToSign);
+        });
+    }
+    getHorizonServer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            return new Horizon.Server((_b = (_a = this.selectedNetwork) === null || _a === void 0 ? void 0 : _a.rpcUrls[0]) !== null && _b !== void 0 ? _b : '');
+        });
+    }
+    isTestnet() {
+        var _a, _b;
+        const network = this.getSelectedNetwork();
+        if (!network) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve((_b = (_a = network.name) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes('testnet')) !== null && _b !== void 0 ? _b : false);
+    }
+    /**
+     * Gets the connected public key.
+     */
+    getConnectedPublicKey() {
+        return this.connectedPublicKey;
+    }
+    /**
+     * Fetches the public address from the wallet provider.
+     * This method ensures the wallet is connected before fetching the address.
+     * Override this method in child classes if the wallet has a custom way to fetch addresses.
+     * @returns The public address from the wallet
+     */
+    fetchPublicAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const provider = this.getProvider();
+            if (!provider) {
+                return '';
+            }
+            // Ensure provider is connected
+            yield this.connect();
+            // After connection, try to get the public key from the provider
+            // Different wallets may store it in different ways (not part of IStellarProvider but some wallets have these)
+            const providerWithExtras = provider;
+            if (providerWithExtras.publicKey) {
+                return providerWithExtras.publicKey;
+            }
+            // Some wallets require calling getPublicKey()
+            if (typeof providerWithExtras.getPublicKey === 'function') {
+                return providerWithExtras.getPublicKey();
+            }
+            // If we still don't have it, the connectedPublicKey should have been set by connect()
+            return (_a = this.connectedPublicKey) !== null && _a !== void 0 ? _a : '';
+        });
+    }
+    /**
+     * Gets the address from cache or fetches it from the wallet.
+     * This implementation avoids prompting the user unnecessarily by checking cache first.
+     * Uses promise caching to prevent multiple simultaneous calls.
+     */
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // If there's already a pending getAddress call, return the same promise
+            // This prevents multiple simultaneous wallet prompts
+            if (this.getAddressPromise) {
+                try {
+                    return yield this.getAddressPromise;
+                }
+                catch (error) {
+                    this.logger.error('[getAddress] Error fetching address from promise cache:', error);
+                    this.getAddressPromise = undefined;
+                    // Fall through to try again
+                }
+            }
+            // Return cached public key if already connected
+            if (this.connectedPublicKey) {
+                return this.connectedPublicKey;
+            }
+            // Create a new promise and cache it
+            this.getAddressPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    // Check cache first to avoid prompting the user
+                    const cachedAccount = yield this.cache.getActiveAccount();
+                    if (cachedAccount === null || cachedAccount === void 0 ? void 0 : cachedAccount.address) {
+                        this.connectedPublicKey = cachedAccount.address;
+                        return cachedAccount.address;
+                    }
+                    // Fetch from wallet provider
+                    const address = yield this.fetchPublicAddress();
+                    this.connectedPublicKey = address;
+                    // Cache the address
+                    if (address) {
+                        yield this.cache.setConnectedAccount(address, {
+                            active: true,
+                            additionalAddresses: [],
+                        });
+                    }
+                    return address !== null && address !== void 0 ? address : '';
+                }
+                finally {
+                    // Clear the promise cache after completion
+                    this.getAddressPromise = undefined;
+                }
+            }))();
+            return this.getAddressPromise;
+        });
+    }
+    /**
+     * Clears all connected accounts from cache.
+     */
+    clearConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.cache.clearConnectedAcccounts();
+        });
+    }
+    /**
+     * Gets connected accounts from cache.
+     */
+    getConnectedAccountsFromCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const currentAccount = yield this.cache.getActiveAccount();
+            const allAccounts = yield this.cache.getConnectedAccounts();
+            const allConnectedAddresses = (_a = Object.keys(allAccounts || {})) !== null && _a !== void 0 ? _a : [];
+            if (!(currentAccount === null || currentAccount === void 0 ? void 0 : currentAccount.address)) {
+                return allConnectedAddresses;
+            }
+            return [
+                currentAccount.address,
+                ...allConnectedAddresses.filter((address) => address !== currentAccount.address),
+            ];
+        });
+    }
+    /**
+     * Gets additional addresses for a main address.
+     */
+    getAdditionalAddresses(mainAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!mainAddress) {
+                return [];
+            }
+            const currentAccount = yield this.cache.getConnectedAccount(mainAddress);
+            return (currentAccount === null || currentAccount === void 0 ? void 0 : currentAccount.additionalAddresses) || [];
+        });
+    }
+    /**
+     * Sets additional addresses for a main address.
+     */
+    setAdditionalAddresses(mainAddress, additionalAddresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.cache.setConnectedAccount(mainAddress, {
+                additionalAddresses,
+            });
+        });
+    }
+    /**
+     * Ends the session and clears connected accounts.
+     */
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connectedPublicKey = undefined;
+            this.getAddressPromise = undefined;
+            this.connectionCancelled = false;
+            yield this.cache.clearConnectedAcccounts();
+        });
+    }
+}
+
+export { StellarWalletConnector };

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

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

package/src/index.cjs

@@ -5,16 +5,24 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var assertPackageVersion = require('@dynamic-labs/assert-package-version');
 var _package = require('../package.cjs');
+var fetchInjectedWalletConnectors = require('./injected/fetchInjectedWalletConnectors.cjs');
 var StellarWallet = require('./wallet/StellarWallet.cjs');
+var isStellarWallet = require('./wallet/isStellarWallet/isStellarWallet.cjs');
+var StellarWalletConnector = require('./connectors/StellarWalletConnector/StellarWalletConnector.cjs');
+var StellarLocalStorageCache = require('./StellarLocalStorageCache.cjs');
 var getNetworkFromAddress = require('./utils/getNetworkFromAddress.cjs');
 
 assertPackageVersion.assertPackageVersion('@dynamic-labs/stellar', _package.version);
 // Wallet connector factory (to be implemented by specific wallet connectors)
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const StellarWalletConnectors = (_props) => [
-// Specific wallet connectors will be added here by implementers
+    ...fetchInjectedWalletConnectors.fetchInjectedWalletConnectors(),
+    // Specific wallet connectors will be added here by implementers
 ];
 
 exports.StellarWallet = StellarWallet.StellarWallet;
+exports.isStellarWallet = isStellarWallet.isStellarWallet;
+exports.StellarWalletConnector = StellarWalletConnector.StellarWalletConnector;
+exports.StellarLocalStorageCache = StellarLocalStorageCache.StellarLocalStorageCache;
 exports.getNetworkFromAddress = getNetworkFromAddress.getNetworkFromAddress;
 exports.StellarWalletConnectors = StellarWalletConnectors;

package/src/index.d.ts

@@ -1,3 +1,6 @@
-export { StellarWallet } from './wallet';
+export { StellarWallet, isStellarWallet } from './wallet';
+export { StellarWalletConnector } from './connectors/StellarWalletConnector';
+export { StellarLocalStorageCache, type IStellarSessionCache, type StellarConnectedAccount, } from './StellarLocalStorageCache';
+export type { IStellarProvider, StellarConnectionResult, StellarEventCallback, StellarMethodName, StellarNetworkName, StellarProviderEvent, StellarSendBalanceProps, StellarSignTransactionOptions, StellarWalletConnectorProps, } from './types';
 export { getNetworkFromAddress } from './utils';
-export declare const StellarWalletConnectors: (_props?: unknown) => never[];
+export declare const StellarWalletConnectors: (_props?: unknown) => import("dist/packages/wallet-connector-core/src").WalletConnectorConstructor[];

package/src/index.js

@@ -1,14 +1,19 @@
 'use client'
 import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
 import { version } from '../package.js';
+import { fetchInjectedWalletConnectors } from './injected/fetchInjectedWalletConnectors.js';
 export { StellarWallet } from './wallet/StellarWallet.js';
+export { isStellarWallet } from './wallet/isStellarWallet/isStellarWallet.js';
+export { StellarWalletConnector } from './connectors/StellarWalletConnector/StellarWalletConnector.js';
+export { StellarLocalStorageCache } from './StellarLocalStorageCache.js';
 export { getNetworkFromAddress } from './utils/getNetworkFromAddress.js';
 
 assertPackageVersion('@dynamic-labs/stellar', version);
 // Wallet connector factory (to be implemented by specific wallet connectors)
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const StellarWalletConnectors = (_props) => [
-// Specific wallet connectors will be added here by implementers
+    ...fetchInjectedWalletConnectors(),
+    // Specific wallet connectors will be added here by implementers
 ];
 
 export { StellarWalletConnectors };

package/src/injected/fetchInjectedWalletConnectors.cjs

@@ -0,0 +1,50 @@
+'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 logger$1 = require('@dynamic-labs/logger');
+
+const logger = new logger$1.Logger('fetchInjectedWalletConnectors');
+const stellarWalletConnectors = [];
+const checkAndEmitWalletConnector = (walletConnector) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        yield ((_a = walletConnector.isConnected) === null || _a === void 0 ? void 0 : _a.call(walletConnector));
+        return walletConnector;
+    }
+    catch (error) {
+        logger.logVerboseTroubleshootingMessage(`[STELLAR fetchInjectedWalletConnectors] Error checking ${walletConnector.name}:`, error);
+    }
+    return undefined;
+});
+const setupStellarWalletListener = () => {
+    if (typeof window === 'undefined') {
+        return;
+    }
+    const discoveredWallets = new Set();
+    const checkForNewWallets = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        for (const walletConnector of stellarWalletConnectors) {
+            if (discoveredWallets.has(walletConnector.name)) {
+                continue;
+            }
+            const connector = yield checkAndEmitWalletConnector(walletConnector);
+            if (connector) {
+                discoveredWallets.add(walletConnector.name);
+                logger.logVerboseTroubleshootingMessage(`[STELLAR fetchInjectedWalletConnectors] Emitting providerInjected for ${walletConnector.name}`);
+                walletConnectorCore.walletConnectorEvents.emit('providerInjected', {
+                    injectedConnectorConstructor: connector,
+                });
+            }
+        }
+    });
+    void checkForNewWallets();
+};
+const fetchInjectedWalletConnectors = () => {
+    setupStellarWalletListener();
+    return [...stellarWalletConnectors];
+};
+
+exports.fetchInjectedWalletConnectors = fetchInjectedWalletConnectors;

package/src/injected/fetchInjectedWalletConnectors.d.ts

@@ -0,0 +1,16 @@
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+interface StellarWalletConnectorWithIsConnected extends WalletConnectorConstructor {
+    isConnected?: () => Promise<boolean>;
+}
+/**
+ * Registers a Stellar wallet connector for injection discovery.
+ * @internal - Used for testing and internal registration
+ */
+export declare const registerStellarWalletConnector: (connector: StellarWalletConnectorWithIsConnected) => void;
+/**
+ * Clears all registered Stellar wallet connectors.
+ * @internal - Used for testing cleanup
+ */
+export declare const clearStellarWalletConnectors: () => void;
+export declare const fetchInjectedWalletConnectors: () => WalletConnectorConstructor[];
+export {};

package/src/injected/fetchInjectedWalletConnectors.js

@@ -0,0 +1,46 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { walletConnectorEvents } from '@dynamic-labs/wallet-connector-core';
+import { Logger } from '@dynamic-labs/logger';
+
+const logger = new Logger('fetchInjectedWalletConnectors');
+const stellarWalletConnectors = [];
+const checkAndEmitWalletConnector = (walletConnector) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        yield ((_a = walletConnector.isConnected) === null || _a === void 0 ? void 0 : _a.call(walletConnector));
+        return walletConnector;
+    }
+    catch (error) {
+        logger.logVerboseTroubleshootingMessage(`[STELLAR fetchInjectedWalletConnectors] Error checking ${walletConnector.name}:`, error);
+    }
+    return undefined;
+});
+const setupStellarWalletListener = () => {
+    if (typeof window === 'undefined') {
+        return;
+    }
+    const discoveredWallets = new Set();
+    const checkForNewWallets = () => __awaiter(void 0, void 0, void 0, function* () {
+        for (const walletConnector of stellarWalletConnectors) {
+            if (discoveredWallets.has(walletConnector.name)) {
+                continue;
+            }
+            const connector = yield checkAndEmitWalletConnector(walletConnector);
+            if (connector) {
+                discoveredWallets.add(walletConnector.name);
+                logger.logVerboseTroubleshootingMessage(`[STELLAR fetchInjectedWalletConnectors] Emitting providerInjected for ${walletConnector.name}`);
+                walletConnectorEvents.emit('providerInjected', {
+                    injectedConnectorConstructor: connector,
+                });
+            }
+        }
+    });
+    void checkForNewWallets();
+};
+const fetchInjectedWalletConnectors = () => {
+    setupStellarWalletListener();
+    return [...stellarWalletConnectors];
+};
+
+export { fetchInjectedWalletConnectors };

package/src/types/FreighterProvider.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Freighter Wallet Provider Types
+ *
+ * Types for the Freighter wallet API
+ * From @stellar/freighter-api package
+ */
+/// <reference types="node" />
+/**
+ * Freighter API error type
+ */
+export type FreighterApiError = {
+    code: number;
+    message: string;
+};
+/**
+ * Freighter API response wrapper
+ * All Freighter API methods return responses in this format
+ */
+export type FreighterApiResponse<T> = T & {
+    error?: FreighterApiError;
+};
+/**
+ * Freighter API methods
+ * These are the raw methods provided by @stellar/freighter-api package
+ *
+ * Note: Freighter uses a functional API (individual exported functions)
+ * rather than a provider object at window.freighter
+ */
+export type FreighterApi = {
+    /** Get the user's address */
+    getAddress: () => Promise<FreighterApiResponse<{
+        address: string;
+    }>>;
+    /** Get current network */
+    getNetwork: () => Promise<string>;
+    /** Check if extension is installed and accessible */
+    isConnected: () => Promise<boolean>;
+    /** Check if user has granted access */
+    isAllowed: () => Promise<boolean>;
+    /** Request access to the wallet */
+    requestAccess: () => Promise<FreighterApiResponse<{
+        address: string;
+    }>>;
+    /** Sign a transaction */
+    signTransaction: (transactionXdr: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+    }) => Promise<FreighterApiResponse<{
+        signedTxXdr: string;
+        signerAddress: string;
+    }>>;
+    /** Sign a message */
+    signMessage: (message: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+    }) => Promise<FreighterApiResponse<{
+        signedMessage: string | Buffer | null;
+        signerAddress: string;
+    }>>;
+    /** Sign an auth entry */
+    signAuthEntry: (entry: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+    }) => Promise<FreighterApiResponse<{
+        signedAuthEntry: string;
+        signerAddress: string;
+    }>>;
+    /** Set allowed status (internal use) */
+    setAllowed: () => Promise<void>;
+};
+/**
+ * Type guard to check if a Freighter API response has an error
+ */
+export declare const isFreighterError: <T>(response: FreighterApiResponse<T>) => response is T & {
+    error?: FreighterApiError | undefined;
+} & {
+    error: FreighterApiError;
+};
+/**
+ * Handle Freighter API response and throw if there's an error
+ */
+export declare const handleFreighterResponse: <T>(response: FreighterApiResponse<T>) => T;

package/src/types/LobstrProvider.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Lobstr Signer Extension Provider Types
+ *
+ * Types for the Lobstr Signer Extension API
+ * From @lobstrco/signer-extension-api package
+ */
+/**
+ * Lobstr Signer Extension API
+ * These are the raw methods provided by @lobstrco/signer-extension-api package
+ *
+ * Note: Lobstr uses a functional API (individual exported functions)
+ * rather than a provider object at window.lobstr
+ */
+export type LobstrSignerApi = {
+    /** Get the user's public key */
+    getPublicKey: () => Promise<string>;
+    /** Sign a transaction */
+    signTransaction: (transactionXdr: string) => Promise<string>;
+    /** Check if extension is installed and accessible */
+    isConnected: () => Promise<boolean>;
+    /** Sign a message */
+    signMessage: (message: string) => Promise<{
+        signedMessage: string;
+        signerAddress: string;
+    } | null>;
+};
+/**
+ * Lobstr sign message response
+ */
+export type LobstrSignMessageResponse = {
+    signedMessage: string;
+    signerAddress: string;
+} | null;

package/src/types.d.ts

@@ -1,6 +1,5 @@
-import type { Transaction } from '@stellar/stellar-sdk';
 import type { GenericNetwork } from '@dynamic-labs/types';
-import type { ProviderCondition } from '@dynamic-labs/wallet-connector-core';
+import type { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
 /**
  * Interface for Stellar wallet providers.
  *
@@ -100,16 +99,6 @@ export type StellarWalletConnectorProps = {
     /** Wallet book schema */
     walletBook: unknown;
 };
-/**
- * Extension locators for identifying Stellar wallet browser extensions.
- * These flags are typically set on the injected provider object to identify
- * which wallet extension is present.
- */
-export type ExtensionLocator = 'isAlbedo' | 'isFreighter' | 'isLobstr' | 'isRabet' | 'isXBull';
-/**
- * Type for Stellar provider condition used in provider lookup.
- */
-export type StellarProviderCondition = ProviderCondition<ExtensionLocator>;
 /**
  * Stellar network names
  */
@@ -119,6 +108,9 @@ export type StellarNetworkName = 'FUTURENET' | 'PUBLIC' | 'TESTNET';
  */
 export type StellarMethodName = 'close' | 'connect' | 'disconnect' | 'getNetwork' | 'isUnlocked' | 'on' | 'sign' | 'signMessage';
 /**
- * Stellar transaction type from the SDK
+ * Stellar wallet connector with isConnected check.
+ * Extends WalletConnectorConstructor with an optional isConnected method.
  */
-export type StellarTransaction = Transaction;
+export interface StellarWalletConnectorWithIsConnected extends WalletConnectorConstructor {
+    isConnected?: () => Promise<boolean>;
+}