> ## Documentation Index
> Fetch the complete documentation index at: https://docs.reown.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Options

AppKit for React Native is configured by calling the `createAppKit` function and passing a configuration object to it. This function initializes and returns the AppKit instance that you will use throughout your application, typically by providing it via the `AppKitProvider`.

```typescript theme={null}
import { createAppKit } from '@reown/appkit-react-native';
import { EthersAdapter } from '@reown/appkit-ethers-react-native';
import { SolanaAdapter } from '@reown/appkit-solana-react-native';
// Import other adapters as needed (e.g., BitcoinAdapter)

// Define your network configurations (see 'networks' option below for details)
const ethMainnet = { id: '1', name: 'Ethereum', chainNamespace: 'eip155', caipNetworkId: 'eip155:1', /* ... */ };
const solanaMainnet = { id: '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp', name: 'Solana', chainNamespace: 'solana',  /* ... */ };

export const appKit = createAppKit({
  projectId: 'YOUR_PROJECT_ID',
  metadata: { /* ... dApp metadata ... */ },
  networks: [ethMainnet, solanaMainnet], // Define all supported networks
  adapters: [ // Provide an array of initialized adapters
    new EthersAdapter(),
    new SolanaAdapter()
  ],
  // ... other options detailed below
});

// This appKit instance is then passed to AppKitProvider
```

Below are the detailed configuration options you can pass to `createAppKit`:

## Core Configuration

### `projectId`

* **Type:** `String`
* **Required:** Yes
* **Description:** Your project ID from [Reown Dashboard](https://dashboard.reown.com/). This is essential for enabling WalletConnect functionality, which AppKit uses for connecting with a wide range of wallets.

```typescript theme={null}
{
  projectId: 'YOUR_PROJECT_ID'
}
```

### `metadata`

* **Type:** `Object`
* **Required:** Yes
* **Description:** Information about your decentralized application (dApp) that is displayed to users in wallet connection prompts and used for deep linking.
  * `name`: (String) The name of your dApp.
  * `description`: (String) A brief description of your dApp.
  * `url`: (String) The official URL of your dApp.
  * `icons`: (Array of Strings) URLs to icon images for your dApp.
  * `redirect`: (Object) Configuration for redirecting users back to your app after wallet interactions, especially for mobile wallets.
    * `native`: (String) Your app's custom URL scheme for deep linking (e.g., `'yourappscheme://'`).
    * `universal`: (String) Your app's universal link URL (e.g., `'https://yourdapp.com/connect'`).

```typescript theme={null}
createAppKit({
  //...
  metadata: {
    name: 'My Awesome dApp',
    description: 'Connecting you to the decentralized web!',
    url: 'https://myapp.com',
    icons: ['https://myapp.com/logo.png'],
    redirect: {
      native: 'mydappscheme://',
      universal: 'https://myapp.com/walletconnect' // Or your specific universal link path
    }
  }
})
```

### `networks`

* **Type:** `Array<AppKitNetwork>`
* **Required:** Yes
* **Description:** An array of network objects that your dApp supports. Each object must conform to the `AppKitNetwork` type, which can be imported from `@reown/appkit-react-native`.

  <Note>
    If `chainNamespace` (e.g., 'eip155', 'solana', 'bitcoin') is not provided for a network, it will default to `'eip155'`. If `caipNetworkId` is not provided, it will be constructed as `chainNamespace:id` (e.g., 'eip155:1', 'solana:mainnet').
    Ensure these fields are correctly set for proper adapter mapping, especially for non-EVM chains.
  </Note>

**Example Sources for Network Configurations:**

<Accordion title="Pre-exported by AppKit">
  For convenience, AppKit exports configurations for Solana and Bitcoin networks.

  ```typescript theme={null}
  import { solana, bitcoin } from '@reown/appkit-react-native';

  const configuredNetworks = [solana, bitcoin];
  ```

  *Example of pre-exported Solana network: [packages/appkit/src/networks/solana.ts](https://github.com/reown-com/appkit-react-native/blob/develop/packages/appkit/src/networks/solana.ts)*
</Accordion>

<Accordion title="Using viem/chains for EVM Networks">
  You can often use standard chain definitions from libraries like `viem` or `wagmi` directly, as they typically conform to a compatible structure.

  ```typescript theme={null}
  import { mainnet as viemMainnet, polygon as viemPolygon } from 'viem/chains';

  const configuredNetworks = [viemMainnet, viemPolygon];
  ```
</Accordion>

<Accordion title="Custom Network Definitions">
  You can always define network objects manually. This is necessary for non-EVM chains if not pre-exported, or for custom EVM chains.

  ```typescript theme={null}
  import type { AppKitNetwork } from '@reown/appkit-react-native';

  export const mainnet: AppKitNetwork = {
    id: 1,
    name: 'Ethereum',
    nativeCurrency: {name: 'Ether', symbol: 'ETH', decimals: 18},
    rpcUrls: {
      default: {http: ['https://eth.llamarpc.com']},
    },
    blockExplorers: {
      default: {name: 'Etherscan', url: 'https://etherscan.io'},
    },
    chainNamespace: 'eip155',
    caipNetworkId: 'eip155:1',
  };

  export const polygon: AppKitNetwork = {
    id: 137,
    name: 'Polygon',
    nativeCurrency: {name: 'POL', symbol: 'POL', decimals: 18},
    rpcUrls: {
      default: {http: ['https://polygon-rpc.com']},
    },
    blockExplorers: {
      default: {name: 'PolygonScan', url: 'https://polygonscan.com'},
    },
    chainNamespace: 'eip155',
    caipNetworkId: 'eip155:137',
  };

  export const solanaDevnet: AppKitNetwork = {
    id: 'EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
    name: 'Solana Devnet',
    chainNamespace: 'solana',
    caipNetworkId: 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
    nativeCurrency: {name: 'Solana', symbol: 'SOL', decimals: 9},
    rpcUrls: {
      default: {http: ['https://rpc.walletconnect.org/v1']},
    },
    blockExplorers: {
      default: {name: 'Solscan', url: 'https://solscan.io'},
    },
    testnet: true,
  };

  const configuredNetworks = [mainnet, polygon, solanaDevnet];
  ```
</Accordion>

**Final Configuration Example:**

```typescript theme={null}
createAppKit({
  //...
  networks: configuredNetworks
})
```

### `adapters`

* **Type:** `Array<Adapter>`
* **Required:** Yes
* **Description:** An array of initialized chain adapter instances. Each adapter is responsible for handling a specific blockchain namespace (e.g., 'eip155' for EVM chains, 'solana' for Solana). AppKit will map the networks provided in the `networks` option to the appropriate adapter based on the namespace derived from the network's `id` and the namespaces supported by each adapter.

```typescript theme={null}
import { EthersAdapter } from '@reown/appkit-ethers-react-native';
import { SolanaAdapter } from '@reown/appkit-solana-react-native';
// import { BitcoinAdapter } from '@reown/appkit-bitcoin-react-native';

const projectId = 'YOUR_PROJECT_ID'; // Assuming projectId is defined

createAppKit({
  //...
  adapters: [
    new EthersAdapter(),
    new SolanaAdapter(),
    // new BitcoinAdapter()
  ]
})
```

### `storage`

* **Type:** `Storage`
* **Required:** Yes
* **Description:** A storage implementation that handles data persistence. AppKit provides a flexible storage interface that works with any storage solution you prefer.

The `Storage` interface, which can be imported from `@reown/appkit-react-native`, is defined as follows:

```typescript theme={null}
export interface Storage {
  /**
   * Returns all keys in storage.
   */
  getKeys(): Promise<string[]>;

  /**
   * Returns all key-value entries in storage.
   */
  getEntries<T = any>(): Promise<[string, T][]>;

  /**
   * Get an item from storage for a given key.
   * @param key The key to retrieve.
   */
  getItem<T = any>(key: string): Promise<T | undefined>;

  /**
   * Set an item in storage for a given key.
   * @param key The key to set.
   * @param value The value to set.
   */
  setItem<T = any>(key: string, value: T): Promise<void>;

  /**
   * Remove an item from storage for a given key.
   * @param key The key to remove.
   */
  removeItem(key: string): Promise<void>;
}
```

<AccordionGroup>
  <Accordion title="Example with react-native-mmkv">
    ```typescript theme={null}
      import { MMKV } from 'react-native-mmkv';
      import { safeJsonParse, safeJsonStringify } from '@walletconnect/safe-json';
      import type { Storage } from '@reown/appkit-react-native';

      const mmkv = new MMKV();

      const storage: Storage = {
        getKeys: async () => {
            return mmkv.getAllKeys();
        },
        getEntries: async <T = any>(): Promise<[string, T][]> => {
          function parseEntry(key: string): [string, any] {
            const value = mmkv.getString(key);
            return [key, safeJsonParse(value ?? '')];
          }

          const keys = mmkv.getAllKeys();
          return keys.map(parseEntry);
        },
        setItem: async <T = any>(key: string, value: T) => {
          return mmkv.set(key, safeJsonStringify(value));
        },
        getItem: async <T = any>(key: string): Promise<T | undefined> => {
          const item = mmkv.getString(key);
          if (typeof item === 'undefined' || item === null) {
            return undefined;
          }

          return safeJsonParse(item) as T;
        },
        removeItem: async (key: string) => {
          return mmkv.delete(key);
        },
      };

      createAppKit({
        //...
        storage
      })
    ```
  </Accordion>

  <Accordion title="Example with react-native-async-storage">
    ```typescript theme={null}
    import AsyncStorage from '@react-native-async-storage/async-storage';

    import { type Storage } from '@reown/appkit-react-native';
    import { safeJsonParse, safeJsonStringify } from '@walletconnect/safe-json';

    const storage: Storage = {
      getKeys: async () => {
        return await AsyncStorage.getAllKeys() as string[];
      },
      getEntries: async <T = any>(): Promise<[string, T][]> => {
        const keys = await AsyncStorage.getAllKeys();
        return await Promise.all(keys.map(async key => [
          key,
          safeJsonParse(await AsyncStorage.getItem(key) ?? '') as T,
        ]));
      },
      setItem: async <T = any>(key: string, value: T) => {
        await AsyncStorage.setItem(key, safeJsonStringify(value));
      },
      getItem: async <T = any>(key: string): Promise<T | undefined> => {
        const item = await AsyncStorage.getItem(key);
        if (typeof item === 'undefined' || item === null) {
          return undefined;
        }

        return safeJsonParse(item) as T;
      },
      removeItem: async (key: string) => {
        await AsyncStorage.removeItem(key);
      },
    };

    createAppKit({
      //...
      storage
    })
    ```
  </Accordion>
</AccordionGroup>

### `extraConnectors`

* **Type:** `Array<Connector>`
* **Required:** No
* **Description:** Additional wallet connectors that extend AppKit's connection capabilities beyond the standard WalletConnect protocol. This is useful for wallets that require custom connection methods, like Phantom Wallet and Coinbase.

```typescript theme={null}
import { PhantomConnector } from '@reown/appkit-solana-react-native';

createAppKit({
  //...
  extraConnectors: [
    new PhantomConnector({ cluster: 'mainnet-beta' }) // Or 'devnet', 'testnet'
  ]
})
```

### `defaultNetwork`

* **Type:** `AppKitNetwork` (Optional)
* **Description:** The network that AppKit should attempt to connect to by default, or highlight initially if no prior session exists. This object must be one of the networks defined in your `networks` array.

```typescript theme={null}
createAppKit({
  //...
  // Assuming ethereumMainnet is a valid AppKitNetwork object defined in your 'networks' array
  defaultNetwork: ethereumMainnet
})
```

## Modal & Wallet Display Customization

### `customWallets`

* **Type:** `Array<WalletEntry>` (Optional)
* **Description:** Allows you to add custom wallet entries to the connection modal. Each object in the array defines a wallet not available through WalletConnect's default registry. Refer to `WalletEntry` type for exact properties.

```typescript theme={null}
createAppKit({
  // ...
  customWallets: [
    {
      id: "myCustomWallet",
      name: "My Custom Wallet",
      homepage: "www.mycustomwallet.com", // Optional
      mobile_link: "mobile_link", // Optional - Deeplink or universal
      link_mode: "universal_link", // Optional - Universal link if the wallet supports link-mode
      desktop_link: "desktop_link", // Optional - Deeplink
      webapp_link: "webapp_link", // Optional
      app_store: "app_store", // Optional
      play_store: "play_store", // Optional
    },
  ]
})
```

### `featuredWalletIds`

* **Type:** `Array<String>` (Optional)
* **Description:** Select wallets that are going to be shown on the modal's main view. Array of wallet IDs defined will be prioritized (order is respected). These wallets will also show up first in `All Wallets` view. You can find the wallets ids in [WalletGuide](https://walletguide.walletconnect.network/).

```ts theme={null}
createAppKit({
  //...
  featuredWalletIds: [
    "1ae92b26df02f0abca6304df07debccd18262fdf5fe82daa81593582dac9a369", // Rainbow
    "4622a2b2d6af1c9844944291e5e7351a6aa24cd7b23099efac1b2fd875da31a0", // Trust
  ]
})
```

### `includeWalletIds`

* **Type:** `Array<String>` (Optional)
* **Description:** If provided, only wallets whose IDs are in this array will be shown in the modal. This effectively creates an allowlist, overriding the default WalletConnect registry listings.

```typescript theme={null}
createAppKit({
  //...
  includeWalletIds: [
    "c57ca95b47569778a828d19178114f2db125b25b778adf5cba72bd778e231769", // Example: MetaMask
    // ... only include these wallets
  ]
})
```

### `excludeWalletIds`

* **Type:** `Array<String>` (Optional)
* **Description:** An array of wallet IDs to be hidden from the modal. This allows you to remove specific wallets from the default WalletConnect registry listings.

```typescript theme={null}
createAppKit({
  //...
  excludeWalletIds: [
    "fd20dc426fb37566d803205b19bbc1d4096b248ac04548e3cfb6b3a38bd033aa", // Example: Coinbase Wallet (if you wish to exclude it)
  ]
})
```

## Theming & UI Customization

### `themeMode`

* **Type:** `'light' | 'dark'` (Optional)
* **Description:** Sets the initial theme for the AppKit modal. Defaults to the system theme or 'light' if system theme is unavailable.

```typescript theme={null}
createAppKit({
  //...
  themeMode: 'dark'
})
```

### `themeVariables`

* **Type:** `Object` (Optional)
* **Description:** Allows you to customize the accent color of the AppKit modal. Refer to the Theming documentation for details.

```typescript theme={null}
createAppKit({
  //...
  themeVariables: {
    'accent': '#4E88F7'
  }
})
```

### `networkImages` (Formerly `chainImages`)

* **Type:** `Record<string, string>` (Optional)
* **Description:** An object to provide custom image URLs for network icons in the modal. Keys should be network IDs (e.g., 'eip155:1', 'solana:mainnet').

```typescript theme={null}
createAppKit({
  //...
  networkImages: {
    'eip155:1': 'https://example.com/images/ethereum.png',
    'solana:mainnet': 'https://example.com/images/solana.png'
  }
})
```

## Token Balance Configuration

### `tokens`

* **Type:** `Record<string, { address: string }>` (Optional)
* **Description:** An object to configure specific tokens for which AppKit should display balances. The keys are CAIP-2 network IDs (e.g., 'eip155:1' for Ethereum Mainnet for a specific Solana network instance if required by ID structure). The value for each network ID is an object containing the token's contract `address` on that network.

```typescript theme={null}
createAppKit({
  //...
  tokens: {
    'eip155:1': { // Ethereum Mainnet
      address: '0xdAC17F958D2ee523a2206206994597C13D831ec7' // USDT on Ethereum
    },
    'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': { // Solana Mainnet
      address: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v' // USDC on Solana
    }
    // Add other tokens for other configured networks as needed
  }
})
```

## Utility & Advanced Options

### `clipboardClient`

* **Type:** `Object`
* **Required:** No (but functionally required for copy features)
* **Description:** Allows you to provide your own clipboard implementation. **If this client is not provided, all UI elements within AppKit that offer a "copy to clipboard" functionality (e.g., for addresses, QR code URIs) will be hidden.** To enable copy features, you must supply this client.
  It requires an async `setString` method that takes a string value to be copied.

```typescript theme={null}
import * as Clipboard from 'expo-clipboard'; // or from '@react-native-clipboard/clipboard'

createAppKit({
  //...
  clipboardClient: {
    setString: async (value: string) => {
      await Clipboard.setStringAsync(value);
      // console.log('Copied to clipboard!');
    }
  }
})
```

### `enableAnalytics`

* **Type:** `boolean` (Optional)
* **Default:** `true`
* **Description:** Set to `true` to enable analytics and gather insights on user activity within your [Reown Cloud dashboard](https://cloud.reown.com).

```typescript theme={null}
createAppKit({
  //...
  enableAnalytics: true
})
```

### `debug`

* **Type:** `boolean` (Optional)
* **Default:** `false`
* **Description:** Set to `true` to enable debug mode. This may show additional console logs helpful for development and troubleshooting.

```typescript theme={null}
createAppKit({
  //...
  debug: true
})
```

### universalProviderConfigOverride

Lets you customize specific aspects of the provider's behavior.

```typescript theme={null}
createAppKit({
  //...
  universalProviderConfigOverride: {
    methods: { eip155: ['eth_sendTransaction', 'personal_sign'] },
    chains: { eip155: ['1', '137'] },
    events: { eip155: ['chainChanged', 'accountsChanged'] },
    rpcMap: { eip155:1: 'https://ethereum.publicnode.com' },
  },
});
```

You can override any of the following properties:

* `methods`: Custom RPC methods for each namespace
* `chains`: Supported chains for each namespace
* `events`: Events to subscribe to for each namespace
* `rpcMap`: Custom RPC URLs for specific chains

## Feature Flags

### `features`

* **Type:** `Object` (Optional)
* **Description:** An object to toggle additional AppKit features on or off.

  * `swaps`: (Boolean, Optional) Enable/disable the token swap feature. Default: `true`.
  * `onramp`: (Boolean, Optional) Enable/disable the onramp feature. Default: `true`.
  * `socials`: (Array of Strings or Boolean, Optional) Configure email and social login options. Provide an array like `["google", "x", "discord", "apple"]` to enable specific platforms. Set to `false` or an empty array `[]` to disable all social logins. Default: All available socials enabled.
  * `showWallets`: (Boolean, Optional) If social login is enabled, this controls whether wallet options are shown on the initial connect screen alongside social options. If `false`, a button will redirect to a separate screen for wallet options. Default: `true`.

```typescript theme={null}
createAppKit({
  //...
  features: {
    swaps: true,
    onramp: true,
    socials: ['email', 'google', 'x', 'discord', 'apple', 'facebook', 'github', 'farcaster'],
    showWallets: true
  }
})
```

*This list may not be exhaustive. Always refer to the arguments of the `createAppKit` function and associated type definitions in the source code for the most up-to-date and complete list of options and their structures.*