> ## Documentation Index
> Fetch the complete documentation index at: https://rain-sandbox-trial.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Receiving Funds

> How to display deposit addresses, receive funds across supported networks, and detect incoming transfers.


Let users receive assets into their Rain wallet from an exchange, another wallet, an employer, or another onchain source.

There is no separate setup required to receive funds. Once the wallet is created, it has addresses that can receive assets on supported networks. Your application should show the correct address for the selected network and make the network clear before the user sends funds.

## Choose the correct address

The address you display depends on the network the sender will use.

| Network | Address to show | SDK method |
| - | - | - |
| Supported EVM networks | The wallet’s EVM address | `getWalletAddress()` |
| Solana | The wallet’s Solana address | `getWalletAddress(chainId: RainChain.solanaMainnet)` |

The same EVM address is used across supported EVM networks. The Solana account has a separate address.

Always show the selected network alongside the wallet address. A deposit screen should include:

1. The network
2. The wallet address
3. A copy action
4. A QR code
5. Clear guidance about which assets and networks your application supports

For example:`Only send USDC on Base to this address.`

<Warning>
  The wallet address is **not** where users add collateral for their card. Card collateral goes to the collateral contract's deposit address, which your backend reads from the Rain API. Sending collateral to the wallet just puts it in the wallet. See [Card funding and settlement](/docs/embedded-wallets/card-funding-and-settlement).
</Warning>

## QR codes

Use the SDK to generate a QR code for the wallet address. The QR code encodes the address itself and can be scanned by compatible wallet applications.

<CodeGroup>
  ```swift iOS theme={null}
  let png = try await client.generateAddressQRCode()                          // wallet's EVM address
  let solanaPng = try await client.generateAddressQRCode(
      address: try await client.getWalletAddress(chainId: RainChain.solanaMainnet),
      dimension: 512,
      backgroundColor: nil,
      foregroundColor: nil
  )
  let image = UIImage(data: png)
  ```

  ```kotlin Android theme={null}
  val bitmap = client.generateAddressQRCode()                                 // wallet's EVM address, 256 px
  val solanaBitmap = client.generateAddressQRCode(
      address = client.getWalletAddress(RainChain.SOLANA_MAINNET),
      dimension = 512,
  )
  ```
</CodeGroup>

Display the address in text alongside the QR code so users can verify or copy it directly.

## Detecting an incoming transfer

During beta, wallet deposits do not generate push notifications or webhooks. If your application needs to show when a deposit arrives, poll while the deposit experience is active and refresh when the application returns to the foreground.

* **Check the balance.**  Call `getBalance` for the token you expect, or `getTokenBalances` for everything on the chain, every 10 to 15 seconds while the screen is visible. Compare with the previous value to detect the arrival.
* **Check transaction history.** `getTransactions(chainId:)` returns transfers into the wallet as well as out of it, including transfers that didn't go through your app. Use it to show the deposit as a row once it lands.

Wallet deposit webhooks will be available at GA. See [Transaction webhooks and history](/docs/embedded-wallets/transaction-webhooks).

## Receiving on Solana

Solana tokens are held in associated token accounts. If the recipient does not yet have an account for the token being received, the sender’s transaction can create it automatically.

The recipient does not need to take a separate action before receiving the token. `getBalance` for a token the wallet has never received returns zero rather than an error.

## Unsupported networks and tokens

Balances and history cover any chain you registered an RPC endpoint for, whether or not the wallet can send there. If a user receives funds on Avalanche or Celo, they can see them, but they can't move them from the Rain wallet until Rain adds sending on that chain; the way out is [key export](/docs/embedded-wallets/key-export) into another wallet. Say so in your deposit UI by listing only the networks you support.

Tokens outside the SDK's registry show up in `getTokenBalances` with their on-chain decimals and, on EVM, symbol and name. Register the tokens you display prominently with `registerTokens` so they carry consistent metadata on every chain.

## What's next

<Columns cols={2}>
  <Card title="Balances and history" icon="list" href="/docs/embedded-wallets/balances-and-history">
    Read what arrived, on one chain or all of them.
  </Card>

  <Card title="Card funding and settlement" icon="credit-card" href="/docs/embedded-wallets/card-funding-and-settlement">
    Move funds from the wallet into card collateral.
  </Card>
</Columns>