# Build with Phantom
Source: https://docs.phantom.com/introduction

Integrate wallet functionality into your apps with Phantom's powerful SDKs.

**Phantom** is a leading crypto wallet enabling users to manage digital assets and access decentralized applications across Solana, Ethereum, Bitcoin, Base, Polygon, Sui, and Monad. Available as a browser extension, iOS app, and Android app, Phantom provides developers with enterprise-grade wallet infrastructure through our comprehensive SDK suite.

This documentation is for developers building with Phantom. For integration support, submit a request using this form. For general support, visit our Help Center.

## Key Features

### Phantom Connect
Enable smooth and fast authentication with Phantom Connect, offering users the choice between social login providers (Google, Apple) or their existing Phantom browser extension.

### Phantom Connect SDKs
Build with our comprehensive SDK suite for web and mobile platforms. Choose from React, React Native, or Browser SDKs to integrate wallet functionality into your app with native multi-chain support.

### Phantom Portal
Publish and maintain your app with Phantom Portal, a self-service dashboard for managing branding, supported networks, and contract verification.


# Phantom MCP server
Source: https://docs.phantom.com/phantom-mcp-server

The Phantom MCP server (`@phantom/mcp-server`) gives AI agents a Phantom wallet. Agents can sign transactions, transfer tokens, swap, and interact onchain across Solana, Ethereum, Bitcoin, and Sui. It's a Phantom wallet product for users who interact through AI agents — the same way the mobile wallet and browser extension serve users who interact directly.

## Quick install

Add to your AI client config (requires App ID from phantom.com/portal):

```json
{
  "mcpServers": {
    "phantom": {
      "command": "npx",
      "args": ["-y", "@phantom/mcp-server@latest"],
      "env": { "PHANTOM_APP_ID": "your_app_id_from_portal" }
    }
  }
}
```

Supported clients: Claude Desktop, Cursor, Claude Code.

## Available tools

| Tool | Description |
|------|-------------|
| `get_connection_status` | Check if the wallet session is active |
| `get_wallet_addresses` | Get addresses for Solana, Ethereum, Bitcoin, and Sui |
| `get_token_balances` | View token holdings with live USD pricing |
| `transfer_tokens` | Transfer SOL, ETH, and SPL/ERC-20 tokens |
| `buy_token` | Swap tokens via Phantom routing (Solana, EVM, cross-chain) |
| `send_solana_transaction` | Sign and broadcast Solana transactions |
| `send_evm_transaction` | Sign and broadcast EVM transactions |
| `sign_solana_message` | Sign UTF-8 messages on Solana |
| `sign_evm_personal_message` | EIP-191 personal message signing |
| `sign_evm_typed_data` | EIP-712 structured data signing |
| `phantom_login` | Re-authenticate, switch accounts, or refresh a session |
| `pay_api_access` | Pay for daily API access when quota is consumed |
| `portfolio_rebalance` | Analyze and rebalance portfolio allocation via token swaps |


# Phantom MCP server setup
Source: https://docs.phantom.com/phantom-mcp-server/setup

Full installation and reference guide for the Phantom MCP server (`@phantom/mcp-server`).

## Prerequisites

Requires an App ID from Phantom Portal (phantom.com/portal):
1. Visit phantom.com/portal and sign in
2. Create an app and fill in required details
3. Navigate to Dashboard > View App > Redirect URLs and add `http://localhost:8080/callback`
4. Get your App ID from the Phantom Connect tab

## Installation

```bash
npx -y @phantom/mcp-server@latest
```

Or install globally: `npm install -g @phantom/mcp-server@latest` then run `phantom-mcp`.

## Setup by client

**Claude Desktop** — add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
```json
{
  "mcpServers": {
    "phantom": {
      "command": "npx",
      "args": ["-y", "@phantom/mcp-server@latest"],
      "env": { "PHANTOM_APP_ID": "your_app_id_from_portal" }
    }
  }
}
```

**Cursor** — add to `~/.cursor/mcp.json` (same config as above).

**Claude Code**:
```bash
claude mcp add phantom -- npx -y @phantom/mcp-server@latest
export PHANTOM_APP_ID=your_app_id_from_portal
```

## Environment variables

Required: `PHANTOM_APP_ID` — App ID from Phantom Portal.

Optional: `PHANTOM_CLIENT_SECRET`, `PHANTOM_CALLBACK_PORT` (default 8080), `PHANTOM_CALLBACK_PATH` (default /callback), `PHANTOM_MCP_DEBUG` (set to 1), `PHANTOM_AUTH_BASE_URL`, `PHANTOM_CONNECT_BASE_URL`, `PHANTOM_API_BASE_URL`, `PHANTOM_QUOTES_API_URL`.

## Authentication flow

On first run: opens browser to connect.phantom.app for Google/Apple login, starts local server on port 8080 for OAuth callback, saves session to `~/.phantom-mcp/session.json`. Sessions persist indefinitely via stamper keys.

## Tools reference

### get_connection_status
Checks whether the authenticated wallet session is active.

### get_wallet_addresses
Gets all blockchain addresses for the authenticated wallet.
- `derivationIndex` (number, optional): default 0

### get_token_balances
Returns token holdings with live USD pricing.
- `networks` (string[], optional): filter by network names e.g. `["solana", "ethereum", "base", "polygon", "arbitrum", "bitcoin", "sui", "monad"]`. Omit to return all.
- `derivationIndex` (number, optional): default 0

### send_solana_transaction
Signs and broadcasts a Solana transaction.
- `transaction` (string, required): Base64-encoded transaction (standard base64 with `A-Za-z0-9+/=`)
- `networkId` (string, optional): e.g. `solana:mainnet`. Defaults to `solana:mainnet`.
- `walletId` (string, optional): wallet ID to use for signing
- `derivationIndex` (number, optional): default 0

### send_evm_transaction
Signs and broadcasts an EVM transaction with automatic gas estimation.
- `chainId` (number, required): EVM chain ID e.g. `1` (Ethereum), `8453` (Base), `137` (Polygon)
- `to` (string, required): destination address (`0x`-prefixed)
- `value` (string, optional): value in wei as hex e.g. `"0x0"`
- `data` (string, optional): calldata as hex
- `gasLimit` (string, optional): gas limit as hex. Auto-estimated if omitted.
- `derivationIndex` (number, optional): default 0

### transfer_tokens
Transfers native tokens or SPL/ERC-20 tokens across Solana and EVM.
- `networkId` (string, required), `to` (string, required), `amount` (string, required)
- `tokenMint` (string, optional): SPL token mint (Solana only, omit for native SOL)
- `tokenAddress` (string, optional): ERC-20 contract address (EVM only, omit for native ETH)

### buy_token
Fetches a swap quote from Phantom routing. Optionally executes when `execute: true`.
- `amount` (string, required), `sellChainId`, `buyChainId`, `buyTokenMint`, `sellTokenMint`, `execute` (boolean)

### sign_solana_message
Signs a UTF-8 message on Solana.
- `message` (string, required), `networkId` (string, required)

### sign_evm_personal_message
Signs a message using EIP-191 for EVM chains.
- `message` (string, required), `chainId` (number, required): e.g. `1`, `8453`

### sign_evm_typed_data
Signs EIP-712 structured data.
- `typedData` (object, required), `chainId` (number, required): e.g. `1`, `8453`

## Supported networks

Solana: `solana:mainnet`, `solana:devnet`, `solana:testnet`
EVM: `eip155:1` (Ethereum), `eip155:8453` (Base), `eip155:137` (Polygon), `eip155:42161` (Arbitrum), `eip155:143` (Monad), plus testnets
Bitcoin: `bip122:000000000019d6689c085ae165831e93`
Sui: `sui:mainnet`, `sui:testnet`

## Session management

Sessions stored in `~/.phantom-mcp/session.json`. To reset: `rm ~/.phantom-mcp/session.json` then restart your AI client.


# Phantom Connect
Source: https://docs.phantom.com/phantom-connect

Onboard users with embedded wallets and authenticate them using Google or Apple.

## Overview

Phantom Connect is a suite of tools that lets developers onboard users instantly with embedded wallets powered by Phantom. Users sign in with Google or Apple (with more identity providers coming in the future), and your app receives a secure, ready-to-use wallet without requiring extensions, mobile apps, or private-key management.

When users authenticate with social login, Phantom creates an embedded wallet inside a secure environment on the user's device. This wallet is authorized to transact with your app and is protected by spending-limit controls, domain binding, and real-time risk evaluation. Your app never handles private keys and never becomes a custodian.

Phantom Connect also supports users connecting through the Phantom extension or other injected wallets. In this case, Phantom doesn't create an embedded wallet. Users approve transactions directly in their existing wallet, and your app interacts with it through the same Phantom Connect SDK interface.

## Embedded Wallets

Embedded wallets are wallets built directly into your application. No browser extensions, mobile apps, or external wallet software required. Users authenticate with familiar methods like Google or Apple, and your app instantly has access to a fully functional wallet.

## Authentication Methods

### Social Login
When a user selects **Sign in with Google** or **Sign in with Apple**, Phantom Connect creates or retrieves an embedded wallet tied to that identity.

Flow summary:
1. Users authenticate with Google or Apple.
2. Users enter their 4-digit PIN.
3. Users approve any required permissions or spending limits.
4. Your app receives the connected embedded wallet.

### Extension and Injected Wallets
When users connect with the Phantom extension or any other injected wallet:
- Phantom Connect doesn't create an embedded wallet.
- Users transact and approve actions directly inside their extension.
- The extension signs using whatever key-management system that wallet uses.
- Your app receives the connected account through the same Phantom Connect SDK interface.

## Session Duration
A Phantom Connect session remains active for seven days from the last login. After it expires, users must sign in again with Google or Apple.


# Phantom Portal Overview
Source: https://docs.phantom.com/phantom-portal/portal

Dashboard for managing app configuration, branding, and integration with Phantom.

Phantom Portal is a self-service dashboard where developers manage their app's configuration, branding, and presence within Phantom. To sign up, go to phantom.app/portal and sign up with a Google account or Apple ID.

## Key Features

- Configure your app: Set up allowed URLs, network support, and authentication settings.
- Manage branding: Upload your app icon, cover image, and description.
- View access mode: See your app's current access mode (DISABLED, PRIVATE, or PUBLIC).
- Verify your domain: Confirm that you own the domain in order to have your app displayed in Phantom.

## Apps That Need Phantom Portal Access

You need to use Phantom Portal if you're building one of the following:
- Apps with embedded wallet: Using React SDK, Browser SDK, or React Native SDK
- Apps with Phantom Connect: Implementing social login or extension-based authentication
- Apps that need public listing: Appearing in Phantom's Explore tab, search results, or recommended apps

## Domain Verification

Domain verification confirms that you control the domain where your app runs. While domain verification is not required to use Phantom Connect, it is required for your app to appear in Phantom's public discovery surfaces.


# Phantom Connect SDK Overview
Source: https://docs.phantom.com/wallet-sdks-overview

Compare React, React Native, and Browser SDKs to choose the right one for your application.

| SDK | Platform | Best For |
|-----|----------|----------|
| React SDK | Web (React) | React apps with built-in UI components and hooks |
| React Native SDK | Mobile (iOS/Android) | React Native and Expo mobile apps |
| Browser SDK | Web (Any) | Vanilla JS or non-React frameworks |

All SDKs support:
- Social login (Google, Apple)
- Browser extension connection
- Multi-chain support (Solana, Ethereum, Bitcoin, Base, Polygon, Sui, Monad)
- Message signing
- Transaction signing and sending


# React SDK
Source: https://docs.phantom.com/sdks/react-sdk

React hooks for wallet integration with built-in UI components and native transaction support.

## Installation

```bash
npm install @phantom/react-sdk
```

## Quick Start

```tsx
import { PhantomProvider, AddressType } from "@phantom/react-sdk";

function App() {
  return (
    <PhantomProvider
      config={{
        providers: ["google", "apple"],
        appId: "your-app-id",
        addressTypes: [AddressType.solana, AddressType.ethereum],
      }}
    >
      <YourApp />
    </PhantomProvider>
  );
}
```

## Hooks

### useConnect
Manages wallet connection functionality.

```tsx
const { connect, isConnecting, error } = useConnect();

// Connect with Google
await connect({ provider: "google" });

// Connect with Apple
await connect({ provider: "apple" });

// Connect with the Phantom browser extension
await connect({ provider: "injected" });
```

### useAccounts
Provides access to connected wallet information.

```tsx
const {
  addresses,    // Array of wallet addresses
  isConnected,  // Connection status
  walletId,     // Phantom wallet ID
} = useAccounts();
```

### useSolana
Provides access to Solana-specific operations.

```tsx
const { solana, isAvailable } = useSolana();

// Sign a message
const signature = await solana.signMessage("Hello Solana!");

// Sign and send a transaction
const result = await solana.signAndSendTransaction(transaction);
```

### useEthereum
Provides access to Ethereum-specific operations.

```tsx
const { ethereum, isAvailable } = useEthereum();

// Get accounts
const accounts = await ethereum.getAccounts();

// Sign a message
const signature = await ethereum.signPersonalMessage("Hello!", accounts[0]);

// Send a transaction
const result = await ethereum.sendTransaction(transactionData);
```

### useDisconnect
Manages wallet disconnection.

```tsx
const { disconnect, isDisconnecting } = useDisconnect();
await disconnect();
```


# React Native SDK
Source: https://docs.phantom.com/sdks/react-native-sdk

Mobile wallet integration for React Native apps with OAuth authentication.

## Installation

```bash
npm install @phantom/react-native-sdk

# For Expo projects
npx expo install expo-secure-store expo-web-browser expo-auth-session expo-router react-native-svg

# Required polyfill
npm install react-native-get-random-values
```

## Required Polyfill

You must polyfill random byte generation. Add this import at the very top of your app's entry point (before any other imports):

```tsx
// index.js, App.tsx, or _layout.tsx - MUST be the first import
import "react-native-get-random-values";
```

## Configure App Scheme

Add your custom scheme to `app.json`:

```json
{
  "expo": {
    "scheme": "mywalletapp",
    "plugins": ["expo-router", "expo-secure-store", "expo-web-browser", "expo-auth-session"]
  }
}
```

## Quick Start

```tsx
import "react-native-get-random-values";
import { PhantomProvider, AddressType, darkTheme } from "@phantom/react-native-sdk";

export default function App() {
  return (
    <PhantomProvider
      config={{
        providers: ["google", "apple"],
        appId: "your-app-id",
        scheme: "mywalletapp",
        addressTypes: [AddressType.solana],
        authOptions: {
          redirectUrl: "mywalletapp://phantom-auth-callback",
        },
      }}
      theme={darkTheme}
    >
      <WalletScreen />
    </PhantomProvider>
  );
}
```

## Using the Connection Modal

```tsx
import { useModal, useAccounts } from "@phantom/react-native-sdk";

export function WalletScreen() {
  const modal = useModal();
  const { isConnected, addresses } = useAccounts();

  if (!isConnected) {
    return <Button title="Connect Wallet" onPress={() => modal.open()} />;
  }

  return (
    <View>
      <Text>Connected: {addresses[0]?.address}</Text>
      <Button title="Manage Wallet" onPress={() => modal.open()} />
    </View>
  );
}
```

## Security Features

- iOS uses Keychain Services with hardware security
- Android uses Android Keystore with hardware-backed keys
- Uses system browser rather than in-app webviews
- Verifies redirect origins automatically


# Browser SDK
Source: https://docs.phantom.com/sdks/browser-sdk

Framework-agnostic JavaScript SDK for wallet integration in web apps.

## Installation

```bash
npm install @phantom/browser-sdk
```

## Quick Start

```typescript
import { createPhantom, AddressType } from "@phantom/browser-sdk";

const phantom = await createPhantom({
  providers: ["google", "apple"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana, AddressType.ethereum],
});

// Connect with Google
const accounts = await phantom.connect({ provider: "google" });
console.log("Connected:", accounts);

// Get Solana address
const solanaAddress = phantom.solana.publicKey?.toBase58();
```

## Chain Operations

### Solana

```typescript
// Sign a message
const signature = await phantom.solana.signMessage("Hello Solana!");

// Sign and send transaction
const result = await phantom.solana.signAndSendTransaction(transaction);
```

### Ethereum

```typescript
// Get accounts
const accounts = await phantom.ethereum.getAccounts();

// Sign message
const signature = await phantom.ethereum.signPersonalMessage("Hello!", accounts[0]);

// Send transaction
const result = await phantom.ethereum.sendTransaction(transactionData);
```


# Solana Integration - Detect the Provider
Source: https://docs.phantom.com/solana/detecting-the-provider

To detect if a user has already installed Phantom, a web application should check for the existence of a `phantom` object.

Phantom's browser extension and mobile in-app browser will both inject a `phantom` object into the window of any web application the user visits, provided that site is using `https://`, on `localhost`, or is `127.0.0.1`. Phantom will not inject the provider into iframes or sites that use `http://`.

If a `phantom` object exists, Solana apps can interact with Phantom via the API found at `window.phantom.solana`. This `solana` object is also available at `window.solana` to support legacy integrations.

```javascript
const isPhantomInstalled = window.phantom?.solana?.isPhantom;

const getProvider = () => {
  if ('phantom' in window) {
    const provider = window.phantom?.solana;
    if (provider?.isPhantom) {
      return provider;
    }
  }
  window.open('https://phantom.app/', '_blank');
};
```


# Solana Integration - Establish a Connection
Source: https://docs.phantom.com/solana/establishing-a-connection

Once the Phantom provider is detected, an app may request to connect to Phantom. This will prompt the user for permission to share their public key.

```javascript
const provider = getProvider();

try {
  const resp = await provider.connect();
  console.log(resp.publicKey.toString());
} catch (err) {
  // { code: 4001, message: 'User rejected the request.' }
}
```

Once connected, the provider will emit a `connect` event:

```javascript
provider.on("connect", (publicKey) => {
  console.log("Connected:", publicKey.toString());
});
```


# Solana Integration - Send a Transaction
Source: https://docs.phantom.com/solana/sending-a-transaction

Once connected, an app can request to sign and send transactions on the user's behalf.

```javascript
import { Connection, SystemProgram, Transaction, PublicKey } from "@solana/web3.js";

const connection = new Connection("https://api.mainnet-beta.solana.com");
const provider = getProvider();

const transaction = new Transaction().add(
  SystemProgram.transfer({
    fromPubkey: provider.publicKey,
    toPubkey: new PublicKey("..."),
    lamports: 1000000,
  })
);

transaction.feePayer = provider.publicKey;
transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;

const { signature } = await provider.signAndSendTransaction(transaction);
await connection.getSignatureStatus(signature);
```


# Solana Integration - Sign a Message
Source: https://docs.phantom.com/solana/signing-a-message

Apps can request to sign an arbitrary message. This is useful for authentication and verification purposes.

```javascript
const provider = getProvider();
const message = "Hello, Phantom!";
const encodedMessage = new TextEncoder().encode(message);

const { signature } = await provider.signMessage(encodedMessage, "utf8");
```


# Ethereum Integration - Get Started
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/getting-started

Phantom supports Ethereum, Base, Polygon, and Monad. The provider API follows the EIP-1193 standard.

```javascript
const isPhantomInstalled = window.phantom?.ethereum?.isPhantom;

const getProvider = () => {
  if ('phantom' in window) {
    const provider = window.phantom?.ethereum;
    if (provider?.isPhantom) {
      return provider;
    }
  }
  window.open('https://phantom.app/', '_blank');
};
```


# Ethereum Integration - Connect
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/establishing-a-connection

Request access to the user's Ethereum accounts:

```javascript
const provider = getProvider();

try {
  const accounts = await provider.request({ method: "eth_requestAccounts" });
  console.log("Connected:", accounts[0]);
} catch (err) {
  // { code: 4001, message: 'User rejected the request.' }
}
```


# Ethereum Integration - Send Transaction
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/sending-a-transaction

```javascript
const provider = getProvider();
const accounts = await provider.request({ method: "eth_requestAccounts" });

const transactionParameters = {
  to: "0x...",
  from: accounts[0],
  value: "0x29a2241af62c0000", // 3 ETH in wei
};

const txHash = await provider.request({
  method: "eth_sendTransaction",
  params: [transactionParameters],
});
```


# Bitcoin Integration - Get Started
Source: https://docs.phantom.com/bitcoin/integrating-phantom

Phantom supports Bitcoin with native SegWit addresses.

```javascript
const isPhantomInstalled = window.phantom?.bitcoin?.isPhantom;

const getProvider = () => {
  if ('phantom' in window) {
    const provider = window.phantom?.bitcoin;
    if (provider?.isPhantom) {
      return provider;
    }
  }
  window.open('https://phantom.app/', '_blank');
};
```


# Bitcoin Integration - Connect
Source: https://docs.phantom.com/bitcoin/establishing-a-connection

```javascript
const provider = getProvider();

try {
  const accounts = await provider.requestAccounts();
  console.log("Connected:", accounts[0].address);
} catch (err) {
  // User rejected
}
```


# Sui Integration - Get Started
Source: https://docs.phantom.com/sui/getting-started-with-sui

Phantom supports Sui blockchain.

```javascript
const isPhantomInstalled = window.phantom?.sui?.isPhantom;

const getProvider = () => {
  if ('phantom' in window) {
    const provider = window.phantom?.sui;
    if (provider?.isPhantom) {
      return provider;
    }
  }
  window.open('https://phantom.app/', '_blank');
};
```


# Phantom Deep Links
Source: https://docs.phantom.com/phantom-deeplinks/deeplinks-ios-and-android

iOS and Android apps can natively interact with Phantom through universal links or deeplinks.

Currently only Solana is supported for deeplinks.

All provider methods follow a protocol format of:
```
https://phantom.app/ul/<version>/<method>
```

It is also possible (but not recommended) to call these methods using Phantom's custom protocol handler:
```
phantom://<version>/<method>
```

## Provider Methods

- **Connect**: `https://phantom.app/ul/v1/connect`
- **Disconnect**: `https://phantom.app/ul/v1/disconnect`
- **SignAndSendTransaction**: `https://phantom.app/ul/v1/signAndSendTransaction`
- **SignAllTransactions**: `https://phantom.app/ul/v1/signAllTransactions`
- **SignTransaction**: `https://phantom.app/ul/v1/signTransaction`
- **SignMessage**: `https://phantom.app/ul/v1/signMessage`

## Other Methods

- **Browse**: Open a URL in Phantom's in-app browser
- **Fungible**: Deep link to a token detail page
- **Swap**: Deep link to the swap interface


# Testnet Mode
Source: https://docs.phantom.com/developer-powertools/testnet-mode

Access test networks in Phantom for development and testing.

To access test networks in Phantom, go to Settings → Developer Settings → Testnet Mode.

## Supported Test Networks

- Solana Devnet
- Solana Testnet
- Ethereum Sepolia
- Polygon Amoy
- Base Sepolia
- Monad Testnet

## Get Test Tokens

- Solana Devnet: https://faucet.solana.com
- Ethereum Sepolia: https://sepoliafaucet.com
- Polygon Amoy: https://faucet.polygon.technology
- Base Sepolia: https://www.basescan.org/faucets


# Phantom Connect SDK MCP Server
Source: https://docs.phantom.com/resources/mcp-server

The Phantom Connect SDK MCP (Model Context Protocol) server enables AI coding assistants like Cursor, Claude, and VS Code to search and retrieve information from the Phantom developer documentation.

## Available Tools

- **SearchPhantomDeveloper**: Search across the entire Phantom developer documentation knowledge base

## Configuration

### Cursor
Add to `~/.cursor/mcp.json`:
```json
{
  "mcpServers": {
    "phantom": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-client", "https://docs.phantom.com/mcp"]
    }
  }
}
```

### Claude Code
```bash
claude mcp add phantom https://docs.phantom.com/mcp
```


# FAQ
Source: https://docs.phantom.com/resources/faq

## What is Phantom Connect?
Phantom Connect is a suite of tools that lets developers onboard users with embedded wallets powered by Phantom. Users authenticate with Google or Apple, and your app receives a secure, ready-to-use wallet.

## What's the difference between embedded and extension wallets?
Embedded wallets are created and managed within your application through social login. Extension wallets are the user's existing Phantom browser extension.

## Which SDK should I use?
- **React SDK**: For React web applications
- **React Native SDK**: For React Native/Expo mobile apps
- **Browser SDK**: For vanilla JS or non-React frameworks

## Do I need to set up Phantom Portal?
Yes, you need to register your app in Phantom Portal to obtain an App ID and configure allowed origins.

## Which blockchains does Phantom Connect support?
Solana is fully supported. EVM support (Ethereum, Base, Polygon, Monad) for embedded wallets is planned.

## Can users connect with both social login and extension?
Yes, your app can support both methods. Users choose their preferred authentication method when connecting.


# Demo Apps and Sandbox
Source: https://docs.phantom.com/resources/sandbox

## Multi-chain Sandbox
For a live example of how a multichain dApp can integrate with Phantom, check out our Multichain Sandbox on CodeSandbox and GitHub.
- https://codesandbox.io/s/phantom-multichain-sandbox
- https://github.com/phantom/sandbox

## Solana-only Sandbox
For a Solana-only integration example:
- https://github.com/phantom/sandbox

## React Native Demo
For mobile deep linking demonstration:
- https://github.com/phantom/deep-link-demo-app

# Recipes
Source: https://docs.phantom.com/recipes

Ready-to-use code examples for common Phantom Connect integration patterns.

Recipes are complete, working code examples organized by what you want to build. Each recipe includes full source code you can copy directly into your project.

## Popular

Get started quickly with these commonly used recipes: Send SOL, Social login (Google, Apple), Sign a message, Check wallet balance.

## All recipes

- Authentication: Sign in users with Google, Apple, or browser extension
- Payments: Send SOL, USDC, and other tokens
- Signatures: Sign messages for agreements and verification
- Wallet operations: Check balances and manage token accounts
- Transactions: Advanced transaction features and monitoring

## Authentication

Connect users to your app with Phantom wallets.

- Social login (Google, Apple): Let users sign in with Google or Apple and get a wallet
- Browser extension login: Connect to existing Phantom browser extension wallets
- Session management: Keep users logged in across page reloads

## Payments

Send and receive tokens on Solana.

- Send SOL: Transfer SOL to any wallet address
- Send USDC: Transfer USDC stablecoin payments
- Send any SPL token: Transfer any SPL token by mint address
- Request payment: Generate payment requests with Solana Pay

## Signatures

Sign messages for user agreements, terms of service, or data integrity.

- Sign a message: Request a signature from the connected wallet

## Wallet operations

Check balances, view token accounts, and manage wallet state.

- Check wallet balance: Get SOL and token balances for the connected wallet
- Get all token accounts: List all SPL token accounts and balances

## Transactions

Advanced transaction features for better user experience and monitoring.

- Add priority fees: Add priority fees for faster confirmation
- Check transaction status: Monitor transaction confirmation and get details

## Quickstarts

Get up and running in your framework of choice: Next.js, React (Vite), Vanilla JavaScript, React Native.

## Example apps

Production-ready example applications on GitHub:

- React SDK Demo: https://github.com/phantom/phantom-connect-sdk/tree/main/examples/react-sdk-demo-app
- Next.js Starter: https://github.com/phantom/phantom-connect-sdk/tree/main/examples/with-nextjs
- Browser SDK Demo: https://github.com/phantom/phantom-connect-sdk/tree/main/examples/browser-sdk-demo-app
- React Native Demo: https://github.com/phantom/phantom-connect-sdk/tree/main/examples/react-native-sdk-demo-app


# Social login (Google, Apple)
Source: https://docs.phantom.com/recipes/auth/social-login

Let users sign in with familiar social accounts. Phantom Connect creates a non-custodial wallet for them automatically.

## React

```tsx
import { PhantomProvider, useModal, usePhantom, useAccounts, darkTheme } from "@phantom/react-sdk";
import { AddressType } from "@phantom/browser-sdk";

function App() {
  return (
    <PhantomProvider
      config={{
        providers: ["google", "apple"],
        appId: "your-app-id",
        addressTypes: [AddressType.solana],
        authOptions: {
          redirectUrl: "https://yourapp.com/auth/callback",
        },
      }}
      theme={darkTheme}
      appName="Your App"
    >
      <LoginPage />
    </PhantomProvider>
  );
}

function LoginPage() {
  const { open } = useModal();
  const { isConnected } = usePhantom();
  const addresses = useAccounts();

  if (isConnected && addresses) {
    return (
      <div>
        <p>Welcome! Your wallet: {addresses[0]?.address}</p>
      </div>
    );
  }

  return (
    <div>
      <h1>Sign in to get started</h1>
      <button onClick={open}>Continue with Google or Apple</button>
    </div>
  );
}
```

## Browser SDK

```typescript
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";

const sdk = new BrowserSDK({
  providers: ["google", "apple"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana],
  authOptions: {
    redirectUrl: "https://yourapp.com/callback",
  },
});

// Sign in with Google
document.getElementById("google-btn").onclick = async () => {
  const { addresses } = await sdk.connect({ provider: "google" });
  console.log("Wallet address:", addresses[0].address);
};

// Sign in with Apple
document.getElementById("apple-btn").onclick = async () => {
  const { addresses } = await sdk.connect({ provider: "apple" });
  console.log("Wallet address:", addresses[0].address);
};
```

## React Native

```tsx
import { PhantomProvider, useModal, usePhantom, useAccounts, AddressType, darkTheme } from "@phantom/react-native-sdk";
import { View, Text, Button, StyleSheet } from "react-native";

function App() {
  return (
    <PhantomProvider
      config={{
        providers: ["google", "apple"],
        appId: "your-app-id",
        scheme: "yourapp",
        addressTypes: [AddressType.solana],
        authOptions: {
          redirectUrl: "yourapp://auth/callback",
        },
      }}
      theme={darkTheme}
      appName="Your App"
    >
      <LoginPage />
    </PhantomProvider>
  );
}

function LoginPage() {
  const { open } = useModal();
  const { isConnected } = usePhantom();
  const addresses = useAccounts();

  if (isConnected && addresses) {
    return (
      <View style={styles.container}>
        <Text style={styles.welcome}>Welcome!</Text>
        <Text style={styles.address}>Your wallet: {addresses[0]?.address}</Text>
      </View>
    );
  }

  return (
    <View style={styles.container}>
      <Text style={styles.title}>Sign in to get started</Text>
      <Button title="Continue with Google or Apple" onPress={open} />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: "center",
    alignItems: "center",
    padding: 20,
  },
  title: {
    fontSize: 24,
    fontWeight: "bold",
    marginBottom: 20,
  },
  welcome: {
    fontSize: 20,
    fontWeight: "bold",
    marginBottom: 10,
  },
  address: {
    fontSize: 14,
    color: "#666",
  },
});
```

## Handle the OAuth callback

Create a callback page at your `redirectUrl`:

```tsx
// app/auth/callback/page.tsx (Next.js)
"use client";
import { ConnectBox } from "@phantom/react-sdk";

export default function AuthCallback() {
  return (
    <div style={{ display: "flex", justifyContent: "center", alignItems: "center", minHeight: "100vh" }}>
      <ConnectBox />
    </div>
  );
}
```


# Browser extension login
Source: https://docs.phantom.com/recipes/auth/extension-login

Let users connect their existing Phantom browser extension wallet to your app.

Note for React Native: Browser extension connection is not available in React Native apps. Use OAuth providers (Google, Apple) instead. See Social login for React Native authentication.

## React

```tsx
import { PhantomProvider, useConnect, usePhantom, useAccounts, useIsExtensionInstalled, darkTheme } from "@phantom/react-sdk";
import { AddressType } from "@phantom/browser-sdk";

function App() {
  return (
    <PhantomProvider
      config={{
        providers: ["injected"],
        appId: "your-app-id",
        addressTypes: [AddressType.solana],
      }}
      theme={darkTheme}
      appName="Your App"
    >
      <ExtensionLogin />
    </PhantomProvider>
  );
}

function ExtensionLogin() {
  const { connect, isConnecting } = useConnect();
  const { isConnected } = usePhantom();
  const addresses = useAccounts();
  const { isInstalled, isLoading } = useIsExtensionInstalled();

  if (isLoading) {
    return <p>Checking for Phantom...</p>;
  }

  if (!isInstalled) {
    return (
      <div>
        <p>Phantom extension not found</p>
        <a href="https://phantom.app/download" target="_blank">
          Install Phantom
        </a>
      </div>
    );
  }

  if (isConnected && addresses) {
    return <p>Connected: {addresses[0]?.address}</p>;
  }

  return (
    <button onClick={() => connect({ provider: "injected" })} disabled={isConnecting}>
      {isConnecting ? "Connecting..." : "Connect Phantom"}
    </button>
  );
}
```

## Browser SDK

```typescript
import { BrowserSDK, AddressType, waitForPhantomExtension } from "@phantom/browser-sdk";

const sdk = new BrowserSDK({
  providers: ["injected"],
  addressTypes: [AddressType.solana],
});

// Check if extension is installed
const isAvailable = await waitForPhantomExtension(3000);

if (!isAvailable) {
  // Show install prompt
  window.location.href = "https://phantom.app/download";
}

// Connect to extension
const { addresses } = await sdk.connect({ provider: "injected" });
console.log("Connected:", addresses[0].address);
```


# Session management
Source: https://docs.phantom.com/recipes/auth/session-management

Keep users logged in across page reloads and browser sessions.

The SDK automatically persists sessions. Here's how to handle the connection state and show the right UI.

## React

```tsx
import { PhantomProvider, usePhantom, useModal, useAccounts, useDisconnect, darkTheme } from "@phantom/react-sdk";
import { AddressType } from "@phantom/browser-sdk";

function App() {
  return (
    <PhantomProvider
      config={{
        providers: ["google", "apple", "injected"],
        appId: "your-app-id",
        addressTypes: [AddressType.solana],
        authOptions: {
          redirectUrl: "https://yourapp.com/auth/callback",
        },
      }}
      theme={darkTheme}
      appName="Your App"
    >
      <AppContent />
    </PhantomProvider>
  );
}

function AppContent() {
  const { isConnected } = usePhantom();
  const { open } = useModal();
  const addresses = useAccounts();
  const { disconnect } = useDisconnect();

  // User is logged in
  if (isConnected && addresses) {
    return (
      <div>
        <p>Welcome back!</p>
        <p>Wallet: {addresses[0]?.address}</p>
        <button onClick={() => disconnect()}>Sign out</button>
      </div>
    );
  }

  // User needs to log in
  return (
    <div>
      <h1>Welcome</h1>
      <button onClick={open}>Sign in</button>
    </div>
  );
}
```

## Browser SDK

```typescript
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";

const sdk = new BrowserSDK({
  providers: ["google", "apple", "injected"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana],
});

// Listen for connection events
sdk.on("connect", (data) => {
  console.log("Connected:", data.addresses);
  // Update your UI to show logged-in state
});

sdk.on("disconnect", () => {
  console.log("Disconnected");
  // Update your UI to show logged-out state
});

// Try to restore existing session on page load
await sdk.autoConnect();
```

## React Native

```tsx
import { PhantomProvider, usePhantom, useModal, useAccounts, useDisconnect, AddressType, darkTheme } from "@phantom/react-native-sdk";
import { View, Text, Button, StyleSheet, ActivityIndicator } from "react-native";

function App() {
  return (
    <PhantomProvider
      config={{
        providers: ["google", "apple"],
        appId: "your-app-id",
        scheme: "yourapp",
        addressTypes: [AddressType.solana],
        authOptions: {
          redirectUrl: "yourapp://auth/callback",
        },
      }}
      theme={darkTheme}
      appName="Your App"
    >
      <AppContent />
    </PhantomProvider>
  );
}

function AppContent() {
  const { isConnected } = usePhantom();
  const { open } = useModal();
  const addresses = useAccounts();
  const { disconnect } = useDisconnect();

  if (isConnected && addresses) {
    return (
      <View style={styles.container}>
        <Text style={styles.welcome}>Welcome back!</Text>
        <Text style={styles.address}>Wallet: {addresses[0]?.address}</Text>
        <Button title="Sign out" onPress={() => disconnect()} />
      </View>
    );
  }

  return (
    <View style={styles.container}>
      <Text style={styles.title}>Welcome</Text>
      <Button title="Sign in" onPress={open} />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: "center",
    alignItems: "center",
    padding: 20,
  },
  title: {
    fontSize: 24,
    fontWeight: "bold",
    marginBottom: 20,
  },
  welcome: {
    fontSize: 20,
    fontWeight: "bold",
    marginBottom: 10,
  },
  address: {
    fontSize: 14,
    color: "#666",
    marginBottom: 20,
  },
});
```


# Sign-in with Solana (SIWS)
Source: https://docs.phantom.com/recipes/auth/sign-in-with-solana

Verify a user owns a wallet by asking them to sign a message, then validate the signature on your backend.

## React

```tsx
import { useSolana, useAccounts } from "@phantom/react-sdk";

function SignInWithSolana() {
  const { solana } = useSolana();
  const addresses = useAccounts();

  const signIn = async () => {
    const address = addresses?.[0]?.address;
    if (!solana || !address) return;

    // Create a sign-in message
    const message = `Sign in to MyApp

Address: ${address}
Timestamp: ${new Date().toISOString()}
Nonce: ${crypto.randomUUID()}`;

    // Request signature
    const { signature } = await solana.signMessage(message);

    // Send to your backend for verification
    const response = await fetch("/api/auth/verify", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ address, message, signature }),
    });

    const { token } = await response.json();
    console.log("Authenticated! Token:", token);
  };

  return <button onClick={signIn}>Sign in with Solana</button>;
}
```

## Browser SDK

```typescript
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";

const sdk = new BrowserSDK({
  providers: ["google", "apple", "injected"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana],
});

async function signIn() {
  const address = await sdk.solana.getPublicKey();

  const message = `Sign in to MyApp

Address: ${address}
Timestamp: ${new Date().toISOString()}
Nonce: ${crypto.randomUUID()}`;

  const { signature } = await sdk.solana.signMessage(message);

  // Send to backend for verification
  const response = await fetch("/api/auth/verify", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ address, message, signature }),
  });

  const { token } = await response.json();
  return token;
}
```

## React Native

```tsx
import { useSolana, useAccounts } from "@phantom/react-native-sdk";
import { View, Button, Alert, StyleSheet } from "react-native";

function SignInWithSolana() {
  const { solana } = useSolana();
  const addresses = useAccounts();

  const signIn = async () => {
    try {
      const address = addresses?.[0]?.address;
      if (!solana || !address) {
        Alert.alert("Error", "Please connect your wallet first");
        return;
      }

      const message = `Sign in to MyApp

Address: ${address}
Timestamp: ${new Date().toISOString()}
Nonce: ${crypto.randomUUID()}`;

      const { signature } = await solana.signMessage(message);

      const response = await fetch("/api/auth/verify", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ address, message, signature }),
      });

      const { token } = await response.json();
      Alert.alert("Success", "Authenticated!");
      console.log("Token:", token);
    } catch (error) {
      Alert.alert("Error", error.message);
    }
  };

  return (
    <View style={styles.container}>
      <Button title="Sign in with Solana" onPress={signIn} />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    padding: 20,
  },
});
```

## Verify on the backend

```typescript
// api/auth/verify.ts
import { PublicKey } from "@solana/web3.js";
import nacl from "tweetnacl";
import bs58 from "bs58";
import jwt from "jsonwebtoken";

export async function POST(request: Request) {
  const { address, message, signature } = await request.json();

  // Verify the signature
  const publicKey = new PublicKey(address);
  const messageBytes = new TextEncoder().encode(message);
  const signatureBytes = bs58.decode(signature);

  const isValid = nacl.sign.detached.verify(
    messageBytes,
    signatureBytes,
    publicKey.toBytes()
  );

  if (!isValid) {
    return Response.json({ error: "Invalid signature" }, { status: 401 });
  }

  // Create a session token
  const token = jwt.sign({ address }, process.env.JWT_SECRET, { expiresIn: "7d" });

  return Response.json({ token });
}
```


# Send SOL
Source: https://docs.phantom.com/recipes/payments/send-sol

Send native SOL tokens to another wallet.

## React

```tsx
import { useSolana } from "@phantom/react-sdk";
import {
  Connection,
  PublicKey,
  VersionedTransaction,
  TransactionMessage,
  SystemProgram,
  LAMPORTS_PER_SOL,
} from "@solana/web3.js";

function SendSOL() {
  const { solana } = useSolana();

  const send = async (to: string, amount: number) => {
    const connection = new Connection("https://api.mainnet-beta.solana.com");
    const { blockhash } = await connection.getLatestBlockhash();
    const from = new PublicKey(await solana.getPublicKey());

    const transaction = new VersionedTransaction(
      new TransactionMessage({
        payerKey: from,
        recentBlockhash: blockhash,
        instructions: [
          SystemProgram.transfer({
            fromPubkey: from,
            toPubkey: new PublicKey(to),
            lamports: amount * LAMPORTS_PER_SOL,
          }),
        ],
      }).compileToV0Message()
    );

    const { signature } = await solana.signAndSendTransaction(transaction);
    console.log("Transaction:", signature);
    return signature;
  };

  return (
    <button onClick={() => send("RECIPIENT_ADDRESS", 0.1)}>
      Send 0.1 SOL
    </button>
  );
}
```

## Browser SDK

```typescript
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";
import {
  Connection,
  PublicKey,
  VersionedTransaction,
  TransactionMessage,
  SystemProgram,
  LAMPORTS_PER_SOL,
} from "@solana/web3.js";

const sdk = new BrowserSDK({
  providers: ["google", "apple", "injected"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana],
});

async function sendSOL(to: string, amount: number) {
  const connection = new Connection("https://api.mainnet-beta.solana.com");
  const { blockhash } = await connection.getLatestBlockhash();
  const from = new PublicKey(await sdk.solana.getPublicKey());

  const transaction = new VersionedTransaction(
    new TransactionMessage({
      payerKey: from,
      recentBlockhash: blockhash,
      instructions: [
        SystemProgram.transfer({
          fromPubkey: from,
          toPubkey: new PublicKey(to),
          lamports: amount * LAMPORTS_PER_SOL,
        }),
      ],
    }).compileToV0Message()
  );

  const { signature } = await sdk.solana.signAndSendTransaction(transaction);
  return signature;
}
```

## React Native

```tsx
import { useSolana } from "@phantom/react-native-sdk";
import {
  Connection,
  PublicKey,
  VersionedTransaction,
  TransactionMessage,
  SystemProgram,
  LAMPORTS_PER_SOL,
} from "@solana/web3.js";
import { View, Button, Alert, StyleSheet } from "react-native";

function SendSOL() {
  const { solana } = useSolana();

  const send = async (to: string, amount: number) => {
    try {
      const connection = new Connection("https://api.mainnet-beta.solana.com");
      const { blockhash } = await connection.getLatestBlockhash();
      const from = new PublicKey(await solana.getPublicKey());

      const transaction = new VersionedTransaction(
        new TransactionMessage({
          payerKey: from,
          recentBlockhash: blockhash,
          instructions: [
            SystemProgram.transfer({
              fromPubkey: from,
              toPubkey: new PublicKey(to),
              lamports: amount * LAMPORTS_PER_SOL,
            }),
          ],
        }).compileToV0Message()
      );

      const { signature } = await solana.signAndSendTransaction(transaction);
      Alert.alert("Success", `Transaction sent: ${signature}`);
      return signature;
    } catch (error) {
      Alert.alert("Error", error instanceof Error ? error.message : "Transaction failed");
      throw error;
    }
  };

  return (
    <View style={styles.container}>
      <Button
        title="Send 0.1 SOL"
        onPress={() => send("RECIPIENT_ADDRESS", 0.1)}
      />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    padding: 20,
  },
});
```


# Send USDC
Source: https://docs.phantom.com/recipes/payments/send-usdc

Send USDC stablecoin to another wallet. This automatically creates the recipient's token account if needed.

## React

```tsx
import { useSolana } from "@phantom/react-sdk";
import { Connection, PublicKey, VersionedTransaction, TransactionMessage } from "@solana/web3.js";
import { getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction, getAccount } from "@solana/spl-token";

const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
const USDC_DECIMALS = 6;

function SendUSDC() {
  const { solana } = useSolana();

  const send = async (to: string, amount: number) => {
    const connection = new Connection("https://api.mainnet-beta.solana.com");
    const from = new PublicKey(await solana.getPublicKey());
    const recipient = new PublicKey(to);

    const fromATA = await getAssociatedTokenAddress(USDC_MINT, from);
    const toATA = await getAssociatedTokenAddress(USDC_MINT, recipient);

    const instructions = [];

    // Create recipient's token account if it doesn't exist
    try {
      await getAccount(connection, toATA);
    } catch {
      instructions.push(
        createAssociatedTokenAccountInstruction(from, toATA, recipient, USDC_MINT)
      );
    }

    // Add transfer instruction
    instructions.push(
      createTransferInstruction(fromATA, toATA, from, amount * 10 ** USDC_DECIMALS)
    );

    const { blockhash } = await connection.getLatestBlockhash();
    const transaction = new VersionedTransaction(
      new TransactionMessage({
        payerKey: from,
        recentBlockhash: blockhash,
        instructions,
      }).compileToV0Message()
    );

    const { signature } = await solana.signAndSendTransaction(transaction);
    return signature;
  };

  return (
    <button onClick={() => send("RECIPIENT_ADDRESS", 10)}>
      Send 10 USDC
    </button>
  );
}
```

## Browser SDK

```typescript
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";
import { Connection, PublicKey, VersionedTransaction, TransactionMessage } from "@solana/web3.js";
import { getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction, getAccount } from "@solana/spl-token";

const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
const USDC_DECIMALS = 6;

const sdk = new BrowserSDK({
  providers: ["google", "apple", "injected"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana],
});

async function sendUSDC(to: string, amount: number) {
  const connection = new Connection("https://api.mainnet-beta.solana.com");
  const from = new PublicKey(await sdk.solana.getPublicKey());
  const recipient = new PublicKey(to);

  const fromATA = await getAssociatedTokenAddress(USDC_MINT, from);
  const toATA = await getAssociatedTokenAddress(USDC_MINT, recipient);

  const instructions = [];

  try {
    await getAccount(connection, toATA);
  } catch {
    instructions.push(
      createAssociatedTokenAccountInstruction(from, toATA, recipient, USDC_MINT)
    );
  }

  instructions.push(
    createTransferInstruction(fromATA, toATA, from, amount * 10 ** USDC_DECIMALS)
  );

  const { blockhash } = await connection.getLatestBlockhash();
  const transaction = new VersionedTransaction(
    new TransactionMessage({
      payerKey: from,
      recentBlockhash: blockhash,
      instructions,
    }).compileToV0Message()
  );

  const { signature } = await sdk.solana.signAndSendTransaction(transaction);
  return signature;
}
```

## React Native

```tsx
import { useSolana } from "@phantom/react-native-sdk";
import { Connection, PublicKey, VersionedTransaction, TransactionMessage } from "@solana/web3.js";
import { getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction, getAccount } from "@solana/spl-token";
import { View, Button, Alert, StyleSheet } from "react-native";

const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
const USDC_DECIMALS = 6;

function SendUSDC() {
  const { solana } = useSolana();

  const send = async (to: string, amount: number) => {
    try {
      const connection = new Connection("https://api.mainnet-beta.solana.com");
      const from = new PublicKey(await solana.getPublicKey());
      const recipient = new PublicKey(to);

      const fromATA = await getAssociatedTokenAddress(USDC_MINT, from);
      const toATA = await getAssociatedTokenAddress(USDC_MINT, recipient);

      const instructions = [];

      try {
        await getAccount(connection, toATA);
      } catch {
        instructions.push(
          createAssociatedTokenAccountInstruction(from, toATA, recipient, USDC_MINT)
        );
      }

      instructions.push(
        createTransferInstruction(fromATA, toATA, from, amount * 10 ** USDC_DECIMALS)
      );

      const { blockhash } = await connection.getLatestBlockhash();
      const transaction = new VersionedTransaction(
        new TransactionMessage({
          payerKey: from,
          recentBlockhash: blockhash,
          instructions,
        }).compileToV0Message()
      );

      const { signature } = await solana.signAndSendTransaction(transaction);
      Alert.alert("Success", `Transaction sent: ${signature}`);
      return signature;
    } catch (error) {
      Alert.alert("Error", error instanceof Error ? error.message : "Transaction failed");
      throw error;
    }
  };

  return (
    <View style={styles.container}>
      <Button
        title="Send 10 USDC"
        onPress={() => send("RECIPIENT_ADDRESS", 10)}
      />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    padding: 20,
  },
});
```

## Token addresses

| Token | Mint Address | Decimals |
|-------|--------------|----------|
| USDC | `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v` | 6 |
| USDT | `Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB` | 6 |


# Send any SPL token
Source: https://docs.phantom.com/recipes/payments/send-spl-token

Send any SPL token by providing the token's mint address and decimals.

## React

```tsx
import { useSolana } from "@phantom/react-sdk";
import { Connection, PublicKey, VersionedTransaction, TransactionMessage } from "@solana/web3.js";
import { getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction, getAccount } from "@solana/spl-token";

function SendToken() {
  const { solana } = useSolana();

  const send = async (
    to: string,
    amount: number,
    mintAddress: string,
    decimals: number
  ) => {
    const connection = new Connection("https://api.mainnet-beta.solana.com");
    const from = new PublicKey(await solana.getPublicKey());
    const recipient = new PublicKey(to);
    const mint = new PublicKey(mintAddress);

    const fromATA = await getAssociatedTokenAddress(mint, from);
    const toATA = await getAssociatedTokenAddress(mint, recipient);

    const instructions = [];

    // Create recipient's token account if needed
    try {
      await getAccount(connection, toATA);
    } catch {
      instructions.push(
        createAssociatedTokenAccountInstruction(from, toATA, recipient, mint)
      );
    }

    instructions.push(
      createTransferInstruction(fromATA, toATA, from, amount * 10 ** decimals)
    );

    const { blockhash } = await connection.getLatestBlockhash();
    const transaction = new VersionedTransaction(
      new TransactionMessage({
        payerKey: from,
        recentBlockhash: blockhash,
        instructions,
      }).compileToV0Message()
    );

    const { signature } = await solana.signAndSendTransaction(transaction);
    return signature;
  };

  return (
    <button onClick={() => send(
      "RECIPIENT_ADDRESS",
      100,
      "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263", // BONK
      5
    )}>
      Send 100 BONK
    </button>
  );
}
```

## Browser SDK

```typescript
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";
import { Connection, PublicKey, VersionedTransaction, TransactionMessage } from "@solana/web3.js";
import { getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction, getAccount } from "@solana/spl-token";

const sdk = new BrowserSDK({
  providers: ["google", "apple", "injected"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana],
});

async function sendToken(
  to: string,
  amount: number,
  mintAddress: string,
  decimals: number
) {
  const connection = new Connection("https://api.mainnet-beta.solana.com");
  const from = new PublicKey(await sdk.solana.getPublicKey());
  const recipient = new PublicKey(to);
  const mint = new PublicKey(mintAddress);

  const fromATA = await getAssociatedTokenAddress(mint, from);
  const toATA = await getAssociatedTokenAddress(mint, recipient);

  const instructions = [];

  try {
    await getAccount(connection, toATA);
  } catch {
    instructions.push(
      createAssociatedTokenAccountInstruction(from, toATA, recipient, mint)
    );
  }

  instructions.push(
    createTransferInstruction(fromATA, toATA, from, amount * 10 ** decimals)
  );

  const { blockhash } = await connection.getLatestBlockhash();
  const transaction = new VersionedTransaction(
    new TransactionMessage({
      payerKey: from,
      recentBlockhash: blockhash,
      instructions,
    }).compileToV0Message()
  );

  const { signature } = await sdk.solana.signAndSendTransaction(transaction);
  return signature;
}
```

## React Native

```tsx
import { useSolana } from "@phantom/react-native-sdk";
import { Connection, PublicKey, VersionedTransaction, TransactionMessage } from "@solana/web3.js";
import { getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction, getAccount } from "@solana/spl-token";
import { View, Button, Alert, StyleSheet } from "react-native";

function SendToken() {
  const { solana } = useSolana();

  const send = async (
    to: string,
    amount: number,
    mintAddress: string,
    decimals: number
  ) => {
    try {
      const connection = new Connection("https://api.mainnet-beta.solana.com");
      const from = new PublicKey(await solana.getPublicKey());
      const recipient = new PublicKey(to);
      const mint = new PublicKey(mintAddress);

      const fromATA = await getAssociatedTokenAddress(mint, from);
      const toATA = await getAssociatedTokenAddress(mint, recipient);

      const instructions = [];

      try {
        await getAccount(connection, toATA);
      } catch {
        instructions.push(
          createAssociatedTokenAccountInstruction(from, toATA, recipient, mint)
        );
      }

      instructions.push(
        createTransferInstruction(fromATA, toATA, from, amount * 10 ** decimals)
      );

      const { blockhash } = await connection.getLatestBlockhash();
      const transaction = new VersionedTransaction(
        new TransactionMessage({
          payerKey: from,
          recentBlockhash: blockhash,
          instructions,
        }).compileToV0Message()
      );

      const { signature } = await solana.signAndSendTransaction(transaction);
      Alert.alert("Success", `Transaction sent: ${signature}`);
      return signature;
    } catch (error) {
      Alert.alert("Error", error instanceof Error ? error.message : "Transaction failed");
      throw error;
    }
  };

  return (
    <View style={styles.container}>
      <Button
        title="Send 100 BONK"
        onPress={() => send(
          "RECIPIENT_ADDRESS",
          100,
          "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263", // BONK
          5
        )}
      />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    padding: 20,
  },
});
```

## Popular tokens

| Token | Mint Address | Decimals |
|-------|--------------|----------|
| USDC | `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v` | 6 |
| USDT | `Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB` | 6 |
| BONK | `DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263` | 5 |
| JUP | `JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN` | 6 |
| WIF | `EKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzLHYxdM65zcjm` | 6 |


# Request payment
Source: https://docs.phantom.com/recipes/payments/request-payment

Create a payment request link or QR code using Solana Pay that users can scan to pay you. This recipe shows how to use the Phantom SDK to get your wallet address and create payment requests.

## React

```tsx
import { PhantomProvider, useSolana, useAccounts, usePhantom, darkTheme } from "@phantom/react-sdk";
import { AddressType } from "@phantom/browser-sdk";
import { encodeURL, createQR } from "@solana/pay";
import { PublicKey, Keypair } from "@solana/web3.js";
import { useEffect, useRef } from "react";
import BigNumber from "bignumber.js";

// USDC mint address
const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");

function App() {
  return (
    <PhantomProvider
      config={{
        providers: ["google", "apple", "injected"],
        appId: "your-app-id",
        addressTypes: [AddressType.solana],
        authOptions: {
          redirectUrl: "https://yourapp.com/auth/callback",
        },
      }}
      theme={darkTheme}
      appName="Your Store"
    >
      <PaymentRequest />
    </PhantomProvider>
  );
}

function PaymentRequest() {
  const { solana } = useSolana();
  const addresses = useAccounts();
  const { isConnected } = usePhantom();
  const qrRef = useRef<HTMLDivElement>(null);

  useEffect(() => {
    if (!isConnected || !addresses?.[0]) return;

    // Get your wallet address from the SDK
    const recipient = new PublicKey(addresses[0].address);
    const amount = new BigNumber(10); // 10 USDC
    const reference = new PublicKey(Keypair.generate().publicKey); // Unique identifier
    const label = "Your Store";
    const message = "Thanks for your purchase!";

    // Create the payment URL
    const url = encodeURL({
      recipient,
      amount,
      splToken: USDC_MINT,
      reference,
      label,
      message,
    });

    // Generate QR code
    const qr = createQR(url, 300, "transparent");

    if (qrRef.current) {
      qrRef.current.innerHTML = "";
      qr.append(qrRef.current);
    }
  }, [isConnected, addresses]);

  if (!isConnected) {
    return <div>Please connect your wallet to generate a payment request</div>;
  }

  return (
    <div>
      <h2>Scan to pay 10 USDC</h2>
      <p>Your wallet: {addresses?.[0]?.address}</p>
      <div ref={qrRef} />
    </div>
  );
}
```

## Browser SDK

```typescript
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";
import { encodeURL, createQR } from "@solana/pay";
import { PublicKey, Keypair } from "@solana/web3.js";
import BigNumber from "bignumber.js";

// USDC mint address
const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");

const sdk = new BrowserSDK({
  providers: ["google", "apple", "injected"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana],
});

async function createPaymentRequest(amount: BigNumber) {
  // Connect if not already connected
  if (!sdk.solana.isConnected()) {
    await sdk.connect({ provider: "google" });
  }

  // Get your wallet address from the SDK
  const recipientAddress = await sdk.solana.getPublicKey();
  const recipient = new PublicKey(recipientAddress);
  const reference = new PublicKey(Keypair.generate().publicKey);
  const label = "Your Store";
  const message = "Thanks for your purchase!";

  // Create the payment URL
  const url = encodeURL({
    recipient,
    amount,
    splToken: USDC_MINT,
    reference,
    label,
    message,
  });

  // Generate QR code
  const qr = createQR(url, 300, "transparent");
  return { url, qr, reference };
}

// Usage
const { url, qr, reference } = await createPaymentRequest(new BigNumber(10));
qr.append(document.getElementById("qr-container"));
```

## React Native

```tsx
import { PhantomProvider, useSolana, useAccounts, usePhantom, AddressType, darkTheme } from "@phantom/react-native-sdk";
import { encodeURL } from "@solana/pay";
import { PublicKey, Keypair } from "@solana/web3.js";
import { View, Text, StyleSheet, Linking } from "react-native";
import { useEffect, useState } from "react";
import BigNumber from "bignumber.js";

// USDC mint address
const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");

function App() {
  return (
    <PhantomProvider
      config={{
        providers: ["google", "apple"],
        appId: "your-app-id",
        scheme: "yourapp",
        addressTypes: [AddressType.solana],
        authOptions: {
          redirectUrl: "yourapp://auth/callback",
        },
      }}
      theme={darkTheme}
      appName="Your Store"
    >
      <PaymentRequest />
    </PhantomProvider>
  );
}

function PaymentRequest() {
  const { solana } = useSolana();
  const addresses = useAccounts();
  const { isConnected } = usePhantom();
  const [paymentUrl, setPaymentUrl] = useState<string | null>(null);

  useEffect(() => {
    if (!isConnected || !addresses?.[0]) return;

    const recipient = new PublicKey(addresses[0].address);
    const amount = new BigNumber(10); // 10 USDC
    const reference = new PublicKey(Keypair.generate().publicKey);
    const label = "Your Store";
    const message = "Thanks for your purchase!";

    const url = encodeURL({
      recipient,
      amount,
      splToken: USDC_MINT,
      reference,
      label,
      message,
    });

    setPaymentUrl(url.toString());
  }, [isConnected, addresses]);

  if (!isConnected) {
    return (
      <View style={styles.container}>
        <Text>Please connect your wallet to generate a payment request</Text>
      </View>
    );
  }

  return (
    <View style={styles.container}>
      <Text style={styles.title}>Payment Request</Text>
      <Text>Your wallet: {addresses?.[0]?.address}</Text>
      {paymentUrl && (
        <Text
          style={styles.link}
          onPress={() => Linking.openURL(paymentUrl)}
        >
          Open Payment Link
        </Text>
      )}
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    padding: 20,
    justifyContent: "center",
  },
  title: {
    fontSize: 24,
    fontWeight: "bold",
    marginBottom: 20,
  },
  link: {
    color: "#0ea5e9",
    marginTop: 20,
    textDecorationLine: "underline",
  },
});
```

## Install dependencies

```bash
npm install @solana/pay bignumber.js @phantom/react-sdk
# or
npm install @solana/pay bignumber.js @phantom/browser-sdk
```

## Verify payment

After a user pays, verify the payment on your backend:

```typescript
import { findReference, validateTransfer } from "@solana/pay";
import { Connection, PublicKey } from "@solana/web3.js";
import BigNumber from "bignumber.js";

const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");

async function verifyPayment(reference: PublicKey, recipient: PublicKey, amount: BigNumber) {
  const connection = new Connection("https://api.mainnet-beta.solana.com");

  // Find the transaction
  const signatureInfo = await findReference(connection, reference);

  // Validate it matches our request
  await validateTransfer(connection, signatureInfo.signature, {
    recipient,
    amount,
    splToken: USDC_MINT,
  });

  return signatureInfo.signature;
}
```


# Sign a message
Source: https://docs.phantom.com/recipes/signatures/sign-message

Ask the user to sign a message. Useful for authentication, proving ownership, or agreeing to terms.

## React

```tsx
import { useSolana } from "@phantom/react-sdk";

function SignMessage() {
  const { solana } = useSolana();

  const sign = async () => {
    const message = "Hello, please sign this message to verify your identity.";
    const { signature, publicKey } = await solana.signMessage(message);

    console.log("Signature:", signature);
    console.log("Public key:", publicKey);

    return signature;
  };

  return <button onClick={sign}>Sign Message</button>;
}
```

## Browser SDK

```typescript
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";

const sdk = new BrowserSDK({
  providers: ["google", "apple", "injected"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana],
});

const { signature, publicKey } = await sdk.solana.signMessage("Sign to verify");
console.log("Signature:", signature);
console.log("Public key:", publicKey);
```

## React Native

```tsx
import { useSolana } from "@phantom/react-native-sdk";
import { View, Button, Alert, StyleSheet } from "react-native";

function SignMessage() {
  const { solana } = useSolana();

  const sign = async () => {
    try {
      const message = "Hello, please sign this message to verify your identity.";
      const { signature, publicKey } = await solana.signMessage(message);

      Alert.alert("Signed!", `Public key: ${publicKey}`);
      return signature;
    } catch (error) {
      Alert.alert("Error", error instanceof Error ? error.message : "Signing failed");
      throw error;
    }
  };

  return (
    <View style={styles.container}>
      <Button title="Sign Message" onPress={sign} />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    padding: 20,
    gap: 10,
  },
});
```


# Verify a signature
Source: https://docs.phantom.com/recipes/signatures/verify-signature

After a user signs a message using the Phantom Connect SDK, verify the signature on your backend to prove they own the wallet.

## Get a signature (frontend)

First, have the user sign a message using the SDK:

### React

```tsx
import { useSolana } from "@phantom/react-sdk";

function SignForVerification() {
  const { solana } = useSolana();

  const signAndVerify = async () => {
    const message = "Hello, please sign this message";

    // Sign the message using the SDK
    const { signature } = await solana.signMessage(message);

    // Send to your backend for verification
    const response = await fetch("/api/verify", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        address: await solana.getPublicKey(),
        message,
        signature,
      }),
    });

    const { verified } = await response.json();
    console.log("Signature verified:", verified);
  };

  return <button onClick={signAndVerify}>Sign and Verify</button>;
}
```

### Browser SDK

```typescript
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";

const sdk = new BrowserSDK({
  providers: ["google", "apple", "injected"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana],
});

async function signAndVerify() {
  const message = "Hello, please sign this message";

  // Sign the message using the SDK
  const { signature } = await sdk.solana.signMessage(message);
  const address = await sdk.solana.getPublicKey();

  // Send to your backend for verification
  const response = await fetch("/api/verify", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ address, message, signature }),
  });

  const { verified } = await response.json();
  return verified;
}
```

### React Native

```tsx
import { useSolana } from "@phantom/react-native-sdk";
import { View, Button, Alert, StyleSheet } from "react-native";

function SignForVerification() {
  const { solana } = useSolana();

  const signAndVerify = async () => {
    try {
      const message = "Hello, please sign this message";

      const { signature } = await solana.signMessage(message);
      const address = await solana.getPublicKey();

      const response = await fetch("/api/verify", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          address,
          message,
          signature,
        }),
      });

      const { verified } = await response.json();

      if (verified) {
        Alert.alert("Success", "Signature verified!");
      } else {
        Alert.alert("Error", "Signature verification failed");
      }
    } catch (error) {
      Alert.alert("Error", error.message);
    }
  };

  return (
    <View style={styles.container}>
      <Button title="Sign and Verify" onPress={signAndVerify} />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    padding: 20,
  },
});
```

## Verify a signature (backend)

### Install dependencies

```bash
npm install @solana/web3.js tweetnacl bs58
```

### Verify a Solana signature

```typescript
import { PublicKey } from "@solana/web3.js";
import nacl from "tweetnacl";
import bs58 from "bs58";

function verifySignature(
  walletAddress: string,
  message: string,
  signature: string
): boolean {
  try {
    const publicKey = new PublicKey(walletAddress);
    const messageBytes = new TextEncoder().encode(message);
    const signatureBytes = bs58.decode(signature);

    return nacl.sign.detached.verify(
      messageBytes,
      signatureBytes,
      publicKey.toBytes()
    );
  } catch {
    return false;
  }
}

// Usage
const isValid = verifySignature(
  "7fUAJdStEuGbc3sM84cKRL6yYaaSstyLSU4ve5oovLS7",
  "Hello, please sign this message",
  "5eyJhbGciOiJFZERTQSIsInR5cCI6IkpXVCJ9..."
);

console.log("Signature valid:", isValid);
```

### API route example (Next.js)

```typescript
// app/api/verify/route.ts
import { PublicKey } from "@solana/web3.js";
import nacl from "tweetnacl";
import bs58 from "bs58";
import { NextResponse } from "next/server";

export async function POST(request: Request) {
  const { address, message, signature } = await request.json();

  try {
    const publicKey = new PublicKey(address);
    const messageBytes = new TextEncoder().encode(message);
    const signatureBytes = bs58.decode(signature);

    const isValid = nacl.sign.detached.verify(
      messageBytes,
      signatureBytes,
      publicKey.toBytes()
    );

    if (!isValid) {
      return NextResponse.json({ error: "Invalid signature" }, { status: 401 });
    }

    return NextResponse.json({ verified: true, address });
  } catch (error) {
    return NextResponse.json({ error: "Verification failed" }, { status: 400 });
  }
}
```


# Sign typed data (EIP-712)
Source: https://docs.phantom.com/recipes/signatures/sign-typed-data

Sign structured, typed data using the EIP-712 standard. This provides a better user experience by showing human-readable data in the wallet.

```tsx
import { useEthereum } from "@phantom/react-sdk";

function SignTypedData() {
  const { ethereum } = useEthereum();

  const sign = async () => {
    const accounts = await ethereum.getAccounts();

    const typedData = {
      types: {
        EIP712Domain: [
          { name: "name", type: "string" },
          { name: "version", type: "string" },
          { name: "chainId", type: "uint256" },
          { name: "verifyingContract", type: "address" },
        ],
        Order: [
          { name: "from", type: "address" },
          { name: "to", type: "address" },
          { name: "amount", type: "uint256" },
          { name: "nonce", type: "uint256" },
        ],
      },
      primaryType: "Order",
      domain: {
        name: "My App",
        version: "1",
        chainId: 1,
        verifyingContract: "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC",
      },
      message: {
        from: accounts[0],
        to: "0x742d35Cc6634C0532925a3b8D4C8db86fB5C4A7E",
        amount: "1000000000000000000",
        nonce: 1,
      },
    };

    const { signature } = await ethereum.signTypedData(typedData, accounts[0]);
    console.log("Signature:", signature);
    return signature;
  };

  return <button onClick={sign}>Sign Order</button>;
}
```

### React Native

```tsx
import { useEthereum } from "@phantom/react-native-sdk";
import { View, Button, Alert, StyleSheet } from "react-native";

function SignTypedData() {
  const { ethereum } = useEthereum();

  const sign = async () => {
    try {
      const accounts = await ethereum.getAccounts();

      const typedData = {
        types: {
          EIP712Domain: [
            { name: "name", type: "string" },
            { name: "version", type: "string" },
            { name: "chainId", type: "uint256" },
            { name: "verifyingContract", type: "address" },
          ],
          Order: [
            { name: "from", type: "address" },
            { name: "to", type: "address" },
            { name: "amount", type: "uint256" },
            { name: "nonce", type: "uint256" },
          ],
        },
        primaryType: "Order",
        domain: {
          name: "My App",
          version: "1",
          chainId: 1,
          verifyingContract: "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC",
        },
        message: {
          from: accounts[0],
          to: "0x742d35Cc6634C0532925a3b8D4C8db86fB5C4A7E",
          amount: "1000000000000000000",
          nonce: 1,
        },
      };

      const { signature } = await ethereum.signTypedData(typedData, accounts[0]);
      Alert.alert("Success", `Signature: ${signature.slice(0, 20)}...`);
      return signature;
    } catch (error) {
      Alert.alert("Error", error.message);
      throw error;
    }
  };

  return (
    <View style={styles.container}>
      <Button title="Sign Order" onPress={sign} />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    padding: 20,
  },
});
```

## Verify with viem

```typescript
import { verifyTypedData } from "viem";

const isValid = await verifyTypedData({
  address: signerAddress,
  domain: typedData.domain,
  types: typedData.types,
  primaryType: typedData.primaryType,
  message: typedData.message,
  signature,
});
```


# Check wallet balance
Source: https://docs.phantom.com/recipes/wallet-operations/check-balance

Check the SOL balance and SPL token balances for the connected wallet using the Phantom SDK.

## React

```tsx
import { useSolana, useAccounts } from "@phantom/react-sdk";
import { Connection, PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";
import { getAssociatedTokenAddress, getAccount } from "@solana/spl-token";
import { useEffect, useState } from "react";

function WalletBalance() {
  const { solana } = useSolana();
  const addresses = useAccounts();
  const [solBalance, setSolBalance] = useState<number | null>(null);
  const [loading, setLoading] = useState(false);

  const checkBalance = async () => {
    if (!addresses?.[0]) return;

    setLoading(true);
    try {
      const connection = new Connection("https://api.mainnet-beta.solana.com");
      const publicKey = new PublicKey(addresses[0].address);

      // Get SOL balance
      const balance = await connection.getBalance(publicKey);
      setSolBalance(balance / LAMPORTS_PER_SOL);
    } catch (error) {
      console.error("Failed to fetch balance:", error);
    } finally {
      setLoading(false);
    }
  };

  useEffect(() => {
    if (addresses?.[0]) {
      checkBalance();
    }
  }, [addresses]);

  if (!addresses?.[0]) {
    return <div>Please connect your wallet</div>;
  }

  return (
    <div>
      <h2>Wallet Balance</h2>
      <p>Address: {addresses[0].address}</p>
      {loading ? (
        <p>Loading balance...</p>
      ) : (
        <p>SOL Balance: {solBalance?.toFixed(4) ?? "0.0000"} SOL</p>
      )}
      <button onClick={checkBalance}>Refresh Balance</button>
    </div>
  );
}
```

## Browser SDK

```typescript
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";
import { Connection, PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";

const sdk = new BrowserSDK({
  providers: ["google", "apple", "injected"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana],
});

async function getWalletBalance() {
  if (!sdk.solana.isConnected()) {
    await sdk.connect({ provider: "google" });
  }

  const connection = new Connection("https://api.mainnet-beta.solana.com");
  const publicKey = new PublicKey(await sdk.solana.getPublicKey());

  // Get SOL balance
  const balance = await connection.getBalance(publicKey);
  const solBalance = balance / LAMPORTS_PER_SOL;

  return {
    address: publicKey.toString(),
    solBalance,
    lamports: balance,
  };
}

// Usage
const balance = await getWalletBalance();
console.log(`${balance.solBalance} SOL`);
```

## React Native

```tsx
import { useSolana, useAccounts } from "@phantom/react-native-sdk";
import { Connection, PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";
import { View, Text, Button, StyleSheet, ActivityIndicator } from "react-native";
import { useEffect, useState } from "react";

function WalletBalance() {
  const { solana } = useSolana();
  const addresses = useAccounts();
  const [solBalance, setSolBalance] = useState<number | null>(null);
  const [loading, setLoading] = useState(false);

  const checkBalance = async () => {
    if (!addresses?.[0]) return;

    setLoading(true);
    try {
      const connection = new Connection("https://api.mainnet-beta.solana.com");
      const publicKey = new PublicKey(addresses[0].address);

      const balance = await connection.getBalance(publicKey);
      setSolBalance(balance / LAMPORTS_PER_SOL);
    } catch (error) {
      console.error("Failed to fetch balance:", error);
    } finally {
      setLoading(false);
    }
  };

  useEffect(() => {
    if (addresses?.[0]) {
      checkBalance();
    }
  }, [addresses]);

  if (!addresses?.[0]) {
    return (
      <View style={styles.container}>
        <Text>Please connect your wallet</Text>
      </View>
    );
  }

  return (
    <View style={styles.container}>
      <Text style={styles.title}>Wallet Balance</Text>
      <Text style={styles.address}>{addresses[0].address}</Text>
      {loading ? (
        <ActivityIndicator size="large" style={styles.loader} />
      ) : (
        <Text style={styles.balance}>
          {solBalance?.toFixed(4) ?? "0.0000"} SOL
        </Text>
      )}
      <Button title="Refresh Balance" onPress={checkBalance} />
    </View>
  );
}

const styles = StyleSheet.create({
  container: { flex: 1, padding: 20, justifyContent: "center" },
  title: { fontSize: 24, fontWeight: "bold", marginBottom: 10 },
  address: { fontSize: 14, color: "#666", marginBottom: 20 },
  balance: { fontSize: 32, fontWeight: "bold", marginBottom: 20 },
  loader: { marginVertical: 20 },
});
```

## Get token balances

Check balances for specific SPL tokens:

### React

```tsx
import { useSolana, useAccounts } from "@phantom/react-sdk";
import { Connection, PublicKey } from "@solana/web3.js";
import { getAssociatedTokenAddress, getAccount, getMint } from "@solana/spl-token";
import { useState } from "react";

const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");

function TokenBalance() {
  const { solana } = useSolana();
  const addresses = useAccounts();
  const [tokenBalance, setTokenBalance] = useState<string | null>(null);

  const checkTokenBalance = async () => {
    if (!addresses?.[0]) return;

    try {
      const connection = new Connection("https://api.mainnet-beta.solana.com");
      const publicKey = new PublicKey(addresses[0].address);

      // Get associated token account
      const tokenAccount = await getAssociatedTokenAddress(USDC_MINT, publicKey);

      // Get token account info
      const accountInfo = await getAccount(connection, tokenAccount);

      // Get mint info to get decimals
      const mintInfo = await getMint(connection, USDC_MINT);

      // Calculate balance with decimals
      const balance = Number(accountInfo.amount) / 10 ** mintInfo.decimals;
      setTokenBalance(balance.toFixed(mintInfo.decimals));
    } catch (error) {
      // Token account doesn't exist
      setTokenBalance("0");
    }
  };

  return (
    <div>
      <button onClick={checkTokenBalance}>Check USDC Balance</button>
      {tokenBalance !== null && <p>USDC Balance: {tokenBalance}</p>}
    </div>
  );
}
```

### Browser SDK

```typescript
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";
import { Connection, PublicKey } from "@solana/web3.js";
import { getAssociatedTokenAddress, getAccount, getMint } from "@solana/spl-token";

const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");

const sdk = new BrowserSDK({
  providers: ["google", "apple", "injected"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana],
});

async function getTokenBalance(mintAddress: PublicKey) {
  const connection = new Connection("https://api.mainnet-beta.solana.com");
  const publicKey = new PublicKey(await sdk.solana.getPublicKey());

  try {
    const tokenAccount = await getAssociatedTokenAddress(mintAddress, publicKey);
    const accountInfo = await getAccount(connection, tokenAccount);
    const mintInfo = await getMint(connection, mintAddress);

    const balance = Number(accountInfo.amount) / 10 ** mintInfo.decimals;
    return balance;
  } catch {
    return 0; // Token account doesn't exist
  }
}

// Usage
const usdcBalance = await getTokenBalance(USDC_MINT);
console.log(`USDC Balance: ${usdcBalance}`);
```


# Get all token accounts
Source: https://docs.phantom.com/recipes/wallet-operations/get-token-accounts

Get all token accounts and their balances for the connected wallet. Useful for displaying a complete token portfolio.

## React

```tsx
import { useSolana, useAccounts } from "@phantom/react-sdk";
import { Connection, PublicKey } from "@solana/web3.js";
import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
import { useEffect, useState } from "react";

interface TokenAccount {
  mint: string;
  balance: string;
  decimals: number;
}

function TokenAccounts() {
  const { solana } = useSolana();
  const addresses = useAccounts();
  const [tokens, setTokens] = useState<TokenAccount[]>([]);
  const [loading, setLoading] = useState(false);

  const fetchTokenAccounts = async () => {
    if (!addresses?.[0]) return;

    setLoading(true);
    try {
      const connection = new Connection("https://api.mainnet-beta.solana.com");
      const publicKey = new PublicKey(addresses[0].address);

      // Get all token accounts using connection method
      const response = await connection.getParsedTokenAccountsByOwner(
        publicKey,
        { programId: TOKEN_PROGRAM_ID }
      );

      const tokenList: TokenAccount[] = response.value.map((item) => {
        const info = item.account.data.parsed.info;
        return {
          mint: info.mint,
          balance: info.tokenAmount.uiAmountString || "0",
          decimals: info.tokenAmount.decimals,
        };
      });

      setTokens(tokenList);
    } catch (error) {
      console.error("Failed to fetch token accounts:", error);
    } finally {
      setLoading(false);
    }
  };

  useEffect(() => {
    if (addresses?.[0]) {
      fetchTokenAccounts();
    }
  }, [addresses]);

  if (!addresses?.[0]) {
    return <div>Please connect your wallet</div>;
  }

  return (
    <div>
      <h2>Token Accounts</h2>
      <button onClick={fetchTokenAccounts} disabled={loading}>
        {loading ? "Loading..." : "Refresh Tokens"}
      </button>
      {tokens.length === 0 ? (
        <p>No token accounts found</p>
      ) : (
        <ul>
          {tokens.map((token) => (
            <li key={token.mint}>
              <strong>Mint:</strong> {token.mint}
              <br />
              <strong>Balance:</strong> {token.balance}
            </li>
          ))}
        </ul>
      )}
    </div>
  );
}
```

## Browser SDK

```typescript
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";
import { Connection, PublicKey } from "@solana/web3.js";
import { TOKEN_PROGRAM_ID } from "@solana/spl-token";

const sdk = new BrowserSDK({
  providers: ["google", "apple", "injected"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana],
});

interface TokenAccount {
  mint: string;
  balance: string;
  decimals: number;
}

async function getAllTokenAccounts(): Promise<TokenAccount[]> {
  if (!sdk.solana.isConnected()) {
    await sdk.connect({ provider: "google" });
  }

  const connection = new Connection("https://api.mainnet-beta.solana.com");
  const publicKey = new PublicKey(await sdk.solana.getPublicKey());

  const response = await connection.getParsedTokenAccountsByOwner(
    publicKey,
    { programId: TOKEN_PROGRAM_ID }
  );

  const tokenList: TokenAccount[] = response.value.map((item) => {
    const info = item.account.data.parsed.info;
    return {
      mint: info.mint,
      balance: info.tokenAmount.uiAmountString || "0",
      decimals: info.tokenAmount.decimals,
    };
  });

  return tokenList;
}

// Usage
const tokens = await getAllTokenAccounts();
tokens.forEach((token) => {
  console.log(`${token.mint}: ${token.balance}`);
});
```

## React Native

```tsx
import { useSolana, useAccounts } from "@phantom/react-native-sdk";
import { Connection, PublicKey } from "@solana/web3.js";
import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
import { View, Text, Button, FlatList, StyleSheet, ActivityIndicator } from "react-native";
import { useEffect, useState } from "react";

interface TokenAccount {
  mint: string;
  balance: string;
  decimals: number;
}

function TokenAccounts() {
  const { solana } = useSolana();
  const addresses = useAccounts();
  const [tokens, setTokens] = useState<TokenAccount[]>([]);
  const [loading, setLoading] = useState(false);

  const fetchTokenAccounts = async () => {
    if (!addresses?.[0]) return;

    setLoading(true);
    try {
      const connection = new Connection("https://api.mainnet-beta.solana.com");
      const publicKey = new PublicKey(addresses[0].address);

      const response = await connection.getParsedTokenAccountsByOwner(
        publicKey,
        { programId: TOKEN_PROGRAM_ID }
      );

      const tokenList: TokenAccount[] = response.value.map((item) => {
        const info = item.account.data.parsed.info;
        return {
          mint: info.mint,
          balance: info.tokenAmount.uiAmountString || "0",
          decimals: info.tokenAmount.decimals,
        };
      });

      setTokens(tokenList);
    } catch (error) {
      console.error("Failed to fetch token accounts:", error);
    } finally {
      setLoading(false);
    }
  };

  useEffect(() => {
    if (addresses?.[0]) {
      fetchTokenAccounts();
    }
  }, [addresses]);

  if (!addresses?.[0]) {
    return (
      <View style={styles.container}>
        <Text>Please connect your wallet</Text>
      </View>
    );
  }

  return (
    <View style={styles.container}>
      <Text style={styles.title}>Token Accounts</Text>
      <Button
        title={loading ? "Loading..." : "Refresh Tokens"}
        onPress={fetchTokenAccounts}
        disabled={loading}
      />
      {loading ? (
        <ActivityIndicator size="large" style={styles.loader} />
      ) : tokens.length === 0 ? (
        <Text style={styles.empty}>No token accounts found</Text>
      ) : (
        <FlatList
          data={tokens}
          keyExtractor={(item) => item.mint}
          renderItem={({ item }) => (
            <View style={styles.tokenItem}>
              <Text style={styles.mint}>{item.mint}</Text>
              <Text style={styles.balance}>Balance: {item.balance}</Text>
            </View>
          )}
        />
      )}
    </View>
  );
}

const styles = StyleSheet.create({
  container: { flex: 1, padding: 20 },
  title: { fontSize: 24, fontWeight: "bold", marginBottom: 20 },
  loader: { marginVertical: 20 },
  empty: { textAlign: "center", marginTop: 20, color: "#666" },
  tokenItem: { padding: 15, borderBottomWidth: 1, borderBottomColor: "#eee" },
  mint: { fontSize: 12, color: "#666", marginBottom: 5 },
  balance: { fontSize: 16, fontWeight: "600" },
});
```

## Filter by specific token

Get the token account for a specific mint:

```tsx
import { Connection, PublicKey } from "@solana/web3.js";
import { getAssociatedTokenAddress, getAccount } from "@solana/spl-token";

async function getTokenAccountForMint(
  connection: Connection,
  owner: PublicKey,
  mint: PublicKey
) {
  try {
    const tokenAccount = await getAssociatedTokenAddress(mint, owner);
    const accountInfo = await getAccount(connection, tokenAccount);
    return accountInfo;
  } catch {
    return null; // Token account doesn't exist
  }
}
```


# Add priority fees
Source: https://docs.phantom.com/recipes/transactions/add-priority-fees

Add priority fees to your transactions to ensure faster confirmation during network congestion. Phantom automatically applies priority fees, but you can also set them manually.

## React

```tsx
import { useSolana } from "@phantom/react-sdk";
import {
  Connection,
  PublicKey,
  VersionedTransaction,
  TransactionMessage,
  SystemProgram,
  LAMPORTS_PER_SOL,
  ComputeBudgetProgram,
} from "@solana/web3.js";

function SendWithPriorityFees() {
  const { solana } = useSolana();

  const sendWithPriorityFees = async (
    to: string,
    amount: number,
    priorityFee: number = 1000 // micro-lamports per compute unit
  ) => {
    const connection = new Connection("https://api.mainnet-beta.solana.com");
    const { blockhash } = await connection.getLatestBlockhash();
    const from = new PublicKey(await solana.getPublicKey());
    const recipient = new PublicKey(to);

    // Create transfer instruction
    const transferInstruction = SystemProgram.transfer({
      fromPubkey: from,
      toPubkey: recipient,
      lamports: amount * LAMPORTS_PER_SOL,
    });

    // Add priority fee instructions
    const instructions = [
      // Set compute unit limit (optional, defaults to 200,000)
      ComputeBudgetProgram.setComputeUnitLimit({ units: 200_000 }),
      // Set compute unit price (priority fee)
      ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
      transferInstruction,
    ];

    const transaction = new VersionedTransaction(
      new TransactionMessage({
        payerKey: from,
        recentBlockhash: blockhash,
        instructions,
      }).compileToV0Message()
    );

    const { signature } = await solana.signAndSendTransaction(transaction);
    return signature;
  };

  return (
    <button onClick={() => sendWithPriorityFees("RECIPIENT_ADDRESS", 0.1, 5000)}>
      Send with Priority Fee
    </button>
  );
}
```

## Browser SDK

```typescript
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";
import {
  Connection, PublicKey, VersionedTransaction, TransactionMessage,
  SystemProgram, LAMPORTS_PER_SOL, ComputeBudgetProgram,
} from "@solana/web3.js";

const sdk = new BrowserSDK({
  providers: ["google", "apple", "injected"],
  appId: "your-app-id",
  addressTypes: [AddressType.solana],
});

async function sendWithPriorityFees(to: string, amount: number, priorityFee: number = 1000) {
  const connection = new Connection("https://api.mainnet-beta.solana.com");
  const { blockhash } = await connection.getLatestBlockhash();
  const from = new PublicKey(await sdk.solana.getPublicKey());
  const recipient = new PublicKey(to);

  const transferInstruction = SystemProgram.transfer({
    fromPubkey: from, toPubkey: recipient, lamports: amount * LAMPORTS_PER_SOL,
  });

  const instructions = [
    ComputeBudgetProgram.setComputeUnitLimit({ units: 200_000 }),
    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
    transferInstruction,
  ];

  const transaction = new VersionedTransaction(
    new TransactionMessage({ payerKey: from, recentBlockhash: blockhash, instructions }).compileToV0Message()
  );

  const { signature } = await sdk.solana.signAndSendTransaction(transaction);
  return signature;
}
```

## React Native

```tsx
import { useSolana } from "@phantom/react-native-sdk";
import {
  Connection, PublicKey, VersionedTransaction, TransactionMessage,
  SystemProgram, LAMPORTS_PER_SOL, ComputeBudgetProgram,
} from "@solana/web3.js";
import { View, Button, Alert, StyleSheet } from "react-native";

function SendWithPriorityFees() {
  const { solana } = useSolana();

  const sendWithPriorityFees = async (to: string, amount: number, priorityFee: number = 1000) => {
    try {
      const connection = new Connection("https://api.mainnet-beta.solana.com");
      const { blockhash } = await connection.getLatestBlockhash();
      const from = new PublicKey(await solana.getPublicKey());
      const recipient = new PublicKey(to);

      const transferInstruction = SystemProgram.transfer({
        fromPubkey: from, toPubkey: recipient, lamports: amount * LAMPORTS_PER_SOL,
      });

      const instructions = [
        ComputeBudgetProgram.setComputeUnitLimit({ units: 200_000 }),
        ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
        transferInstruction,
      ];

      const transaction = new VersionedTransaction(
        new TransactionMessage({ payerKey: from, recentBlockhash: blockhash, instructions }).compileToV0Message()
      );

      const { signature } = await solana.signAndSendTransaction(transaction);
      Alert.alert("Success", `Transaction sent: ${signature}`);
      return signature;
    } catch (error) {
      Alert.alert("Error", error instanceof Error ? error.message : "Transaction failed");
      throw error;
    }
  };

  return (
    <View style={styles.container}>
      <Button title="Send with Priority Fee" onPress={() => sendWithPriorityFees("RECIPIENT_ADDRESS", 0.1, 5000)} />
    </View>
  );
}

const styles = StyleSheet.create({ container: { padding: 20 } });
```

## Priority fee recommendations

Priority fees are measured in micro-lamports per compute unit. Common values:

- Low priority: 1,000 - 5,000 micro-lamports (for non-urgent transactions)
- Medium priority: 5,000 - 25,000 micro-lamports (standard transactions)
- High priority: 25,000+ micro-lamports (urgent transactions during congestion)

Automatic priority fees: If you don't add priority fee instructions, Phantom will automatically calculate and apply appropriate priority fees to your transaction, provided it meets certain requirements.

## Dynamic priority fee calculation

Calculate priority fees based on recent network activity:

```typescript
import { Connection } from "@solana/web3.js";

async function getRecommendedPriorityFee(connection: Connection): Promise<number> {
  // Get recent priority fee samples
  const feeSample = await connection.getRecentPrioritizationFees();

  if (feeSample.length === 0) {
    return 1000; // Default fallback
  }

  // Calculate median priority fee
  const fees = feeSample.map((sample) => sample.prioritizationFee);
  fees.sort((a, b) => a - b);
  const median = fees[Math.floor(fees.length / 2)];

  // Add 20% buffer for safety
  return Math.ceil(median * 1.2);
}
```


# Check transaction status
Source: https://docs.phantom.com/recipes/transactions/check-transaction-status

Check the status of a transaction after sending it to the network. Useful for showing users when their transaction is confirmed.

## React

```tsx
import { Connection } from "@solana/web3.js";
import { useEffect, useState } from "react";

type TransactionStatus = "pending" | "confirmed" | "finalized" | "failed";

function TransactionStatus({ signature }: { signature: string }) {
  const [status, setStatus] = useState<TransactionStatus>("pending");
  const [transaction, setTransaction] = useState<any>(null);
  const [error, setError] = useState<string | null>(null);

  useEffect(() => {
    const connection = new Connection("https://api.mainnet-beta.solana.com");

    const checkStatus = async () => {
      try {
        const txStatus = await connection.getSignatureStatus(signature);

        if (txStatus.value?.err) {
          setStatus("failed");
          setError(JSON.stringify(txStatus.value.err));
          return;
        }

        if (txStatus.value?.confirmationStatus === "finalized") {
          setStatus("finalized");
        } else if (txStatus.value?.confirmationStatus === "confirmed") {
          setStatus("confirmed");
        } else {
          setStatus("pending");
        }

        const txDetails = await connection.getTransaction(signature, {
          maxSupportedTransactionVersion: 0,
        });

        setTransaction(txDetails);
      } catch (err) {
        setError(err instanceof Error ? err.message : "Unknown error");
      }
    };

    checkStatus();

    const interval = setInterval(() => {
      if (status !== "finalized" && status !== "failed") {
        checkStatus();
      } else {
        clearInterval(interval);
      }
    }, 2000);

    return () => clearInterval(interval);
  }, [signature, status]);

  return (
    <div>
      <h3>Transaction Status</h3>
      <p><strong>Signature:</strong> {signature}</p>
      <p><strong>Status:</strong> {status}</p>
      {error && <p style={{ color: "red" }}>Error: {error}</p>}
      {transaction && (
        <div>
          <p><strong>Slot:</strong> {transaction.slot}</p>
          <p><strong>Block Time:</strong> {transaction.blockTime ? new Date(transaction.blockTime * 1000).toLocaleString() : "N/A"}</p>
          <a href={`https://explorer.solana.com/tx/${signature}`} target="_blank" rel="noopener noreferrer">View on Explorer</a>
        </div>
      )}
    </div>
  );
}
```

## Browser SDK

```typescript
import { Connection } from "@solana/web3.js";

type TransactionStatus = "pending" | "confirmed" | "finalized" | "failed";

async function checkTransactionStatus(
  signature: string,
  connection: Connection
): Promise<{ status: TransactionStatus; transaction: any; error?: string }> {
  try {
    const txStatus = await connection.getSignatureStatus(signature);

    if (txStatus.value?.err) {
      return { status: "failed", transaction: null, error: JSON.stringify(txStatus.value.err) };
    }

    let status: TransactionStatus = "pending";
    if (txStatus.value?.confirmationStatus === "finalized") {
      status = "finalized";
    } else if (txStatus.value?.confirmationStatus === "confirmed") {
      status = "confirmed";
    }

    const txDetails = await connection.getTransaction(signature, { maxSupportedTransactionVersion: 0 });

    return { status, transaction: txDetails };
  } catch (error) {
    return { status: "failed", transaction: null, error: error instanceof Error ? error.message : "Unknown error" };
  }
}

// Poll until finalized
async function waitForConfirmation(
  signature: string,
  connection: Connection,
  maxAttempts: number = 30
): Promise<TransactionStatus> {
  for (let i = 0; i < maxAttempts; i++) {
    const { status } = await checkTransactionStatus(signature, connection);

    if (status === "finalized" || status === "failed") {
      return status;
    }

    await new Promise((resolve) => setTimeout(resolve, 2000));
  }

  return "pending"; // Timeout
}

// Usage
const connection = new Connection("https://api.mainnet-beta.solana.com");
const signature = "your-transaction-signature";

const finalStatus = await waitForConfirmation(signature, connection);
console.log(`Transaction ${finalStatus}`);
```

## React Native

```tsx
import { Connection } from "@solana/web3.js";
import { View, Text, StyleSheet, Linking, ActivityIndicator } from "react-native";
import { useEffect, useState } from "react";

type TransactionStatus = "pending" | "confirmed" | "finalized" | "failed";

function TransactionStatus({ signature }: { signature: string }) {
  const [status, setStatus] = useState<TransactionStatus>("pending");
  const [transaction, setTransaction] = useState<any>(null);
  const [error, setError] = useState<string | null>(null);

  useEffect(() => {
    const connection = new Connection("https://api.mainnet-beta.solana.com");

    const checkStatus = async () => {
      try {
        const txStatus = await connection.getSignatureStatus(signature);

        if (txStatus.value?.err) {
          setStatus("failed");
          setError(JSON.stringify(txStatus.value.err));
          return;
        }

        if (txStatus.value?.confirmationStatus === "finalized") {
          setStatus("finalized");
        } else if (txStatus.value?.confirmationStatus === "confirmed") {
          setStatus("confirmed");
        } else {
          setStatus("pending");
        }

        const txDetails = await connection.getTransaction(signature, { maxSupportedTransactionVersion: 0 });
        setTransaction(txDetails);
      } catch (err) {
        setError(err instanceof Error ? err.message : "Unknown error");
      }
    };

    checkStatus();

    const interval = setInterval(() => {
      if (status !== "finalized" && status !== "failed") {
        checkStatus();
      } else {
        clearInterval(interval);
      }
    }, 2000);

    return () => clearInterval(interval);
  }, [signature, status]);

  return (
    <View style={styles.container}>
      <Text style={styles.title}>Transaction Status</Text>
      <Text style={styles.signature}>{signature}</Text>
      <Text style={styles.status}>Status: {status}</Text>
      {error && <Text style={styles.error}>Error: {error}</Text>}
      {status === "pending" && <ActivityIndicator size="small" />}
      {transaction && (
        <View style={styles.details}>
          <Text>Slot: {transaction.slot}</Text>
          <Text>Block Time: {transaction.blockTime ? new Date(transaction.blockTime * 1000).toLocaleString() : "N/A"}</Text>
          <Text style={styles.link} onPress={() => Linking.openURL(`https://explorer.solana.com/tx/${signature}`)}>View on Explorer</Text>
        </View>
      )}
    </View>
  );
}

const styles = StyleSheet.create({
  container: { padding: 20 },
  title: { fontSize: 20, fontWeight: "bold", marginBottom: 10 },
  signature: { fontSize: 12, color: "#666", marginBottom: 10 },
  status: { fontSize: 16, fontWeight: "600", marginBottom: 10 },
  error: { color: "red", marginTop: 10 },
  details: { marginTop: 20, padding: 15, backgroundColor: "#f5f5f5", borderRadius: 8 },
  link: { color: "#0ea5e9", marginTop: 10, textDecorationLine: "underline" },
});
```

## Confirmation statuses

Solana transactions have three confirmation statuses:

- Pending: Transaction has been submitted but not yet confirmed
- Confirmed: Transaction has been confirmed by the cluster (not yet finalized)
- Finalized: Transaction has been finalized and cannot be rolled back

Transactions are typically confirmed within 1-2 seconds and finalized within ~30 seconds on mainnet. Use "confirmed" status for most UI updates, and "finalized" for critical operations.


# Next.js Quickstart
Source: https://docs.phantom.com/recipes/quickstarts/nextjs

Complete guide to integrating Phantom Connect in a Next.js application.

## 1. Install dependencies

```bash
npm install @phantom/react-sdk @solana/web3.js
```

## 2. Create the provider

```tsx
// app/providers.tsx
"use client";

import { PhantomProvider, darkTheme } from "@phantom/react-sdk";
import { AddressType } from "@phantom/browser-sdk";

export function Providers({ children }: { children: React.ReactNode }) {
  return (
    <PhantomProvider
      config={{
        providers: ["google", "apple", "injected"],
        appId: "your-app-id", // Get from phantom.com/portal
        addressTypes: [AddressType.solana],
        authOptions: {
          redirectUrl: "https://yourapp.com/auth/callback",
        },
      }}
      theme={darkTheme}
      appName="Your App"
    >
      {children}
    </PhantomProvider>
  );
}
```

## 3. Wrap your layout

```tsx
// app/layout.tsx
import { Providers } from "./providers";

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html lang="en">
      <body>
        <Providers>{children}</Providers>
      </body>
    </html>
  );
}
```

## 4. Create the auth callback page

```tsx
// app/auth/callback/page.tsx
"use client";

import { ConnectBox } from "@phantom/react-sdk";

export default function AuthCallback() {
  return (
    <div style={{ display: "flex", justifyContent: "center", alignItems: "center", minHeight: "100vh" }}>
      <ConnectBox />
    </div>
  );
}
```

## 5. Add connect button to your page

```tsx
// app/page.tsx
"use client";

import { useModal, usePhantom, useAccounts, useDisconnect, useSolana } from "@phantom/react-sdk";

export default function Home() {
  const { open } = useModal();
  const { isConnected, isLoading } = usePhantom();
  const addresses = useAccounts();
  const { disconnect } = useDisconnect();
  const { solana } = useSolana();

  if (isLoading) return <p>Loading...</p>;

  if (isConnected && addresses) {
    return (
      <main>
        <p>Connected: {addresses[0]?.address}</p>
        <button onClick={() => solana.signMessage("Hello!")}>Sign Message</button>
        <button onClick={() => disconnect()}>Disconnect</button>
      </main>
    );
  }

  return (
    <main>
      <h1>Welcome</h1>
      <button onClick={open}>Connect Wallet</button>
    </main>
  );
}
```

## 6. Configure Phantom Portal

1. Go to phantom.com/portal
2. Create or select your app
3. Add your domain to allowed URLs
4. Add `https://yourapp.com/auth/callback` to redirect URLs
5. Copy your App ID


# React (Vite) Quickstart
Source: https://docs.phantom.com/recipes/quickstarts/react

Complete guide to integrating Phantom Connect in a React application.

## 1. Install dependencies

```bash
npm install @phantom/react-sdk @solana/web3.js
```

## 2. Wrap your app with the provider

```tsx
// src/main.tsx
import React from "react";
import ReactDOM from "react-dom/client";
import { PhantomProvider, darkTheme } from "@phantom/react-sdk";
import { AddressType } from "@phantom/browser-sdk";
import App from "./App";

ReactDOM.createRoot(document.getElementById("root")!).render(
  <React.StrictMode>
    <PhantomProvider
      config={{
        providers: ["google", "apple", "injected"],
        appId: "your-app-id", // Get from phantom.com/portal
        addressTypes: [AddressType.solana],
        authOptions: {
          redirectUrl: "https://yourapp.com/callback",
        },
      }}
      theme={darkTheme}
      appName="Your App"
    >
      <App />
    </PhantomProvider>
  </React.StrictMode>
);
```

## 3. Create your app component

```tsx
// src/App.tsx
import { useModal, usePhantom, useAccounts, useDisconnect, useSolana } from "@phantom/react-sdk";

function App() {
  const { open } = useModal();
  const { isConnected, isLoading } = usePhantom();
  const addresses = useAccounts();
  const { disconnect } = useDisconnect();
  const { solana } = useSolana();

  if (isLoading) return <p>Loading...</p>;

  if (isConnected && addresses) {
    return (
      <div>
        <p>Connected: {addresses[0]?.address}</p>
        <button onClick={() => solana.signMessage("Hello!")}>Sign Message</button>
        <button onClick={() => disconnect()}>Disconnect</button>
      </div>
    );
  }

  return (
    <div>
      <h1>Welcome</h1>
      <button onClick={open}>Connect Wallet</button>
    </div>
  );
}

export default App;
```

## 4. Create a callback page

```tsx
// src/Callback.tsx
import { ConnectBox } from "@phantom/react-sdk";

function Callback() {
  return (
    <div style={{ display: "flex", justifyContent: "center", alignItems: "center", minHeight: "100vh" }}>
      <ConnectBox />
    </div>
  );
}

export default Callback;
```

## 5. Add routing (React Router)

```tsx
// src/main.tsx
import { BrowserRouter, Routes, Route } from "react-router-dom";
import App from "./App";
import Callback from "./Callback";

// Inside your PhantomProvider:
<BrowserRouter>
  <Routes>
    <Route path="/" element={<App />} />
    <Route path="/callback" element={<Callback />} />
  </Routes>
</BrowserRouter>
```

## 6. Configure Phantom Portal

1. Go to phantom.com/portal
2. Create or select your app
3. Add your domain to allowed URLs
4. Add your callback URL to redirect URLs
5. Copy your App ID


# Vanilla JavaScript Quickstart
Source: https://docs.phantom.com/recipes/quickstarts/vanilla-js

Complete guide to integrating Phantom Connect using plain JavaScript.

## 1. Install the Browser SDK

```bash
npm install @phantom/browser-sdk @solana/web3.js
```

## 2. Initialize the SDK

```typescript
// wallet.ts
import { BrowserSDK, AddressType } from "@phantom/browser-sdk";

// These functions are defined in main.ts
declare function updateUI(address: string): void;
declare function showConnectButton(): void;

export const sdk = new BrowserSDK({
  providers: ["google", "apple", "injected"],
  appId: "your-app-id", // Get from phantom.com/portal
  addressTypes: [AddressType.solana],
  authOptions: {
    redirectUrl: "https://yourapp.com/callback.html",
  },
});

// Set up event listeners
sdk.on("connect", (data) => {
  console.log("Connected:", data.addresses);
  updateUI(data.addresses[0].address);
});

sdk.on("disconnect", () => {
  console.log("Disconnected");
  showConnectButton();
});

// Try to restore existing session
sdk.autoConnect();
```

## 3. Create the HTML

```html
<!-- index.html -->
<!DOCTYPE html>
<html>
  <head>
    <title>My App</title>
  </head>
  <body>
    <div id="app">
      <div id="disconnected">
        <h1>Welcome</h1>
        <button id="connect-google">Continue with Google</button>
        <button id="connect-apple">Continue with Apple</button>
        <button id="connect-extension">Connect Phantom</button>
      </div>

      <div id="connected" style="display: none;">
        <p>Connected: <span id="address"></span></p>
        <button id="sign">Sign Message</button>
        <button id="disconnect">Disconnect</button>
      </div>
    </div>

    <script type="module" src="./main.ts"></script>
  </body>
</html>
```

## 4. Add the JavaScript

```typescript
// main.ts
import { sdk } from "./wallet";

// Connect buttons
document.getElementById("connect-google")!.onclick = () => {
  sdk.connect({ provider: "google" });
};

document.getElementById("connect-apple")!.onclick = () => {
  sdk.connect({ provider: "apple" });
};

document.getElementById("connect-extension")!.onclick = () => {
  sdk.connect({ provider: "injected" });
};

// Sign message
document.getElementById("sign")!.onclick = async () => {
  const { signature } = await sdk.solana.signMessage("Hello!");
  alert("Signature: " + signature);
};

// Disconnect
document.getElementById("disconnect")!.onclick = () => {
  sdk.disconnect();
};

// UI helpers
function updateUI(address: string) {
  document.getElementById("disconnected")!.style.display = "none";
  document.getElementById("connected")!.style.display = "block";
  document.getElementById("address")!.textContent = address;
}

function showConnectButton() {
  document.getElementById("disconnected")!.style.display = "block";
  document.getElementById("connected")!.style.display = "none";
}
```

## 5. Create the callback page

```html
<!-- callback.html -->
<!DOCTYPE html>
<html>
  <head>
    <title>Connecting...</title>
  </head>
  <body>
    <p>Connecting to Phantom...</p>
    <script type="module">
      import { sdk } from "./wallet";
      // SDK handles the callback automatically
      // Redirect back to main page after connection
      sdk.on("connect", () => {
        window.location.href = "/";
      });
    </script>
  </body>
</html>
```

## 6. Configure Phantom Portal

1. Go to phantom.com/portal
2. Create or select your app
3. Add your domain to allowed URLs
4. Add your callback URL to redirect URLs
5. Copy your App ID


# React Native Quickstart
Source: https://docs.phantom.com/recipes/quickstarts/react-native

Complete guide to integrating Phantom Connect in a React Native app.

## 1. Install dependencies

```bash
npm install @phantom/react-native-sdk @solana/web3.js

# Required polyfill for cryptographic operations
npm install react-native-get-random-values

# Install peer dependencies
npx expo install expo-secure-store expo-web-browser expo-auth-session react-native-svg
```

If you're using Expo, use `npx expo install` to ensure compatibility. For bare React Native projects, you can install the packages directly with npm.

## 2. Configure app scheme

Add your custom scheme to `app.json`:

```json
{
  "expo": {
    "name": "My App",
    "slug": "my-app",
    "scheme": "myapp",
    "plugins": [
      "expo-router",
      "expo-secure-store",
      "expo-web-browser",
      "expo-auth-session"
    ]
  }
}
```

For bare React Native projects, configure deep linking in your native project files. See React Native deep linking documentation for details.

## 3. Create the app entry point

The `react-native-get-random-values` import must be the very first import in your app's entry point, before any other imports.

### With Expo Router

```tsx
// app/_layout.tsx
import "react-native-get-random-values"; // Must be first!

import { Stack } from "expo-router";
import { PhantomProvider, AddressType, darkTheme } from "@phantom/react-native-sdk";

export default function Layout() {
  return (
    <PhantomProvider
      config={{
        providers: ["google", "apple"],
        appId: "your-app-id", // Get from phantom.com/portal
        scheme: "myapp",
        addressTypes: [AddressType.solana],
        authOptions: {
          redirectUrl: "myapp://phantom-auth-callback",
        },
      }}
      theme={darkTheme}
      appName="My App"
    >
      <Stack />
    </PhantomProvider>
  );
}
```

### Without Expo Router

```tsx
// App.tsx or index.js
import "react-native-get-random-values"; // Must be first!

import React from "react";
import { PhantomProvider, AddressType, darkTheme } from "@phantom/react-native-sdk";
import { WalletScreen } from "./WalletScreen";

export default function App() {
  return (
    <PhantomProvider
      config={{
        providers: ["google", "apple"],
        appId: "your-app-id", // Get from phantom.com/portal
        scheme: "myapp",
        addressTypes: [AddressType.solana],
        authOptions: {
          redirectUrl: "myapp://phantom-auth-callback",
        },
      }}
      theme={darkTheme}
      appName="My App"
    >
      <WalletScreen />
    </PhantomProvider>
  );
}
```

## 4. Create the wallet screen

```tsx
// WalletScreen.tsx
import React from "react";
import { View, Text, Button, StyleSheet, Alert } from "react-native";
import {
  useModal, usePhantom, useAccounts, useDisconnect, useSolana,
} from "@phantom/react-native-sdk";

export function WalletScreen() {
  const { open } = useModal();
  const { isConnected } = usePhantom();
  const addresses = useAccounts();
  const { disconnect } = useDisconnect();
  const { solana } = useSolana();

  if (isConnected && addresses) {
    return (
      <View style={styles.container}>
        <Text style={styles.title}>Wallet Connected</Text>
        <Text style={styles.address}>{addresses[0]?.address}</Text>
        <Button
          title="Sign Message"
          onPress={async () => {
            try {
              const { signature } = await solana.signMessage("Hello!");
              Alert.alert("Success", `Signature: ${signature.slice(0, 10)}...`);
            } catch (error) {
              Alert.alert("Error", error instanceof Error ? error.message : "Failed to sign");
            }
          }}
        />
        <Button title="Disconnect" onPress={() => disconnect()} />
      </View>
    );
  }

  return (
    <View style={styles.container}>
      <Text style={styles.title}>Welcome</Text>
      <Button title="Connect Wallet" onPress={open} />
    </View>
  );
}

const styles = StyleSheet.create({
  container: { flex: 1, justifyContent: "center", alignItems: "center", padding: 20 },
  title: { fontSize: 24, marginBottom: 20, fontWeight: "bold" },
  address: { fontSize: 14, marginBottom: 20, color: "#666" },
});
```

## 5. Configure Phantom Portal

1. Go to phantom.com/portal
2. Create or select your app
3. Add your redirect URL (e.g., `myapp://phantom-auth-callback`) to redirect URLs
4. Copy your App ID


# Go-live checklist
Source: https://docs.phantom.com/best-practices/launching-a-dapp

Integrating your app with Phantom? Use this checklist to make sure everything is set up correctly.

## Phantom Portal setup

### Account created in Phantom Portal

Go to phantom.com/portal and sign up with Google or Apple.

### App created and configured in Phantom Portal

Confirm that your app is fully set up in Phantom Portal:

- The app has been created in Phantom Portal.
- Branding and app details have been added.
- The domain has been verified.
- Allowed origin URLs have been configured.
- An App ID has been generated.
- The app access mode is set to `PUBLIC`.

## Integration testing

Validate that your integration works correctly across common user flows:

- Wallet connection and authentication work through Phantom Connect.
- Transaction signing works on all supported networks.
- Spending limit behavior is correct, if you're using embedded wallets.
- Error handling works as expected for rejected transactions or insufficient funds.
- The app behaves correctly across browsers and devices.

## Security

Verify that basic security requirements are met:

- HTTPS is enforced across all production URLs.
- No private keys or sensitive data are logged.
- All transactions clearly display the correct amounts and intent to users.

## Common issues

### Transactions fail

If transactions fail during testing or after launch, common causes include the following:

- Insufficient funds to cover gas or rent.
- Contract errors or RPC-related failures.

### App doesn't show in the Explore tab

If your app isn't visible in the Explore tab, it's usually because of the following reason:

- Cause: Your app profile changes are still under review.
- Solution: Wait for Phantom to approve the updates. Once approved, changes appear immediately.


# Display apps in the Recent Activity tab
Source: https://docs.phantom.com/best-practices/displaying-apps-within-the-activity-tab

When a user views their historical activity, Phantom will parse their dapp interactions and enrich them with known metadata.

To display your app within the Activity tab, fill out the form at https://docs.google.com/forms/d/e/1FAIpQLSeHWETFkEJbHQCF-lnl1AHmVQPuyfC0HbnxjDjIp6VYV1sBZQ/viewform with the following information:

- URL of the website
- Display name of the dapp
- Program/Contract IDs
- Interaction names (corresponding to program IDs)


# Display apps within dialogs
Source: https://docs.phantom.com/best-practices/displaying-your-app

When an app is establishing a connection or sending a transaction, Phantom will present the user with dialogs. In order to display the title and icon for these dialogs, Phantom will inspect the application's HTML for the following items:

| Value | Primary lookup | Secondary lookup | Fallback |
| ----- | -------------- | ---------------- | -------- |
| Title | Open Graph title | Document Title Element | None |
| Icon  | Apple touch icon | Favicon | A default icon |


# Display tokens on Solana
Source: https://docs.phantom.com/best-practices/tokens

If you've created a token on Solana using the SPL Token Program or Token-2022 Program ("Token Extensions"), then your token is compatible with Phantom. If Phantom users own a certain balance of a token made with these programs, that balance will always appear in their wallet. However, if Phantom cannot find more metadata about that token, it will display the token as "Unknown."

## Search for metadata

When searching for metadata, Phantom will first look to the Token Metadata Program established by Metaplex. This program enhances ordinary SPL token mints with a Metadata Account that describes additional fields such as the token's `symbol`, `image`, and `description`. Some of these fields exist on-chain in the Metadata Account itself, while others exist off-chain in a JSON file that follows a standard format. The link to this off-chain JSON file is found at the Metadata Account's `uri` field.

If a Metadata Account is found, Phantom will prioritize on-chain fields (such as `name`, `symbol`) before off-chain fields described in the `uri` JSON file.

## Categorize tokens

Phantom will categorize and display tokens based on their Token Standard. The `tokenStandard` field can be found in the token's on-chain Metadata Account and is used to describe a token's fungibility. The `tokenStandard` field has four options:

- `Fungible`: A token with simple metadata that can be freely mixed with others of the same mint. Common examples include USDC and SRM.
- `FungibleAsset`: A token with metadata that can also have NFT-like attributes. Commonly referred to as Semi-Fungible, these tokens are often used in gaming contexts to support stackable items like a piece of wood.
- `NonFungible`: A non-fungible token with a Master Edition account. This is the most popular type of NFT, encompassing well known collections like Solana Monkey Business and DeGods.
- `NonFungibleEdition`: A non-fungible token with an Edition account (printed from a Master Edition). This is a helpful feature for creators who want to offer multiple copies of their 1/1 NFTs.
- `ProgrammableNonFungible`: A new non-fungible asset class that allows for flexible configuration of various lifecycle rules triggered by specific actions.

If no `tokenStandard` is set, Phantom will fallback to categorizing tokens based on the following logic:

1. If the total mint supply is 1, Phantom will consider the token to be `NonFungible`.
2. If the total mint supply is greater than 1 and the mint has 0 decimals, Phantom will consider the token to be a `FungibleAsset`.
3. Phantom will consider all other tokens to be `Fungible`.

## Display tokens

Phantom will display all `Fungible` tokens in the Home tab. All other token standards (`FungibleAsset`, `NonFungible`, and `NonFungibleEdition`) will be displayed in the Collectibles tab.


# Fungibles
Source: https://docs.phantom.com/best-practices/tokens/home-tab-fungibles

## Display fungible tokens

Phantom prioritizes on-chain metadata that follows the Token Metadata Standard. For fungible tokens specifically, Phantom will show the following fields:

| Field  | Description |
| ------ | ----------- |
| name   | The name of the token, such as "USD Coin." |
| symbol | The symbol of the token, such as "USDC." |
| image  | A URI pointing to the token's logo. |

If a `Fungible` token has `name` and `symbol` fields present on both its on-chain Metadata Account and off-chain JSON file (linked via the on-chain `uri` field), Phantom will prioritize the on-chain fields.

If a `Fungible` token does not have an on-chain Metadata Account, Phantom will fallback to displaying data from the Solana Labs Token List. This list is considered deprecated and should not be used to host new tokens. When reading from the token list, Phantom will display the following fields:

| Field | Description |
| ----- | ----------- |
| name | The name of the token, such as "USD Coin." |
| symbol | The symbol of the token, such as "USDC." |
| logoURI | A URI pointing to the token's logo. |
| extensions.coingeckoID | The token ID as defined by the Coingecko API. Phantom uses this to fetch the price of the token. |

## Display prices

Phantom will display prices for any token that is verified on Coingecko. When verifying with Coingecko, be sure to include the token's `contract`. For Solana tokens, this should be the mint address. Once a token has verified its `contract` address with Coingecko, Phantom will automatically begin displaying its price.

If Coingecko is unable to return a price for a given token, Phantom will fallback to using Birdeye for token prices.


# NFTs and semi-fungibles
Source: https://docs.phantom.com/best-practices/tokens/collectibles-nfts-and-semi-fungibles

On Solana, NFTs are often thought of as SPL Tokens with 0 decimals and a supply of 1. According to the Token Metadata Standard, however, it is possible for a range of different tokens to have NFT-like characteristics. Phantom refers to all NFT-like tokens as collectibles and will display them separately from `Fungible` tokens that appear on the Home tab. Specifically, Phantom will display all `FungibleAsset`, `NonFungible`, `NonFungibleEdition` and `ProgrammableNonFungible` tokens on their own Collectibles tab.

## Group collectibles

Phantom groups collectibles by their Certified Collections introduced in v1.1.0 of the Token Metadata Standard. In order to be grouped together, individual NFTs should all reference the same verified collection mint address.

If no verified collection is found, Phantom will fallback to grouping NFTs by the first verified creator's address in the on-chain `creators` field.

## Name grouped collectibles

When a group is created, a best-effort process is used to determine that group's name. Phantom will look to these fields in the following order of preference:

1. `name` of the verified on-chain collection NFT
2. `collection.name`
3. `collection.family`
4. `external_url` (parsed to remove url parts)
5. `name` (of a single collectible)
6. `symbol`
7. address of the first verified creator in the `creators` array

## Display an individual collectible

When displaying the detail view of an individual collectible, Phantom will prioritize on-chain data in the Metadata Account over off-chain JSON linked via the `uri` field.

## Render collectible media

### Supported media types

Phantom supports a wide-range of media types. For a full list, refer to Supported media types.

### Select media

When determining what media to display for a given collectible, Phantom will search the off-chain JSON for data in the following order:

1. `animation_url`: Phantom will select the media source at the collectible's `animation_url` field.
2. `properties.files`: If no `animation_url` is found, Phantom will choose the first file where the `cdn` property is set to `true`. Otherwise, a file will be chosen based on the media type in the following order of preference: image, audio, video, vr or model.
3. `image`: Finally, if Phantom still cannot find media to display, it will fallback to the media source at the collectible's `image` field.

### Determine media type

If a media source is found in `properties.files`, and that source is defined as an object, Phantom will determine the media type based on that file's `type` property.

In cases where Phantom cannot find a source from `properties.files`, it may fallback to a media source that is defined as a `string`. In these cases, Phantom will look for data in the following order of preference:

1. The media source URI's `?ext=` query string parameter.
2. The media source URI's pathname extension.
3. If the media source URI comes from the `animation_url`, Phantom will infer the media type based on the collectible's `properties.category` field.
4. If the media source URI comes from the `image` field, Phantom will default to assume it is a PNG.

### Resize images

Phantom will resize all collectible images to 256x256 pixels. For best results, we recommend images with a square aspect ratio and a power-of-2 dimension (for example, 256x256, 512x512, or 1024x1024).


# Supported media types
Source: https://docs.phantom.com/best-practices/tokens/supported-media-types

Phantom supports a range of token media types, including images, audio files, video files, and 3D models. At this time, Phantom doesn't support HTML files. The following list includes all file types supported by Phantom:

| Media | Format |
| ----- | ------ |
| Images | JPEG, JPG, PNG, GIF, SVG, WEBP |
| Video | MP4, MOV, WEBM, M4V, OGV, OGG |
| Audio | MP3, WAV, OGA, FLAC |
| 3D models | GLB, GLTF, GLTF-BINARY |


# Make your token appear as verified
Source: https://docs.phantom.com/best-practices/tokens/token-verification

Phantom doesn't manage token verification directly and doesn't have an email address or form to assist with verification. Instead, Phantom displays token information using data from trusted third-party sources (for example, CoinGecko and Jupiter).

We're unable to provide specific details about how token verification status is determined in Phantom. If you're trying to have a token appear as verified, a good first step is to make sure the token is recognized by major token data sources (for example, by being listed or verified there).


# Developer tools and resources
Source: https://docs.phantom.com/developer-powertools/overview

Build better apps with Phantom using our developer tools, integration guides, and best practices. This section covers everything from AI-assisted development to transaction handling and token display.

## Developer tools

Accelerate your Phantom integration with AI-powered tools and starter templates.

- Recipes and starter kits: Example implementations and starter templates
- Cursor AI prompts: One-shot prompts for implementing Phantom SDKs
- MCP server: Give your AI assistant access to Phantom docs

## Security and validation

- Domain and transaction warnings: Understand and resolve Phantom security warnings
- Transaction validation: How Phantom validates transactions with Lighthouse
- Token pages: Shareable web-accessible token detail pages
- Sign-In-With standards: Implement SIWS, SIWE, and CAIP-122 authentication
- Shortcuts: Surface curated links to NFT collection holders

## Solana features

- Priority fees: How Phantom calculates and applies priority fees
- Versioned Transactions: Use Address Lookup Tables and versioned transactions
- Token Extensions (Token22): Supported Token-2022 extensions in Phantom
- Actions and Blinks: Enable interactive transactions on Twitter/X

## Testing and debugging

- Testnet mode: Access test networks in Phantom for development
- Mobile web debugging: Debug your mobile web app using browser dev tools

## Best practices

- Go-live checklist: Pre-launch checklist for Phantom integrations
- Display apps in dialogs: Configure your app title and icon in Phantom dialogs
- Display in Recent Activity: Show your app in the user's transaction history
- Token display guidelines: Ensure your tokens display correctly in Phantom


# AI-assisted development
Source: https://docs.phantom.com/developer-powertools/ai-tools

Build Phantom integrations faster with AI tools that understand our SDKs.

Your AI coding assistant can search Phantom documentation directly, giving you accurate, up-to-date guidance while you build.

## MCP server

The Phantom MCP (Model Context Protocol) server enables AI coding assistants to search and retrieve information from the Phantom developer documentation. This allows your AI assistant to provide accurate, up-to-date guidance when building Phantom integrations.

### Setup

| Tool | One-click | Manual |
|------|-----------|--------|
| Cursor | Click "Connect to Cursor" on any docs page | Add to `~/.cursor/mcp.json` |
| VS Code | Click "Connect to VS Code" | Add to `.vscode/mcp.json` |
| Claude.ai | -- | Add connector in Settings |
| Claude Code | -- | `claude mcp add --transport http phantom-docs https://docs.phantom.com/mcp` |

### Configuration

Add this configuration to your MCP settings:

```json
{
  "mcpServers": {
    "phantom-docs": {
      "type": "sse",
      "url": "https://docs.phantom.com/mcp"
    }
  }
}
```

### Example prompts

Once configured, try asking your AI assistant:

- "How do I set up Phantom Connect in a React app?"
- "Show me how to sign a message with the Browser SDK."
- "What's the process for verifying a domain in Phantom Portal?"
- "How do I handle transaction errors in React Native?"

## Cursor AI prompts

Use one-shot prompts with Cursor AI to generate complete, production-ready Phantom SDK implementations. These prompts create full applications with wallet connection, message signing, and transaction handling.

### Available prompts

| SDK | What it generates |
|-----|-------------------|
| React SDK | Complete app with wallet connection, message signing, SOL transfers |
| React Native SDK | Mobile app with Expo, OAuth flow, native wallet functionality |
| Browser SDK | Vanilla JS implementation for any web framework |

### How to use

1. Get App ID from Phantom Portal: Visit Phantom Portal to get your App ID before using any prompt.
2. Copy prompt for your SDK: Open the Cursor AI prompts page and copy the prompt for your preferred SDK (React, React Native, or Browser).
3. Replace placeholders: Replace `[YOUR_APP_ID]` and `[YOUR_REDIRECT_URL]` (or `[YOUR_SCHEME]` for React Native) with your actual values.
4. Paste into Cursor: Open Cursor AI, press `Cmd+K` (or `Ctrl+K` on Windows), and paste the complete prompt.
5. Review and run: Cursor will generate a full implementation. Review the code, then run and test your integration.

## Best practices

### Provide context

Give your AI assistant enough context to generate accurate code. Include:

- Your target framework (React, React Native, or vanilla JS).
- Specific features you need (wallet connection, transactions, message signing).
- General app structure and requirements.

Security best practice: Avoid sharing sensitive information like App IDs, redirect URLs, or API keys with AI assistants. Use placeholders like `[YOUR_APP_ID]` in prompts, then replace them with actual values in your code after generation.

### Combine tools

Use MCP server for questions and documentation lookups, then use Cursor prompts for scaffolding complete implementations:

1. Ask questions first: Use MCP server to understand concepts.
2. Generate code: Use Cursor prompts to scaffold your implementation.
3. Refine with MCP: Ask follow-up questions to customize the generated code.

### Verify generated code

Always review AI-generated code before deploying:

- Check App ID matches your Phantom Portal app.
- Verify redirect URLs are allowlisted in Phantom Portal.
- Ensure error handling is present for all async operations.
- Confirm lamports are calculated correctly (1 SOL = 1,000,000,000 lamports).
- Test wallet connection flow end-to-end.
- Validate transaction amounts and recipient addresses.


# Domain and transaction warnings
Source: https://docs.phantom.com/developer-powertools/domain-and-transaction-warnings

Phantom may display different warnings when users connect to your app or sign transactions. These warnings are designed to help protect users from unexpected or unsafe activity.

## New domain warning

If your app or website has been newly launched, Phantom may show users the following message:

"This domain is new or has not been reviewed yet. Proceed with caution."

This warning appears automatically for newly detected domains and typically disappears after a few days once the domain has been reviewed.

There's usually no action required on your part. If the warning remains visible for more than a week, contact the domain review team using this form: https://docs.google.com/forms/d/1JgIxdmolgh_80xMfQKBKx9-QPC7LRdN6LHpFFW8BlKM/viewform

## Transaction simulation warning

If Phantom can't accurately simulate a transaction before it's sent, users may see the following message:

"This dApp could be malicious. Do not proceed unless you are certain it is safe."

This message appears when Phantom is unable to safely predict a transaction's outcome before execution.

If Phantom displays this warning when you sign a transaction on your domain, follow these steps:

- Limit the transaction to one signer.
- If the transaction requires multiple signers, sign it with Phantom first using signTransaction instead of signAndSendTransaction, then collect signatures from the other signers.
- If your transaction approaches Solana's size limit, split it into multiple signing requests or use Address Lookup Tables.
- Before submitting the transaction for signing, simulate the transaction with `sigVerify: false` using your RPC node to ensure they will not fail onchain. Failed transactions could trigger simulation warnings.

If you've made these changes and the warning persists, contact the domain review team.

## Prediction market token burn warning

If a transaction attempts to burn a prediction market token, Phantom may show users the following message:

"This transaction will burn a valuable prediction market token. Please use the Phantom app to close the position first."

This warning appears when Phantom detects a transaction that would permanently burn a prediction market token. To resolve this warning, contact the Trust and Safety team.


# Transaction Validation
Source: https://docs.phantom.com/developer-powertools/lighthouse

When building with Phantom, you may see transactions that include Lighthouse assertion instructions. Lighthouse is a Solana program that adds runtime checks to transactions. These checks validate onchain state and will cause the transaction to fail if conditions aren't met.

These assertions are included to ensure user safety by protecting against unexpected outcomes like simulation spoofing or malicious transaction manipulation.

## What this means for your transactions

When you submit a transaction to Phantom, it may be augmented with Lighthouse assertion instructions before being submitted to the network. This means that if you're checking transactions onchain as part of your confirmation flow, you should be aware that the transaction onchain will be different from what you originally submitted.

Additionally, these assertions can cause a transaction to fail even when it would otherwise execute successfully. For example, if a swap transaction includes an assertion checking for a specific token balance and the actual balance differs, the entire transaction will fail.

You don't need to do anything special to handle these assertions. They're included in the transaction by Phantom and are processed automatically onchain.


# Token pages
Source: https://docs.phantom.com/developer-powertools/token-pages

Phantom provides shareable, web-accessible token pages that display detailed token information. These pages provide a seamless experience whether accessed through the Phantom wallet app or via web browsers.

## Generate a token page URL

To create a shareable token page URL:

1. Open the desired token page in Phantom.
2. Tap the share button.
3. Copy or share the generated URL.

The URL follows this format:

```
https://phantom.com/tokens/<chain>/<token_address>
```

For example, the WIF token on Solana can be accessed at:

```
https://phantom.com/tokens/solana/EKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzLHYxdM65zcjm
```

## Key features

### Universal and deep linking

When accessed on mobile devices with Phantom installed, token page URLs automatically open the corresponding details page within the Phantom app. For users without Phantom installed, the links gracefully fallback to the web view.

### Quick access to swapper

The web view includes a QR code that, when scanned, deep links directly to the token's swap screen within the Phantom app.

### Enhanced social sharing

Each token page generates dynamic OpenGraph images that display essential token information and price charts. When shared on social media platforms, these rich previews provide immediate context about the token's performance and status.


# Sign-In-With (SIW) standards
Source: https://docs.phantom.com/developer-powertools/signing-a-message

Applications that rely on `signMessage` for authenticating users can choose to opt-in to one of the various Sign-In with (SIW) standards. If a message follows one of the supported standards, Phantom will verify required fields at the time of signing.

At the time of this writing, Phantom supports:

- Sign-In with Solana (specification: https://github.com/phantom/sign-in-with-solana)
- Sign-In with Ethereum (EIP-4361)
- Sign-In with X (CAIP-122)

The serialized format of SIW messages is as follows:

```
${domain} wants you to sign in with your ${blockchain} account:
${address}

${statement}

URI: ${uri}
Version: ${version}
Chain ID: ${chain-id}
Nonce: ${nonce}
Issued At: ${issued-at}
Expiration Time: ${expiration-time}
Not Before: ${not-before}
Request ID: ${request-id}
Resources:
- ${resources[0]}
- ${resources[1]}
...
- ${resources[n]}
```

| Name | Type | Required? | Description |
| ---- | ---- | --------- | ----------- |
| `domain` | `string` | true | The authority that is requesting the signing. |
| `address` | `string` | true | The blockchain address that is performing the signing. |
| `statement` | `string` | false | A human-readable ASCII assertion that the user will sign. |
| `uri` | `string` | true | A URI referring to the resource that is the subject of the signing. |
| `version` | `string` | true | The current version of the message. |
| `chain-id` | `string` | true | The Chain ID to which the session is bound. |
| `nonce` | `string` | true | A randomized token to prevent signature replay attacks. |
| `issued-at` | `string` | true | The issuance time. |
| `expiration-time` | `string` | false | The time at which the signed authentication message is no longer valid. |
| `not-before` | `string` | false | The time at which the signed authentication message starts being valid. |
| `request-id` | `string` | false | A system-specific identifier used to uniquely refer to the authentication request. |
| `resources` | `string[]` | false | A list of URIs the user wishes to have resolved as part of the authentication. |

### Sign-In with Solana

See the specification and integration guide at https://github.com/phantom/sign-in-with-solana on GitHub.

### Sign-In with Ethereum

The Sign-In with Ethereum standard is defined by EIP-4361.

#### Examples

signMessage()

```javascript
const provider = getProvider(); // see "Detecting the Provider"
const message = `magiceden.io wants you to sign in with your Ethereum account:
0xb9c5714089478a327f09197987f16f9e5d936e8a

Click Sign or Approve only means you have proved this wallet is owned by you.

URI: https://magiceden.io
Version: 1
Chain ID: 1
Nonce: bZQJ0SL6gJ
Issued At: 2022-10-25T16:52:02.748Z
Resources:
- https://foo.com
- https://bar.com`;
const encodedMessage = new TextEncoder().encode(message);
const signedMessage = await provider.signMessage(encodedMessage, "utf8");
```

request()

```javascript
const provider = getProvider(); // see "Detecting the Provider"
const message = `magiceden.io wants you to sign in with your Ethereum account:
0xb9c5714089478a327f09197987f16f9e5d936e8a

Click Sign or Approve only means you have proved this wallet is owned by you.

URI: https://magiceden.io
Version: 1
Chain ID: 1
Nonce: bZQJ0SL6gJ
Issued At: 2022-10-25T16:52:02.748Z
Resources:
- https://foo.com
- https://bar.com`;
const encodedMessage = new TextEncoder().encode(message);
const signedMessage = await provider.request({
    method: "signMessage",
    params: {
         message: encodedMessage,
         display: "utf8",
    }
});
```

### Sign-In with X

The Sign-In with X standard is defined by CAIP-122. It uses CAIP-10 identifiers for the `address` field and CAIP-2 for `chain-id`.

While CAIP-122 is technically chain-agnostic, only Ethereum and Solana parsing are supported at this time.

#### Solana example

```javascript
const provider = getProvider(); // see "Detecting the Provider"
const message = `magiceden.io wants you to sign in with your Solana account:
solana:mainnet:FYpB58cLw5cwiN763ayB2sFT8HLF2MRUBbbyRgHYiRpK

Click Sign or Approve only means you have proved this wallet is owned by you.

URI: https://magiceden.io
Version: 1
Chain ID: solana:mainnet
Nonce: bZQJ0SL6gJ
Issued At: 2022-10-25T16:52:02.748Z
Resources:
- https://foo.com
- https://bar.com`;
const encodedMessage = new TextEncoder().encode(message);
const signedMessage = await provider.signMessage(encodedMessage, "utf8");
```

Phantom uses Ed25519 signatures for Solana message signatures. To verify a message signature, you can use the tweetnacl npm package.


# Shortcuts
Source: https://docs.phantom.com/developer-powertools/shortcuts

Shortcuts is a feature that enables NFT collections to surface a curated list of links to their holders.

Shortcuts are currently in beta. If you want to enable this in your project within Phantom, let us know by submitting this form: https://docs.google.com/forms/d/e/1FAIpQLSeHWETFkEJbHQCF-lnl1AHmVQPuyfC0HbnxjDjIp6VYV1sBZQ/viewform

For details, see the implementation guide at https://github.com/phantom/shortcuts on GitHub.


# Solana priority fees
Source: https://docs.phantom.com/developer-powertools/solana-priority-fees

Phantom automatically calculates and applies Priority fees to all Phantom-generated transactions and dapp-generated transactions that meet our requirements.

## How transaction fees work on Solana

Solana transactions fees are calculated based on two main parts:

- A statically set base fee per signature, and
- The computational resources used during the transaction, measured in Compute Units (CU)

Since each transaction requires different computational resources, they are allotted a maximum number of compute units, known as the Compute Budget. After the Compute Budget is exhausted, the runtime halts the transaction and returns an error, resulting in a failed transaction.

The maximum budget for a transaction is 1.4 million CU, while the total blockspace limit is 48 million CU.

The fee priority of a transaction T can be defined as F(T), where F(T) is the "fee-per compute-unit", calculated by: (additional_fee + base_fee) / requested_compute_units

## Priority fee calculation

Priority fees are calculated as: priority_fees = compute_budget * compute_unit_price

Where: compute_budget = # of instructions * compute_unit_limit

## How Phantom applies priority fees to app transactions

Although dapps can set their own priority fees on transactions they generate, we highly discourage doing so as it often surfaces unnecessary complexity to end-users. Instead, we recommend that dapp developers let Phantom apply priority fees on the user's behalf.

Phantom will calculate and apply Priority Fees to all dapp-generated transactions, provided:

- The transaction(s) do not already have signature(s) present.
- The transaction(s) do not have existing priority fee instructions (`computeUnitBudget` or `computeUnitLimit`).
- After enhancing transaction(s) with Priority Fees, the size of each transaction will still be less than the byte size limit (1232 bytes).

If all of the above conditions are met, Phantom will automatically calculate and apply priority fees at the time of signing. This pattern applies to all Phantom provider methods (`signAndSendTransaction`, `signTransaction`, `signAllTransactions`) across all environments (extension, mobile in-app browser, deeplinks, mobile wallet adapter).


# Solana Versioned Transactions
Source: https://docs.phantom.com/developer-powertools/solana-versioned-transactions

Phantom supports Versioned Transactions and Legacy Transactions. Versioned Transactions and Address Lookup Tables (LUTs) were introduced by Solana in an effort to improve the developer and end-user experience. The proposed changes are as follows:

- Introduce a program which manages on-chain address lookup tables
- Add a new transaction format which can make use of the above on-chain address lookup tables

Legacy transactions have a major issue: Maximum allowed size of 1232 bytes, and hence the number of accounts that can fit in an atomic transaction: 35 addresses. This is where Address LUTs come into the picture.

## Address LUTs

The idea behind Address LUTs is to store account addresses in array-like data structures on-chain. Once accounts are stored in this table, the address of the table can be referenced in a transaction message using 1-byte u8 indices. This allows 2^8=256 accounts to be included in 1 tx, as accounts are referenced using u8 indices.

## RPC changes

Transaction responses will require a new version field: `maxSupportedTransactionVersion` to indicate to clients which transaction structure needs to be followed for deserialisation.

The following methods need to be updated to avoid errors: `getTransaction`, `getBlock`

The following parameter needs to be added to the requests: `maxSupportedTransactionVersion: 0`

```bash
curl http://localhost:8899 -X POST -H "Content-Type: application/json" -d \
'{"jsonrpc": "2.0", "id":1, "method": "getBlock", "params": [430, {
  "encoding":"json",
  "maxSupportedTransactionVersion":0,
  "transactionDetails":"full",
  "rewards":false
}]}'
```

```javascript
// connect to the `devnet` cluster and get the current `slot`
const connection = new web3.Connection(web3.clusterApiUrl("devnet"));
const slot = await connection.getSlot();

// get the latest block (allowing for v0 transactions)
const block = await connection.getBlock(slot, {
  maxSupportedTransactionVersion: 0,
});

// get a specific transaction (allowing for v0 transactions)
const getTx = await connection.getTransaction(
  "3jpoANiFeVGisWRY5UP648xRXs3iQasCHABPWRWnoEjeA93nc79WrnGgpgazjq4K9m8g2NJoyKoWBV1Kx5VmtwHQ",
  {
    maxSupportedTransactionVersion: 0,
  },
);
```


# Solana Token Extensions (Token22)
Source: https://docs.phantom.com/developer-powertools/solana-token-extensions-token22

Phantom supports fungible and non-fungible tokens created with the Token-2022 Program. At the time of this writing, Phantom supports the following Token Extensions:

## Group and Group Pointer

The Group and Group Pointer extensions allow token creators to create configurations for grouping tokens together. Phantom currently supports both extensions for non-fungible tokens in the Collectibles tab.

## Interest-Bearing Tokens

The Interest-Bearing Tokens extension allows creators to set an interest rate on their tokens. This interest rate is for cosmetic purposes only, no new tokens are created as a result of the interest. If this extension is enabled, Phantom will display the current interest rate on the token's detail screen.

## Memo on Transfer

The Memo on Transfer extension enforces that all incoming transfers must have an accompanying memo instruction right before the transfer instruction. Phantom will allow a user to input a memo on transfers, even if it is optional.

## Metadata

The Metadata extension allows a token creator to include their metadata directly in the token's mint account. Phantom will display the `name` and `symbol` that is stored in the mint account, and look to the `uri` field for additional information such as the token's `image`.

## Metadata Pointer

The Metadata Pointer extension allows a token creator to designate an address that describes the canonical metadata. Phantom supports the Metadata Pointer Extension. At the time of this writing, Phantom will assume all metadata schemas follow the Metaplex Standard.

## Permanent Delegate

The Permanent Delegate extension allows token creators to grant unlimited delegation privileges over any account for that mint. If enabled, a delegate can burn or transfer any amount of tokens. Phantom will display a warning for any token that has this extension enabled.

## Transfer Fees

The Transfer Fees extension allows a token creator to assess fees on every token transfer. If this extension is enabled, Phantom will display the fee on the confirmation screen of every send.

## Transfer Hooks

The Transfer Hooks extension allows a token to invoke a custom program at the time of transfer. This program can be used to add custom logic on transfers, such as assessing royalties or determining if the transfer is allowed based on a range of on-chain data sources.


# Solana Actions and Blinks
Source: https://docs.phantom.com/developer-powertools/solana-actions-and-blinks

Solana Actions are APIs to deliver signable transactions from a variety of web contexts. Blockchain links, or Blinks, are client applications that introspect Action APIs and construct user interfaces to interact with Actions.

The Phantom Extension supports rendering Blinks on Twitter/X.com. If an Action URL is posted to Twitter/X.com, the Phantom extension can construct a UI to interact with the transaction from directly within the user's timeline.

This feature is disabled by default. Users can opt-in to enabling this feature via by going to Settings > Experimental Features and turning on Blinks. Phantom will only render Actions that are registered under the Dialect-maintained Actions Registry.


# Mobile web debugging
Source: https://docs.phantom.com/developer-powertools/mobile-web-debugging

Developers can debug their mobile web dapps using PC browsers. To enable this in Phantom mobile, go to Settings > Developer Settings, and toggle Web View Debugging on. Then follow the steps for your platform.

## iOS

1. Tether your iPhone to your computer via USB.
2. On your iPhone go to Settings > Safari > Advanced and turn on Web Inspector.
3. On your computer open Safari. Then from the menu bar Safari > Settings > Advanced tab > turn on Show features for web developers.
4. Open your web dapp in Phantom on your tethered device.
5. Back on your computer from the Safari menu bar, go to Develop > [Your device] > [Your dapp].

## Android

1. Tether your Android phone to your computer via USB.
2. Open your web dapp in Phantom on your tethered device.
3. On your computer open `chrome://inspect/#devices` on Chrome.
4. Select your device on the left and select Inspect on the Phantom dapp contents you'd like to inspect.


# Wallet Standard
Source: https://docs.phantom.com/developer-powertools/wallet-standard

Wallet Standard is a chain-agnostic set of interfaces and conventions that aim to improve how applications interact with injected wallets such as Phantom. The standard was pioneered on Solana and is used as the foundation for the Solana Wallet Adapter. Phantom supports the Wallet Standard and is open to working with others to bring this innovation to other ecosystems.

Wallet Standard introduces an event-based model that:

1. Standardizes the way wallets attach themselves to the window.
2. Defines a set of standard APIs that dapps can rely upon.

```typescript
export interface WalletEventsWindow extends Omit<Window, 'addEventListener' | 'dispatchEvent'> {
    addEventListener(type: WindowAppReadyEventType, listener: (event: WindowAppReadyEvent) => void): void;
    addEventListener(type: WindowRegisterWalletEventType, listener: (event: WindowRegisterWalletEvent) => void): void;
    dispatchEvent(event: WindowAppReadyEvent): void;
    dispatchEvent(event: WindowRegisterWalletEvent): void;
}
```

When a wallet is ready to inject into a website, it will dispatch a `register-wallet` event and listen for an `app-ready` event. Conversely, an app will dispatch an `app-ready` event and listen for `register-wallet` events.

## For app developers

Phantom comes with built-in support for Wallet Standard on Solana. To get started, simply update the Solana Wallet Adapter to the latest release.

If you are migrating an existing Solana dapp to use Wallet Standard, please ensure that you are not mutating transactions in place. Failure to do so will result in a breaking change.


# Cursor AI prompts
Source: https://docs.phantom.com/resources/cursor-prompts

Use these prompts with Cursor AI to quickly implement Phantom wallet integration. Copy the prompt for your preferred SDK and paste it into Cursor to generate a complete, production-ready implementation.

For even better results, add the Phantom MCP server to Cursor. This gives your AI assistant direct access to our documentation for more accurate and contextual help.

## React SDK prompt

```text
Implement Phantom React SDK integration for Solana with the following requirements:

INSTALLATION:
1. Install the SDK: npm install @phantom/react-sdk
2. Install Solana dependencies: npm install @solana/web3.js

SETUP:
1. Create App.tsx that wraps your application with PhantomProvider:
   - Import: PhantomProvider, useConnect, useSolana, useAccounts, useDisconnect from "@phantom/react-sdk"
   - Import: AddressType from "@phantom/browser-sdk"
   - Configure PhantomProvider with:
     * providerType: "embedded"
     * addressTypes: [AddressType.solana]
     * appId: "[YOUR_APP_ID]"
     * authOptions: {
         authUrl: "https://connect.phantom.app/login",
         redirectUrl: "[YOUR_REDIRECT_URL]"
       }

WALLET CONNECTION COMPONENT:
1. Create a component that uses useConnect() and useAccounts() hooks
2. useConnect() returns: { connect, isConnecting }
3. Call connect() to initiate connection, returns: { addresses }
4. useAccounts() returns the connected Solana addresses array
5. Display "Connect Wallet" button when not connected
6. Display connected Solana address when connected
7. Add a disconnect button using useDisconnect() hook

MESSAGE SIGNING COMPONENT:
1. Create component that uses useSolana() hook
2. Get Solana interface: const { solana } = useSolana()
3. Sign message: await solana.signMessage("Your message here")
4. Returns signature object with the signed message
5. Display signature to user in a readable format

TRANSACTION COMPONENT:
1. Import required Solana libraries: Transaction, SystemProgram, PublicKey from @solana/web3.js
2. Create transfer transaction using SystemProgram.transfer()
3. Sign and send: await solana.signAndSendTransaction(transaction)
4. Returns { hash } with transaction signature
5. Display transaction hash with link to Solana explorer

REQUIREMENTS:
- Use TypeScript with proper types
- Add try-catch error handling for all async operations
- Show loading states during connection and transactions
- Display error messages to users with helpful context
- Style with Tailwind CSS for modern UI
- Convert lamports to SOL for user display (divide by 1,000,000,000)
```

Replace `[YOUR_APP_ID]` with your App ID from Phantom Portal and `[YOUR_REDIRECT_URL]` with your authentication callback URL (must be allowlisted in Phantom Portal).

## React Native SDK prompt

```text
Implement Phantom React Native SDK integration for Solana mobile apps with the following requirements:

INSTALLATION:
1. Install SDK: npm install @phantom/react-native-sdk
2. Install Solana dependency: npm install @solana/web3.js
3. Install peer dependencies:
   - For Expo: npx expo install expo-secure-store expo-web-browser expo-auth-session expo-router
   - Required polyfill: npm install react-native-get-random-values

POLYFILL SETUP (CRITICAL):
Add this import at the VERY TOP of your app entry point:
  import "react-native-get-random-values";

PROVIDER SETUP:
Wrap your app with PhantomProvider:
  import { PhantomProvider, AddressType } from "@phantom/react-native-sdk";
  Configure with providerType: "embedded", appId: "[YOUR_APP_ID]", scheme: "[YOUR_SCHEME]"

WALLET SCREEN: Use useConnect, useAccounts, useSolana, useDisconnect hooks
MESSAGE SIGNING: const { solana } = useSolana(); await solana.signMessage("message")
TRANSACTIONS: Build with @solana/web3.js SystemProgram.transfer()

REQUIREMENTS:
- TypeScript, error handling with Alert.alert, loading states
- Test on both iOS and Android
```

Replace `[YOUR_APP_ID]` with your App ID from Phantom Portal and `[YOUR_SCHEME]` with your custom URL scheme (for example, `myapp`).

## Browser SDK prompt

```text
Implement Phantom Browser SDK integration for Solana with the following requirements:

INSTALLATION:
1. Install SDK: npm install @phantom/browser-sdk
2. Install Solana dependency: npm install @solana/web3.js

SDK INITIALIZATION:
  import { BrowserSDK, AddressType } from "@phantom/browser-sdk";
  export const sdk = new BrowserSDK({
    providerType: "embedded",
    addressTypes: [AddressType.solana],
    appId: "[YOUR_APP_ID]",
    authOptions: {
      authUrl: "https://connect.phantom.app/login",
      redirectUrl: "[YOUR_REDIRECT_URL]",
    },
  });

CONNECTION: sdk.connect() returns { addresses }
MESSAGE SIGNING: await sdk.solana.signMessage(message)
TRANSACTIONS: Build with @solana/web3.js, send with sdk.solana.signAndSendTransaction(transaction)

REQUIREMENTS:
- TypeScript, error handling, loading states, input validation
```

Replace `[YOUR_APP_ID]` with your App ID from Phantom Portal and `[YOUR_REDIRECT_URL]` with your authentication callback URL.

## Step-by-step guide for using the prompts

1. Get your App ID: Make sure you have your App ID from Phantom Portal before using any prompt.
2. Customize the prompt: Replace placeholder values such as `[YOUR_APP_ID]`, `[YOUR_REDIRECT_URL]`, and `[YOUR_SCHEME]` with your actual values.
3. Paste into Cursor: Open Cursor AI, press `Cmd+K` (or `Ctrl+K` on Windows), and paste the complete prompt.
4. Review the generated code: Cursor will generate a full implementation. Review the code to ensure it meets your requirements.
5. Test the integration: Run your application and test wallet connection, message signing, and transaction flows.


# Phantom Portal - Get started
Source: https://docs.phantom.com/phantom-portal/getting-started

Follow this step-by-step guide to set up your app in Phantom Portal and prepare it for discovery within Phantom.

## Signup to live

Create account -> Create app -> Verify domain -> Configure URLs -> Go live

## Before you begin

Before starting, make sure you have the following:

- A deployed web app with a public domain
- HTTPS enabled with a valid SSL certificate
- Domain access to add DNS records
- Branding assets (logo and optional cover image)
- A clear description of what your app does

## Account setup

Setting up your app in Phantom Portal involves six main steps:

1. Create an account: Sign up with Google or Apple to access Phantom Portal
2. Create your app: Set up your app with a name, icon, and website URL
3. Verify your domain: Required to use Phantom Connect SDK and for app display
4. Configure URLs: Add allowed origins and redirect URLs for your app
5. Add your app information (optional): Add branding and details for the app to appear in Phantom's Explore tab
6. Get your App ID and integrate: Get your App ID and begin integrating your SDK of choice

## After setup

After your app is published, keep maintaining it:

- Monitor performance in the Phantom Portal dashboard
- Update information when releasing new features
- Review community feedback to improve your app
- Maintain domain verification by keeping DNS records in place

## Need help?

Contact Phantom developer support at https://docs.google.com/forms/d/e/1FAIpQLSeHWETFkEJbHQCF-lnl1AHmVQPuyfC0HbnxjDjIp6VYV1sBZQ/viewform


# Deeplinks - Handle sessions
Source: https://docs.phantom.com/phantom-deeplinks/handling-sessions

When a user connects to Phantom for the first time, Phantom will return a `session` param that represents the user's connection. The app should pass this `session` param back to Phantom on all subsequent provider methods. It is the app's responsibility to store this `session`.

Sessions do not expire. Once a user has connected with Phantom, the corresponding app can indefinitely make requests such as SignTransaction and SignMessage without prompting the user to re-connect with Phantom. Apps will still need to re-connect to Phantom after a disconnect event or an invalid session.

## Session structure

The entire `session` param is encoded in base58. A `session` should contain the following data:

- JSON Data Signature: A base58 signature of the JSON data that is 64 bytes.
- JSON Data: A JSON object with the following fields:
  - `app_url` (string): A URL that was provided during the initial connection request.
  - `timestamp` (number): The timestamp at which the user approved the connection.
  - `chain` (string): The chain that the user connected to at the start of the session. At the time of this writing, Phantom only supports `solana`.
  - `cluster` (string) (optional): The approved cluster. Can be: `mainnet-beta`, `testnet`, or `devnet`. Defaults to `mainnet-beta`.

About `app_url` in sessions: The `app_url` stored in the session token is used for validation purposes only. App metadata is fetched from the `redirect_link` parameter during the initial connection request.

## Decode sessions

Phantom will decode and validate the `session` param on every request. To decode the session, decode it with `bs58`, slice off the first 64 bytes of the signature, and treat the rest as JSON data.

```javascript
// Encoding a session
const privateKey = ...;
const sessionData = JSON.stringify({
  "app_id": "APP_ID",
  "chain": "CHAIN",
  "cluster": "CLUSTER",
  "timestamp": 1644954984,
});
const bytes = Buffer.from(sessionData, "utf-8");

// tweetnacl-js formats signature in format <signature><sessionData>
const signature = bs58.encode(nacl.sign(bytes, privateKey));

// Decoding a session
const publicKey = ...;
const verifiedSessionData = nacl.sign.open(bs58.decode(signature), publicKey.toBytes());
if (!verifiedSessionData) throw new Error(`This session was not signed by ${publicKey}`);
```

## Invalid sessions

While sessions do not expire, there are a number of reasons why a sessions could still be deemed invalid:

1. It was not signed by the current wallet keypair.
2. It was signed by the current wallet keypair, but the session's JSON `data` does not pass muster:
   - The user switched chains (or possibly networks).
   - The `app_url` could be blocked if malicious.

You must pass the session token for all requests or Phantom will redirect the user back to your app and a new session will be created.


# Deeplinks - Specifying redirects
Source: https://docs.phantom.com/phantom-deeplinks/specifying-redirects

All methods support a `redirect_link=` param that lets Phantom know how to get back to the original app. The URI specified by this param should be URL encoded.

If the deeplink request to Phantom comes with a response, Phantom will append the results as query parameters in the `redirect_link=` upon redirecting.

## Redirect link types

You can use either HTTPS URLs or custom scheme URIs for `redirect_link`, but each has different behavior:

### HTTPS URLs

When using an HTTPS URL (e.g., `https://yourapp.com/callback`):

- App metadata displays correctly: Logo, title, and favicon are fetched and shown in the connection approval dialog
- Opens in browser: The redirect opens in the mobile browser instead of redirecting back to your app

### Custom scheme URIs

When using a custom scheme URI (e.g., `mydapp://onPhantomConnected`):

- Redirects back to app: Properly redirects back to your mobile app
- No app metadata: Logo, title, and favicon are not displayed in the connection approval dialog

Choosing a redirect link type: Use HTTPS URLs if displaying your app's branding in the connection dialog is important. Use custom scheme URIs if seamless app redirection is critical.


# Deeplinks - Encryption
Source: https://docs.phantom.com/phantom-deeplinks/encryption

Deeplinks are encrypted using symmetric key encryption generated from a Diffie-Hellman key exchange. While deeplink sessions will be created in plaintext, an encrypted channel will be created to prevent session tokens from getting hijacked.

## Encryption and decryption workflow

### Connect

1. [dapp]: On the initial connect deeplink, dapps should include a `dapp_encryption_public_key` query parameter. It's recommended to create a new x25519 keypair for every session started with `connect`.
2. [phantom]: Upon handling a `connect` deeplink, Phantom will also generate a new x25519 keypair. Phantom will return this public key as `phantom_encryption_public_key` in the `connect` response. Phantom will create a shared secret using Diffie-Hellman.
3. [dapp]: Upon receiving the `connect` response, the dapp should create a shared secret by using Diffie-Hellman with `phantom_encryption_public_key` and the private key associated with `dapp_encryption_public_key`.

### Subsequent deeplinks

1. [dapp]: For any subsequent methods, dapps should send a `dapp_encryption_public_key` along with an encrypted `payload` object.
2. [phantom]: Upon approval, Phantom will encrypt the signed response as a JSON object with the encryption sent as a `data=` query param.
3. [dapp]: Upon receiving the deeplink response, dapps should decrypt the object in the `data=` query param.

## Encryption resources

- JavaScript: TweetNaCl.js (https://github.com/dchest/tweetnacl-js)
- iOS: TweetNaCl SwiftWrap (https://github.com/bitmark-inc/tweetnacl-swiftwrap)
- Android: Tink (https://github.com/google/tink), TweetNaCl Java (https://github.com/InstantWebP2P/tweetnacl-java)


# Deeplinks - Limitations
Source: https://docs.phantom.com/phantom-deeplinks/limitations

## Android

Android has a 500kb transaction limit when passing data between services and apps. The requesting app may crash with a `TransactionTooLarge` exception when requesting a string over 500kb (over 31k characters). This tends to happen with significantly large intents.

## iOS

iOS is not known to have a 500kb transaction and allows transmissions up to 1 MB.


# Deeplinks - Connect
Source: https://docs.phantom.com/phantom-deeplinks/provider-methods/connect

In order to start interacting with Phantom, an app must first establish a connection. This connection request will prompt the user for permission to share their public key, indicating that they are willing to interact further.

Once a user connects to Phantom, Phantom will return a `session` param that should be used on all subsequent methods.

## Base URL

```
https://phantom.app/ul/v1/connect
```

## Query string parameters

- `app_url` (required): A URL that is stored in the session token for validation purposes. URL-encoded.
- `dapp_encryption_public_key` (required): A public key used for end-to-end encryption.
- `redirect_link` (required): The URI where Phantom should redirect the user upon connection. This URL is also used to fetch app metadata (title, icon, favicon) for display in the connection approval dialog. URL-encoded.
- `cluster` (optional): The network for subsequent interactions. Can be: `mainnet-beta`, `testnet`, or `devnet`. Defaults to `mainnet-beta`.

Important distinction: `redirect_link` is used to fetch app metadata for display in the connection approval dialog. `app_url` is stored in the session token for validation purposes only.

## Returns

### Approve

- `phantom_encryption_public_key`: An encryption public key used by Phantom, encoded in base58.
- `nonce`: A nonce used for encrypting the response, encoded in base58.
- `data`: An encrypted JSON string containing:

```json
{
  "public_key": "BSFtCudCd4pR4LSFqWPjbtXPKSNVbGkc35gRNdnqjMCU",
  "session": "..."
}
```

### Reject

An `errorCode` and `errorMessage` as query parameters.

## Example

Refer to the connect method implemented in the React Native demo application: https://github.com/phantom-labs/deep-link-demo-app


# Deeplinks - Disconnect
Source: https://docs.phantom.com/phantom-deeplinks/provider-methods/disconnect

After an initial Connect event has taken place, an app may disconnect from Phantom at anytime. Once disconnected, Phantom will reject all signature requests until another connection is established.

## Base URL

```
https://phantom.app/ul/v1/disconnect
```

## Query string parameters

- `dapp_encryption_public_key` (required): The original encryption public key used from the app side for an existing Connect session.
- `nonce` (required): A nonce used for encrypting the request, encoded in base58.
- `redirect_link` (required): The URI where Phantom should redirect the user upon completion. URL-encoded.
- `payload` (required): An encrypted JSON string with the following fields:

```json
{
    "session": "..."
}
```

## Returns

### Approve

No query params returned.

### Reject

An `errorCode` and `errorMessage` as query parameters.


# Deeplinks - SignAndSendTransaction (deprecated)
Source: https://docs.phantom.com/phantom-deeplinks/provider-methods/signandsendtransaction

The `signAndSendTransaction` deeplink has been deprecated. Use the signAllTransactions or signTransaction deeplink instead.


# Deeplinks - SignAllTransactions
Source: https://docs.phantom.com/phantom-deeplinks/provider-methods/signalltransactions

Once an app is connected, it is also possible to sign multiple transactions at once. Phantom will not submit these transactions to the network. Applications can submit signed transactions using `sendRawTransaction` in web3.js.

## Base URL

```
https://phantom.app/ul/v1/signAllTransactions
```

## Query string parameters

- `dapp_encryption_public_key` (required): The original encryption public key used from the app side for an existing Connect session.
- `nonce` (required): A nonce used for encrypting the request, encoded in base58.
- `redirect_link` (required): The URI where Phantom should redirect the user upon completion. URL-encoded.
- `payload` (required): An encrypted JSON string with the following fields:

```json
{
  "transactions": [
    "...",
    "..."
  ],
  "session": "..."
}
```

## Returns

### Approve

- `nonce`: A nonce used for encrypting the response, encoded in base58.
- `data`: An encrypted JSON string containing:

```json
{
    "transactions": [
        "...",
        "..."
    ]
}
```

### Reject

An `errorCode` and `errorMessage` as query parameters.


# Deeplinks - SignTransaction
Source: https://docs.phantom.com/phantom-deeplinks/provider-methods/signtransaction

Request Phantom to sign the prepared transaction and return the signature. After receiving the signature, your app can broadcast the transaction itself with `sendRawTransaction` in web3.js, giving you full control over timing, batching, or custom error handling.

## Base URL

```
https://phantom.app/ul/v1/signTransaction
```

## Query string parameters

- `dapp_encryption_public_key` (required): The original encryption public key.
- `nonce` (required): A nonce used for encrypting the request, encoded in base58.
- `redirect_link` (required): The URI where Phantom should redirect. URL-encoded.
- `payload` (required): An encrypted JSON string:

```json
{
  "transaction": "...",
  "session": "..."
}
```

## Returns

### Approve

- `nonce`: A nonce for encrypting the response, encoded in base58.
- `data`: An encrypted JSON string containing:

```json
{
    "transaction": "..."
}
```

### Reject

An `errorCode` and `errorMessage` as query parameters.


# Deeplinks - SignMessage
Source: https://docs.phantom.com/phantom-deeplinks/provider-methods/signmessage

Once it's connected to Phantom, an app can request that the user signs a given message. Applications are free to write their own messages which will be displayed to users from within Phantom's signature prompt. Message signatures do not involve network fees and are a convenient way for apps to verify ownership of an address.

The message to be signed must be passed as a base58-encoded string.

## Base URL

```
https://phantom.app/ul/v1/signMessage
```

## Query string parameters

- `dapp_encryption_public_key` (required): The original encryption public key.
- `nonce` (required): A nonce used for encrypting the request, encoded in base58.
- `redirect_link` (required): The URI where Phantom should redirect. URL-encoded.
- `payload` (required): An encrypted JSON string:

```json
{
  "message": "...",
  "session": "...",
  "display": "utf8"
}
```

- `message` (required): The message that should be signed by the user, encoded in base58.
- `session` (required): The session token from Connect.
- `display` (optional): How to display the string. Defaults to `utf8`.

## Returns

### Approve

- `nonce`: A nonce for encrypting the response, encoded in base58.
- `data`: An encrypted JSON string containing:

```json
{
    "signature": "..."
}
```

### Reject

An `errorCode` and `errorMessage` as query parameters.


# Deeplinks - Browse
Source: https://docs.phantom.com/phantom-deeplinks/other-methods/browse

Deeplinks provide a convenient way for users to open web apps within Phantom. Using their phone's camera, users can scan a QR code to open a page directly within Phantom's in-app browser.

The `browse` deeplink can be used before a Connect event takes places, as it does not require a `session` param.

The `browse` deeplinks are not intended to be pasted into mobile web browsers. These deeplinks must either be handled by an app or clicked on by an end user.

## URL structure

```
https://phantom.app/ul/browse/<url>?ref=<ref>
```

## Parameters

- `url` (required): The URL that should open within Phantom's in-app browser, URL-encoded.
- `ref` (required): The URL of the requesting app, URL-encoded.

## Example

```
https://phantom.app/ul/browse/https%3A%2F%2Fmagiceden.io%2Fitem-details%2F8yjN8iRuoiYiKW487cnW9vn6mLBR5E8aCNKsBRmTP9vN?ref=https%3A%2F%2Fmagiceden.io
```


# Deeplinks - Fungible
Source: https://docs.phantom.com/phantom-deeplinks/other-methods/fungible

Phantom supports deeplinking directly to a fungible token detail page. Developers can specify which chain and token detail page to navigate to. The `fungible` deeplink can be used at anytime. It does not need to be preceded by a Connect event.

## URL structure

```
https://phantom.app/ul/v1/fungible?token=<fungible>
```

## Parameters

`fungible` (required): The CAIP-19 address of the token page to be viewed, URL-encoded. Defaults to `SOL` if omitted.

## Example

```
https://phantom.app/ul/v1/fungible?token=solana%3A101%2Faddress%3AFoXyMu5xwXre7zEoSvzViRk3nGawHUp9kUh97y2NDhcq
```


# Deeplinks - Swap
Source: https://docs.phantom.com/phantom-deeplinks/other-methods/swap

Phantom supports deeplinking directly to the in-app swapper. Developers can specify which tokens should be prefilled in the `buy` and `sell` fields. In addition to swapping tokens on a single chain, the swapper can also be used to bridge stablecoins across chains.

The `swap` deeplink can be used at anytime. It does not need to be preceded by a Connect event.

The `swap` deeplinks are not intended to be pasted into mobile web browsers. These deeplinks must either be handled by an app or tapped on by an end user.

## URL structure

```
https://phantom.app/ul/v1/swap?buy=<buy>&sell=<sell>
```

## Parameters

- `buy`: The CAIP-19 address of the token that should be bought, URL-encoded. Defaults to SOL if omitted.
- `sell`: The CAIP-19 address of the token that should be sold, URL-encoded. Defaults to SOL if omitted.

## Examples

### Swap SOL to WIF

```
https://phantom.app/ul/v1/swap/?buy=solana%3A101%2Faddress%3AEKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzLHYxdM65zcjm&sell=
```

### Bridge USDC on Solana to USDT on Ethereum

```
https://phantom.app/ul/v1/swap/?buy=eip155%3A1%2Faddress%3A0xdAC17F958D2ee523a2206206994597C13D831ec7&sell=solana%3A101%2Faddress%3AEPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
```


# EVM Provider API reference
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/provider-api-reference

Phantom's provider API is exposed to the user through the `window.ethereum` object that is injected into the browser. This same provider is made available at `window.phantom.ethereum` to prevent namespace collisions.

This API is how a dapp will make requests to the user; reading account data, connecting to the website, signing messages, and sending transactions will all be done through this provider object.

This provider API is specified in greater detail in EIP-1193.

This area of the documentation contains information about the API's properties, events, and methods.


# EVM Provider API - Error messages and codes
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/provider-api-reference/errors

When making requests to Phantom in establishing a connection, sending a transaction, or signing a message, Phantom may respond with an error. The following is a list of all possible error codes and their meanings. These error messages follow EIP-1474 and EIP-1193.

| Code   | Title                            | Description |
| ------ | -------------------------------- | ----------- |
| 4900   | Disconnected                     | Phantom could not connect to the network. |
| 4100   | Unauthorized                     | The requested method and/or account has not been authorized by the user. |
| 4001   | User Rejected Request            | The user rejected the request through Phantom. |
| -32000 | Invalid Input                    | Missing or invalid parameters. |
| -32002 | Requested resource not available | This error occurs when a dapp attempts to submit a new transaction while Phantom's approval dialog is already open for a previous transaction. Only one approve window can be open at a time. |
| -32003 | Transaction Rejected             | Phantom does not recognize a valid transaction. |
| -32601 | Method Not Found                 | Phantom does not recognize the method. |
| -32603 | Internal Error                   | Something went wrong within Phantom. |


# EVM Provider API - request
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/provider-api-reference/methods/request

Sends a JSON RPC request to the wallet.

## Params

`method: string;` `params?: unknown[] | object;`

## Returns

`Promise<unknown>`

## Example

```javascript
const accounts = await window.phantom.ethereum.request({
    method: "eth_requestAccounts", params: []
})
console.log(accounts)
// ["0xDAFEA492D9c6733ae3d56b7Ed1ADB60692c98Bc5"]
```

The `request` method is the go-to way for you to interface with the wallet in your dapp. It accepts most JSON RPC requests that would need to interact with the wallet.

However it will not work for methods that don't make sense for a wallet. For example, you can't use the provider object Phantom injects to call something like `eth_getTransactionByHash`. If you send a method that the provider object does not support, it will throw an error.


# EVM Provider API - isConnected
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/provider-api-reference/methods/isconnected

Checks if the wallet is connected to the dapp.

## Parameters

None

## Response

Boolean

```typescript
window.phantom.ethereum.isConnected()
// true if connected
// false if not
```


# EVM Provider API - Connect event
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/provider-api-reference/events/connect

Event emitted upon connecting to a dapp.

```typescript
interface connectionInfo {
  chainId: string;
}

window.ethereum.on('connect', (connectionInfo: connectionInfo) => {
      console.log(connectionInfo.chainId);
      // "0x1" On Ethereum
});
```


# EVM Provider API - Disconnect event
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/provider-api-reference/events/disconnect

Event emitted upon the wallet losing connection to the RPC provider.

This is not a user "disconnecting" from a dapp, or otherwise revoking access between the dapp and the wallet.

```typescript
window.ethereum.on('disconnect', () => {
      console.log('lost connection to the rpc')
});
```


# EVM Provider API - Accounts changed event
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/provider-api-reference/events/accounts-changed

Event emitted upon changing accounts within your Phantom wallet.

```typescript
window.ethereum.on('accountsChanged', (newAccounts: String[]) => {
      // "newAccounts" will always be an array, but it can be empty.
      if (newAccounts) {
        console.log(`switched to new account: ${newAccounts}`);
        accounts = newAccounts;
      } else {
        /**
         * In this case dApps could...
         *
         * 1. Not do anything
         * 2. Only re-connect to the new account if it is trusted
         * 3. Always attempt to reconnect
         */
  }
})
```


# EVM Provider API - Chain changed event
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/provider-api-reference/events/chain-changed

Event emitted upon the dapp or wallet changing the network/chain you are connected to.

Phantom abstracts the concept of networks, and network switching. So there is no action required on your end as a dapp developer.

```typescript
ethereum.on('chainChanged', (chainId: string) => {
  console.log(chainId);
  // "0x1" on Ethereum
  /* Phantom will handle all of the internal changes needed to handle the new chain.
   * As the dapp developer,
   * you just need to make sure all of your transaction requests
   * populate the correct chainId
   */
});
```


# EVM Provider API - isPhantom property
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/provider-api-reference/properties/isphantom

## window.phantom.ethereum.isPhantom

A boolean that identifies if Phantom is installed.

```javascript
const isPhantomInstalled = window.phantom?.ethereum?.isPhantom;
console.log(isPhantomInstalled);
// true
```


# EVM Provider API - chainId property
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/provider-api-reference/properties/chainid

## window.phantom.ethereum.chainId

The `chainId` of the network you are currently connected to, returned as a hexadecimal string.

```javascript
const chainId = window.phantom.ethereum.chainId;
console.log(chainId);
// "0x1"
// hexadecimal representation of Ethereum Mainnet
```


# EVM Provider API - selectedAddress property
Source: https://docs.phantom.com/ethereum-monad-testnet-base-and-polygon/provider-api-reference/properties/selectedaddress

## window.phantom.ethereum.selectedAddress

The address of the wallet that is currently connected to the dapp. This value will update upon accountsChanged and connect events.

Returns a hexadecimal string.

```javascript
const address = window.phantom.ethereum.selectedAddress;
console.log(address);
// "0xDAFEA492D9c6733ae3d56b7Ed1ADB60692c98Bc5"
```


# Spending limits
Source: https://docs.phantom.com/spending-limits

Understand user spending limit policies and transaction constraints.

## Overview

Spending limits are security policies that allow users to control how much your app can spend on their behalf. When users connect to your app via Phantom Connect, they can set maximum spending amounts that are enforced on-chain.

## How spending limits work

### Policy enforcement

When a transaction is submitted through an embedded wallet, Phantom follows a three-step enforcement process:

1. Transaction simulation: Phantom simulates the transaction to calculate its impact on the user's wallet.
2. Policy check: The simulated transaction is checked against the user's configured spending limit policies.
3. Approval or rejection:
   - If the transaction is within the spending limit, it proceeds.
   - If the spending limit is exceeded, the transaction is rejected with a custom error.

### User control

Users have full control over how their spending limits are configured for your app:

- Setting limits: During the Phantom Connect flow, users can configure spending limit policies.
- Updating limits: Users can adjust their spending limits at any time through their Phantom wallet settings.

Spending limits are configured on a per-app basis, allowing users to apply different limits to different apps.

## Transaction constraints

Phantom embedded wallets don't support Solana features that execute multiple transactions together, such as Jito bundles or any mechanism that submits transactions atomically. Users must sign and send each transaction individually.

### Why this limitation exists

To enforce spending limits correctly, Phantom needs to simulate each transaction on its own to understand its financial impact. Bundles and parallel execution would prevent policy enforcement from working as intended:

- It would make it impossible to calculate spending across multiple transactions accurately.
- It would introduce race conditions that could cause transactions to revert on-chain.
- Make the final wallet state unpredictable, breaking policy enforcement.

### What this means for developers

This constraint prevents your app from using Solana features that rely on multiple transactions being sent together. These features include:

- Jito bundles, where several transactions execute atomically as a group.
- Parallel transaction execution, where transactions are sent to the network at the same time.
- Atomic multi-transaction flows, where multiple transactions must all succeed or all fail.

## Handling spending limit errors

When a transaction exceeds the user's spending limit, the SDK rejects the transaction and the user must adjust their limit.

```typescript
try {
  const result = await solana.signAndSendTransaction(transaction);
  console.log('Transaction successful:', result.hash);
} catch (error) {
  if (error.code === 'SPENDING_LIMIT_EXCEEDED') {
    // Show user-friendly message
    showMessage(
      'This transaction exceeds your spending limit. ' +
      'Please update your spending limit in Phantom settings to continue.'
    );
  } else {
    // Handle other errors
    console.error('Transaction failed:', error);
  }
}
```


# Solana - Error messages and codes
Source: https://docs.phantom.com/solana/errors

When making requests to Phantom in establishing a connection, sending a transaction, or signing a message, Phantom may respond with an error. The following is a list of all possible error codes and their meanings. These error messages are inspired by Ethereum's EIP-1474 and EIP-1193.

| Code   | Title                            | Description |
| ------ | -------------------------------- | ----------- |
| 4900   | Disconnected                     | Phantom could not connect to the network. |
| 4100   | Unauthorized                     | The requested method and/or account has not been authorized by the user. |
| 4001   | User Rejected Request            | The user rejected the request through Phantom. |
| -32000 | Invalid Input                    | Missing or invalid parameters. |
| -32002 | Requested resource not available | This error occurs when a dapp attempts to submit a new transaction while Phantom's approval dialog is already open for a previous transaction. Only one approve window can be open at a time. |
| -32003 | Transaction Rejected             | Phantom does not recognize a valid transaction. |
| -32601 | Method Not Found                 | Phantom does not recognize the method. |
| -32603 | Internal Error                   | Something went wrong within Phantom. |

Typically, these errors will be easily parseable and have both a code and an explanation. For example:

```javascript
try {
  await window.solana.signMessage();
} catch (err) {
  //  {code: 4100, message: 'The requested method and/or account has not been authorized by the user.'}
}
```


# Bitcoin - Provider API reference
Source: https://docs.phantom.com/bitcoin/provider-api-reference

## Methods

### requestAccounts

Connects to the user's Phantom account.

Parameters: None

Response: `Promise<BtcAccount[]>` - Array of the connected user's BtcAccount objects.

BtcAccount response object properties:

- `address` (string): The Bitcoin address owned by the user.
- `addressType` (p2tr, p2wpkh, p2sh, p2pkh): The address's format.
- `publicKey` (string): A hex string representing the bytes of the public key of the account.
- `purpose` (payment, ordinals): The general purpose of the address. If `ordinals`, the user prefers to store Ordinals on this address. If `payment`, the user prefers to store Bitcoin on this address.

### signMessage

Signs a message with the user's Phantom account.

Parameters:
- `message` (Uint8Array): The message to be signed.
- `address` (string): One of the user's addresses that should be used to sign the message.

Response: `Promise<{ signature: Uint8Array; }>` - Object containing the signature.

### signPSBT

Signs a Partially-Signed Bitcoin Transaction (PSBT).

Parameters:
- `psbtHex` (Uint8Array): A serialized PSBT.
- `options` (object): Configuration options for signing the PSBT. An array containing the indexes of which transaction inputs to sign, and how to sign them.

Response: `Promise<string>` - A serialized PSBT where the inputs belonging to the user's account have been signed.

## Events

### accountsChanged

The event that is emitted when a user changes their connected Phantom account.

```typescript
type AccountsChangedEvent = (accounts: BtcAccount[]) => void;
```

Properties:
- `accounts` (BtcAccount[]): The array of BtcAccount objects of the newly connected Phantom account.

BtcAccount response object properties:
- `address` (string): The Bitcoin address owned by the user.
- `addressType` (p2tr, p2wpkh, p2sh, p2pkh): The address's format.
- `publicKey` (string): A hex string representing the bytes of the public key of the account.
- `purpose` (payment, ordinals): The general purpose of the address.