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

# Wallet Lifecycle by Wallet Type

> Create and manage EVM, Cosmos, Solana, Stellar, and Sui wallets through one REST interface

Para uses one REST route set and REST SDK client to create and manage every supported wallet type. The `type` value you
choose at creation determines the wallet's chain-specific address and how later signing requests are interpreted.

## Wallet type vs signature scheme

Wallet **type** describes the chain behavior you want. Wallet **scheme** describes the cryptography underneath it.
Several wallet types share a scheme, but they remain distinct wallet types with different address and signing formats.

| Wallet type | Default scheme     | Address format               | Chain behavior                                             |
| ----------- | ------------------ | ---------------------------- | ---------------------------------------------------------- |
| `EVM`       | `DKLS` (secp256k1) | `0x...`                      | EVM messages, transactions, typed data, and authorizations |
| `COSMOS`    | `DKLS` (secp256k1) | Bech32, such as `cosmos1...` | Cosmos addresses and raw/message signing                   |
| `SOLANA`    | `ED25519`          | Base58                       | Solana messages and serialized transactions                |
| `STELLAR`   | `ED25519`          | StrKey `G...`                | Stellar messages and XDR transaction envelopes             |
| `SUI`       | `ED25519`          | `0x...`                      | Sui personal messages and BCS transaction data             |

<Info>
  Set `type` for the chain you intend to use and normally omit `scheme`. Para selects `DKLS` for EVM and Cosmos, and
  `ED25519` for Solana, Stellar, and Sui. Sharing a scheme does not make chain-specific transaction payloads
  interchangeable.
</Info>

## Create a REST SDK client

One client works for all five wallet types:

```typescript theme={null}
import { ParaRestClient } from "@getpara/rest-sdk";

const para = new ParaRestClient({
  apiKey: process.env.PARA_API_KEY!,
  env: "BETA",
});
```

## Create each wallet type

Each example calls `POST /v1/wallets`, directly or through `para.createWallet()`. Only the chain-specific `type` changes,
except that Cosmos can also specify its Bech32 prefix.

### EVM

Create an EVM wallet for Ethereum and other EVM-compatible networks.

<CodeGroup>
  ```typescript REST SDK theme={null}
  const evmWallet = await para.createWallet({
    type: "EVM",
    userIdentifier: "user-123",
    userIdentifierType: "CUSTOM_ID",
  });
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.beta.getpara.com/v1/wallets" \
    -H "X-API-Key: $PARA_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "type": "EVM",
      "userIdentifier": "user-123",
      "userIdentifierType": "CUSTOM_ID"
    }'
  ```
</CodeGroup>

### Cosmos

Create a Cosmos wallet and set the Bech32 prefix expected by the target Cosmos chain. The prefix defaults to `cosmos`
when omitted.

<CodeGroup>
  ```typescript REST SDK theme={null}
  const cosmosWallet = await para.createWallet({
    type: "COSMOS",
    cosmosPrefix: "cosmos",
    userIdentifier: "user-123",
    userIdentifierType: "CUSTOM_ID",
  });
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.beta.getpara.com/v1/wallets" \
    -H "X-API-Key: $PARA_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "type": "COSMOS",
      "cosmosPrefix": "cosmos",
      "userIdentifier": "user-123",
      "userIdentifierType": "CUSTOM_ID"
    }'
  ```
</CodeGroup>

### Solana

Create a Solana wallet for Solana message and transaction formats.

<CodeGroup>
  ```typescript REST SDK theme={null}
  const solanaWallet = await para.createWallet({
    type: "SOLANA",
    userIdentifier: "user-123",
    userIdentifierType: "CUSTOM_ID",
  });
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.beta.getpara.com/v1/wallets" \
    -H "X-API-Key: $PARA_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "type": "SOLANA",
      "userIdentifier": "user-123",
      "userIdentifierType": "CUSTOM_ID"
    }'
  ```
</CodeGroup>

### Stellar

Create a Stellar wallet with a Stellar `G...` address.

<CodeGroup>
  ```typescript REST SDK theme={null}
  const stellarWallet = await para.createWallet({
    type: "STELLAR",
    userIdentifier: "user-123",
    userIdentifierType: "CUSTOM_ID",
  });
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.beta.getpara.com/v1/wallets" \
    -H "X-API-Key: $PARA_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "type": "STELLAR",
      "userIdentifier": "user-123",
      "userIdentifierType": "CUSTOM_ID"
    }'
  ```
</CodeGroup>

### Sui

Create a Sui wallet for Sui personal-message and transaction formats.

<CodeGroup>
  ```typescript REST SDK theme={null}
  const suiWallet = await para.createWallet({
    type: "SUI",
    userIdentifier: "user-123",
    userIdentifierType: "CUSTOM_ID",
  });
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.beta.getpara.com/v1/wallets" \
    -H "X-API-Key: $PARA_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "type": "SUI",
      "userIdentifier": "user-123",
      "userIdentifierType": "CUSTOM_ID"
    }'
  ```
</CodeGroup>

With the default schemes, one identifier can have one wallet of each type. Duplicate detection is scoped to the
authenticated partner and matches `userIdentifierType`, `userIdentifier`, `type`, and `scheme`. See
[Multiple Wallets per User](/v3/rest/multi-wallet) when one user needs more than one wallet of the same type.

## Manage every wallet with one interface

After creation, store the returned wallet `id`. Every common lifecycle operation uses that Para wallet ID, regardless of
wallet type.

| Operation             | REST SDK                                     | REST API                       |
| --------------------- | -------------------------------------------- | ------------------------------ |
| Create                | `para.createWallet(...)`                     | `POST /v1/wallets`             |
| Get by wallet ID      | `para.getWallet(walletId)`                   | `GET /v1/wallets/{walletId}`   |
| List or filter        | `para.listWallets({ type, ... })`            | `GET /v1/wallets?type=...`     |
| Update the identifier | `para.updateWalletIdentifier(walletId, ...)` | `PATCH /v1/wallets/{walletId}` |

The response uses one shape. A create response can report `creating` even when it includes `address` and `publicKey`.
For an individual wallet response, `ready` means key generation is complete.

```typescript theme={null}
const wallet = await para.getWallet(walletId);

if (wallet.status === "ready") {
  console.log(wallet.type, wallet.address);
}
```

Wallet type is fixed at creation. To use another wallet type, create another wallet with the corresponding `type` rather
than changing an existing wallet. A `status=ready` list filter returns only wallets whose key generation and share
persistence are both complete.

## Claiming changes the signing boundary

REST-created wallets begin as API-key-managed wallets. If a user signs up with the same identifier, Para automatically
claims the wallet into that user's account. You can still identify the wallet, but REST signing is no longer allowed after
claiming; use a user-facing Para SDK and the user's authenticated session for subsequent signing.

Continue to [Sign messages by wallet type](/v3/rest/signing) for message formats, then
[Transaction signing by wallet type](/v3/rest/transaction-signing) for transaction and raw-byte formats.