# Chain Support

MoonPay Wallets provides wallet infrastructure for Ethereum/EVM, Solana/SVM, Tron, and Bitcoin. Wallets are created explicitly by your app, and each chain has a native signing surface in the React SDK.

## Fully supported chains

MoonPay Wallets offers production-ready embedded wallet support for the following blockchain ecosystems:

<CardGroup cols={2}>
  <Card title="Ethereum & EVM Networks" icon="ethereum" href="/get-started/frontend-sdks/react/advance/configure-networks">
    Full support for Ethereum and all EVM-compatible networks including Base, Arbitrum, Polygon, Optimism, and more.
  </Card>

  <Card title="Solana & SVM Networks" icon="bolt" href="/get-started/frontend-sdks/react/advance/configure-networks">
    Complete support for Solana and all SVM-compatible networks including mainnet, devnet, and testnet.
  </Card>

  <Card title="Tron" icon="wallet" href="/wallets/using-wallets/tron/sign-message">
    Support for embedded Tron wallets, TIP-191 message signatures, and TronWeb transaction signing.
  </Card>

  <Card title="Bitcoin" icon="wallet" href="/wallets/using-wallets/bitcoin/overview">
    Taproot, Native SegWit, and Legacy wallets with BIP322 messages, PSBT signing, balance, UTXO, broadcast, import, export, and native BTC funding.
  </Card>
</CardGroup>

## What "fully supported" means

Chains with full MoonPay Wallets support include the same core product surface across wallets, transactions, UI, and developer tooling:

| Capability | Included |
| --- | --- |
| **Wallets** | Embedded wallet creation on demand (a single `createWallet()` call, never automatic at login), and private-key export for portability |
| **Transactions** | Message signing, transaction signing, and send-and-broadcast hooks on every chain (`useSendTransaction`) |
| **User experience** | Customizable UI components, headless APIs for custom interfaces, real-time transaction status, and clear error handling |
| **Developer tools** | TypeScript React SDK, documentation, examples, and guides |

## Ethereum ecosystem

MoonPay Wallets provides native support for Ethereum and the entire EVM ecosystem:

### Mainnet networks

* **Ethereum** - Ethereum mainnet
* **Base** - Coinbase's L2 solution
* **Arbitrum** - Optimistic rollup L2
* **Optimism** - Another optimistic rollup
* **Polygon** - Fast and low-cost EVM sidechain
* **And more** - Any EVM-compatible network

### Testnets

* **Sepolia** - Ethereum testnet
* **Base Sepolia** - Base testnet
* **Arbitrum Sepolia** - Arbitrum testnet
* **Other testnets** - All major EVM testnets

### Configuration

Configure EVM networks in your MoonPay Wallets provider:

```tsx
import { MoonXProvider, base, arbitrum, polygon } from '@moon-x/react-sdk';

<MoonXProvider
  publishableKey="your_publishable_key"
  config={{
    chains: [base, arbitrum, polygon],
    defaultChain: 'eth:base',
  }}
>
  {children}
</MoonXProvider>
```

Learn more about [configuring networks](/get-started/frontend-sdks/react/advance/configure-networks).

## Solana ecosystem

MoonPay Wallets offers complete support for Solana and SVM-compatible networks:

### Networks

* **Mainnet Beta** - Solana production network
* **Devnet** - Development and testing network
* **Testnet** - Public testing network
* **Custom SVM** - Other SVM-compatible chains

### Configuration

Configure Solana networks with custom RPC endpoints:

```tsx
import { MoonXProvider } from '@moon-x/react-sdk';

<MoonXProvider
  publishableKey="your_publishable_key"
  config={{
    chains: [
      {
        id: 'solana:mainnet',
        rpcUrl: 'https://api.mainnet-beta.solana.com',
        wsUrl: 'wss://api.mainnet-beta.solana.com',
      },
      {
        id: 'solana:devnet',
        rpcUrl: 'https://api.devnet.solana.com',
        wsUrl: 'wss://api.devnet.solana.com',
      },
    ],
    defaultChain: 'solana:mainnet',
  }}
>
  {children}
</MoonXProvider>
```

Learn more about [configuring networks](/get-started/frontend-sdks/react/advance/configure-networks).

## Tron ecosystem

MoonPay Wallets supports embedded Tron wallets and Tron signing operations:

### Networks

* **Tron mainnet** - Production Tron network
* **Tron testnets** - Use TronWeb against the testnet RPC your app chooses

### Usage

Create a Tron wallet from the Tron subpath, then use TronWeb to build transactions:

```tsx
import { useCreateWallet, useSignTransaction } from '@moon-x/react-sdk/tron';
import { TronWeb } from 'tronweb';

const tronWeb = new TronWeb({ fullHost: 'https://api.trongrid.io' });

const { createWallet } = useCreateWallet();
const { signTransaction } = useSignTransaction();

const { wallet } = await createWallet();
const tx = await tronWeb.transactionBuilder.sendTrx(
  'TRecipientAddressHere',
  1_000_000,
  wallet.public_address
);
const { signedTransaction } = await signTransaction({ transaction: tx, wallet });
await tronWeb.trx.sendRawTransaction(signedTransaction);
```

Prefer the built-in send when you want MoonPay Wallets to broadcast for you: add a Tron
entry to the provider `chains` array and call `useSendTransaction` from the
Tron subpath - it signs and posts the transaction to your configured fullnode
in one call.

```tsx
// Provider config
chains: [
  { id: 'tron:mainnet', rpcUrl: 'https://api.trongrid.io' },
],
```

```tsx
import { useSendTransaction } from '@moon-x/react-sdk/tron';

const { sendTransaction } = useSendTransaction();
const { txid } = await sendTransaction({ transaction: tx, wallet });
```

TRX balances are available the same way via `useGetBalance`.

## Bitcoin ecosystem

MoonPay Wallets supports three mainnet Bitcoin wallet types:

* **Taproot** (`p2tr`) uses `bc1p` addresses and BIP340 Schnorr signatures
* **Native SegWit** (`p2wpkh`) uses `bc1q` addresses and secp256k1 ECDSA signatures
* **Legacy** (`p2pkh`) uses `1...` addresses and secp256k1 ECDSA signatures

Create, list, import, export, sign, send, query balances and UTXOs, and fund wallets from the Bitcoin subpath:

```tsx
import {
  useCreateWallet,
  useGetBalance,
  useGetUtxos,
} from '@moon-x/react-sdk/bitcoin';

const { createWallet } = useCreateWallet();
const { wallet } = await createWallet({ addressType: 'p2wpkh' });

const { getBalance } = useGetBalance();
const { getUtxos } = useGetUtxos();

const balance = await getBalance({ wallet });
const utxos = await getUtxos({ wallet });
```

Taproot, Native SegWit, and Legacy wallets have separate keys and addresses when created in MoonPay Wallets. See [Bitcoin Overview and Wallet Types](/wallets/using-wallets/bitcoin/overview) before designing deposits or private-key export.

## Features by chain

Feature support differs by chain surface:

| Feature | Ethereum/EVM | Solana/SVM | Tron | Bitcoin |
|---------|--------------|------------|------|---------|
| Embedded wallets | Yes | Yes | Yes | Yes |
| Explicit wallet creation | Yes | Yes | Yes | Yes |
| Sign messages | Yes | Yes | Yes | Yes, BIP322 Simple/Full |
| Sign transactions | Yes | Yes | Yes | Yes, supported PSBT v0 |
| Send transactions | Yes | Yes | Yes | Yes |
| Import private key | Yes | Yes | Yes | Yes, WIF or raw hex |
| Export private key | Yes | Yes | Yes | Yes, compressed mainnet WIF |
| Native balance | Yes | Yes | Yes | Yes |
| UI components | Yes | Yes | Yes | Yes |
| REST API | Yes | Yes | Yes | Yes |
| Ephemeral signers | Yes | Yes | Yes | Yes, P2TR/P2WPKH/P2PKH |
| Custom RPC | Provider `chains` config | Provider `chains` config | Provider `chains` config (`tron:` entries) | Provider `chains` config (`bitcoin:` entries) |

## Custom networks

Every chain uses the provider `chains` array for custom networks. EVM entries carry a viem `Chain`. Solana, Tron, and Bitcoin entries carry an ecosystem-prefixed `id` plus an `rpcUrl`.

### Custom EVM networks

Add any EVM-compatible network using `viem`'s `defineChain`:

```tsx
import { defineChain } from 'viem';

const customChain = defineChain({
  id: 12345,
  name: 'Custom Chain',
  network: 'custom',
  nativeCurrency: {
    decimals: 18,
    name: 'Custom Token',
    symbol: 'CTK',
  },
  rpcUrls: {
    default: {
      http: ['https://custom-rpc-url.com'],
    },
  },
  blockExplorers: {
    default: {
      name: 'Explorer',
      url: 'https://explorer.custom-chain.com',
    },
  },
});
```

### Custom SVM networks

Connect to custom SVM-compatible networks with custom RPC endpoints:

```tsx
import { Connection } from '@solana/web3.js';

const connection = new Connection('https://custom-svm-rpc.com');
```

## Choosing your blockchain

When building with MoonPay Wallets, consider these factors:

<AccordionGroup>
  <Accordion title="Ethereum/EVM for...">
    * **DeFi applications** - Largest DeFi ecosystem
    * **NFT marketplaces** - Most NFT activity
    * **Smart contracts** - Mature tooling and libraries
    * **Institutional adoption** - Widely recognized
    * **L2 solutions** - Fast and cheap with Base, Arbitrum, etc.
  </Accordion>

  <Accordion title="Solana/SVM for...">
    * **High performance** - Fast transaction speeds
    * **Low costs** - Minimal transaction fees
    * **Gaming** - Real-time blockchain gaming
    * **NFT minting** - Fast and affordable minting
    * **Payment applications** - Micropayments and instant transfers
  </Accordion>

  <Accordion title="Tron for...">
    * **TRX payments** - Native TRX transfer flows
    * **TRC-20 token apps** - Token interactions through TronWeb-built transactions
    * **Apps already using TronWeb** - Build with existing Tron tooling and let MoonPay Wallets sign
    * **Agent signing** - Delegate scoped Tron signing through ephemeral signers
  </Accordion>

  <Accordion title="Bitcoin for...">
    * **BTC payments** - Receive and send native Bitcoin
    * **Multiple address formats** - Choose Taproot, Native SegWit, or Legacy
    * **Portable ownership proofs** - Sign BIP322 Simple or Full messages
    * **PSBT workflows** - Build transactions in your app, then let MoonPay Wallets review, sign, and broadcast
  </Accordion>
</AccordionGroup>

## Future chain support

The MoonPay Wallets architecture is designed to support additional blockchains in the future. We're continuously evaluating new chains and ecosystems to add to our platform.

<Info>
  Interested in support for a specific blockchain? [Contact us](mailto:support@moonpay.com) to discuss your requirements.
</Info>

## Best practices

<AccordionGroup>
  <Accordion title="Use appropriate networks">
    * Develop on testnets (Sepolia, Devnet)
    * Test thoroughly before mainnet deployment
    * Use separate API keys for test and production
  </Accordion>

  <Accordion title="Configure RPC endpoints">
    * Use reliable RPC providers (Alchemy, QuickNode, etc.)
    * Consider rate limits for free RPC endpoints
    * Set up fallback RPC URLs for reliability
  </Accordion>

  <Accordion title="Handle chain switching">
    * Allow users to switch chains easily
    * Show current chain clearly in your UI
    * Handle transactions for the correct chain
  </Accordion>

  <Accordion title="Test cross-chain scenarios">
    * Test every ecosystem and Bitcoin address type your app supports
    * Verify proper chain isolation
    * Test network switching flows
  </Accordion>
</AccordionGroup>

## Getting started

<CardGroup cols={2}>
  <Card title="Configure Networks" icon="globe" href="/get-started/frontend-sdks/react/advance/configure-networks">
    Set up EVM, Solana, Tron, and Bitcoin RPCs in one unified `chains` config.
  </Card>

  <Card title="Quick Start Guide" icon="rocket" href="/get-started/frontend-sdks/react/quick-start">
    Build your first multi-chain wallet app
  </Card>

  <Card title="REST API" icon="code" href="/get-started/rest-api/setup">
    Manage wallets via REST API
  </Card>
</CardGroup>