> ## Documentation Index
> Fetch the complete documentation index at: https://crossmint-devin-1787949784-wallet-docs-two-concept-model.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Wallet

> Kotlin Class

**Class**

```kotlin theme={null}
class Wallet
```

## Properties

| Property    | Type           | Description                                     |
| ----------- | -------------- | ----------------------------------------------- |
| `address`   | `String`       | The blockchain address of the wallet            |
| `chain`     | `Chain`        | The specific blockchain this wallet lives on    |
| `chainType` | `ChainType`    | -                                               |
| `config`    | `WalletConfig` | The wallet configuration including admin signer |
| `owner`     | `Owner?`       | The owner of the wallet, if available           |
| `type`      | `WalletType`   | The type of wallet (smart wallet or MPC wallet) |

## Functions

| Function                   | Description                                                                                                                                                          |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `addSigner`                | Registers a new delegated signer on this wallet via the recovery/approval flow. Does not change the active signer.                                                   |
| `approve`                  | Signs a transaction that is in AWAITING\_APPROVAL status.                                                                                                            |
| `balances`                 | Gets the wallet balances.                                                                                                                                            |
| `fund`                     | Funds the wallet with test tokens (staging only).                                                                                                                    |
| `getSigner`                | Returns the current signer for this wallet.                                                                                                                          |
| `getTransaction`           | Retrieves a transaction by its ID.                                                                                                                                   |
| `isSignerApproved`         | Returns true if the given signer is approved on this wallet's chain.                                                                                                 |
| `listTransactions`         | Lists all transactions for this wallet.                                                                                                                              |
| `listTransfers`            | Lists transfers for this wallet.                                                                                                                                     |
| `localDeviceSignerLocator` | Returns the locator of the device signer that lives on this device. Returns null if this wallet has no device signer on this device.                                 |
| `needsRecovery`            | Returns true when a device signer was configured for this wallet but no matching hardware key exists on the current device.                                          |
| `nfts`                     | Lists NFTs held by this wallet. Supported on EVM and Solana chains.                                                                                                  |
| `recover`                  | Generates a new hardware key on this device and registers it on the wallet using the admin/recovery signer approval flow.                                            |
| `removeSigner`             | Removes a delegated signer from this wallet. Supported types: DelegatedSigner.Email, DelegatedSigner.Phone, DelegatedSigner.ExternalWallet, DelegatedSigner.Locator. |
| `send`                     | Sends tokens to a recipient address.                                                                                                                                 |
| `sendTransaction`          | Submits a raw transaction and polls until it reaches a terminal state.                                                                                               |
| `signerIsRegistered`       | Checks if the signer is registered on this wallet.                                                                                                                   |
| `signers`                  | Fetches the live list of signers registered on this wallet.                                                                                                          |
| `useSigner`                | Sets the active signer for subsequent send and approve operations.                                                                                                   |
| `withSigner`               | Creates a new Wallet instance that uses the specified signer for transactions.                                                                                       |

### addSigner

```kotlin theme={null}
suspend fun addSigner(signer: DelegatedSigner): Result<Unit, WalletError>
```

Registers a new delegated signer on this wallet via the recovery/approval flow. Does not change the active signer.

### approve

```kotlin theme={null}
suspend fun approve(transactionId: String, signer: SignerSelection = SignerSelection.Admin): Result<Transaction, TransactionError>
```

Signs a transaction that is in AWAITING\_APPROVAL status.

### balances

```kotlin theme={null}
suspend fun balances(tokens: List<String> = emptyList()): Result<Balances, BalanceError>
```

Gets the wallet balances.

### fund

```kotlin theme={null}
suspend fun fund(token: String, amount: Int, chain: String): Result<Unit, BalanceError>
```

Funds the wallet with test tokens (staging only).

### getSigner

```kotlin theme={null}
fun getSigner(): Signer?
```

Returns the current signer for this wallet.

### getTransaction

```kotlin theme={null}
suspend fun getTransaction(transactionId: String): Result<Transaction, TransactionError>
```

Retrieves a transaction by its ID.

### isSignerApproved

```kotlin theme={null}
suspend fun isSignerApproved(locator: String): Result<Boolean, WalletError>
```

Returns true if the given signer is approved on this wallet's chain.

### listTransactions

```kotlin theme={null}
suspend fun listTransactions(): Result<List<Transaction>, TransactionError>
```

Lists all transactions for this wallet.

### listTransfers

```kotlin theme={null}
suspend fun listTransfers(tokens: List<String> = emptyList()): Result<TransferList, TransferError>
```

Lists transfers for this wallet.

### localDeviceSignerLocator

```kotlin theme={null}
suspend fun localDeviceSignerLocator(): DelegatedSignerData?
```

Returns the locator of the device signer that lives on this device. Returns null if this wallet has no device signer on this device.

### needsRecovery

```kotlin theme={null}
suspend fun needsRecovery(): Boolean
```

Returns true when a device signer was configured for this wallet but no matching hardware key exists on the current device.

### nfts

```kotlin theme={null}
suspend fun nfts(page: Int = 1, perPage: Int = 20): Result<List<NFT>, WalletError>
```

Lists NFTs held by this wallet. Supported on EVM and Solana chains.

### recover

```kotlin theme={null}
suspend fun recover(): Result<Unit, WalletError>
```

Generates a new hardware key on this device and registers it on the wallet using the admin/recovery signer approval flow.

### removeSigner

```kotlin theme={null}
suspend fun removeSigner(signer: DelegatedSigner): Result<Unit, WalletError>
```

Removes a delegated signer from this wallet. Supported types: DelegatedSigner.Email, DelegatedSigner.Phone, DelegatedSigner.ExternalWallet, DelegatedSigner.Locator.

### send

```kotlin theme={null}
suspend fun send(recipient: String, tokenLocator: String, amount: Double, idempotencyKey: String? = null, signer: SignerSelection = SignerSelection.Admin): Result<Transaction, TransactionError>
```

Sends tokens to a recipient address.

### sendTransaction

```kotlin theme={null}
suspend fun sendTransaction(params: RawTransactionParams, signer: SignerSelection = SignerSelection.Admin): Result<Transaction, TransactionError>
```

Submits a raw transaction and polls until it reaches a terminal state.

### signerIsRegistered

```kotlin theme={null}
fun signerIsRegistered(signer: DelegatedSigner): Boolean
```

Checks if the signer is registered on this wallet.

```kotlin theme={null}
fun ~~signerIsRegistered~~(locator: String): Boolean
```

Returns true if the given locator is registered as a delegated signer on this wallet.

### signers

```kotlin theme={null}
suspend fun signers(): Result<List<DelegatedSignerData>, WalletError>
```

Fetches the live list of signers registered on this wallet.

### useSigner

```kotlin theme={null}
suspend fun useSigner(signer: DelegatedSigner): Result<Unit, WalletError>
```

Sets the active signer for subsequent send and approve operations.

### withSigner

```kotlin theme={null}
open fun withSigner(newSigner: Signer): Wallet
```

Creates a new Wallet instance that uses the specified signer for transactions.