@reown/appkit-react-native 2.0.0 → 2.0.2

package/lib/typescript/connectors/WalletConnectConnector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WalletConnectConnector.d.ts","sourceRoot":"","sources":["../../../src/connectors/WalletConnectConnector.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,EACf,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EAE1B,MAAM,mCAAmC,CAAC;AAE3C,UAAU,4BAA4B;IACpC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,sBAAuB,SAAQ,eAAe;IACzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+B;gBAE1C,MAAM,EAAE,4BAA4B;IAKjC,IAAI,CAAC,GAAG,EAAE,oBAAoB;YAa/B,cAAc;YAwBd,oBAAoB;IAkBzB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,OAAO,CAAC,IAAI,EAAE,cAAc;IA0BlC,WAAW,IAAI,QAAQ;IAQvB,aAAa,IAAI,UAAU;IAI3B,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAUpD,aAAa,IAAI,UAAU,GAAG,SAAS;IAIvC,UAAU,CAAC,SAAS,EAAE,cAAc,GAAG,aAAa,GAAG,SAAS;CAe1E"}
+{"version":3,"file":"WalletConnectConnector.d.ts","sourceRoot":"","sources":["../../../src/connectors/WalletConnectConnector.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,EACf,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EAEzB,KAAK,oBAAoB,EAE1B,MAAM,mCAAmC,CAAC;AAG3C,UAAU,4BAA4B;IACpC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,sBAAuB,SAAQ,eAAe;IACzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+B;gBAE1C,MAAM,EAAE,4BAA4B;IAKjC,IAAI,CAAC,GAAG,EAAE,oBAAoB;IAa9B,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC;YAwCnC,oBAAoB;IAkBnB,OAAO,CAAC,IAAI,EAAE,cAAc;IAmElC,WAAW,CAAC,SAAS,CAAC,EAAE,cAAc,GAAG,QAAQ;IAyBjD,aAAa,IAAI,UAAU;IAQ3B,aAAa,IAAI,oBAAoB,GAAG,SAAS;IAIjD,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAUpD,aAAa,IAAI,UAAU,GAAG,SAAS;IAIvC,UAAU,CAAC,SAAS,EAAE,cAAc,GAAG,aAAa,GAAG,SAAS;CAgB1E"}

package/lib/typescript/hooks/useAccount.d.ts

@@ -1,6 +1,63 @@
+import type { AccountType, AppKitNetwork } from '@reown/appkit-common-react-native';
+/**
+ * Represents a blockchain account with its associated metadata
+ */
+export interface Account {
+    /** The blockchain address of the account */
+    address: string;
+    /** The blockchain namespace (e.g., 'eip155' for Ethereum, 'solana' for Solana) */
+    namespace: string;
+    /** The chain ID where this account is active */
+    chainId: string;
+    /** Optional account type (e.g. 'eoa' or 'smartAccount') */
+    type?: AccountType;
+}
+/**
+ * Hook to access the current account state and connection information
+ *
+ * @remarks
+ * This hook provides access to all connected accounts, the currently active account,
+ * connection status, and active chain information. It automatically subscribes to
+ * connection state changes via valtio.
+ *
+ * The hook parses account data from CAIP-10 format (namespace:chainId:address)
+ * and provides a normalized structure.
+ *
+ * @returns An object containing:
+ * - `allAccounts` - Array of all connected accounts across all connections
+ * - `address` - The plain address of the currently active account (without namespace or chain prefix)
+ * - `isConnected` - Boolean indicating if a wallet is currently connected
+ * - `chainId` - The ID of the currently active chain
+ * - `chain` - The full chain/network object of the currently active chain
+ * - `namespace` - The namespace of the currently active account (e.g. 'eip155', 'solana' or 'bip122')
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { address, isConnected, chainId, allAccounts } = useAccount();
+ *
+ *   if (!isConnected) {
+ *     return <Text>Not connected</Text>;
+ *   }
+ *
+ *   return (
+ *     <View>
+ *       <Text>Connected: {address}</Text>
+ *       <Text>Chain: {chainId}</Text>
+ *       <Text>Total accounts: {allAccounts.length}</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ *
+ * @throws Will log errors via LogController if account parsing fails
+ */
 export declare function useAccount(): {
+    allAccounts: Account[];
     address: string | undefined;
     isConnected: boolean;
-    chainId: `${string}:${string}` | undefined;
+    chainId: string | undefined;
+    chain: AppKitNetwork | undefined;
+    namespace: import("@reown/appkit-common-react-native").ChainNamespace | undefined;
 };
 //# sourceMappingURL=useAccount.d.ts.map

package/lib/typescript/hooks/useAccount.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAccount.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAccount.ts"],"names":[],"mappings":"AAIA,wBAAgB,UAAU;;;;EAgBzB"}
+{"version":3,"file":"useAccount.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAccount.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGpF;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,kFAAkF;IAClF,SAAS,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,UAAU;;;;;;;EAsDzB"}

package/lib/typescript/hooks/useAppKit.d.ts

@@ -1,11 +1,53 @@
+import type { ChainNamespace } from '@reown/appkit-common-react-native';
 import type { AppKit } from '../AppKit';
+/**
+ * Interface representing the return value of the useAppKit hook
+ */
 interface UseAppKitReturn {
+    /** Function to open the AppKit modal with optional view configuration */
     open: AppKit['open'];
+    /** Function to close the AppKit modal */
     close: AppKit['close'];
-    disconnect: (namespace?: string) => void;
+    /** Function to disconnect the wallet, optionally scoped to a specific namespace */
+    disconnect: (namespace?: ChainNamespace) => void;
+    /** Function to switch to a different network */
     switchNetwork: AppKit['switchNetwork'];
-    isOpen: boolean;
 }
+/**
+ * Hook to access core AppKit functionality for controlling the modal
+ *
+ * @remarks
+ * This hook provides access to the main AppKit instance methods for opening/closing
+ * the modal, disconnecting wallets, and switching networks. All functions are memoized
+ * and properly bound to ensure stable references across renders.
+ *
+ * @returns {UseAppKitReturn} An object containing:
+ *   - `open`: Opens the AppKit modal, optionally with a specific view
+ *   - `close`: Closes the AppKit modal
+ *   - `disconnect`: Disconnects the current wallet connection (optionally for a specific namespace)
+ *   - `switchNetwork`: Switches to a different blockchain network
+ *
+ * @throws {Error} If used outside of an AppKitProvider
+ * @throws {Error} If AppKit instance is not available in context
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { open, close, disconnect, switchNetwork } = useAppKit();
+ *
+ *   return (
+ *     <View>
+ *       <Button onPress={() => open()} title="Connect Wallet" />
+ *       <Button onPress={() => disconnect()} title="Disconnect" />
+ *       <Button
+ *         onPress={() => switchNetwork('eip155:1')}
+ *         title="Switch to Ethereum"
+ *       />
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
 export declare const useAppKit: () => UseAppKitReturn;
 export {};
 //# sourceMappingURL=useAppKit.d.ts.map

package/lib/typescript/hooks/useAppKit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAppKit.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAppKit.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGxC,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IACvB,UAAU,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,aAAa,EAAE,MAAM,CAAC,eAAe,CAAC,CAAC;IACvC,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,eAAO,MAAM,SAAS,QAAO,eAmB5B,CAAC"}
+{"version":3,"file":"useAppKit.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAppKit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAExE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGxC;;GAEG;AACH,UAAU,eAAe;IACvB,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IACrB,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IACvB,mFAAmF;IACnF,UAAU,EAAE,CAAC,SAAS,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IACjD,gDAAgD;IAChD,aAAa,EAAE,MAAM,CAAC,eAAe,CAAC,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,SAAS,QAAO,eAkB5B,CAAC"}

package/lib/typescript/hooks/useAppKitContext.d.ts

@@ -0,0 +1,27 @@
+import { type AppKitContextType } from '../AppKitContext';
+/**
+ * Hook to access the AppKit context
+ *
+ * @remarks
+ * This is an internal hook used by other AppKit hooks to ensure they're used within
+ * the AppKitProvider. You typically don't need to use this hook directly - use the
+ * higher-level hooks like `useAppKit`, `useAccount`, `useAppKitTheme`, etc. instead.
+ *
+ * @returns {AppKitContextType} The AppKit context containing the AppKit instance
+ *
+ * @throws {Error} If used outside of an AppKitProvider
+ * @throws {Error} If the AppKit instance is not yet available in context
+ *
+ * @internal
+ *
+ * @example
+ * ```tsx
+ * // This is typically used internally by other hooks
+ * function MyCustomHook() {
+ *   const context = useAppKitContext();
+ *   // Use context.appKit...
+ * }
+ * ```
+ */
+export declare const useAppKitContext: () => AppKitContextType;
+//# sourceMappingURL=useAppKitContext.d.ts.map

package/lib/typescript/hooks/useAppKitContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAppKitContext.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAppKitContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,eAAO,MAAM,gBAAgB,QAAO,iBAanC,CAAC"}

package/lib/typescript/hooks/useAppKitEvents.d.ts

@@ -1,4 +1,37 @@
-import { type EventName, type EventsControllerState } from '@reown/appkit-core-react-native';
+import { type EventsControllerState } from '@reown/appkit-core-react-native';
+import { type EventName } from '@reown/appkit-common-react-native';
+/**
+ * Hook to subscribe to all AppKit events
+ *
+ * @remarks
+ * This hook provides reactive access to AppKit's event system, allowing you to
+ * monitor all events that occur within the AppKit lifecycle (connections, disconnections,
+ * network changes, etc.). The callback is invoked whenever a new event is emitted.
+ *
+ * @param callback - Optional callback function invoked when any event occurs
+ *
+ * @returns An object containing:
+ *   - `data`: The most recent event data
+ *   - `timestamp`: The timestamp of the most recent event
+ *
+ * @throws {Error} If used outside of an AppKitProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { data, timestamp } = useAppKitEvents((event) => {
+ *     console.log('Event occurred:', event.data.event);
+ *   });
+ *
+ *   return (
+ *     <View>
+ *       <Text>Last event: {data?.event}</Text>
+ *       <Text>Time: {timestamp}</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
 export declare function useAppKitEvents(callback?: (newEvent: EventsControllerState) => void): {
     data: {
         readonly type: "track";
@@ -12,6 +45,39 @@ export declare function useAppKitEvents(callback?: (newEvent: EventsControllerSt
         readonly properties: {
             readonly connected: boolean;
         };
+    } | {
+        readonly type: "track";
+        readonly event: "INITIALIZE";
+        readonly properties: {
+            readonly showWallets?: boolean | undefined;
+            readonly themeMode?: import("@reown/appkit-common-react-native").ThemeMode | undefined;
+            readonly themeVariables?: {
+                readonly accent?: string | undefined;
+            } | undefined;
+            readonly networks: readonly `${string}:${string}`[];
+            readonly defaultNetwork?: `${string}:${string}` | undefined;
+            readonly metadata?: {
+                readonly name: string;
+                readonly description: string;
+                readonly url: string;
+                readonly icons: readonly string[];
+                readonly redirect?: {
+                    readonly native?: string | undefined;
+                    readonly universal?: string | undefined;
+                    readonly linkMode?: boolean | undefined;
+                } | undefined;
+            } | undefined;
+            readonly enableAnalytics?: boolean | undefined;
+            readonly features?: {
+                readonly swaps?: boolean | undefined;
+                readonly onramp?: boolean | undefined;
+                readonly showWallets?: boolean | undefined;
+                readonly socials?: false | readonly import("@reown/appkit-common-react-native").SocialProvider[] | undefined;
+            } | undefined;
+            readonly adapters?: readonly string[] | undefined;
+            readonly extraConnectors?: readonly string[] | undefined;
+            readonly siwx?: boolean | undefined;
+        };
     } | {
         readonly type: "track";
         readonly event: "MODAL_CLOSE";
@@ -28,23 +94,29 @@ export declare function useAppKitEvents(callback?: (newEvent: EventsControllerSt
         readonly type: "track";
         readonly event: "SWITCH_NETWORK";
         readonly properties: {
-            readonly network: string | number;
+            readonly network: `${string}:${string}`;
         };
     } | {
         readonly type: "track";
         readonly event: "SELECT_WALLET";
         readonly properties: {
             readonly name: string;
-            readonly platform?: import("@reown/appkit-core-react-native").Platform | undefined;
-            readonly explorer_id?: string | undefined;
+            readonly platform?: import("@reown/appkit-common-react-native").Platform | undefined;
+            readonly explorerId?: string | undefined;
+            readonly walletRank?: number | undefined;
+            readonly displayIndex?: number | undefined;
+            readonly view?: "AllWallets" | "Connect" | undefined;
         };
     } | {
         readonly type: "track";
         readonly event: "CONNECT_SUCCESS";
+        readonly address?: string | undefined;
         readonly properties: {
             readonly name: string;
-            readonly method: import("@reown/appkit-core-react-native").Platform;
-            readonly explorer_id?: string | undefined;
+            readonly caipNetworkId?: `${string}:${string}` | undefined;
+            readonly method?: import("@reown/appkit-common-react-native").Platform | undefined;
+            readonly explorerId?: string | undefined;
+            readonly reconnect?: boolean | undefined;
         };
     } | {
         readonly type: "track";
@@ -52,9 +124,19 @@ export declare function useAppKitEvents(callback?: (newEvent: EventsControllerSt
         readonly properties: {
             readonly message: string;
         };
+    } | {
+        readonly type: "track";
+        readonly address?: string | undefined;
+        readonly event: "USER_REJECTED";
+        readonly properties: {
+            readonly message: string;
+        };
     } | {
         readonly type: "track";
         readonly event: "DISCONNECT_SUCCESS";
+        readonly properties: {
+            readonly namespace?: import("@reown/appkit-common-react-native").ChainNamespace | undefined;
+        };
     } | {
         readonly type: "track";
         readonly event: "DISCONNECT_ERROR";
@@ -66,19 +148,20 @@ export declare function useAppKitEvents(callback?: (newEvent: EventsControllerSt
         readonly event: "CLICK_NETWORK_HELP";
     } | {
         readonly type: "track";
-        readonly event: "CLICK_GET_WALLET";
-    } | {
-        readonly type: "track";
-        readonly event: "EMAIL_LOGIN_SELECTED";
+        readonly event: "CLICK_GET_WALLET_HELP";
     } | {
         readonly type: "track";
-        readonly event: "EMAIL_SUBMITTED";
-    } | {
-        readonly type: "track";
-        readonly event: "DEVICE_REGISTERED_FOR_EMAIL";
+        readonly event: "GET_WALLET";
+        readonly properties: {
+            readonly name: string;
+            readonly explorerId?: string | undefined;
+            readonly link?: string | undefined;
+            readonly linkType?: "appstore" | "playstore" | undefined;
+            readonly walletRank?: number | undefined;
+        };
     } | {
         readonly type: "track";
-        readonly event: "EMAIL_VERIFICATION_CODE_SENT";
+        readonly event: "EMAIL_LOGIN_SELECTED";
     } | {
         readonly type: "track";
         readonly event: "EMAIL_VERIFICATION_CODE_PASS";
@@ -96,31 +179,33 @@ export declare function useAppKitEvents(callback?: (newEvent: EventsControllerSt
         readonly event: "EMAIL_UPGRADE_FROM_MODAL";
     } | {
         readonly type: "track";
-        readonly event: "CLICK_SIGN_SIWE_MESSAGE";
+        readonly address?: string | undefined;
+        readonly event: "CLICK_SIGN_SIWX_MESSAGE";
         readonly properties: {
-            readonly network: string;
+            readonly network?: `${string}:${string}` | undefined;
             readonly isSmartAccount: boolean;
         };
     } | {
         readonly type: "track";
-        readonly event: "CLICK_CANCEL_SIWE";
+        readonly event: "CLICK_CANCEL_SIWX";
         readonly properties: {
-            readonly network: string;
+            readonly network?: `${string}:${string}` | undefined;
             readonly isSmartAccount: boolean;
         };
     } | {
         readonly type: "track";
-        readonly event: "SIWE_AUTH_SUCCESS";
+        readonly event: "SIWX_AUTH_SUCCESS";
         readonly properties: {
-            readonly network: string;
+            readonly network?: `${string}:${string}` | undefined;
             readonly isSmartAccount: boolean;
         };
     } | {
         readonly type: "track";
-        readonly event: "SIWE_AUTH_ERROR";
+        readonly event: "SIWX_AUTH_ERROR";
         readonly properties: {
-            readonly network: string;
+            readonly network?: `${string}:${string}` | undefined;
             readonly isSmartAccount: boolean;
+            readonly message?: string | undefined;
         };
     } | {
         readonly type: "track";
@@ -151,21 +236,21 @@ export declare function useAppKitEvents(callback?: (newEvent: EventsControllerSt
         readonly event: "OPEN_SEND";
         readonly properties: {
             readonly isSmartAccount: boolean;
-            readonly network: string;
+            readonly network?: `${string}:${string}` | undefined;
         };
     } | {
         readonly type: "track";
         readonly event: "OPEN_SWAP";
         readonly properties: {
             readonly isSmartAccount: boolean;
-            readonly network: string;
+            readonly network?: `${string}:${string}` | undefined;
         };
     } | {
         readonly type: "track";
         readonly event: "INITIATE_SWAP";
         readonly properties: {
             readonly isSmartAccount: boolean;
-            readonly network: string;
+            readonly network?: `${string}:${string}` | undefined;
             readonly swapFromToken: string;
             readonly swapToToken: string;
             readonly swapFromAmount: string;
@@ -176,7 +261,7 @@ export declare function useAppKitEvents(callback?: (newEvent: EventsControllerSt
         readonly event: "SWAP_SUCCESS";
         readonly properties: {
             readonly isSmartAccount: boolean;
-            readonly network: string;
+            readonly network?: `${string}:${string}` | undefined;
             readonly swapFromToken: string;
             readonly swapToToken: string;
             readonly swapFromAmount: string;
@@ -187,7 +272,7 @@ export declare function useAppKitEvents(callback?: (newEvent: EventsControllerSt
         readonly event: "SWAP_ERROR";
         readonly properties: {
             readonly isSmartAccount: boolean;
-            readonly network: string;
+            readonly network?: `${string}:${string}` | undefined;
             readonly swapFromToken: string;
             readonly swapToToken: string;
             readonly swapFromAmount: string;
@@ -199,7 +284,7 @@ export declare function useAppKitEvents(callback?: (newEvent: EventsControllerSt
         readonly event: "SEND_INITIATED";
         readonly properties: {
             readonly isSmartAccount: boolean;
-            readonly network: string;
+            readonly network?: `${string}:${string}` | undefined;
             readonly token: string;
             readonly amount: number;
         };
@@ -208,7 +293,7 @@ export declare function useAppKitEvents(callback?: (newEvent: EventsControllerSt
         readonly event: "SEND_SUCCESS";
         readonly properties: {
             readonly isSmartAccount: boolean;
-            readonly network: string;
+            readonly network?: `${string}:${string}` | undefined;
             readonly token: string;
             readonly amount: number;
         };
@@ -217,7 +302,7 @@ export declare function useAppKitEvents(callback?: (newEvent: EventsControllerSt
         readonly event: "SEND_ERROR";
         readonly properties: {
             readonly isSmartAccount: boolean;
-            readonly network: string;
+            readonly network?: `${string}:${string}` | undefined;
             readonly token: string;
             readonly amount: number;
         };
@@ -255,7 +340,7 @@ export declare function useAppKitEvents(callback?: (newEvent: EventsControllerSt
         readonly type: "track";
         readonly event: "SET_PREFERRED_ACCOUNT_TYPE";
         readonly properties: {
-            readonly accountType: import("@reown/appkit-core-react-native").AppKitFrameAccountType;
+            readonly accountType: import("@reown/appkit-common-react-native").AccountType;
             readonly network: string;
         };
     } | {
@@ -309,8 +394,48 @@ export declare function useAppKitEvents(callback?: (newEvent: EventsControllerSt
         readonly properties?: {
             readonly message?: string | undefined;
         } | undefined;
+    } | {
+        readonly type: "track";
+        readonly event: "WALLET_IMPRESSION";
+        readonly items: readonly {
+            readonly name: string;
+            readonly walletRank: number | undefined;
+            readonly explorerId: string;
+            readonly view: "AllWallets" | "Connect";
+            readonly displayIndex?: number | undefined;
+            readonly query?: string | undefined;
+            readonly certified?: boolean | undefined;
+            readonly installed?: boolean | undefined;
+        }[];
     };
     timestamp: number;
 };
+/**
+ * Hook to subscribe to a specific AppKit event
+ *
+ * @remarks
+ * This hook allows you to listen for a specific event type rather than all events.
+ * It's more efficient than `useAppKitEvents` when you only care about a particular event.
+ *
+ * @param event - The specific event name to subscribe to (e.g., 'MODAL_OPEN', 'CONNECT_SUCCESS')
+ * @param callback - Callback function invoked when the specified event occurs
+ *
+ * @throws {Error} If used outside of an AppKitProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   useAppKitEventSubscription('CONNECT_SUCCESS', (event) => {
+ *     console.log('Wallet connected!', event.data);
+ *   });
+ *
+ *   useAppKitEventSubscription('DISCONNECT_SUCCESS', (event) => {
+ *     console.log('Wallet disconnected!', event.data);
+ *   });
+ *
+ *   return <View>{/ Your component /}</View>;
+ * }
+ * ```
+ */
 export declare function useAppKitEventSubscription(event: EventName, callback: (newEvent: EventsControllerState) => void): void;
 //# sourceMappingURL=useAppKitEvents.d.ts.map

package/lib/typescript/hooks/useAppKitEvents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAppKitEvents.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAppKitEvents.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,qBAAqB,EAC3B,MAAM,iCAAiC,CAAC;AAGzC,wBAAgB,eAAe,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAenF;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI,QAWpD"}
+{"version":3,"file":"useAppKitEvents.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAppKitEvents.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,KAAK,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC/F,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAGnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,eAAe,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAenF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI,QAWpD"}

package/lib/typescript/hooks/useAppKitLogs.d.ts

@@ -0,0 +1,57 @@
+import { type LogEntry, type LogLevel } from '@reown/appkit-core-react-native';
+export interface UseAppKitLogsReturn {
+    /**
+     * All logs from AppKit
+     */
+    logs: LogEntry[];
+    /**
+     * Get logs filtered by level
+     */
+    getLogsByLevel: (level: LogLevel) => LogEntry[];
+    /**
+     * Get recent logs (default: 100)
+     */
+    getRecentLogs: (count?: number) => LogEntry[];
+    /**
+     * Export all logs as JSON string
+     */
+    exportLogs: () => string;
+    /**
+     * Get logging statistics by level
+     */
+    getLogsStats: () => Record<LogLevel, number>;
+    /**
+     * Clear all logs
+     */
+    clearLogs: () => void;
+    /**
+     * Convenience getters for different log levels (regular arrays, safe for console.log)
+     */
+    errorLogs: LogEntry[];
+    warningLogs: LogEntry[];
+    infoLogs: LogEntry[];
+    debugLogs: LogEntry[];
+}
+/**
+ * React hook for accessing AppKit logs
+ *
+ * This hook provides reactive access to AppKit's internal logging system.
+ * It automatically updates when new logs are added or when logs are cleaned up.
+ *
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const { logs, errorLogs, exportLogs, clearLogs } = useAppKitLogs();
+ *
+ *   return (
+ *     <View>
+ *       <Text>Total logs: {logs.length}</Text>
+ *       <Text>Error logs: {errorLogs.length}</Text>
+ *       <Button onPress={clearLogs} title="Clear Logs" />
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+export declare const useAppKitLogs: () => UseAppKitLogsReturn;
+//# sourceMappingURL=useAppKitLogs.d.ts.map

package/lib/typescript/hooks/useAppKitLogs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAppKitLogs.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAppKitLogs.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiB,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAG9F,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,IAAI,EAAE,QAAQ,EAAE,CAAC;IAEjB;;OAEG;IACH,cAAc,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,QAAQ,EAAE,CAAC;IAEhD;;OAEG;IACH,aAAa,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,QAAQ,EAAE,CAAC;IAE9C;;OAEG;IACH,UAAU,EAAE,MAAM,MAAM,CAAC;IAEzB;;OAEG;IACH,YAAY,EAAE,MAAM,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAE7C;;OAEG;IACH,SAAS,EAAE,MAAM,IAAI,CAAC;IAEtB;;OAEG;IACH,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,WAAW,EAAE,QAAQ,EAAE,CAAC;IACxB,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,SAAS,EAAE,QAAQ,EAAE,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa,QAAO,mBAsDhC,CAAC"}

package/lib/typescript/hooks/useAppKitState.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Hook to access the overall state of the AppKit modal and connection
+ *
+ * @remarks
+ * This hook provides a high-level view of the AppKit's current state, including
+ * whether the modal is open, if it's loading, connection status, and the active chain.
+ * It's useful for coordinating UI elements with the AppKit's state.
+ *
+ * @returns An object containing:
+ *   - `isOpen`: Whether the AppKit modal is currently open
+ *   - `isLoading`: Whether the AppKit is in a loading state
+ *   - `isConnected`: Whether a wallet is currently connected
+ *   - `chain`: The currently active blockchain network
+ *
+ * @throws {Error} If used outside of an AppKitProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { isOpen, isLoading, isConnected, chain } = useAppKitState();
+ *
+ *   return (
+ *     <View>
+ *       <Text>Modal: {isOpen ? 'Open' : 'Closed'}</Text>
+ *       <Text>Loading: {isLoading ? 'Yes' : 'No'}</Text>
+ *       <Text>Connected: {isConnected ? 'Yes' : 'No'}</Text>
+ *       {chain && <Text>Chain: {chain.name}</Text>}
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+export declare function useAppKitState(): {
+    isOpen: boolean;
+    isLoading: boolean;
+    isConnected: boolean;
+    chain: {
+        readonly id: string | number;
+        readonly name: string;
+        readonly nativeCurrency: {
+            readonly name: string;
+            readonly symbol: string;
+            readonly decimals: number;
+        };
+        readonly rpcUrls: {
+            readonly [x: string]: {
+                readonly http: readonly string[];
+            } | undefined;
+            readonly default: {
+                readonly http: readonly string[];
+            };
+        };
+        readonly blockExplorers?: {
+            readonly [x: string]: {
+                readonly name: string;
+                readonly url: string;
+            } | undefined;
+            readonly default: {
+                readonly name: string;
+                readonly url: string;
+            };
+        } | undefined;
+        readonly chainNamespace: "eip155" | "solana" | "bip122";
+        readonly caipNetworkId: `${string}:${string}`;
+        readonly testnet?: boolean | undefined;
+        readonly deprecatedCaipNetworkId?: `${string}:${string}` | undefined;
+        readonly imageUrl?: string | undefined;
+    } | undefined;
+};
+//# sourceMappingURL=useAppKitState.d.ts.map

package/lib/typescript/hooks/useAppKitState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAppKitState.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAppKitState.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmB7B"}