@tomo-inc/wallet-connect-protocol 0.0.8 → 0.0.10

package/dist/index.d.ts

@@ -1,169 +1,689 @@
-import { W as WalletConnectClient, S as SessionInfo, Q as QRCodeOptions, a as WalletConnectConfig, b as SiweConfig } from './vanilla-2_OWCFEZ.js';
-export { Z as APTOS_CHAINS, R as APTOS_NAMESPACE, t as AuthMethod, A as AuthOptions, T as COSMOS_NAMESPACE, u as ChainType, C as ConnectParams, M as EIP155_NAMESPACE, X as EVM_CHAINS, E as EventHandler, V as NEAR_NAMESPACE, N as NamespaceConfig, U as POLKADOT_NAMESPACE, P as POPULAR_WALLET_IDS, Y as SOLANA_CHAINS, O as SOLANA_NAMESPACE, a8 as SiweAuth, a1 as SiweResult, k as Wallet, l as WalletApp, r as WalletConnectEvent, m as WalletImage, n as WalletListOptions, o as WalletListResponse, p as WalletMetadata, q as WalletPlatform, I as copyToClipboard, $ as createMultiChainNamespaces, a7 as createSiweConfigFromSession, a2 as createSiweMessage, y as extractAddressFromAccount, z as extractChainIdFromAccount, a6 as extractChainIdNumber, x as formatAddress, J as formatError, F as formatTimestamp, H as generateDeepLink, a5 as generateNonce, g as getAllWallets, c as getBrowserWallets, _ as getChainName, a0 as getChainType, d as getDesktopWallets, e as getMobileWallets, f as getRecommendedWallets, D as getSessionTimeRemaining, h as getWalletById, i as getWalletConnectWallets, j as getWalletsByChain, G as isMobile, B as isSessionExpired, K as isValidChainId, v as isValidWalletConnectUri, L as parseChainId, a3 as parseSiweMessage, w as parseWalletConnectUri, s as searchWallets, a4 as verifySiweSignature } from './vanilla-2_OWCFEZ.js';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode } from 'react';
+/**
+ * WalletConnect configuration type definition
+ */
+interface WalletConnectConfig {
+    /** WalletConnect Project ID (get from https://cloud.walletconnect.com) */
+    projectId: string;
+    /** application metadata */
+    metadata: {
+        /** application name */
+        name: string;
+        /** application description */
+        description: string;
+        /** application website address */
+        url: string;
+        /** application icon URL */
+        icons: string[];
+    };
+    /** optional configuration */
+    relayUrl?: string;
+    /** authentication options */
+    auth?: AuthOptions;
+}
+/**
+ * session information
+ */
+interface SessionInfo {
+    /** session topic/ID */
+    topic: string;
+    /** peer information */
+    peer: {
+        metadata: {
+            name: string;
+            description: string;
+            url: string;
+            icons: string[];
+        };
+    };
+    /** namespace configuration */
+    namespaces: Record<string, any>;
+    /** expiry timestamp */
+    expiry: number;
+}
+/**
+ * connection request parameters
+ */
+interface ConnectParams {
+    /** optional pairing topic */
+    pairingTopic?: string;
+    /** required namespaces */
+    requiredNamespaces?: Record<string, NamespaceConfig>;
+    /** optional namespaces */
+    optionalNamespaces?: Record<string, NamespaceConfig>;
+}
+/**
+ * namespace configuration
+ */
+interface NamespaceConfig {
+    /** chain ID list */
+    chains: string[];
+    /** supported methods */
+    methods: string[];
+    /** subscribed events */
+    events: string[];
+}
+/**
+ * supported blockchain types
+ */
+declare enum ChainType {
+    /** Ethereum and EVM compatible chains */
+    EIP155 = "eip155",
+    /** Solana */
+    SOLANA = "solana",
+    /** Aptos */
+    APTOS = "aptos",
+    /** Cosmos */
+    COSMOS = "cosmos",
+    /** Polkadot */
+    POLKADOT = "polkadot",
+    /** Near */
+    NEAR = "near"
+}
+/**
+ * QR code options
+ */
+interface QRCodeOptions {
+    /** QR code width (pixels) */
+    width?: number;
+    /** QR code height (pixels) */
+    height?: number;
+    /** error correction level */
+    errorCorrectionLevel?: "L" | "M" | "Q" | "H";
+    /** margin */
+    margin?: number;
+    /** color configuration */
+    color?: {
+        dark?: string;
+        light?: string;
+    };
+}
+/**
+ * event types
+ */
+type WalletConnectEvent = "session_proposal" | "session_update" | "session_delete" | "session_request" | "display_uri";
+/**
+ * event handler type
+ */
+type EventHandler<T = any> = (data: T) => void | Promise<void>;
+/**
+ * Authentication method
+ */
+declare enum AuthMethod {
+    /** Standard WalletConnect connection */
+    STANDARD = "standard",
+    /** Sign-In with Ethereum (SIWE) */
+    SIWE = "siwe"
+}
+/**
+ * Authentication options
+ */
+interface AuthOptions {
+    /** Authentication method */
+    method?: AuthMethod;
+    /** SIWE specific options */
+    siwe?: {
+        /** Domain requesting the signing */
+        domain: string;
+        /** Statement to present to user */
+        statement?: string;
+        /** URI of the application */
+        uri: string;
+        /** Resources the user wishes to access */
+        resources?: string[];
+    };
+}
+
+/**
+ * WalletConnect client class
+ * wraps the core functionality of WalletConnect
+ */
+declare class WalletConnectClient {
+    private signClient;
+    private config;
+    private eventHandlers;
+    private initialized;
+    constructor(config: WalletConnectConfig);
+    /**
+     * initialize WalletConnect client
+     */
+    initialize(): Promise<void>;
+    /**
+     * set event listeners
+     */
+    private setupEventListeners;
+    /**
+     * create pairing connection and generate URI
+     * @param params connection parameters
+     * @returns WalletConnect URI
+     */
+    connect(params?: ConnectParams): Promise<string>;
+    /**
+     * generate QR code (Base64 format)
+     * @param uri WalletConnect URI
+     * @param options QR code options
+     * @returns Base64 formatted QR code image
+     */
+    generateQRCode(uri: string, options?: QRCodeOptions): Promise<string>;
+    /**
+     * generate QR code (Canvas format)
+     * @param canvas Canvas element
+     * @param uri WalletConnect URI
+     * @param options QR code options
+     */
+    generateQRCodeToCanvas(canvas: HTMLCanvasElement, uri: string, options?: QRCodeOptions): Promise<void>;
+    /**
+     * get all active sessions
+     * @returns session information array
+     */
+    getActiveSessions(): SessionInfo[];
+    /**
+     * disconnect specified session
+     * @param topic session topic/ID
+     */
+    disconnectSession(topic: string): Promise<void>;
+    /**
+     * listen to events
+     * @param event event name
+     * @param handler event handler
+     */
+    on<T = any>(event: WalletConnectEvent, handler: EventHandler<T>): void;
+    /**
+     * remove event listener
+     * @param event event name
+     * @param handler event handler
+     */
+    off<T = any>(event: WalletConnectEvent, handler: EventHandler<T>): void;
+    /**
+     * trigger event
+     * @param event event name
+     * @param data event data
+     */
+    private emit;
+    /**
+     * send JSON-RPC request to wallet
+     * @param params request parameters
+     * @returns request result
+     */
+    sendRequest(params: {
+        topic: string;
+        chainId: string;
+        request: {
+            method: string;
+            params: any[];
+        };
+    }): Promise<any>;
+    /**
+     * destroy client
+     */
+    destroy(): Promise<void>;
+    /**
+     * get if client is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * get configuration information
+     */
+    getConfig(): WalletConnectConfig;
+}
 
 /**
- * WalletConnect Context type
- */
-interface WalletConnectContextType {
-    /** client instance */
-    client: WalletConnectClient | null;
-    /** whether initialized */
-    initialized: boolean;
-    /** whether connecting */
-    connecting: boolean;
-    /** current URI */
-    uri: string | null;
-    /** active sessions list */
-    sessions: SessionInfo[];
-    /** initialize client */
-    initialize: () => Promise<void>;
-    /** create connection */
-    connect: () => Promise<string>;
-    /** generate QR code */
-    generateQRCode: (uri: string, options?: QRCodeOptions) => Promise<string>;
-    /** disconnect session */
-    disconnect: (topic: string) => Promise<void>;
-    /** refresh sessions list */
-    refreshSessions: () => void;
-}
-/**
- * WalletConnect Provider Props
- */
-interface WalletConnectProviderProps {
-    /** WalletConnect configuration */
-    config: WalletConnectConfig;
-    /** child components */
-    children: ReactNode;
-    /** whether to auto initialize */
-    autoInit?: boolean;
-}
-/**
- * WalletConnect Provider Component
+ * utility functions
+ */
+/**
+ * validate WalletConnect URI format
+ * @param uri WalletConnect URI
+ * @returns whether valid
+ */
+declare function isValidWalletConnectUri(uri: string): boolean;
+/**
+ * parse WalletConnect URI
+ * @param uri WalletConnect URI
+ * @returns parsed object
+ */
+declare function parseWalletConnectUri(uri: string): {
+    topic: string;
+    version: string;
+    symKey?: string;
+    relay?: {
+        protocol: string;
+        data?: string;
+    };
+} | null;
+/**
+ * format address (shorten display)
+ * @param address full address
+ * @param startLength start length
+ * @param endLength end length
+ * @returns formatted address
+ */
+declare function formatAddress(address: string, startLength?: number, endLength?: number): string;
+/**
+ * extract address from account string
+ * @param account account string (format: chainId:address)
+ * @returns address
+ */
+declare function extractAddressFromAccount(account: string): string;
+/**
+ * extract chain ID from account string
+ * @param account account string (format: namespace:chainId:address)
+ * @returns chain ID
+ */
+declare function extractChainIdFromAccount(account: string): string;
+/**
+ * check if session is expired
+ * @param expiry expiry timestamp (seconds)
+ * @returns whether expired
+ */
+declare function isSessionExpired(expiry: number): boolean;
+/**
+ * get session remaining time
+ * @param expiry expiry timestamp (seconds)
+ * @returns remaining seconds
+ */
+declare function getSessionTimeRemaining(expiry: number): number;
+/**
+ * format timestamp to readable format
+ * @param timestamp timestamp (seconds)
+ * @returns formatted timestamp string
+ */
+declare function formatTimestamp(timestamp: number): string;
+/**
+ * check if is mobile device
+ * @returns whether is mobile device
+ */
+declare function isMobile(): boolean;
+/**
+ * generate deep link
+ * @param uri WalletConnect URI
+ * @param walletName wallet name (optional)
+ * @returns deep link
+ */
+declare function generateDeepLink(uri: string, walletName?: string): string;
+/**
+ * copy text to clipboard
+ * @param text text to copy
+ * @returns whether successful
+ */
+declare function copyToClipboard(text: string): Promise<boolean>;
+/**
+ * format error message
+ * @param error error object
+ * @returns formatted error message
+ */
+declare function formatError(error: any): string;
+/**
+ * validate chain ID format
+ * @param chainId chain ID
+ * @returns whether valid
+ */
+declare function isValidChainId(chainId: string): boolean;
+/**
+ * parse chain ID
+ * @param chainId chain ID (format: namespace:reference)
+ * @returns parsed result
+ */
+declare function parseChainId(chainId: string): {
+    namespace: string;
+    reference: string;
+} | null;
+
+/**
+ * multi-chain support configuration
+ */
+
+/**
+ * Ethereum (EVM compatible chains) namespace configuration
+ */
+declare const EIP155_NAMESPACE: NamespaceConfig;
+/**
+ * Solana namespace configuration
+ */
+declare const SOLANA_NAMESPACE: NamespaceConfig;
+/**
+ * Aptos namespace configuration
+ */
+declare const APTOS_NAMESPACE: NamespaceConfig;
+/**
+ * Cosmos namespace configuration
+ */
+declare const COSMOS_NAMESPACE: NamespaceConfig;
+/**
+ * Polkadot namespace configuration
+ */
+declare const POLKADOT_NAMESPACE: NamespaceConfig;
+/**
+ * Near namespace configuration
+ */
+declare const NEAR_NAMESPACE: NamespaceConfig;
+/**
+ * commonly used EVM chains configuration
+ */
+declare const EVM_CHAINS: {
+    ETHEREUM_MAINNET: string;
+    ETHEREUM_GOERLI: string;
+    ETHEREUM_SEPOLIA: string;
+    POLYGON: string;
+    POLYGON_MUMBAI: string;
+    ARBITRUM: string;
+    ARBITRUM_GOERLI: string;
+    OPTIMISM: string;
+    OPTIMISM_GOERLI: string;
+    BSC: string;
+    BSC_TESTNET: string;
+    AVALANCHE: string;
+    AVALANCHE_FUJI: string;
+    FANTOM: string;
+    CRONOS: string;
+    GNOSIS: string;
+    BASE: string;
+    ZKSYNC: string;
+    LINEA: string;
+    SCROLL: string;
+};
+/**
+ * Solana chains configuration
+ */
+declare const SOLANA_CHAINS: {
+    MAINNET: string;
+    DEVNET: string;
+    TESTNET: string;
+};
+/**
+ * Aptos chains configuration
+ */
+declare const APTOS_CHAINS: {
+    MAINNET: string;
+    TESTNET: string;
+    DEVNET: string;
+};
+/**
+ * create multi-chain namespaces configuration
+ */
+declare function createMultiChainNamespaces(chains: string[]): Record<string, NamespaceConfig>;
+
+/**
+ * Sign-In with Ethereum (SIWE) Support
+ * Implementation of EIP-4361: Sign-In with Ethereum
+ */
+/**
+ * SIWE configuration options
+ */
+interface SiweConfig {
+    /** Domain requesting the signing */
+    domain: string;
+    /** Statement to present to user (optional) */
+    statement?: string;
+    /** URI of the application */
+    uri: string;
+    /** Version of the SIWE message (default: "1") */
+    version?: string;
+    /** Chain ID */
+    chainId: number;
+    /** Nonce for preventing replay attacks */
+    nonce?: string;
+    /** ISO 8601 datetime string of current time */
+    issuedAt?: string;
+    /** ISO 8601 datetime string when message expires */
+    expirationTime?: string;
+    /** ISO 8601 datetime string when message becomes valid */
+    notBefore?: string;
+    /** Request ID */
+    requestId?: string;
+    /** Resources the user wishes to access */
+    resources?: string[];
+}
+/**
+ * SIWE message and signature result
+ */
+interface SiweResult {
+    /** The SIWE message that was signed */
+    message: string;
+    /** The signature */
+    signature: string;
+    /** The address that signed */
+    address: string;
+    /** Parsed SIWE message object */
+    siweMessage: any;
+}
+/**
+ * Create a SIWE message
+ */
+declare function createSiweMessage(config: SiweConfig, address: string): Promise<string>;
+/**
+ * Parse a SIWE message
+ */
+declare function parseSiweMessage(message: string): Promise<any>;
+/**
+ * Verify a SIWE signature
+ */
+declare function verifySiweSignature(params: {
+    message: string;
+    signature: string;
+    nonce?: string;
+    domain?: string;
+    time?: string;
+}): Promise<{
+    success: boolean;
+    data?: any;
+    error?: string;
+}>;
+/**
+ * Create SIWE configuration from session
+ */
+declare function createSiweConfigFromSession(params: {
+    domain: string;
+    uri: string;
+    chainId: number;
+    statement?: string;
+    resources?: string[];
+}): SiweConfig;
+/**
+ * SIWE authentication flow helper
+ */
+declare class SiweAuth {
+    private config;
+    constructor(config: Omit<SiweConfig, "nonce" | "issuedAt">);
+    /**
+     * Create the message to sign
+     */
+    createMessage(address: string): Promise<string>;
+    /**
+     * Verify the signature
+     */
+    verify(message: string, signature: string): Promise<{
+        success: boolean;
+        data?: any;
+        error?: string;
+    }>;
+    /**
+     * Get the nonce
+     */
+    getNonce(): string;
+    /**
+     * Refresh nonce (for new sign-in attempts)
+     */
+    refreshNonce(): void;
+}
+
+/**
+ * WalletConnect Wallet List API
+ *
+ * Fetch all supported wallets using WalletConnect Cloud Explorer API
+ * API Documentation: https://explorer-api.walletconnect.com/docs
+ */
+interface WalletImage {
+    id: string;
+    image_id: string;
+    image_url: string;
+}
+interface WalletMetadata {
+    shortName: string;
+    colors: {
+        primary?: string;
+        secondary?: string;
+    };
+}
+interface WalletPlatform {
+    native?: string;
+    universal?: string;
+}
+interface WalletApp {
+    browser?: string;
+    ios?: string;
+    android?: string;
+    mac?: string;
+    windows?: string;
+    linux?: string;
+    chrome?: string;
+    firefox?: string;
+    safari?: string;
+    edge?: string;
+    opera?: string;
+}
+interface Wallet {
+    id: string;
+    name: string;
+    homepage: string;
+    image_id: string;
+    image_url?: WalletImage;
+    order?: number;
+    mobile_link?: string;
+    desktop_link?: string;
+    webapp_link?: string;
+    app_type?: string;
+    rdns?: string;
+    metadata?: WalletMetadata;
+    app?: WalletApp;
+    injected?: Array<{
+        namespace: string;
+        injected_id: string;
+    }>;
+    mobile?: WalletPlatform;
+    desktop?: WalletPlatform;
+}
+interface WalletListResponse {
+    count: number;
+    data: Wallet[];
+}
+interface WalletListOptions {
+    /** Project ID (obtain from WalletConnect Cloud) */
+    projectId?: string;
+    /** Number of entries per page (default 100) */
+    entries?: number;
+    /** Page number (default 1) */
+    page?: number;
+    /** Search keyword */
+    search?: string;
+    /** Filter by chain */
+    chains?: string;
+    /** Include image URLs */
+    include?: string;
+    /** Exclude specific wallets */
+    exclude?: string;
+    /** Recommended wallet IDs */
+    recommendedIds?: string;
+}
+/**
+ * Get all WalletConnect supported wallets
+ *
+ * @param options Query options
+ * @returns Wallet list
  *
  * @example
- * ```tsx
- * import { WalletConnectProvider } from '@tomo-inc/wallet-connect-protocol';
+ * ```typescript
+ * // Get all wallets
+ * const wallets = await getWalletConnectWallets({ projectId: 'your-project-id' });
  *
- * function App() {
- *   return (
- *     <WalletConnectProvider
- *       config={{
- *         projectId: 'YOUR_PROJECT_ID',
- *         metadata: {
- *           name: 'My App',
- *           description: 'My awesome dApp',
- *           url: 'https://myapp.com',
- *           icons: ['https://myapp.com/icon.png']
- *         }
- *       }}
- *       autoInit
- *     >
- *       <YourApp />
- *     </WalletConnectProvider>
- *   );
- * }
+ * // Search wallets
+ * const results = await getWalletConnectWallets({
+ *   projectId: 'your-project-id',
+ *   search: 'metamask'
+ * });
+ *
+ * // Filter by chain
+ * const ethWallets = await getWalletConnectWallets({
+ *   projectId: 'your-project-id',
+ *   chains: 'eip155:1'
+ * });
  * ```
  */
-declare function WalletConnectProvider({ config, children, autoInit }: WalletConnectProviderProps): react_jsx_runtime.JSX.Element;
+declare function getWalletConnectWallets(options?: WalletListOptions): Promise<WalletListResponse>;
 /**
- * Hook to use WalletConnect Context
+ * Get all wallets (automatically handles pagination)
  *
- * @example
- * ```tsx
- * import { useWalletConnect } from '@tomo-inc/wallet-connect-protocol';
+ * @param options Query options
+ * @returns Complete list of all wallets
+ */
+declare function getAllWallets(options?: WalletListOptions): Promise<Wallet[]>;
+/**
+ * Get specific wallet by ID
  *
- * function ConnectButton() {
- *   const { connect, uri, generateQRCode } = useWalletConnect();
- *   const [qrCode, setQrCode] = useState<string | null>(null);
+ * @param walletId Wallet ID
+ * @param projectId Project ID
+ * @returns Wallet information
+ */
+declare function getWalletById(walletId: string, projectId?: string): Promise<Wallet | null>;
+/**
+ * Search wallets
  *
- *   const handleConnect = async () => {
- *     const connectionUri = await connect();
- *     const qr = await generateQRCode(connectionUri);
- *     setQrCode(qr);
- *   };
+ * @param query Search keyword
+ * @param options Additional options
+ * @returns Matching wallet list
+ */
+declare function searchWallets(query: string, options?: Omit<WalletListOptions, "search">): Promise<Wallet[]>;
+/**
+ * Get wallets that support a specific chain
  *
- *   return (
- *     <div>
- *       <button onClick={handleConnect}>Connect Wallet</button>
- *       {qrCode && <img src={qrCode} alt="WalletConnect QR Code" />}
- *     </div>
- *   );
- * }
- * ```
+ * @param chainId Chain ID (CAIP-2 format, e.g. 'eip155:1')
+ * @param options Additional options
+ * @returns Wallets that support the chain
+ */
+declare function getWalletsByChain(chainId: string, options?: Omit<WalletListOptions, "chains">): Promise<Wallet[]>;
+/**
+ * Get recommended wallet list
  *
- * @throws if used outside WalletConnectProvider
+ * @param walletIds List of recommended wallet IDs
+ * @param options Additional options
+ * @returns Recommended wallet list
  */
-declare function useWalletConnect(): WalletConnectContextType;
-
+declare function getRecommendedWallets(walletIds: string[], options?: Omit<WalletListOptions, "recommendedIds">): Promise<Wallet[]>;
 /**
- * QR code generation Hook
- * @param uri WalletConnect URI
- * @param options QR code options
- * @returns QR code data URL
- */
-declare function useQRCode(uri?: string, options?: QRCodeOptions): {
-    qrCode: string | null;
-    loading: boolean;
-    error: Error | null;
-    generate: (targetUri?: string) => Promise<void>;
-};
-
+ * Get mobile wallet list
+ *
+ * @param options Query options
+ * @returns Mobile wallet list
+ */
+declare function getMobileWallets(options?: WalletListOptions): Promise<Wallet[]>;
 /**
- * session management Hook
- * @param topic optional session topic (if not provided, manage all sessions)
- */
-declare function useSession(topic?: string): {
-    session: SessionInfo | null;
-    allSessions: SessionInfo[];
-    disconnect: (sessionTopic?: string) => Promise<void>;
-    refresh: () => void;
-    isExpired: boolean;
-    getAccounts: (session?: SessionInfo) => string[];
-    getChains: (session?: SessionInfo) => string[];
-    hasSession: boolean;
-};
-
+ * Get desktop wallet list
+ *
+ * @param options Query options
+ * @returns Desktop wallet list
+ */
+declare function getDesktopWallets(options?: WalletListOptions): Promise<Wallet[]>;
 /**
- * connection management Hook
- * @param options configuration options
- */
-declare function useConnect(options?: {
-    autoGenerateQRCode?: boolean;
-    qrCodeOptions?: QRCodeOptions;
-    onConnect?: (uri: string) => void;
-    onError?: (error: Error) => void;
-}): {
-    connect: () => Promise<string>;
-    uri: string | null;
-    qrCode: string | null;
-    connecting: boolean;
-    error: Error | null;
-    reset: () => void;
-};
-
+ * Get browser extension wallet list
+ *
+ * @param options Query options
+ * @returns Browser extension wallet list
+ */
+declare function getBrowserWallets(options?: WalletListOptions): Promise<Wallet[]>;
 /**
- * SIWE authentication Hook
+ * Popular wallet ID list
  */
-declare function useSiwe(config?: Partial<SiweConfig>): {
-    signIn: (sessionTopic?: string) => Promise<{
-        success: boolean;
-        address: string;
-        message: string;
-        signature: any;
-        siweMessage: any;
-    }>;
-    signOut: () => void;
-    isAuthenticating: boolean;
-    authResult: {
-        success: boolean;
-        address?: string;
-        message?: string;
-        signature?: string;
-        error?: string;
-    } | null;
-    isAuthenticated: boolean;
+declare const POPULAR_WALLET_IDS: {
+    readonly METAMASK: "c57ca95b47569778a828d19178114f4db188b89b763c899ba0be274e97267d96";
+    readonly TRUST: "4622a2b2d6af1c9844944291e5e7351a6aa24cd7b23099efac1b2fd875da31a0";
+    readonly RAINBOW: "1ae92b26df02f0abca6304df07debccd18262fdf5fe82daa81593582dac9a369";
+    readonly COINBASE: "fd20dc426fb37566d803205b19bbc1d4096b248ac04548e3cfb6b3a38bd033aa";
+    readonly SAFE: "225affb176778569276e484e1b92637ad061b01e13a048b35a9d280c3b58970f";
+    readonly ARGENT: "bc949c5d968ae81310268bf9193f9c9fb7bb4e1283e1284af8f2bd4992535fd6";
+    readonly ZERION: "ecc4036f814562b41a5268adc86270fba1365471402006302e70169465b7ac18";
+    readonly IMTOKEN: "ef333840daf915aafdc4a004525502d6d49d77bd9c65e0642dbaefb3c2893bef";
+    readonly OKX: "971e689d0a5be527bac79629b4ee9b925e82208e5168b733496a09c0faed0709";
+    readonly PHANTOM: "a797aa35c0fadbfc1a53e7f675162ed5226968b44a19ee3d24385c64d1d3c393";
+    readonly TOKENPOCKET: "20459438007b75f4f4acb98bf29aa3b800550309646d375da5fd4aac6c2a2c66";
+    readonly BITGET: "7674bb4e353bf52886768a3ddc2a4562ce2f4191c80831291218ebd90f5f5e26";
 };
 
-export { QRCodeOptions, SessionInfo, SiweConfig, WalletConnectClient, WalletConnectConfig, WalletConnectProvider, type WalletConnectProviderProps, useConnect, useQRCode, useSession, useSiwe, useWalletConnect };
+export { APTOS_CHAINS, APTOS_NAMESPACE, AuthMethod, type AuthOptions, COSMOS_NAMESPACE, ChainType, type ConnectParams, EIP155_NAMESPACE, EVM_CHAINS, type EventHandler, NEAR_NAMESPACE, type NamespaceConfig, POLKADOT_NAMESPACE, POPULAR_WALLET_IDS, type QRCodeOptions, SOLANA_CHAINS, SOLANA_NAMESPACE, type SessionInfo, SiweAuth, type SiweConfig, type SiweResult, type Wallet, type WalletApp, WalletConnectClient, type WalletConnectConfig, type WalletConnectEvent, type WalletImage, type WalletListOptions, type WalletListResponse, type WalletMetadata, type WalletPlatform, copyToClipboard, createMultiChainNamespaces, createSiweConfigFromSession, createSiweMessage, extractAddressFromAccount, extractChainIdFromAccount, formatAddress, formatError, formatTimestamp, generateDeepLink, getAllWallets, getBrowserWallets, getDesktopWallets, getMobileWallets, getRecommendedWallets, getSessionTimeRemaining, getWalletById, getWalletConnectWallets, getWalletsByChain, isMobile, isSessionExpired, isValidChainId, isValidWalletConnectUri, parseChainId, parseSiweMessage, parseWalletConnectUri, searchWallets, verifySiweSignature };