@tuwaio/orbit-core 0.1.2 → 0.2.1

package/README.md

@@ -18,17 +18,17 @@ Its primary goal is to establish a **unified interface** for interacting with di
 
 ## ✨ Key Features
 
--   **Multi-Chain Foundation:** Defines the core `OrbitAdapter` enum (supporting EVM, Solana, Starknet) and types for building consistent multi-chain support.
--   **Framework Agnostic & Headless:** Contains only logic, no UI components, ensuring compatibility with any frontend setup.
--   **Type-Safe Development:** Fully written in TypeScript 5.9+ for a robust developer experience.
--   **Flexible Adapter System:** Provides utilities like `selectAdapterByKey` to easily manage and switch between different blockchain adapter implementations.
--   **Essential Utilities:** Includes common helpers for tasks such as:
-    * Formatting wallet names and chain IDs (`formatWalletName`, `formatWalletChainId`).
-    * Identifying chain types (`isSolanaChain`, `getAdapterFromWalletType`).
-    * Managing wallet connection state in localStorage (`lastConnectedWalletHelpers`, `recentConnectedWalletHelpers`).
-    * Handling impersonation for development/testing (`impersonatedHelpers`).
-    * Basic async operations (`delay`, `waitFor`).
--   **SSR Safe:** Utilities are designed to work safely in both browser and Server-Side Rendering environments.
+- **Multi-Chain Foundation:** Defines the core `OrbitAdapter` enum (supporting EVM, Solana, Starknet) and types for building consistent multi-chain support.
+- **Framework Agnostic & Headless:** Contains only logic, no UI components, ensuring compatibility with any frontend setup.
+- **Type-Safe Development:** Fully written in TypeScript 5.9+ for a robust developer experience.
+- **Flexible Adapter System:** Provides utilities like `selectAdapterByKey` to easily manage and switch between different blockchain adapter implementations.
+- **Essential Utilities:** Includes common helpers for tasks such as:
+  - Formatting connector names and chain IDs (`formatConnectorName`, `formatConnectorChainId`).
+  - Identifying chain types (`isSolanaChain`, `getAdapterFromConnectorType`).
+  - Managing connector connection state in localStorage (`lastConnectedConnectorHelpers`, `recentConnectedConnectorHelpers`).
+  - Handling impersonation for development/testing (`impersonatedHelpers`).
+  - Basic async operations (`delay`, `waitFor`).
+- **SSR Safe:** Utilities are designed to work safely in both browser and Server-Side Rendering environments.
 
 ---
 
@@ -117,33 +117,33 @@ if (selectedSolanaAdapter && selectedSolanaAdapter.key === OrbitAdapter.SOLANA)
 ```typescript
 import {
   OrbitAdapter,
-  formatWalletName,
-  getAdapterFromWalletType,
-  getWalletTypeFromConnectorName,
+  formatConnectorName,
+  getAdapterFromConnectorType,
+  getConnectorTypeFromName,
   isSolanaChain,
-  lastConnectedWalletHelpers
+  lastConnectedConnectorHelpers
 } from '@tuwaio/orbit-core';
 
 // Formatting
-const formattedName = formatWalletName('MetaMask'); // "metamask"
+const formattedName = formatConnectorName('MetaMask'); // "metamask"
 console.log(formattedName);
-const walletType = getWalletTypeFromConnectorName(OrbitAdapter.EVM, 'Brave Wallet'); // "evm:bravewallet"
-console.log(walletType);
+const connectorType = getConnectorTypeFromName(OrbitAdapter.EVM, 'Brave Wallet'); // "evm:bravewallet"
+console.log(connectorType);
 
 // Identification
-const adapterType = getAdapterFromWalletType(walletType); // OrbitAdapter.EVM
+const adapterType = getAdapterFromConnectorType(connectorType); // OrbitAdapter.EVM
 console.log(adapterType);
 console.log(isSolanaChain('devnet')); // true
 console.log(isSolanaChain(1)); // false
 
-// Local Storage Management for Last Connected Wallet
-lastConnectedWalletHelpers.setLastConnectedWallet({
-  walletType: 'evm:metamask',
+// Local Storage Management for Last Connected Connector
+lastConnectedConnectorHelpers.setLastConnectedConnector({
+  connectorType: 'evm:metamask',
   chainId: 1,
   address: '0x123...'
 });
-const lastWallet = lastConnectedWalletHelpers.getLastConnectedWallet();
-console.log(lastWallet); // { walletType: 'evm:metamask', chainId: 1, address: '0x123...' }
+const lastWallet = lastConnectedConnectorHelpers.getLastConnectedConnector();
+console.log(lastWallet); // { connectorType: 'evm:metamask', chainId: 1, address: '0x123...' }
 
 // lastConnectedWalletHelpers.removeLastConnectedWallet();
 ```
@@ -154,17 +154,17 @@ console.log(lastWallet); // { walletType: 'evm:metamask', chainId: 1, address: '
 
 Orbit Core is designed around modularity and abstraction:
 
-1.  **Core Types (`types.ts`):** Defines fundamental structures like `OrbitAdapter` (enum for EVM, Solana, Starknet), `BaseAdapter` (common interface), and `WalletType`.
-2.  **Adapter System:** Enables handling multiple blockchain types via a common interface. The `selectAdapterByKey` utility allows runtime selection of the correct adapter implementation based on the `OrbitAdapter` key. Chain-specific logic resides in separate packages (e.g., `@tuwaio/orbit-evm`).
-3.  **Utilities (`utils/`):** A collection of framework-agnostic helper functions covering formatting, chain identification, localStorage management (for connection state persistence), async operations, and other common tasks needed when building multi-chain UIs.
+1. **Core Types (`types.ts`):** Defines fundamental structures like `OrbitAdapter` (enum for EVM, Solana, Starknet), `BaseAdapter` (common interface), and `ConnectorType`.
+2. **Adapter System:** Enables handling multiple blockchain types via a common interface. The `selectAdapterByKey` utility allows runtime selection of the correct adapter implementation based on the `OrbitAdapter` key. Chain-specific logic resides in separate packages (e.g., `@tuwaio/orbit-evm`).
+3. **Utilities (`utils/`):** A collection of framework-agnostic helper functions covering formatting, chain identification, localStorage management (for connection state persistence), async operations, and other common tasks needed when building multi-chain UIs.
 
 ### Key Exports (`index.ts`)
 
-- **Types:** `OrbitAdapter`, `BaseAdapter`, `WalletType`, `OrbitGenericAdapter`, `RecentConnectedWallet`.
-- **Adapter Utilities:** `selectAdapterByKey`, `getAdapterFromWalletType`.
-- **Formatting Utilities:** `formatWalletChainId`, `formatWalletName`, `getWalletTypeFromConnectorName`.
+- **Types:** `OrbitAdapter`, `BaseAdapter`, `ConnectorType`, `OrbitGenericAdapter`, `RecentConnectedConnector`.
+- **Adapter Utilities:** `selectAdapterByKey`, `getAdapterFromConnectorType`.
+- **Formatting Utilities:** `formatConnectorChainId`, `formatConnectorName`, `getConnectorTypeFromName`.
 - **Chain Helpers:** `isSolanaChain`, `setChainId`.
-- **Storage Helpers:** `lastConnectedWalletHelpers`, `recentConnectedWalletHelpers`, `impersonatedHelpers`, `getParsedStorageItem`.
+- **Storage Helpers:** `lastConnectedConnectorHelpers`, `recentConnectedConnectorHelpers`, `impersonatedHelpers`, `getParsedStorageItem`.
 - **General Utilities:** `delay`, `filterUniqueByKey`, `waitFor`, `isSafeApp`.
 
 -----

package/dist/index.d.mts

@@ -100,12 +100,32 @@ type BaseAdapter = {
     getName?: (address: string) => Promise<string | null>;
     /** Optional method to get avatar for resolved names */
     getAvatar?: (name: string) => Promise<string | null>;
+    /** Optional method to resolve names to addresses */
+    getAddress?: (name: string) => Promise<string | null>;
 };
 /**
- * Type representing a wallet identifier in format "OrbitAdapter:wallet"
+ * Type representing a connector identifier in format "OrbitAdapter:connector"
  * @example "evm:metamask" | "solana:phantom"
  */
-type WalletType = `${OrbitAdapter}:${string}`;
+type ConnectorType = `${OrbitAdapter}:${string}`;
+/**
+ * Array of chain identifiers (replaces IdentifierArray from @wallet-standard/base)
+ * Can contain strings, numbers, or other primitive types
+ *
+ * @example
+ * ```typescript
+ * const chainIds: ChainIdentifierArray = ['ethereum', 1, 'solana:mainnet-beta'];
+ * ```
+ */
+type ChainIdentifierArray = readonly (string | number)[];
+
+/**
+ * Universal address validation function that supports multiple blockchain formats
+ * @param value - Address string to validate
+ * @param type - Optional blockchain type to validate against ('evm' | 'solana' | 'auto')
+ * @returns boolean indicating if the address is valid
+ */
+declare function isAddress(value: string, type?: 'evm' | 'solana' | 'auto'): boolean;
 
 /**
  * @name delay
@@ -152,69 +172,92 @@ declare const delay: <T>(value: T, ms: number) => Promise<T>;
  */
 declare function filterUniqueByKey<T>(array: T[], key: keyof T): T[];
 
-declare function formatWalletChainId(chainId: string | number, connectedAdapter: OrbitAdapter): string | number;
+declare function formatConnectorChainId(chainId: string | number, connectedAdapter: OrbitAdapter): string | number;
 
-declare const formatWalletName: (walletName: string) => string;
+declare const formatConnectorName: (connectorName: string) => string;
 
 /**
- * Extracts the adapter type from a wallet type string
+ * Extracts the adapter type from a connector type string
  *
  * @example
  * ```typescript
  * // Returns OrbitAdapter.EVM
- * getAdapterFromWalletType('evm:metamask');
+ * getAdapterFromConnectorType('evm:metamask');
  *
  * // Returns OrbitAdapter.SOLANA
- * getAdapterFromWalletType('solana:phantom');
+ * getAdapterFromConnectorType('solana:phantom');
  *
  * // Returns OrbitAdapter.EVM (default)
- * getAdapterFromWalletType('unknown');
+ * getAdapterFromConnectorType('unknown');
  * ```
  *
- * @param walletType - Wallet type in format "chain:wallet" (e.g. "evm:metamask", "solana:phantom")
+ * @param connectorType - Connector type in format "orbit-adapter:connector" (e.g. "evm:metamask", "solana:phantom")
  * @returns The corresponding {@link OrbitAdapter} type or EVM as default
  *
  * @remarks
- * The function splits the wallet type string by ":" and takes the first part as the adapter type.
+ * The function splits the connector type string by ":" and takes the first part as the adapter type.
  * If the split fails or the first part is empty, it defaults to EVM adapter.
  */
-declare function getAdapterFromWalletType(walletType: WalletType): OrbitAdapter;
+declare function getAdapterFromConnectorType(connectorType: ConnectorType): OrbitAdapter;
 
 /**
- * Internal function for safely retrieving and parsing data from localStorage.
- *
- * @param key - The key for localStorage
- * @returns The parsed LastConnectedWallet object or undefined if data is not found/invalid
- */
-declare function getParsedStorageItem<ReturnType>(key: string): ReturnType | undefined;
-
-/**
- * Generates a standardized wallet type identifier from adapter type and connector name
+ * Generates a standardized connector type identifier from adapter type and connector name
  *
  * @example
  * ```typescript
  * // Returns "evm:metamask"
- * getWalletTypeFromConnectorName(OrbitAdapter.EVM, "MetaMask");
+ * getConnectorTypeFromName(OrbitAdapter.EVM, "MetaMask");
  *
  * // Returns "solana:phantom"
- * getWalletTypeFromConnectorName(OrbitAdapter.SOLANA, "Phantom");
+ * getConnectorTypeFromName(OrbitAdapter.SOLANA, "Phantom");
  *
  * // Returns "evm:coinbasewallet" (removes spaces)
- * getWalletTypeFromConnectorName(OrbitAdapter.EVM, "Coinbase Wallet");
+ * getConnectorTypeFromName(OrbitAdapter.EVM, "Coinbase Wallet");
  * ```
  *
  * @param adapter - The blockchain adapter type (e.g. EVM, SOLANA)
- * @param name - The wallet connector name (e.g. "MetaMask", "Phantom")
- * @returns A formatted wallet type string in format "chain:wallet"
+ * @param name - The connector name (e.g. "MetaMask", "Phantom")
+ * @returns A formatted connector type string in format "orbit-adapter:connector"
  *
  * @remarks
  * The function:
  * 1. Combines adapter type with connector name using ":" as separator
  * 2. Removes all whitespace from connector name
  * 3. Converts connector name to lowercase
- * This ensures consistent wallet type identifiers across the application
+ * This ensures consistent connector type identifiers across the application
+ * and normalizes connector names for better UX/consistency.
+ */
+declare function getConnectorTypeFromName(adapter: OrbitAdapter, name: string): string;
+
+declare const getNetworkData: (adapter: OrbitAdapter) => {
+    chain: {
+        chainId: number;
+        name: string;
+    };
+    links: {
+        aboutNetwork: string;
+        choseWallet: string;
+        about: string;
+    };
+} | {
+    chain: {
+        chainId: string;
+        name: string;
+    };
+    links: {
+        aboutNetwork: string;
+        choseWallet: string;
+        about: string;
+    };
+} | undefined;
+
+/**
+ * Internal function for safely retrieving and parsing data from localStorage.
+ *
+ * @param key - The key for localStorage
+ * @returns The parsed LastConnectedConnector object or undefined if data is not found/invalid
  */
-declare function getWalletTypeFromConnectorName(adapter: OrbitAdapter, name: string): string;
+declare function getParsedStorageItem<ReturnType>(key: string): ReturnType | undefined;
 
 /**
  * Helper utilities for managing impersonated wallet addresses
@@ -263,8 +306,8 @@ declare const impersonatedHelpers: {
 
 declare const isSafeApp: boolean;
 
-type LastConnectedWallet = {
-    walletType: WalletType;
+type LastConnectedConnector = {
+    connectorType: ConnectorType;
     chainId: number | string;
     address?: string;
 };
@@ -272,71 +315,269 @@ type LastConnectedWallet = {
  * Helper utilities for managing the last connected wallet state
  *
  * @remarks
- * All data is stored in localStorage with the 'orbit-core:lastConnectedWallet' key.
+ * All data is stored in localStorage with the 'orbit-core:lastConnectedConnector' key.
  * Functions are safe to use in both browser and SSR environments.
  */
-declare const lastConnectedWalletHelpers: {
+declare const lastConnectedConnectorHelpers: {
     STORAGE_KEY: string;
     /**
      * The value of the last connected wallet, initialized when the module loads.
      * Returns undefined if not set, invalid, or in an SSR context.
      */
-    lastConnectedWallet: LastConnectedWallet | undefined;
+    lastConnectedConnector: LastConnectedConnector | undefined;
     /**
      * Stores the last connected wallet data in localStorage.
      *
      * @param data - Object containing the wallet type and chain ID.
      * @returns undefined in SSR context, void in browser
      */
-    setLastConnectedWallet: ({ walletType, chainId, address }: LastConnectedWallet) => void;
+    setLastConnectedConnector: ({ connectorType, chainId, address }: LastConnectedConnector) => void;
     /**
      * Retrieves the current last connected wallet data from localStorage.
      *
-     * @returns The LastConnectedWallet object or undefined if not set or in SSR context
+     * @returns The LastConnectedConnector object or undefined if not set or in SSR context
      */
-    getLastConnectedWallet: () => LastConnectedWallet | undefined;
+    getLastConnectedConnector: () => LastConnectedConnector | undefined;
     /**
      * Removes the last connected wallet data from localStorage.
      *
      * @returns undefined in SSR context, void in browser
      */
-    removeLastConnectedWallet: () => void;
+    removeLastConnectedConnector: () => void;
 };
 
-type RecentConnectedWallet = Record<OrbitAdapter, Record<string, boolean>>;
 /**
- * Helper utilities for managing the last connected wallet state
+ * Data structure for a recently connected connector
+ *
+ * @interface RecentlyConnectedConnectorData
+ * @property {string} address - The wallet address that was connected
+ * @property {number} disconnectedTimestamp - Unix timestamp in milliseconds when the connector was disconnected
+ * @property {string} [icon] - Optional icon URL or identifier for the connector
+ */
+type RecentlyConnectedConnectorData = {
+    address: string;
+    disconnectedTimestamp: number;
+    icon?: string;
+};
+/**
+ * Record mapping connector types to their recently connected data
+ *
+ * @type RecentlyConnectedConnectorsList
+ */
+type RecentlyConnectedConnectorsList = Record<ConnectorType, RecentlyConnectedConnectorData>;
+/**
+ * Helper utilities for managing recently connected connectors list with disconnect timestamps
  *
  * @remarks
- * All data is stored in localStorage with the 'orbit-core:lastConnectedWallet' key.
+ * All data is stored in localStorage with the 'orbit-core:recentlyConnectedConnectorsListHelpers' key.
  * Functions are safe to use in both browser and SSR environments.
+ *
+ * The storage contains a record where each key is a ConnectorType and value contains
+ * address, disconnectedTimestamp (Unix timestamp in milliseconds), and optional icon for that connector.
+ * This allows tracking when each connector was last disconnected for cleanup and sorting purposes.
+ *
+ * @example
+ * ```typescript
+ * // Set entire list
+ * recentlyConnectedConnectorsListHelpers.setRecentlyConnectedConnectorsList({
+ *   'evm:metamask': {
+ *     address: '0x123...',
+ *     disconnectedTimestamp: Date.now(),
+ *     icon: 'metamask-icon.png'
+ *   },
+ *   'solana:phantom': {
+ *     address: 'ABC123...',
+ *     disconnectedTimestamp: Date.now() - 3600000, // 1 hour ago
+ *     icon: 'phantom-icon.png'
+ *   }
+ * });
+ *
+ * // Add single connector
+ * recentlyConnectedConnectorsListHelpers.addConnector('evm:walletconnect', {
+ *   address: '0x456...',
+ *   disconnectedTimestamp: Date.now(),
+ *   icon: 'walletconnect-icon.png'
+ * });
+ *
+ * // Remove single connector
+ * recentlyConnectedConnectorsListHelpers.removeConnector('evm:metamask');
+ * ```
  */
-declare const recentConnectedWalletHelpers: {
+declare const recentlyConnectedConnectorsListHelpers: {
+    /** Key used for localStorage storage */
     STORAGE_KEY: string;
     /**
-     * The value of the last connected wallet, initialized when the module loads.
+     * The current recently connected connectors list, initialized when the module loads.
      * Returns undefined if not set, invalid, or in an SSR context.
+     *
+     * @readonly
      */
-    recentConnectedWallet: RecentConnectedWallet | undefined;
+    recentlyConnectedConnectorsList: RecentlyConnectedConnectorsList | undefined;
     /**
-     * Stores the last connected wallet data in localStorage.
+     * Stores the complete recently connected connectors list in localStorage.
+     * This will overwrite the entire existing list.
      *
-     * @param wallets - RecentConnectedWallet
+     * @param connectors - Complete RecentlyConnectedConnectorsList object
      * @returns undefined in SSR context, void in browser
+     *
+     * @example
+     * ```typescript
+     * recentlyConnectedConnectorsListHelpers.setRecentlyConnectedConnectorsList({
+     *   'evm:metamask': {
+     *     address: '0x123...',
+     *     disconnectedTimestamp: Date.now(),
+     *     icon: 'metamask.png'
+     *   },
+     *   'solana:phantom': {
+     *     address: 'ABC123...',
+     *     disconnectedTimestamp: Date.now() - 1800000 // 30 minutes ago
+     *   }
+     * });
+     * ```
      */
-    setRecentConnectedWallet: (wallets: RecentConnectedWallet) => void;
+    setRecentlyConnectedConnectorsList: (connectors: RecentlyConnectedConnectorsList) => void;
     /**
-     * Retrieves the current last connected wallet data from localStorage.
+     * Retrieves the current recently connected connectors list from localStorage.
+     *
+     * @returns The RecentlyConnectedConnectorsList object or undefined if not set or in SSR context
      *
-     * @returns The LastConnectedWallet object or undefined if not set or in SSR context
+     * @example
+     * ```typescript
+     * const connectors = recentlyConnectedConnectorsListHelpers.getRecentlyConnectedConnectorsList();
+     * if (connectors) {
+     *   console.log('Available connectors:', Object.keys(connectors));
+     *   // Sort by most recently disconnected
+     *   const sorted = Object.entries(connectors)
+     *     .sort(([,a], [,b]) => b.disconnectedTimestamp - a.disconnectedTimestamp);
+     * }
+     * ```
      */
-    getRecentConnectedWallet: () => RecentConnectedWallet | undefined;
+    getRecentlyConnectedConnectorsList: () => RecentlyConnectedConnectorsList | undefined;
     /**
-     * Removes the last connected wallet data from localStorage.
+     * Adds or updates a single connector in the recently connected connectors list.
+     * Preserves existing connectors and only adds/updates the specified one.
      *
+     * @param connectorType - The connector type to add/update
+     * @param connectorData - The connector data (address, disconnectedTimestamp, and optional icon)
      * @returns undefined in SSR context, void in browser
+     *
+     * @example
+     * ```typescript
+     * // Add new connector with current timestamp
+     * recentlyConnectedConnectorsListHelpers.addConnector('evm:metamask', {
+     *   address: '0x123...',
+     *   disconnectedTimestamp: Date.now(),
+     *   icon: 'metamask.png'
+     * });
+     *
+     * // Update existing connector with new disconnect time
+     * recentlyConnectedConnectorsListHelpers.addConnector('evm:metamask', {
+     *   address: '0x456...',
+     *   disconnectedTimestamp: Date.now(),
+     *   icon: 'new-metamask.png'
+     * });
+     * ```
+     */
+    addConnector: (connectorType: ConnectorType, connectorData: RecentlyConnectedConnectorData) => undefined;
+    /**
+     * Removes a single connector from the recently connected connectors list.
+     * Preserves all other connectors in the list.
+     *
+     * @param connectorType - The connector type to remove
+     * @returns undefined in SSR context, void in browser
+     *
+     * @example
+     * ```typescript
+     * // Remove specific connector
+     * recentlyConnectedConnectorsListHelpers.removeConnector('evm:metamask');
+     * ```
+     */
+    removeConnector: (connectorType: ConnectorType) => undefined;
+    /**
+     * Checks if a specific connector exists in the recently connected connectors list.
+     *
+     * @param connectorType - The connector type to check
+     * @returns true if the connector exists, false otherwise, undefined in SSR context
+     *
+     * @example
+     * ```typescript
+     * if (recentlyConnectedConnectorsListHelpers.hasConnector('evm:metamask')) {
+     *   console.log('MetaMask was recently connected');
+     * }
+     * ```
+     */
+    hasConnector: (connectorType: ConnectorType) => boolean | undefined;
+    /**
+     * Gets data for a specific connector from the recently connected connectors list.
+     *
+     * @param connectorType - The connector type to get data for
+     * @returns The connector data (including address, disconnectedTimestamp, and optional icon) or undefined if not found or in SSR context
+     *
+     * @example
+     * ```typescript
+     * const metamaskData = recentlyConnectedConnectorsListHelpers.getConnector('evm:metamask');
+     * if (metamaskData) {
+     *   console.log('MetaMask address:', metamaskData.address);
+     *   console.log('Disconnected at:', new Date(metamaskData.disconnectedTimestamp));
+     *   console.log('MetaMask icon:', metamaskData.icon);
+     * }
+     * ```
+     */
+    getConnector: (connectorType: ConnectorType) => RecentlyConnectedConnectorData | undefined;
+    /**
+     * Gets the count of recently connected connectors.
+     *
+     * @returns Number of connectors in the list, 0 in SSR context or if list is empty
+     *
+     * @example
+     * ```typescript
+     * const count = recentlyConnectedConnectorsListHelpers.getConnectorCount();
+     * console.log(`${count} connectors recently connected`);
+     * ```
+     */
+    getConnectorCount: () => number;
+    /**
+     * Gets recently connected connectors sorted by disconnect time (most recent first).
+     * Useful for showing connectors in order of recent usage.
+     *
+     * @returns Array of [ConnectorType, RecentlyConnectedConnectorData] tuples sorted by disconnectedTimestamp (descending), empty array in SSR context
+     *
+     * @example
+     * ```typescript
+     * const sortedConnectors = recentlyConnectedConnectorsListHelpers.getConnectorsSortedByTime();
+     * sortedConnectors.forEach(([connectorType, data]) => {
+     *   console.log(`${connectorType}: disconnected ${new Date(data.disconnectedTimestamp)}`);
+     * });
+     * ```
+     */
+    getConnectorsSortedByTime: () => [ConnectorType, RecentlyConnectedConnectorData][];
+    /**
+     * Removes connectors that were disconnected before the specified timestamp.
+     * Useful for cleaning up old connector entries.
+     *
+     * @param beforeTimestamp - Unix timestamp in milliseconds; connectors disconnected before this time will be removed
+     * @returns undefined in SSR context, void in browser
+     *
+     * @example
+     * ```typescript
+     * // Remove connectors disconnected more than 7 days ago
+     * const weekAgo = Date.now() - (7 * 24 * 60 * 60 * 1000);
+     * recentlyConnectedConnectorsListHelpers.removeConnectorsOlderThan(weekAgo);
+     * ```
+     */
+    removeConnectorsOlderThan: (beforeTimestamp: number) => undefined;
+    /**
+     * Removes all recently connected connectors from localStorage.
+     *
+     * @returns undefined in SSR context, void in browser
+     *
+     * @example
+     * ```typescript
+     * // Clear all recently connected connectors
+     * recentlyConnectedConnectorsListHelpers.removeRecentlyConnectedConnectorsList();
+     * ```
      */
-    removeRecentConnectedWallet: () => void;
+    removeRecentlyConnectedConnectorsList: () => void;
 };
 
 /**
@@ -406,4 +647,4 @@ declare function isSolanaChain(chainId: number | string): boolean;
  */
 declare function setChainId(chainId: number | string): string | number;
 
-export { type BaseAdapter, OrbitAdapter, type OrbitGenericAdapter, type RecentConnectedWallet, type WalletType, delay, filterUniqueByKey, formatWalletChainId, formatWalletName, getAdapterFromWalletType, getParsedStorageItem, getWalletTypeFromConnectorName, impersonatedHelpers, isSafeApp, isSolanaChain, lastConnectedWalletHelpers, recentConnectedWalletHelpers, selectAdapterByKey, setChainId, waitFor };
+export { type BaseAdapter, type ChainIdentifierArray, type ConnectorType, OrbitAdapter, type OrbitGenericAdapter, type RecentlyConnectedConnectorData, type RecentlyConnectedConnectorsList, delay, filterUniqueByKey, formatConnectorChainId, formatConnectorName, getAdapterFromConnectorType, getConnectorTypeFromName, getNetworkData, getParsedStorageItem, impersonatedHelpers, isAddress, isSafeApp, isSolanaChain, lastConnectedConnectorHelpers, recentlyConnectedConnectorsListHelpers, selectAdapterByKey, setChainId, waitFor };