@dynamic-labs/stellar 4.58.1 → 4.59.2

package/CHANGELOG.md

@@ -1,4 +1,33 @@
 
+### [4.59.2](https://github.com/dynamic-labs/dynamic-auth/compare/v4.59.1...v4.59.2) (2026-02-03)
+
+
+### Features
+
+* add more copykeys in the send widget. ([#10271](https://github.com/dynamic-labs/dynamic-auth/issues/10271)) ([d62c4c5](https://github.com/dynamic-labs/dynamic-auth/commit/d62c4c50feaebb2449b1b3b8372638257761a729))
+* add StellarWalletConnector ([#10249](https://github.com/dynamic-labs/dynamic-auth/issues/10249)) ([152b400](https://github.com/dynamic-labs/dynamic-auth/commit/152b4001fd17f3f11581e66502edd6e17b51ecd0))
+
+
+### Bug Fixes
+
+* filter delegated wallets to only include EVM and Solana chains ([#10237](https://github.com/dynamic-labs/dynamic-auth/issues/10237)) ([53f9b00](https://github.com/dynamic-labs/dynamic-auth/commit/53f9b003b95dcd11ea380893f28085362e42f252))
+
+### [4.59.1](https://github.com/dynamic-labs/dynamic-auth/compare/v4.59.0...v4.59.1) (2026-01-30)
+
+This was a version bump only, there were no code changes.
+
+## [4.59.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.58.1...v4.59.0) (2026-01-30)
+
+
+### Features
+
+* add password requirement to auto-create wallet flow ([#10324](https://github.com/dynamic-labs/dynamic-auth/issues/10324)) ([f81162d](https://github.com/dynamic-labs/dynamic-auth/commit/f81162dfb8607580192d0683ed6ecb82481d97fd))
+
+
+### Bug Fixes
+
+* ensure useReinitialize will load state from local storage ([#10312](https://github.com/dynamic-labs/dynamic-auth/issues/10312)) ([647ac6c](https://github.com/dynamic-labs/dynamic-auth/commit/647ac6c35a7a3a747897943b4667d63e57968227))
+
 ### [4.58.1](https://github.com/dynamic-labs/dynamic-auth/compare/v4.58.0...v4.58.1) (2026-01-29)
 
 

package/package.cjs

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

package/package.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/stellar",
-  "version": "4.58.1",
+  "version": "4.59.2",
   "description": "A React SDK for implementing Stellar wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -18,10 +18,14 @@
   },
   "homepage": "https://www.dynamic.xyz/",
   "dependencies": {
+    "@dynamic-labs/sdk-api-core": "0.0.860",
     "@stellar/stellar-sdk": "14.4.3",
-    "@dynamic-labs/wallet-connector-core": "4.58.1",
-    "@dynamic-labs/assert-package-version": "4.58.1",
-    "@dynamic-labs/types": "4.58.1"
+    "@dynamic-labs/wallet-connector-core": "4.59.2",
+    "@dynamic-labs/assert-package-version": "4.59.2",
+    "@dynamic-labs/logger": "4.59.2",
+    "@dynamic-labs/types": "4.59.2",
+    "@dynamic-labs/utils": "4.59.2",
+    "@dynamic-labs/wallet-book": "4.59.2"
   },
   "peerDependencies": {}
 }

package/src/StellarLocalStorageCache.cjs

@@ -0,0 +1,65 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+
+class StellarLocalStorageCache {
+    constructor(key) {
+        this.CONNECTED_ACCOUNTS_KEY = `stellar_${key}_connectedAccounts`;
+    }
+    getActiveAccount() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const connectedAccounts = yield utils.getItemAsync(this.CONNECTED_ACCOUNTS_KEY);
+            if (!connectedAccounts) {
+                return;
+            }
+            const activeAddress = Object.keys(connectedAccounts).find((key) => connectedAccounts[key].active);
+            if (!activeAddress) {
+                return;
+            }
+            return {
+                additionalAddresses: connectedAccounts[activeAddress].additionalAddresses,
+                address: activeAddress,
+            };
+        });
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const connectedAccounts = yield utils.getItemAsync(this.CONNECTED_ACCOUNTS_KEY);
+            return connectedAccounts;
+        });
+    }
+    getConnectedAccount(address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const connectedAccounts = yield utils.getItemAsync(this.CONNECTED_ACCOUNTS_KEY);
+            return connectedAccounts === null || connectedAccounts === void 0 ? void 0 : connectedAccounts[address];
+        });
+    }
+    setConnectedAccount(address, account) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            let connectedAccounts = yield utils.getItemAsync(this.CONNECTED_ACCOUNTS_KEY);
+            if (!connectedAccounts) {
+                connectedAccounts = {};
+            }
+            if (account.active) {
+                Object.keys(connectedAccounts).forEach((key) => {
+                    if (connectedAccounts) {
+                        connectedAccounts[key].active = false;
+                    }
+                });
+            }
+            connectedAccounts[address] = account;
+            return utils.setItemAsync(this.CONNECTED_ACCOUNTS_KEY, connectedAccounts);
+        });
+    }
+    clearConnectedAcccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return utils.removeItemAsync(this.CONNECTED_ACCOUNTS_KEY);
+        });
+    }
+}
+
+exports.StellarLocalStorageCache = StellarLocalStorageCache;

package/src/StellarLocalStorageCache.d.ts

@@ -0,0 +1,29 @@
+import { WalletAdditionalAddress } from '@dynamic-labs/sdk-api-core';
+export type StellarConnectedAccount = {
+    additionalAddresses: WalletAdditionalAddress[];
+    active?: boolean;
+};
+type StellarConnectedAccounts = {
+    [key: string]: StellarConnectedAccount;
+};
+type StellarActiveAccount = {
+    address: string;
+    additionalAddresses: WalletAdditionalAddress[];
+};
+export declare class StellarLocalStorageCache implements IStellarSessionCache {
+    private readonly CONNECTED_ACCOUNTS_KEY;
+    constructor(key: string);
+    getActiveAccount(): Promise<StellarActiveAccount | undefined>;
+    getConnectedAccounts(): Promise<StellarConnectedAccounts | undefined>;
+    getConnectedAccount(address: string): Promise<StellarConnectedAccount | undefined>;
+    setConnectedAccount(address: string, account: StellarConnectedAccount): Promise<void>;
+    clearConnectedAcccounts(): Promise<void>;
+}
+export interface IStellarSessionCache {
+    clearConnectedAcccounts(): Promise<void>;
+    getActiveAccount(): Promise<StellarActiveAccount | undefined>;
+    getConnectedAccount(address: string): Promise<StellarConnectedAccount | undefined>;
+    getConnectedAccounts(): Promise<StellarConnectedAccounts | undefined>;
+    setConnectedAccount(address: string, account: StellarConnectedAccount): Promise<void>;
+}
+export {};

package/src/StellarLocalStorageCache.js

@@ -0,0 +1,61 @@
+'use client'
+import { __awaiter } from '../_virtual/_tslib.js';
+import { getItemAsync, setItemAsync, removeItemAsync } from '@dynamic-labs/utils';
+
+class StellarLocalStorageCache {
+    constructor(key) {
+        this.CONNECTED_ACCOUNTS_KEY = `stellar_${key}_connectedAccounts`;
+    }
+    getActiveAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connectedAccounts = yield getItemAsync(this.CONNECTED_ACCOUNTS_KEY);
+            if (!connectedAccounts) {
+                return;
+            }
+            const activeAddress = Object.keys(connectedAccounts).find((key) => connectedAccounts[key].active);
+            if (!activeAddress) {
+                return;
+            }
+            return {
+                additionalAddresses: connectedAccounts[activeAddress].additionalAddresses,
+                address: activeAddress,
+            };
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connectedAccounts = yield getItemAsync(this.CONNECTED_ACCOUNTS_KEY);
+            return connectedAccounts;
+        });
+    }
+    getConnectedAccount(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connectedAccounts = yield getItemAsync(this.CONNECTED_ACCOUNTS_KEY);
+            return connectedAccounts === null || connectedAccounts === void 0 ? void 0 : connectedAccounts[address];
+        });
+    }
+    setConnectedAccount(address, account) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let connectedAccounts = yield getItemAsync(this.CONNECTED_ACCOUNTS_KEY);
+            if (!connectedAccounts) {
+                connectedAccounts = {};
+            }
+            if (account.active) {
+                Object.keys(connectedAccounts).forEach((key) => {
+                    if (connectedAccounts) {
+                        connectedAccounts[key].active = false;
+                    }
+                });
+            }
+            connectedAccounts[address] = account;
+            return setItemAsync(this.CONNECTED_ACCOUNTS_KEY, connectedAccounts);
+        });
+    }
+    clearConnectedAcccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return removeItemAsync(this.CONNECTED_ACCOUNTS_KEY);
+        });
+    }
+}
+
+export { StellarLocalStorageCache };

package/src/connectors/StellarWalletConnector/StellarWalletConnector.cjs

@@ -0,0 +1,351 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var stellarSdk = require('@stellar/stellar-sdk');
+var logger = require('@dynamic-labs/logger');
+var utils = require('@dynamic-labs/utils');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var StellarWallet = require('../../wallet/StellarWallet.cjs');
+var getNetworkFromAddress = require('../../utils/getNetworkFromAddress.cjs');
+var StellarLocalStorageCache = require('../../StellarLocalStorageCache.cjs');
+
+/**
+ * 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 walletConnectorCore.WalletConnectorBase {
+    constructor(name, opts) {
+        var _a;
+        super({
+            metadata: opts.metadata,
+            walletBook: opts.walletBook,
+        });
+        this.name = 'Stellar';
+        this.ChainWallet = StellarWallet.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.Logger(this.name);
+        this.stellarNetworks = (_a = opts.stellarNetworks) !== null && _a !== void 0 ? _a : [];
+        this.overrideKey = this.key;
+        this.cache = new StellarLocalStorageCache.StellarLocalStorageCache(this.overrideKey);
+    }
+    getEnabledNetworks() {
+        return this.stellarNetworks;
+    }
+    getSelectedNetwork() {
+        var _a;
+        return (_a = this.stellarNetworks) === null || _a === void 0 ? void 0 : _a[0];
+    }
+    getNetwork() {
+        return _tslib.__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.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 _tslib.__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 _tslib.__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 utils.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 utils.DynamicError('Failed to connect to Stellar wallet');
+            }
+            finally {
+                this.isConnecting = false;
+            }
+        });
+    }
+    /**
+     * Disconnects from the wallet.
+     */
+    disconnect() {
+        return _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            const provider = this.getProvider();
+            if (!provider) {
+                throw new utils.DynamicError('No Stellar provider found');
+            }
+            return provider.sign(transactionXdr);
+        });
+    }
+    /**
+     * Signs a message.
+     */
+    signMessage(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const provider = this.getProvider();
+            if (!provider) {
+                return undefined;
+            }
+            return provider.signMessage(messageToSign);
+        });
+    }
+    getHorizonServer() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            return new stellarSdk.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 _tslib.__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 _tslib.__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 = (() => _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.cache.clearConnectedAcccounts();
+        });
+    }
+    /**
+     * Gets connected accounts from cache.
+     */
+    getConnectedAccountsFromCache() {
+        return _tslib.__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 _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.cache.setConnectedAccount(mainAddress, {
+                additionalAddresses,
+            });
+        });
+    }
+    /**
+     * Ends the session and clears connected accounts.
+     */
+    endSession() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            this.connectedPublicKey = undefined;
+            this.getAddressPromise = undefined;
+            this.connectionCancelled = false;
+            yield this.cache.clearConnectedAcccounts();
+        });
+    }
+}
+
+exports.StellarWalletConnector = StellarWalletConnector;

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

@@ -0,0 +1,102 @@
+import { Horizon } from '@stellar/stellar-sdk';
+import { Logger } from '@dynamic-labs/logger';
+import type { GenericNetwork } from '@dynamic-labs/types';
+import { type Chain, WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
+import { WalletAdditionalAddress } from '@dynamic-labs/sdk-api-core';
+import type { IStellarProvider, StellarWalletConnectorProps } from '../../types';
+import { StellarWallet } from '../../wallet/StellarWallet';
+import { IStellarSessionCache } from '../../StellarLocalStorageCache';
+/**
+ * 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.
+ */
+export declare abstract class StellarWalletConnector extends WalletConnectorBase<typeof StellarWallet> {
+    cache: IStellarSessionCache;
+    name: string;
+    ChainWallet: typeof StellarWallet;
+    connectedChain: Chain;
+    supportedChains: Chain[];
+    /** Logger instance */
+    logger: Logger;
+    /** Connection state */
+    protected isConnecting: boolean;
+    /** Flag to track if connection was cancelled by disconnect */
+    private connectionCancelled;
+    /** Connected public key */
+    protected connectedPublicKey: string | undefined;
+    /** Promise cache to prevent multiple simultaneous getAddress calls */
+    private getAddressPromise;
+    private selectedNetwork;
+    stellarNetworks: GenericNetwork[];
+    constructor(name: string, opts: StellarWalletConnectorProps);
+    /**
+     * Abstract method to get the wallet provider.
+     * Must be implemented by concrete connector classes.
+     */
+    abstract getProvider(): IStellarProvider | undefined;
+    getEnabledNetworks(): GenericNetwork[];
+    getSelectedNetwork(): GenericNetwork | undefined;
+    getNetwork(): Promise<string | undefined>;
+    /**
+     * Checks if the provider is already connected.
+     */
+    protected isProviderConnected(): Promise<boolean>;
+    /**
+     * Connects to the Stellar wallet.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnects from the wallet.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Signs a Stellar transaction XDR.
+     */
+    signTransaction(transactionXdr: string): Promise<string>;
+    /**
+     * Signs a message.
+     */
+    signMessage(messageToSign: string): Promise<string | undefined>;
+    getHorizonServer(): Promise<Horizon.Server>;
+    isTestnet(): Promise<boolean>;
+    /**
+     * Gets the connected public key.
+     */
+    getConnectedPublicKey(): string | undefined;
+    /**
+     * 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
+     */
+    protected fetchPublicAddress(): Promise<string>;
+    /**
+     * 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(): Promise<string>;
+    /**
+     * Clears all connected accounts from cache.
+     */
+    clearConnectedAccounts(): Promise<void>;
+    /**
+     * Gets connected accounts from cache.
+     */
+    getConnectedAccountsFromCache(): Promise<string[]>;
+    /**
+     * Gets additional addresses for a main address.
+     */
+    getAdditionalAddresses(mainAddress?: string): Promise<WalletAdditionalAddress[]>;
+    /**
+     * Sets additional addresses for a main address.
+     */
+    setAdditionalAddresses(mainAddress: string, additionalAddresses: WalletAdditionalAddress[]): Promise<void>;
+    /**
+     * Ends the session and clears connected accounts.
+     */
+    endSession(): Promise<void>;
+}