# Para

> Non-custodial embedded wallet infrastructure using MPC for building embedded wallet integrations across web, mobile, and server platforms supporting EVM, Solana, and Cosmos chains.

## Para SDK Implementation Supplement

> Concrete build-time details: packages, initialization, authentication, signing, connectors, account abstraction, and configuration for building Para integrations.


## 1. SDK Package Matrix

All `@getpara/*` packages must use the **same version** as each other. Always pin every `@getpara/*` dependency to the same release to avoid mismatches.

### Core SDKs

| Package | Use When |
|---------|----------|
| `@getpara/react-sdk` | React/Next.js apps with ParaProvider + hooks + ParaModal |
| `@getpara/react-sdk-lite` | React apps using Para only through a connector (Wagmi/Graz) - lighter bundle, exports `ParaWeb` |
| `@getpara/web-sdk` | Non-React web frameworks (Vue, Svelte) - exports `ParaWeb` imperative class |
| `@getpara/server-sdk` | Node.js/Bun/Deno server-side - exports `Para` (aliased as `ParaServer`) |
| `@getpara/react-native-wallet` | React Native / Expo mobile apps |

### Signing Integration Packages

| Package | Web3 Library | Companion Deps |
|---------|-------------|----------------|
| `@getpara/viem-v2-integration` | Viem 2.x | `viem@^2.27.0` |
| `@getpara/ethers-v6-integration` | Ethers 6.x | `ethers@^6.13.0` |
| `@getpara/ethers-v5-integration` | Ethers 5.x | `ethers@^5.8.0` |
| `@getpara/solana-web3.js-v1-integration` | Solana Web3.js 1.x | `@solana/web3.js@^1.98.0` |
| `@getpara/solana-signers-v2-integration` | Solana Signers 2.x | `@solana/web3.js@^1.98.0` |
| `@getpara/cosmjs-v0-integration` | CosmJS 0.34+ | `@cosmjs/stargate@^0.34.0`, `@cosmjs/proto-signing@^0.34.0` |

### Connector Packages

| Package | Connector Ecosystem | Companion Deps |
|---------|-------------------|----------------|
| `@getpara/wagmi-v2-integration` | Wagmi 2.x / 3.x | `wagmi@^2.15.0`, `viem@^2.27.0`, `@tanstack/react-query@^5.0.0` |
| `@getpara/rainbowkit-wallet` | RainbowKit | `@rainbow-me/rainbowkit@^2.0.0`, `wagmi`, `viem` |
| `@getpara/graz-integration` | Graz (Cosmos) | `graz@^0.4.1` |

### External Wallet Connector Packages

| Package | Purpose |
|---------|---------|
| `@getpara/evm-wallet-connectors` | EVM external wallet connections |
| `@getpara/solana-wallet-connectors` | Solana external wallet connections |
| `@getpara/cosmos-wallet-connectors` | Cosmos external wallet connections |

### Account Abstraction Companion Deps

| AA Provider | Key Packages |
|------------|-------------|
| Alchemy (ERC-4337) | `@aa-sdk/core`, `@account-kit/infra`, `@account-kit/smart-contracts` |
| Alchemy (EIP-7702) | Same as above, uses `createModularAccountV2Client` with `mode: "7702"` |
| ZeroDev (ERC-4337) | `@zerodev/sdk`, `@zerodev/ecdsa-validator` |
| ZeroDev (EIP-7702) | Same packages, uses `create7702KernelAccount` + `KERNEL_V3_3` |
| Gelato | `@gelatonetwork/smartwallet` |
| Thirdweb | `thirdweb` |
| Rhinestone | `@rhinestone/sdk` |
| Porto | `porto` |

### Required Companion Dependency

All React examples require:
```
@tanstack/react-query@^5.0.0
```

---

## 2. Initialization Patterns

### React / Next.js (ParaProvider)

```tsx
// src/components/ParaProvider.tsx
"use client";

import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { Environment, ParaProvider as ParaSDKProvider } from "@getpara/react-sdk";

const API_KEY = process.env.NEXT_PUBLIC_PARA_API_KEY ?? "";
const ENVIRONMENT = (process.env.NEXT_PUBLIC_PARA_ENVIRONMENT as Environment) || Environment.BETA;

if (!API_KEY) {
  throw new Error("API key is not defined. Please set NEXT_PUBLIC_PARA_API_KEY in your environment variables.");
}

const queryClient = new QueryClient();

export function ParaProvider({ children }: { children: React.ReactNode }) {
  return (
    <QueryClientProvider client={queryClient}>
      <ParaSDKProvider
        paraClientConfig={{
          apiKey: API_KEY,
          env: ENVIRONMENT,
        }}
        config={{ appName: "My App" }}
        paraModalConfig={{
          disableEmailLogin: false,
          disablePhoneLogin: false,
          authLayout: ["AUTH:FULL", "EXTERNAL:FULL"],
          oAuthMethods: ["APPLE", "DISCORD", "FACEBOOK", "FARCASTER", "GOOGLE", "TWITTER"],
          onRampTestMode: true,
          theme: {
            foregroundColor: "#222222",
            backgroundColor: "#FFFFFF",
            accentColor: "#888888",
            darkForegroundColor: "#EEEEEE",
            darkBackgroundColor: "#111111",
            darkAccentColor: "#AAAAAA",
            mode: "light",
            borderRadius: "none",
            font: "Inter",
          },
          logo: "/logo.svg",
          recoverySecretStepEnabled: true,
          twoFactorAuthEnabled: false,
        }}>
        {children}
      </ParaSDKProvider>
    </QueryClientProvider>
  );
}
```

The `config` prop accepts:
```ts
interface ParaProviderConfig {
  appName: string;                        // required
  disableAutoSessionKeepAlive?: boolean;  // disable automatic session refresh
  disableEmbeddedModal?: boolean;         // set true only when rendering your own ParaModal
  rpcUrl?: string;
  farcasterMiniAppConfig?: FarcasterMiniAppConfig;
}
```

Wrap your app root (e.g., `layout.tsx`):
```tsx
import { ParaProvider } from "@/components/ParaProvider";
export default function RootLayout({ children }) {
  return <html><body><ParaProvider>{children}</ParaProvider></body></html>;
}
```

`ParaProvider` also accepts an optional `callbacks` prop for event handling:
```ts
type Callbacks = {
  onLogout?: (event) => void;
  onLogin?: (event) => void;
  onAccountSetup?: (event) => void;
  onAccountCreation?: (event) => void;
  onSignMessage?: (event) => void;
  onSignTransaction?: (event) => void;
  onWalletsChange?: (event) => void;
  onWalletCreated?: (event) => void;
  onPregenWalletClaimed?: (event) => void;
};
```

### Vue / Svelte (ParaWeb - imperative)

```ts
// src/lib/para.ts
import { Environment, ParaWeb } from "@getpara/web-sdk";

const API_KEY = import.meta.env.VITE_PARA_API_KEY;
const ENVIRONMENT = (import.meta.env.VITE_PARA_ENVIRONMENT as Environment) || Environment.BETA;

if (!API_KEY) {
  throw new Error("API key is not defined. Please set VITE_PARA_API_KEY in your environment variables.");
}

export const para = new ParaWeb(ENVIRONMENT, API_KEY);
```

### Server (ParaServer)

```ts
import { Para as ParaServer, Environment } from "@getpara/server-sdk";

const PARA_API_KEY = process.env.PARA_API_KEY;
const PARA_ENVIRONMENT = (process.env.PARA_ENVIRONMENT as Environment) || Environment.BETA;

const para = new ParaServer(PARA_ENVIRONMENT, PARA_API_KEY);
```

### React Native / Expo (ParaMobile)

```ts
import ParaMobile, { Environment } from "@getpara/react-native-wallet";

const para = new ParaMobile(
  Environment.BETA,
  process.env.EXPO_PUBLIC_PARA_API_KEY,
  undefined,
  { disableWorkers: true }
);
```

The `{ disableWorkers: true }` option is **required** for React Native because Web Workers are not available.

### Chrome Extension (storage overrides)

```ts
import { ParaWeb } from "@getpara/react-sdk";
import { chromeStorageOverrides } from "../chrome-storage";

export const para = new ParaWeb(ENVIRONMENT, API_KEY, {
  ...chromeStorageOverrides,
  useStorageOverrides: true,
});

// Shared init promise - await in any script that needs Para
export const paraReady = para.init();
```

The `chromeStorageOverrides` object maps `chrome.storage.local` / `chrome.storage.session` to replace `localStorage` / `sessionStorage` which are not available in extension service workers. See `examples-hub/web/with-chrome-extension/src/lib/chrome-storage.ts` for the full implementation.

---

## 3. REST API — Default for Server-Side Wallets

**When a backend needs to create wallets or sign on behalf of users (pre-created wallets, agent wallets, automated signing), use the REST API.** It is the recommended path for nearly all server-side integrations: no SDK to install, no user share to store or encrypt, no MPC ceremony to run per signature. Para's enclave holds the key material; your server holds only an API key.

Only fall back to SDK-based pregeneration when the flow requires direct user-share control (see Section 7).

For typed TypeScript access, use `@getpara/rest-sdk`. Otherwise call the HTTP API from any language.

### Base URLs

| Environment | URL |
|------------|-----|
| Beta | `https://api.beta.getpara.com` |
| Production | `https://api.getpara.com` |

### Authentication Header

```
X-API-Key: your_api_key
X-Request-Id: <uuid>          # optional, for request tracing
Content-Type: application/json
```

### Endpoints

```
POST /v1/wallets                     - Create wallet
GET  /v1/wallets/{walletId}          - Get wallet details
POST /v1/wallets/{walletId}/sign-raw - Sign raw bytes (0x-prefixed hex)
```

The API also has `sign-transaction`, `sign-message`, `sign-typed-data`, `sign-authorization`, `transfer`, `balance`, `transactions`, and `estimate-fee` endpoints under `/v1/wallets/{walletId}/`. Full spec: https://docs.getpara.com/openapi.yaml

### Create Wallet Request

```json
{
  "type": "EVM",
  "userIdentifier": "alice@example.com",
  "userIdentifierType": "EMAIL",
  "scheme": "DKLS"
}
```

- `type`: `"EVM"` | `"SOLANA"` | `"COSMOS"` | `"STELLAR"`
- `userIdentifierType`: `"EMAIL"` | `"PHONE"` | `"CUSTOM_ID"` | `"GUEST_ID"` | `"TELEGRAM"` | `"DISCORD"` | `"TWITTER"` | `"FARCASTER"`
- `scheme`: `"DKLS"` | `"CGGMP"` | `"ED25519"` (optional, defaults based on wallet type)
- `cosmosPrefix`: string (optional, for Cosmos wallets)

### Sign Raw Request

```json
{
  "data": "0xdeadbeef..."
}
```

### Error Codes

| Code | Meaning |
|------|---------|
| 201 | Created |
| 200 | Success |
| 400 | Bad request (invalid params) |
| 401 | Unauthorized (invalid API key) |
| 404 | Not found |
| 409 | Conflict (wallet already exists) |
| 429 | Rate limited |
| 500 | Server error |

### Example Node.js client

```ts
const PARA_API_KEY = process.env.PARA_API_KEY;
const BASE_URL = process.env.PARA_REST_BASE_URL ?? "https://api.beta.getpara.com";

async function callPara<T>(path: string, options: { method?: string; body?: unknown } = {}): Promise<T> {
  const { method = "GET", body } = options;
  const headers: Record<string, string> = {
    "X-API-Key": PARA_API_KEY,
    "X-Request-Id": crypto.randomUUID(),
  };
  if (body) headers["Content-Type"] = "application/json";

  const res = await fetch(`${BASE_URL}${path}`, {
    method,
    headers,
    body: body ? JSON.stringify(body) : undefined,
  });

  const data = await res.json();
  if (!res.ok) throw new Error(`Para ${res.status}: ${JSON.stringify(data)}`);
  return data as T;
}
```

### Wallet Claiming

Wallets created over REST are claimable the same way as SDK pregen wallets: when a user signs up through the client SDK with the same identifier (e.g., the same email), the wallet transfers to their account automatically. No server-side action is required.

---

## 4. Environment Variables

### Naming Conventions by Framework

| Framework | Prefix | Example |
|-----------|--------|---------|
| Next.js (client) | `NEXT_PUBLIC_` | `NEXT_PUBLIC_PARA_API_KEY` |
| Next.js (server) | none | `PARA_API_KEY` |
| Vite (Vue/Svelte) | `VITE_` | `VITE_PARA_API_KEY` |
| Expo | `EXPO_PUBLIC_` | `EXPO_PUBLIC_PARA_API_KEY` |
| Node.js server | none | `PARA_API_KEY` |

### Common Variables

```env
# Required - Para
PARA_API_KEY=your_api_key
PARA_ENVIRONMENT=BETA          # or PRODUCTION

# Client-side variants (pick one based on framework)
NEXT_PUBLIC_PARA_API_KEY=your_api_key
NEXT_PUBLIC_PARA_ENVIRONMENT=BETA
VITE_PARA_API_KEY=your_api_key
VITE_PARA_ENVIRONMENT=BETA
EXPO_PUBLIC_PARA_API_KEY=your_api_key

# Server-side pregen encryption
ENCRYPTION_KEY=a_32_byte_string_exactly_this_l   # Must be exactly 32 bytes

# Account Abstraction
ALCHEMY_API_KEY=your_alchemy_key
ALCHEMY_GAS_POLICY_ID=your_policy_id
ALCHEMY_RPC_URL=https://arb-sepolia.g.alchemy.com/v2/your_key
ZERODEV_PROJECT_ID=your_zerodev_project_id
ZERODEV_BUNDLER_RPC=https://rpc.zerodev.app/api/v2/bundler/...
ZERODEV_PAYMASTER_RPC=https://rpc.zerodev.app/api/v2/paymaster/...
ZERODEV_ARBITRUM_SEPOLIA_RPC=https://rpc.zerodev.app/api/v2/rpc/...

# REST API
PARA_REST_BASE_URL=https://api.beta.getpara.com   # or https://api.getpara.com
```

---

## 5. Authentication Flows

### Email Auth (React hooks pattern)

```tsx
import {
  useSignUpOrLogIn,
  useWaitForLogin,
  useWaitForWalletCreation,
  type AuthStateVerify,
} from "@getpara/react-sdk";

// In your hook/component:
const { signUpOrLogIn, isPending: isSigningUp } = useSignUpOrLogIn();
const { waitForLogin, isPending: isWaitingForLogin } = useWaitForLogin();
const { waitForWalletCreation, isPending: isWaitingForWallet } = useWaitForWalletCreation();

const shouldCancel = useRef(false);

// Step 1: Submit email
signUpOrLogIn(
  { auth: { email } },
  {
    onSuccess: (authState) => {
      if (authState?.stage === "verify") {
        const verifyState = authState as AuthStateVerify;
        // verifyState.loginUrl -> open in iframe or popup for passkey verification
        // verifyState.nextStage -> "signup" (new user) or "login" (returning user)
        const isNewUser = verifyState.nextStage === "signup";
        handleAuthComplete(isNewUser);
      }
    },
    onError: (err) => { /* handle error */ },
  }
);

// Step 2: Wait for auth completion
function handleAuthComplete(isNewUser: boolean) {
  if (isNewUser) {
    waitForWalletCreation(
      { isCanceled: () => shouldCancel.current },
      { onSuccess: () => { /* user is logged in with wallet */ } }
    );
  } else {
    waitForLogin(
      { isCanceled: () => shouldCancel.current },
      { onSuccess: () => { /* user is logged in */ } }
    );
  }
}
```

The `loginUrl` from Step 1 must be displayed to the user in an iframe or popup - it's the passkey verification page hosted by Para.

### Email Auth (Imperative / Svelte / Vue)

```ts
import { para } from "@/lib/para";

// Step 1: Submit email
const authState = await para.signUpOrLogIn({ auth: { email } });

if (authState.stage === "verify" && authState.loginUrl) {
  const isNewUser = authState.nextStage === "signup";
  // Show authState.loginUrl to user in iframe/popup

  // Step 2: Wait for completion
  if (isNewUser) {
    await para.waitForWalletCreation({ isCanceled: () => shouldCancel });
  } else {
    const result = await para.waitForLogin({ isCanceled: () => shouldCancel });
    if (result.needsWallet) {
      await para.waitForWalletCreation({ isCanceled: () => shouldCancel });
    }
  }
}
```

### OAuth Auth (React hooks)

```tsx
import {
  useVerifyOAuth,
  useVerifyFarcaster,
  useWaitForLogin,
  useWaitForWalletCreation,
  type TOAuthMethod,
} from "@getpara/react-sdk";

const { verifyOAuth } = useVerifyOAuth();
const { verifyFarcaster } = useVerifyFarcaster();

// Standard OAuth (Google, Apple, Discord, Facebook, Twitter)
verifyOAuth(
  {
    method: "GOOGLE", // TOAuthMethod excluding "TELEGRAM" | "FARCASTER"
    onOAuthUrl: (url) => {
      window.open(url, "oauth", "popup=true");
    },
    isCanceled: () => shouldCancel.current || !!popupWindow.current?.closed,
  },
  {
    onSuccess: (authState) => {
      if (authState.stage === "done") {
        handleAuthComplete(authState.isNewUser);
      }
    },
  }
);

// Farcaster
verifyFarcaster(
  {
    onConnectUri: (uri) => {
      window.open(uri, "farcaster", "popup=true");
    },
    isCanceled: () => shouldCancel.current || !!popupWindow.current?.closed,
  },
  {
    onSuccess: (authState) => {
      if (authState.stage === "done") {
        handleAuthComplete(authState.isNewUser);
      }
    },
  }
);
```

### Verify iframe listener

When showing the `loginUrl` in an iframe, listen for the close message:

```ts
useEffect(() => {
  const portalBase = "https://app.beta.getpara.com"; // or https://app.getpara.com
  const handleMessage = (event: MessageEvent) => {
    if (!event.origin.startsWith(portalBase)) return;
    if (event.data?.type === "CLOSE_WINDOW" && event.data.success) {
      setVerifyUrl(null);
    }
  };
  window.addEventListener("message", handleMessage);
  return () => window.removeEventListener("message", handleMessage);
}, []);
```

---

## 6. Signing Integration Code

### Viem v2

```ts
import { createParaAccount, createParaViemClient } from "@getpara/viem-v2-integration";
import { http, parseEther, parseGwei } from "viem";
import { sepolia } from "viem/chains";

// From client (using useClient hook):
import { useClient } from "@getpara/react-sdk";
const client = useClient(); // returns the Para client instance

// Create account + client
const viemParaAccount = createParaAccount(para); // para = ParaServer or client
const viemClient = createParaViemClient(para, {
  account: viemParaAccount,
  chain: sepolia,
  transport: http("https://ethereum-sepolia-rpc.publicnode.com"),
});

// Sign transaction
const request = await viemClient.prepareTransactionRequest({
  account: viemParaAccount,
  to: "0x...",
  value: parseEther("0.0001"),
  gas: BigInt(21000),
  maxFeePerGas: parseGwei("20"),
  maxPriorityFeePerGas: parseGwei("3"),
  chain: sepolia,
});
const signedTx = await viemClient.signTransaction(request);
```

### Ethers v6

```ts
import { ParaEthersSigner } from "@getpara/ethers-v6-integration";
import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider("https://ethereum-sepolia-rpc.publicnode.com");
const signer = new ParaEthersSigner(para, provider as ethers.Provider);

const address = await signer.getAddress();
const tx = {
  to: address,
  value: ethers.parseEther("0.0001"),
  nonce: await provider.getTransactionCount(address),
  gasLimit: 21000,
  gasPrice: (await provider.getFeeData()).gasPrice,
};
await signer.signTransaction(tx);
```

### Ethers v5

```ts
import { ParaEthersV5Signer } from "@getpara/ethers-v5-integration";
import { ethers } from "ethers";

const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
const signer = new ParaEthersV5Signer(client, provider); // client from useClient()

await signer.signMessage("Hello, Para!");
await signer.sendTransaction(tx);
```

### Solana Web3.js v1

```ts
import { ParaSolanaWeb3Signer } from "@getpara/solana-web3.js-v1-integration";
import { Connection, Transaction, SystemProgram, LAMPORTS_PER_SOL } from "@solana/web3.js";

const connection = new Connection("https://api.testnet.solana.com");
const signer = new ParaSolanaWeb3Signer(para, connection);

const { blockhash } = await connection.getLatestBlockhash();
const tx = new Transaction();
tx.recentBlockhash = blockhash;
tx.feePayer = signer.sender; // PublicKey from Para wallet

tx.add(
  SystemProgram.transfer({
    fromPubkey: signer.sender,
    toPubkey: signer.sender,
    lamports: LAMPORTS_PER_SOL / 1000,
  })
);

await signer.signTransaction(tx);
```

### CosmJS

```ts
import { ParaProtoSigner } from "@getpara/cosmjs-v0-integration";
import { SigningStargateClient } from "@cosmjs/stargate";

const signer = new ParaProtoSigner(para, "cosmos"); // second arg is bech32 prefix

const stargateClient = await SigningStargateClient.connectWithSigner(
  "https://rpc-rs.cosmos.nodestake.top/",
  signer
);

const fee = { amount: [{ denom: "uatom", amount: "500" }], gas: "200000" };
await stargateClient.sign(
  signer.address,
  [{ typeUrl: "/cosmos.bank.v1beta1.MsgSend", value: { fromAddress: signer.address, toAddress: "cosmos1...", amount: [{ denom: "uatom", amount: "1000" }] } }],
  fee,
  "Signed with Para"
);
```

---

## 7. Advanced: SDK Wallet Pregeneration

**Most server integrations should use the REST API (Section 3) instead of this section.** SDK pregeneration requires you to store, encrypt, and restore the wallet's user share yourself, and to run an MPC ceremony for every signature. Use it only when the flow needs direct user-share control — for example, signing with SDK ecosystem integrations (ethers, viem, @solana/web3.js adapters) before the wallet is claimed. Existing SDK pregen integrations can move over: https://docs.getpara.com/v3/rest/migrate-from-sdk-pregen

### Create pre-generated wallet

```ts
import { Para as ParaServer, Environment } from "@getpara/server-sdk";
import { encrypt } from "./encryption-utils";
import { setKeyShareInDB } from "./keySharesDB";

const para = new ParaServer(PARA_ENVIRONMENT, PARA_API_KEY);

// Check if wallet already exists
const walletExists = await para.hasPregenWallet({ pregenId: { email } });

// Create wallets for all chain types
const wallets = await para.createPregenWalletPerType({
  types: ["EVM", "SOLANA", "COSMOS"],
  pregenId: { email },
});

// Get and encrypt the user share
const keyShare = para.getUserShare();
const encryptedKeyShare = await encrypt(keyShare);
await setKeyShareInDB(email, encryptedKeyShare);
```

### Restore user share for signing

```ts
const keyShare = await getKeyShareInDB(email);
const decryptedKeyShare = await decrypt(keyShare);
await para.setUserShare(decryptedKeyShare);

// Now para is ready for signing with any integration
```

### AES-GCM Encryption Pattern

```ts
// encryption-utils.ts
const ALGORITHM = "AES-GCM";
const IV_LENGTH = 12;

// ENCRYPTION_KEY env var must be exactly 32 bytes
async function importSecretKey(keyString: string): Promise<CryptoKey> {
  const keyBuffer = Buffer.from(keyString, "utf-8");
  return await crypto.subtle.importKey("raw", keyBuffer, { name: ALGORITHM }, false, ["encrypt", "decrypt"]);
}

export async function encrypt(text: string): Promise<string> {
  const cryptoKey = await importSecretKey(process.env.ENCRYPTION_KEY);
  const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
  const encoded = new TextEncoder().encode(text);
  const encrypted = await crypto.subtle.encrypt({ name: ALGORITHM, iv }, cryptoKey, encoded);
  return `${Buffer.from(iv).toString("base64")}:${Buffer.from(encrypted).toString("base64")}`;
}

export async function decrypt(encryptedText: string): Promise<string> {
  const [ivBase64, dataBase64] = encryptedText.split(":");
  const iv = new Uint8Array(Buffer.from(ivBase64, "base64"));
  const data = Buffer.from(dataBase64, "base64");
  const cryptoKey = await importSecretKey(process.env.ENCRYPTION_KEY);
  const decrypted = await crypto.subtle.decrypt({ name: ALGORITHM, iv }, cryptoKey, data);
  return new TextDecoder().decode(decrypted);
}
```

### SQLite Storage Schema

```ts
// keySharesDB.ts - uses `sqlite` + `sqlite3` packages
import { open } from "sqlite";
import sqlite3 from "sqlite3";

const db = await open({ filename: "keyShares.db", driver: sqlite3.Database });

await db.exec(`
  CREATE TABLE IF NOT EXISTS keyShares (
    email TEXT PRIMARY KEY NOT NULL,
    keyShare TEXT NOT NULL
  )
`);

// Get
const row = await db.get("SELECT keyShare FROM keyShares WHERE email = ?", [email]);

// Upsert
await db.run(
  "INSERT INTO keyShares (email, keyShare) VALUES (?, ?) ON CONFLICT(email) DO UPDATE SET keyShare = excluded.keyShare",
  [email, encryptedKeyShare]
);
```

---

## 8. Account Abstraction Patterns

### Alchemy ERC-4337

```ts
import { alchemy, arbitrumSepolia } from "@account-kit/infra";
import { WalletClientSigner } from "@aa-sdk/core";
import { createModularAccountAlchemyClient } from "@account-kit/smart-contracts";
import { createParaAccount, createParaViemClient } from "@getpara/viem-v2-integration";

const viemParaAccount = createParaAccount(para);
const viemClient = createParaViemClient(para, {
  account: viemParaAccount,
  chain: arbitrumSepolia,
  transport: http(ALCHEMY_RPC_URL),
});

const walletClientSigner = new WalletClientSigner(viemClient, "para");

const alchemyClient = await createModularAccountAlchemyClient({
  transport: alchemy({ rpcUrl: ALCHEMY_RPC_URL }),
  chain: arbitrumSepolia,
  signer: walletClientSigner,
  policyId: ALCHEMY_GAS_POLICY_ID,
});

const result = await alchemyClient.sendUserOperation({ uo: batchCalls });
await alchemyClient.waitForUserOperationTransaction(result);
```

### Alchemy EIP-7702

```ts
import { createModularAccountV2Client } from "@account-kit/smart-contracts";
import { createParaAccount } from "@getpara/viem-v2-integration";
import type { SmartAccountSigner, LocalAccount } from "@aa-sdk/core";

const viemParaAccount = createParaAccount(para);

// Wrap as SmartAccountSigner
const paraSigner: SmartAccountSigner<LocalAccount> = {
  signerType: "para",
  inner: viemParaAccount,
  getAddress: async () => viemParaAccount.address,
  signMessage: async (message) => viemParaAccount.signMessage({ message }),
  signTypedData: async (typedData) => viemParaAccount.signTypedData(typedData),
  signAuthorization: async (auth) => viemParaAccount.signAuthorization(auth),
};

const alchemyClient = await createModularAccountV2Client({
  mode: "7702",
  transport: alchemy({ rpcUrl: ALCHEMY_RPC_URL }),
  chain: arbitrumSepolia,
  signer: paraSigner,
  policyId: ALCHEMY_GAS_POLICY_ID,
});
```

### ZeroDev ERC-4337

```ts
import { signerToEcdsaValidator } from "@zerodev/ecdsa-validator";
import { createKernelAccount, createKernelAccountClient, createZeroDevPaymasterClient } from "@zerodev/sdk";
import { getEntryPoint, KERNEL_V3_1 } from "@zerodev/sdk/constants";

const viemParaAccount = createParaAccount(para);
const viemClient = createParaViemClient(para, { account: viemParaAccount, chain: arbitrumSepolia, transport: http(ZERODEV_RPC_URL) });
const publicClient = createPublicClient({ chain: arbitrumSepolia, transport: http(ZERODEV_RPC_URL) });

const entryPoint = getEntryPoint("0.7");

const ecdsaValidator = await signerToEcdsaValidator(viemClient, {
  signer: viemParaAccount,
  entryPoint,
  kernelVersion: KERNEL_V3_1,
});

const kernelAccount = await createKernelAccount(publicClient, {
  plugins: { sudo: ecdsaValidator },
  entryPoint,
  kernelVersion: KERNEL_V3_1,
});

const kernelClient = createKernelAccountClient({
  account: kernelAccount,
  chain: arbitrumSepolia,
  bundlerTransport: http(ZERODEV_BUNDLER_RPC),
  paymaster: {
    getPaymasterData: (userOp) =>
      createZeroDevPaymasterClient({ chain: arbitrumSepolia, transport: http(ZERODEV_PAYMASTER_RPC) })
        .sponsorUserOperation({ userOperation: userOp }),
  },
});

const hash = await kernelClient.sendUserOperation({ callData: await kernelClient.account.encodeCalls(calls) });
await kernelClient.waitForUserOperationReceipt({ hash, timeout: 30000 });
```

### ZeroDev EIP-7702

```ts
import { create7702KernelAccount, create7702KernelAccountClient } from "@zerodev/ecdsa-validator";
import { KERNEL_V3_3 } from "@zerodev/sdk/constants";

const kernelAccount = await create7702KernelAccount(publicClient, {
  signer: viemParaAccount,
  entryPoint: getEntryPoint("0.7"),
  kernelVersion: KERNEL_V3_3,
});

const kernelClient = create7702KernelAccountClient({
  account: kernelAccount,
  chain: arbitrumSepolia,
  bundlerTransport: http(ZERODEV_BUNDLER_RPC),
  paymaster: createZeroDevPaymasterClient({ chain: arbitrumSepolia, transport: http(ZERODEV_PAYMASTER_RPC) }),
  client: publicClient,
});

const hash = await kernelClient.sendUserOperation({ calls });
```

### Gelato ERC-4337

```ts
import { accounts, createGelatoSmartWalletClient } from "@gelatonetwork/smartwallet";

const viemParaAccount = createParaAccount(para);
const viemClient = createParaViemClient(para, { account: viemParaAccount, chain: sepolia, transport: http() });

const account = await accounts.kernel({ eip7702: false, signer: viemClient });
const gelatoClient = createGelatoSmartWalletClient({ account, apiKey: GELATO_API_KEY });

const result = await gelatoClient.execute({
  payment: { type: "sponsored" },
  calls: [{ to: "0x...", value: 0n, data: "0x" }],
});
await result.wait();
```

### Gelato EIP-7702

```ts
import { gelato } from "@gelatonetwork/smartwallet/accounts";
import { createGelatoSmartWalletClient } from "@gelatonetwork/smartwallet";

const account = await gelato({ signer: viemClient }); // Different subpath from 4337's accounts.kernel()
const gelatoClient = createGelatoSmartWalletClient({ account, apiKey: GELATO_API_KEY });
// Same execute pattern as 4337
```

### Thirdweb ERC-4337

```ts
import { createThirdwebClient, sendTransaction, prepareTransaction } from "thirdweb";
import { viemAdapter, smartWallet } from "thirdweb/wallets";
import { sepolia } from "thirdweb/chains";

const thirdwebClient = createThirdwebClient({ clientId: THIRDWEB_CLIENT_ID });
const personalAccount = viemAdapter.walletClient.fromViem({ walletClient: viemClient });
const wallet = smartWallet({ chain: sepolia, sponsorGas: true });
const smartAccount = await wallet.connect({ client: thirdwebClient, personalAccount });

const tx = prepareTransaction({ to: "0x...", value: 0n, chain: sepolia, client: thirdwebClient });
await sendTransaction({ account: smartAccount, transaction: tx });
```

### Porto EIP-7702

Porto operates on Base Sepolia with a unique EOA-to-smart-account upgrade flow. See `examples-hub/web/with-react-nextjs/aa-porto-7702/` for the full implementation using `Account.from()`, `Key.createSecp256k1()`, and `RelayActions.prepareUpgradeAccount()`.

### Rhinestone ERC-4337

Rhinestone provides cross-chain account abstraction using `@rhinestone/sdk`. See `examples-hub/web/with-react-nextjs/aa-rhinestone-4337/` for cross-chain USDC transfers (Arbitrum->Base) with sponsored transactions.

---

## 9. Connector Integrations

### Wagmi Connector

```ts
// src/config/wagmi.ts
import { paraConnector } from "@getpara/wagmi-v2-integration";
import { ParaWeb } from "@getpara/react-sdk-lite"; // or @getpara/react-sdk
import { createConfig, http, cookieStorage, createStorage } from "wagmi";
import { sepolia } from "wagmi/chains";

// Initialize ParaWeb (not ParaProvider - connector manages its own UI)
const para = new ParaWeb(Environment.BETA, API_KEY);

const connector = paraConnector({
  para,
  appName: "My App",
  chains: [sepolia],
  queryClient,
  authLayout: ["AUTH:FULL", "EXTERNAL:FULL"],
  oAuthMethods: ["APPLE", "DISCORD", "FACEBOOK", "FARCASTER", "GOOGLE", "TWITTER"],
  disableEmailLogin: false,
  disablePhoneLogin: false,
  logo: "/logo.svg",
  onRampTestMode: true,
  recoverySecretStepEnabled: true,
  twoFactorAuthEnabled: false,
  theme: {
    foregroundColor: "#222222",
    backgroundColor: "#FFFFFF",
    accentColor: "#888888",
    mode: "light",
    borderRadius: "none",
    font: "Inter",
  },
});

export const wagmiConfig = createConfig({
  chains: [sepolia],
  connectors: [connector, injected(), metaMask(), coinbaseWallet()],
  ssr: true,
  storage: createStorage({ storage: cookieStorage }),
  transports: { [sepolia.id]: http(RPC_URL) },
});
```

Important: The Wagmi connector uses `@getpara/react-sdk-lite` (not the full `@getpara/react-sdk`) to avoid bundle bloat, since the connector provides its own modal.

### RainbowKit

```ts
// src/client/wagmi.ts
import { getParaWallet } from "@getpara/rainbowkit-wallet";
import { connectorsForWallets } from "@rainbow-me/rainbowkit";
import { createConfig, http } from "wagmi";
import { sepolia } from "wagmi/chains";

const paraWallet = getParaWallet({
  para,             // ParaWeb instance
  chains: [sepolia],
  appName: "My App",
  // Same modal config options as paraConnector: oAuthMethods, theme, etc.
});

const connectors = connectorsForWallets(
  [{ groupName: "Para", wallets: [paraWallet] }],
  { appName: "My App", projectId: WALLETCONNECT_PROJECT_ID }
);

export const wagmiConfig = createConfig({
  chains: [sepolia],
  connectors,
  transports: { [sepolia.id]: http(RPC_URL) },
});

// Providers: WagmiProvider + QueryClientProvider + RainbowKitProvider
// Then use wagmi hooks: useSignMessage(), useSendTransaction(), etc.
```

### Graz (Cosmos)

```tsx
// src/context/Provider.tsx
import { ParaGrazConnector } from "@getpara/graz-integration";
import { ParaWeb, Environment } from "@getpara/react-sdk-lite";
import { GrazProvider, defineChainInfo, type ParaGrazConfig } from "graz";

const para = new ParaWeb(Environment.BETA, API_KEY);

const cosmosTestnet = defineChainInfo({
  chainId: "provider",
  chainName: "Cosmos ICS Provider Testnet",
  rpc: "https://rpc.provider-sentry-01.ics-testnet.polypore.xyz",
  rest: "https://rest.provider-sentry-01.ics-testnet.polypore.xyz",
  bip44: { coinType: 118 },
  bech32Config: { bech32PrefixAccAddr: "cosmos", /* ... other prefixes */ },
  stakeCurrency: { coinDenom: "ATOM", coinMinimalDenom: "uatom", coinDecimals: 6 },
  currencies: [{ coinDenom: "ATOM", coinMinimalDenom: "uatom", coinDecimals: 6 }],
  feeCurrencies: [{ coinDenom: "ATOM", coinMinimalDenom: "uatom", coinDecimals: 6 }],
});

const paraConfig: ParaGrazConfig = {
  paraWeb: para as ParaGrazConfig["paraWeb"],
  connectorClass: ParaGrazConnector,       // Note: connectorClass, not connector instance
  modalProps: { appName: "My App" },
  queryClient: queryClient,
};

// Wrap your app:
<GrazProvider
  grazOptions={{
    chains: [cosmosTestnet],
    paraConfig,
  }}>
  {children}
</GrazProvider>
```

Note: `defineChainInfo` and `ParaGrazConfig` type are imported from `graz`, not from `@getpara/graz-integration`.

---

## 10. Session Management

### Check and keep alive

```ts
// Client-side (React hooks)
import { useAccount, useKeepSessionAlive } from "@getpara/react-sdk";
const { isConnected } = useAccount();

// Imperative
const isActive = await para.isSessionActive();
if (isActive) {
  await para.keepSessionAlive();
}
```

### Export / Import session (server transfer)

```ts
// Client: export session string
const sessionString = await para.exportSession();

// Send sessionString to server via API call

// Server: import session
const serverPara = new ParaServer(PARA_ENVIRONMENT, PARA_API_KEY);
await serverPara.importSession(sessionString);

// Server can now sign on behalf of the user
const isActive = await serverPara.isSessionActive();
```

### Issue JWT

```ts
// Client-side
import { useIssueJwt } from "@getpara/react-sdk";
const { issueJwt } = useIssueJwt();

const { token, keyId } = await issueJwt();
// Send `token` to your server for verification

// Imperative
const { token, keyId } = await para.issueJWT();
```

---

## 11. ParaModal Configuration

The `paraModalConfig` prop on `<ParaSDKProvider>` (or the config object for `paraConnector`) accepts:

```ts
interface ParaModalConfig {
  // Authentication layout
  authLayout?: ("AUTH:FULL" | "AUTH:CONDENSED" | "EXTERNAL:FULL" | "EXTERNAL:CONDENSED")[];

  // Email / Phone login toggles
  disableEmailLogin?: boolean;
  disablePhoneLogin?: boolean;
  defaultAuthIdentifier?: string; // Pre-fill email/phone

  // OAuth providers
  oAuthMethods?: TOAuthMethod[];
  // TOAuthMethod = "APPLE" | "DISCORD" | "FACEBOOK" | "FARCASTER" | "GOOGLE" | "TWITTER" | "TELEGRAM"

  // Branding
  logo?: string; // recommended 372x160px

  // Theme
  theme?: {
    foregroundColor?: string;
    backgroundColor?: string;
    accentColor?: string;
    darkForegroundColor?: string;
    darkBackgroundColor?: string;
    darkAccentColor?: string;
    overlayBackground?: string;
    mode?: "light" | "dark";
    borderRadius?: "none" | "xs" | "sm" | "md" | "lg" | "xl" | "full";
    font?: string;
    oAuthLogoVariant?: "dark" | "light" | "default";
  };

  // Features
  onRampTestMode?: boolean;
  recoverySecretStepEnabled?: boolean;
  twoFactorAuthEnabled?: boolean;
  hideWallets?: boolean;           // Hide wallet terminology
  isGuestModeEnabled?: boolean;    // Enable guest login
  bareModal?: boolean;             // No overlay backdrop
  embeddedModal?: boolean;         // Embedded styling
  className?: string;              // Custom CSS class

  // Account linking
  supportedAccountLinks?: ("EMAIL" | "PHONE" | "GOOGLE" | "EXTERNAL_WALLET")[];

  // Step override
  currentStepOverride?: ModalStepProp;
  // Steps: AUTH_MAIN, AUTH_MORE, AWAITING_OAUTH, VERIFICATIONS,
  //   BIOMETRIC_CREATION, PASSWORD_CREATION, SECRET, AWAITING_WALLET_CREATION,
  //   ACCOUNT_MAIN, ACCOUNT_PROFILE, CHAIN_SWITCH,
  //   EX_WALLET_MORE, EX_WALLET_SELECTED,
  //   ADD_FUNDS_BUY, ADD_FUNDS_RECEIVE, ADD_FUNDS_WITHDRAW,
  //   SETUP_2FA, VERIFY_2FA

  // Callbacks
  onModalStepChange?: (value: any) => void;
  onClose?: () => void;

  // Advanced overrides
  loginTransitionOverride?: (para: ParaWeb) => Promise<void>;
  createWalletOverride?: (para: ParaWeb) => Promise<{ recoverySecret?: string; walletIds: any }>;
}
```

> **Note:** Password and PIN screens render in an iframe and use the Developer Portal theme settings, not `paraModalConfig.theme`.

---

## 12. Mobile Setup Requirements

### Required Native Modules (Expo)

```json
{
  "@craftzdog/react-native-buffer": "^6.1.0",
  "@getpara/react-native-wallet": "<same version as other @getpara/* packages>",
  "@peculiar/webcrypto": "^1.5.0",
  "@react-native-async-storage/async-storage": "^2.2.0",
  "react-native-keychain": "^10.0.0",
  "react-native-modpow": "^1.1.0",
  "react-native-passkey": "^3.3.2",
  "react-native-quick-base64": "^2.2.0",
  "react-native-quick-crypto": "^0.7.14",
  "react-native-worklets": "^0.5.1",
  "readable-stream": "^4.5.2"
}
```

### Metro Config (polyfills)

```js
// metro.config.js
const { getDefaultConfig } = require('expo/metro-config');
const config = getDefaultConfig(__dirname);

config.resolver.extraNodeModules = {
  crypto: require.resolve('react-native-quick-crypto'),
  buffer: require.resolve('@craftzdog/react-native-buffer'),
};

module.exports = config;
```

### Babel Config

```js
// babel.config.js
module.exports = function (api) {
  api.cache(true);
  return {
    presets: [['babel-preset-expo', { jsxImportSource: 'nativewind' }], 'nativewind/babel'],
    plugins: ['react-native-worklets/plugin'],
  };
};
```

### iOS Passkey Setup

For passkey support on iOS, you must configure your app's Associated Domains capability with a `webcredentials:` entry pointing to your domain. The domain must serve an `apple-app-site-association` file. See `examples-hub/mobile/with-expo-one-click-login/ios/` for an example Xcode project configuration.

### Key Init Option

Always pass `{ disableWorkers: true }` when initializing `ParaMobile` - Web Workers are not available in React Native.

---

## 13. Vite Polyfill Configuration

Vue and Svelte projects using Vite need `vite-plugin-node-polyfills` because the Para SDK uses Node.js built-in modules (`buffer`, `crypto`, `stream`).

```ts
// vite.config.ts
import { defineConfig } from "vite";
import vue from "@vitejs/plugin-vue"; // or svelte()
import { nodePolyfills } from "vite-plugin-node-polyfills";

export default defineConfig({
  plugins: [vue(), nodePolyfills()],
});
```

Install:
```bash
npm install -D vite-plugin-node-polyfills
```

This is required for `@getpara/web-sdk`. The `@getpara/react-sdk` with Next.js does **not** need this (Next.js handles polyfills via `npx setup-para` postinstall script).

---

## 14. React Hook Reference

### CSS Import

ParaModal requires its stylesheet:
```tsx
import "@getpara/react-sdk/styles.css";
```

Add this in your root layout or ParaProvider component.

`ParaProvider` renders an embedded `ParaModal` by default. Do not render a separate `<ParaModal />` unless `config.disableEmbeddedModal` is set to `true`.

### From `@getpara/react-sdk`

**Account & Connection:**
- `useAccount()` -> `{ isConnected, isConnecting, address, embedded }` - `embedded.wallets` contains wallet array
- `useClient()` -> Para client instance (for passing to signer constructors)
- `useIsFullyLoggedIn()` -> `boolean | undefined`
- `useParaStatus()` -> `ParaStatus` (readiness and Farcaster Mini App detection)
- `useModal()` -> `{ isOpen, openModal, closeModal }`
- `useWallet()` -> `Wallet | null | undefined` (active wallet)
- `useWalletState()` -> `{ selectedWallet, setSelectedWallet, updateSelectedWallet }`
- `useLinkedAccounts()` -> `LinkedAccounts & { userId: string }`

**Authentication:**
- `useSignUpOrLogIn()` -> `{ signUpOrLogIn, signUpOrLogInAsync, isPending }`
- `useVerifyOAuth()` -> `{ verifyOAuth, isPending }`
- `useVerifyFarcaster()` -> `{ verifyFarcaster, isPending }`
- `useVerifyNewAccount()` -> `{ verifyNewAccount, verifyNewAccountAsync }`
- `useWaitForLogin()` -> `{ waitForLogin, isPending }`
- `useWaitForWalletCreation()` -> `{ waitForWalletCreation, isPending }`
- `useLoginExternalWallet()` -> `{ loginExternalWallet, loginExternalWalletAsync }`
- `useLogout()` -> `{ logout, logoutAsync }`
- `useAddAuthMethod()` -> `{ addCredential, addCredentialAsync }`
- `useLinkAccount()` -> `{ linkAccount, isPending, error }`

**Signing (low-level):**
- `useSignMessage()` -> `{ signMessage, signMessageAsync }` - signs base64-encoded message with wallet ID
- `useSignTransaction()` -> `{ signTransaction, signTransactionAsync }`

**Session:**
- `useKeepSessionAlive()` -> `{ keepSessionAlive, keepSessionAliveAsync }`
- `useIssueJwt()` -> `{ issueJwt, issueJwtAsync }` -> `{ token, keyId }`

**Wallet Management:**
- `useCreateWallet()` -> `{ createWallet, createWalletAsync }`
- `useCreateWalletPerType()` -> `{ createWalletPerType, createWalletPerTypeAsync }` - create wallets for multiple chain types
- `useCreateGuestWallets()` -> `{ createGuestWallets, createGuestWalletsAsync }`
- `useWalletBalance()` -> `string | null` - balance in native units

### From `@getpara/react-sdk/evm`

EVM-specific hooks for direct Viem client access. `@getpara/react-sdk` includes `@getpara/viem-v2-integration`; install `viem` when your app imports Viem helpers directly:

- `useViemClient({ address, walletClientConfig })` -> `{ viemClient }` - returns a Viem WalletClient pre-configured with the Para signer

```ts
import { useAccount } from "@getpara/react-sdk";
import { useViemClient } from "@getpara/react-sdk/evm";
import { http } from "viem";
import { sepolia } from "viem/chains";

const { embedded } = useAccount();
const address = embedded?.wallets?.[0]?.address as `0x${string}`;
const { viemClient } = useViemClient({
  address,
  walletClientConfig: { chain: sepolia, transport: http() },
});

// viemClient.sendTransaction, viemClient.signMessage, etc.
```

This is the preferred way to use Viem in React - no need to import `createParaAccount` / `createParaViemClient` directly.

### From `@getpara/react-sdk/viem`

- `useViemAccount({ address? })` -> `{ viemAccount: Account | null, isLoading }` - lower-level access to the viem Account without creating a full WalletClient

### From `@getpara/react-sdk/solana`

- `useSolanaSigner({ rpc, walletId? })` -> `{ solanaSigner: SignerWalletAdapter | null, isLoading }` - for Solana Signers v2 integration

### From `@getpara/react-sdk/cosmos`

- `useCosmjsProtoSigner({ prefix?, walletId?, messageSigningTimeoutMs? })` -> `{ protoSigner: OfflineDirectSigner | null, isLoading }` - for CosmJS proto signing
- `useCosmjsAminoSigner({ prefix?, walletId?, messageSigningTimeoutMs? })` -> `{ aminoSigner: OfflineAminoSigner | null, isLoading }` - for CosmJS amino signing

```ts
// CosmJS example using hooks
import { useCosmjsProtoSigner } from "@getpara/react-sdk/cosmos";
import { SigningStargateClient } from "@cosmjs/stargate";

const { protoSigner } = useCosmjsProtoSigner({ prefix: "cosmos" });
const stargateClient = await SigningStargateClient.connectWithSigner(RPC_URL, protoSigner);
```

---

## 15. Testing Credentials

### Beta Environment

- **Environment**: `Environment.BETA` / `"BETA"`
- **Portal base URL**: `https://app.beta.getpara.com`
- **API base URL**: `https://api.beta.getpara.com`

### Test Email Pattern

Use any email ending in `@test.getpara.com` (e.g., `dev@test.getpara.com`, `test1@test.getpara.com`). **Any OTP code works** (e.g., `123456`, `000000`).

### Test Phone Numbers

Use US numbers (+1) with format `(area code)-555-xxxx` (e.g., `(425)-555-1234`, `(206)-555-9876`). **Any OTP code works**.

### User Limits

50 users per beta account. Delete test users via [Developer Portal](https://developer.getpara.com) -> Users section. Users can only be deleted in BETA; in production, wallets are permanent.

### Post-Install Setup

Many Next.js examples include a `postinstall` script:
```json
"postinstall": "npx setup-para"
```

This configures Next.js webpack to handle Para SDK's WASM and worker files. Always run it after `npm install`.

---

## 16. Examples Hub Directory Map

### Web - Framework Setup
| Directory | Framework | SDK | Key Concept |
|-----------|----------|-----|-------------|
| `web/with-react-nextjs/para-modal/` | Next.js | `@getpara/react-sdk` | ParaProvider + ParaModal quickstart |
| `web/with-react-vite/` | React + Vite | `@getpara/react-sdk` | Vite with React |
| `web/with-svelte-vite/` | Svelte + Vite | `@getpara/web-sdk` | Imperative ParaWeb init |
| `web/with-vue-vite/` | Vue + Vite | `@getpara/web-sdk` | Imperative ParaWeb init |
| `web/with-react-tanstack-start/` | TanStack Start | `@getpara/react-sdk` | Full-stack meta-framework |
| `web/with-chrome-extension/` | Chrome Ext | `@getpara/react-sdk` | Storage overrides |
| `web/with-pwa/` | PWA | `@getpara/react-sdk` | Progressive Web App |

### Web - Authentication
| Directory | Auth Method |
|-----------|------------|
| `web/with-react-nextjs/custom-email-auth/` | Email + passkey verification |
| `web/with-react-nextjs/custom-phone-auth/` | Phone + OTP verification |
| `web/with-react-nextjs/custom-oauth-auth/` | OAuth (Google, Apple, etc.) + Farcaster |
| `web/with-react-nextjs/custom-combined-auth/` | All auth methods combined |

### Web - Signing Libraries
| Directory | Library | Package |
|-----------|---------|---------|
| `web/with-react-nextjs/signer-viem-v2/` | Viem 2.x | `@getpara/viem-v2-integration` |
| `web/with-react-nextjs/signer-ethers-v5/` | Ethers 5.x | `@getpara/ethers-v5-integration` |
| `web/with-react-nextjs/signer-ethers-v6/` | Ethers 6.x | `@getpara/ethers-v6-integration` |
| `web/with-react-nextjs/signer-solana-web3/` | Solana Web3.js | `@getpara/solana-web3.js-v1-integration` |
| `web/with-react-nextjs/signer-solana-anchor/` | Anchor | `@getpara/solana-web3.js-v1-integration` |
| `web/with-react-nextjs/signer-solana-signers-v2/` | Solana Signers v2 | `@getpara/solana-signers-v2-integration` |
| `web/with-react-nextjs/signer-cosmjs/` | CosmJS | `@getpara/react-sdk` (uses `useCosmjsProtoSigner` from `/cosmos`) |

### Web - Connectors
| Directory | Connector | Package |
|-----------|-----------|---------|
| `web/with-react-nextjs/connector-wagmi/` | Wagmi v2 | `@getpara/wagmi-v2-integration` + `@getpara/react-sdk-lite` |
| `web/with-react-nextjs/connector-rainbowkit/` | RainbowKit | `@getpara/rainbowkit-wallet` |
| `web/with-react-nextjs/connector-graz/` | Graz (Cosmos) | `@getpara/graz-integration` |
| `web/with-react-nextjs/connector-reown-appkit/` | Reown AppKit | `@getpara/wagmi-v2-integration` |

### Web - Account Abstraction
| Directory | Provider | Standard |
|-----------|----------|----------|
| `web/with-react-nextjs/aa-alchemy-4337/` | Alchemy | ERC-4337 |
| `web/with-react-nextjs/aa-alchemy-7702/` | Alchemy | EIP-7702 |
| `web/with-react-nextjs/aa-zerodev-4337/` | ZeroDev | ERC-4337 |
| `web/with-react-nextjs/aa-zerodev-7702/` | ZeroDev | EIP-7702 |
| `web/with-react-nextjs/aa-gelato-4337/` | Gelato | ERC-4337 |
| `web/with-react-nextjs/aa-gelato-7702/` | Gelato | EIP-7702 |
| `web/with-react-nextjs/aa-thirdweb-4337/` | Thirdweb | ERC-4337 |
| `web/with-react-nextjs/aa-rhinestone-4337/` | Rhinestone | ERC-4337 |
| `web/with-react-nextjs/aa-porto-7702/` | Porto | EIP-7702 |

### Web - Modal Variants
| Directory | Chain Focus |
|-----------|------------|
| `web/with-react-nextjs/para-modal/` | Default (all chains) |
| `web/with-react-nextjs/para-modal-evm/` | EVM only |
| `web/with-react-nextjs/para-modal-solana/` | Solana only |
| `web/with-react-nextjs/para-modal-cosmos/` | Cosmos only |
| `web/with-react-nextjs/para-modal-multichain/` | Explicit multi-chain |
| `web/with-react-nextjs/para-pregen-claim/` | Pre-generated wallet claiming |

### Server
| Directory | Runtime | Key Features |
|-----------|---------|-------------|
| `server/with-node/` | Node.js | Pregen wallets, Viem/Ethers/Solana/CosmJS signing, Alchemy AA, ZeroDev AA |
| `server/with-bun/` | Bun | Session-based signing, Alchemy/ZeroDev EIP-7702 |
| `server/with-deno/` | Deno | Session-based signing, Alchemy/ZeroDev EIP-7702 |
| `server/rest-with-node/` | Node.js | REST API direct usage (no SDK, raw fetch) |

### Mobile
| Directory | Platform | Key Features |
|-----------|----------|-------------|
| `mobile/with-react-native/` | React Native | Standard RN setup |
| `mobile/with-expo-one-click-login/` | Expo | One-click login, passkeys, native crypto polyfills |

### Advanced Patterns
| Directory | Pattern |
|-----------|---------|
| `advanced-patterns/client-auth-server-sign/` | Client authenticates, exports session, server signs |
| `advanced-patterns/with-bulk-pregen/` | Bulk wallet pre-generation with multi-chain claiming UI |

### DeFi Integrations
| Directory | Integration |
|-----------|------------|
| `defi-integrations/with-jupiter-dex-api/` | Jupiter DEX (Solana) |
| `defi-integrations/with-squid-router-api/` | Squid cross-chain router |
| `defi-integrations/with-relay-bridge-api/` | Relay Protocol bridge |

---

## Docs

- [Agentic Development](https://docs.getpara.com/v3/cli/agentic-development.md): Use the Para CLI with Claude, Codex, and other coding agents
- [Command Reference](https://docs.getpara.com/v3/cli/commands.md): Complete reference for all Para CLI commands
- [Installation & Setup](https://docs.getpara.com/v3/cli/installation.md): Install the Para CLI and authenticate with your developer account
- [Para CLI](https://docs.getpara.com/v3/cli/overview.md): Manage API keys, organizations, projects, and configuration from your terminal
- [How Para Works](https://docs.getpara.com/v3/concepts/architecture.md): Para provides non-custodial embedded wallet infrastructure: secure key management, cross-app portability, and policy-based access control
- [Audits & Compliance](https://docs.getpara.com/v3/concepts/compliance.md): Para's audit history, compliance posture, and regulatory classification for security and compliance teams
- [Key Management](https://docs.getpara.com/v3/concepts/key-management.md): How Para's 2-of-2 MPC system protects private keys across generation, signing, and recovery
- [Permissions Reference](https://docs.getpara.com/v3/concepts/permissions-reference.md): Complete schema reference for Para's permissions policy system: permission types, conditions, comparators, and examples
- [Permissions & Access Control](https://docs.getpara.com/v3/concepts/permissions.md): Control exactly what each application can do with a user's wallet: scoped, transparent, and enforced server-side
- [Security Advisories](https://docs.getpara.com/v3/concepts/security-advisories.md): How Para responds to broad ecosystem supply-chain incidents, with per-event investigation status and impact findings
- [Security](https://docs.getpara.com/v3/concepts/security.md): How Para protects user assets with non-custodial key management, phishing-resistant authentication, and server-side enforcement
- [Universal Wallets](https://docs.getpara.com/v3/concepts/universal-embedded-wallets.md): One wallet across your entire ecosystem. Users onboard once and use the same wallet in every connected application
- [Agent Skill](https://docs.getpara.com/v3/developer-tools/ai-tooling/agent-skill.md): Give your AI coding agent full context on Para — setup, CLI, SDKs, and integration patterns
- [Integrate Para Docs MCP with AI Tools](https://docs.getpara.com/v3/developer-tools/ai-tooling/mcp.md): Connect the Para Docs Mintlify MCP server to AI tools for direct documentation access and enhanced coding assistance
- [AI Tooling](https://docs.getpara.com/v3/developer-tools/ai-tooling/overview.md): Connect Para to AI assistants, code editors, and agentic workflows
- [Developer Tools](https://docs.getpara.com/v3/developer-tools/overview.md): CLI, AI integrations, and automation tools for building with Para
- [Flutter SDK API](https://docs.getpara.com/v3/flutter/api/sdk.md): Complete API reference for the Para Flutter SDK, including authentication, wallet management, and blockchain operations.
- [Mobile Examples](https://docs.getpara.com/v3/flutter/examples.md): Explore Para's mobile integration examples for Flutter
- [Account Abstraction](https://docs.getpara.com/v3/flutter/guides/account-abstraction.md): Gasless and batched EVM transactions on Flutter using Alchemy smart accounts backed by Para
- [Cosmos Integration](https://docs.getpara.com/v3/flutter/guides/cosmos.md): Sign transactions for Cosmos chains using Para's unified wallet architecture
- [EVM Integration](https://docs.getpara.com/v3/flutter/guides/evm.md): Transfer ETH and interact with EVM chains using Para's unified wallet architecture
- [External Wallets](https://docs.getpara.com/v3/flutter/guides/external-wallets.md): Connect and authenticate users with external wallets like MetaMask and Phantom in Flutter.
- [Wallet Pregeneration](https://docs.getpara.com/v3/flutter/guides/pregen.md): Create and manage pregenerated wallets for users in Flutter applications
- [Flutter Session Management](https://docs.getpara.com/v3/flutter/guides/sessions.md): Guide to managing authentication sessions in Para for Flutter applications
- [Social Login](https://docs.getpara.com/v3/flutter/guides/social-login.md): Hook Para social login into the unified Flutter auth flow
- [Solana Integration](https://docs.getpara.com/v3/flutter/guides/solana.md): Sign Solana transactions using Para's unified wallet architecture
- [Stellar Integration](https://docs.getpara.com/v3/flutter/guides/stellar.md): Create Stellar wallets and sign Stellar transactions with the Para Flutter SDK
- [Flutter SDK Overview](https://docs.getpara.com/v3/flutter/overview.md): Para Flutter SDK documentation for cross-platform wallet integration
- [Setup](https://docs.getpara.com/v3/flutter/setup.md): Step-by-step guide for integrating the Para Flutter SDK into your mobile application
- [Developer Portal Email Branding](https://docs.getpara.com/v3/flutter/setup/developer-portal-email-branding.md): Customize the appearance of Welcome and OTP emails with your brand.
- [Developer Portal Payment Integration](https://docs.getpara.com/v3/flutter/setup/developer-portal-payments.md): Configure payment providers and transaction features to enable crypto buying, selling, and wallet funding for your users. These settings control which options appear in your Para integration.
- [Developer Portal Security Settings](https://docs.getpara.com/v3/flutter/setup/developer-portal-security.md): Configure authentication methods, session management, and transaction permissions
- [Get Your API Key](https://docs.getpara.com/v3/flutter/setup/developer-portal-setup.md): Get your API key and configure your Para integration through the developer portal.
- [Flutter Troubleshooting Guide](https://docs.getpara.com/v3/flutter/troubleshooting.md): Common issues and solutions when integrating Para with Flutter applications
- [Account Abstraction](https://docs.getpara.com/v3/general/account-abstraction.md): Explore account abstraction integration options with Para across different platforms
- [Go Live Checklist](https://docs.getpara.com/v3/general/checklist.md): A checklist to help you go live with the Para SDK.
- [Set up Custom OIDC](https://docs.getpara.com/v3/general/developer-portal-custom-oidc.md): Add your own OpenID Connect provider as a Para login method — configure it from the Developer Portal or the Para CLI.
- [Developer Portal Email Branding](https://docs.getpara.com/v3/general/developer-portal-email-branding.md): Customize the appearance of Welcome and OTP emails with your brand.
- [Developer Portal Payment Integration](https://docs.getpara.com/v3/general/developer-portal-payments.md): Configure payment providers and transaction features to enable crypto buying, selling, and wallet funding for your users. These settings control which options appear in your Para integration.
- [Developer Portal Security Settings](https://docs.getpara.com/v3/general/developer-portal-security.md): Configure authentication methods, session management, and transaction permissions
- [Get Your API Key](https://docs.getpara.com/v3/general/developer-portal-setup.md): Get your API key and configure your Para integration through the developer portal.
- [Glossary](https://docs.getpara.com/v3/general/glossary.md): Glossary of key terms.
- [iOS App Store Submission](https://docs.getpara.com/v3/general/ios-app-store-submission.md): A friendly checklist to get your Para-powered iOS app through App Review without surprises.
- [Login Two-Factor Authentication (MFA)](https://docs.getpara.com/v3/general/login-mfa.md): Require a TOTP second factor at sign-in. Integrate it with the Para React hooks or your own fully custom UI.
- [Migrating from Capsule to Para](https://docs.getpara.com/v3/general/migration-from-capsule.md): Guide for migrating from @usecapsule/* packages to @getpara/* packages
- [Wallet Pregeneration](https://docs.getpara.com/v3/general/pregen.md): Overview of generating pregenerated wallets for Para
- [Deploy Para Integration to Production](https://docs.getpara.com/v3/general/production-deployment.md): Transition your Para integration from development to production with updated configurations and security settings
- [Check Para System Status](https://docs.getpara.com/v3/general/system-status.md): Use Para Status to review beta and production platform availability before and after launch.
- [Telegram Bots & Mini-Apps](https://docs.getpara.com/v3/general/telegram.md): A user-friendly guide to quickly integrate Telegram Apps
- [Troubleshooting](https://docs.getpara.com/v3/general/troubleshooting.md): Something not working quite right? This is the section for you!
- [User Data Management](https://docs.getpara.com/v3/general/user-data.md): A comprehensive guide to managing user data when integrating Para into your application
- [Webhooks](https://docs.getpara.com/v3/general/webhooks.md): Receive real-time notifications when events occur in your Para integration
- [Build Custom UI](https://docs.getpara.com/v3/introduction/build-custom-ui.md): Follow this path when your app owns the auth and wallet screens while Para handles authentication state, wallets, sessions, and signing.
- [Chain Support](https://docs.getpara.com/v3/introduction/chain-support.md): Build on any supported chain.
- [Changelog](https://docs.getpara.com/v3/introduction/changelog.md): Release notes and version history for Para Web SDK
- [Examples Hub](https://docs.getpara.com/v3/introduction/examples.md): Explore Para's examples hub for integration patterns across web, mobile, and specific use cases
- [Framework Support](https://docs.getpara.com/v3/introduction/framework-support.md): Supported Features Across Para's Frameworks
- [Migrating from Reown to Para](https://docs.getpara.com/v3/introduction/migration-from-reown.md): Step-by-step guide for migrating your Reown (WalletConnect) application to Para SDK
- [Migrating from Thirdweb to Para](https://docs.getpara.com/v3/introduction/migration-from-thirdweb.md): Step-by-step guide for migrating your Thirdweb application to Para SDK
- [Migrating from Web3Modal to Para](https://docs.getpara.com/v3/introduction/migration-from-walletconnect.md): Step-by-step guide for migrating your Web3Modal (WalletConnect) application to Para SDK
- [Migrating from Para v1.x to v2.0](https://docs.getpara.com/v3/introduction/migration-to-alpha.md): Guide for migrating from Para version 1.x to Para's version 2.0 release
- [Migrate to Para](https://docs.getpara.com/v3/introduction/migration-to-para.md): Already have some users in another auth or wallet system? Para makes it easy to migrate!
- [Migrating from Para v2.x to v3.0](https://docs.getpara.com/v3/introduction/migration-to-v3.md): Guide for migrating theme configuration and portal URL consumers from Para v2.x to v3.0
- [Use Para from Your Backend](https://docs.getpara.com/v3/introduction/use-para-api.md): Follow this path when your backend owns auth, wallet provisioning, automation, or signing with Para APIs and server-side tools.
- [Use Para Modal](https://docs.getpara.com/v3/introduction/use-para-ui.md): Follow this path when your React web app uses Para's prebuilt modal for authentication, embedded wallets, and signing.
- [Welcome](https://docs.getpara.com/v3/introduction/welcome.md): Para is the most comprehensive wallet and authentication suite for crypto and fintech developers.
- [What's New in v3.0](https://docs.getpara.com/v3/introduction/whats-new.md): Overview of new features and improvements in Para v3.0
- [React Native & Expo SDK](https://docs.getpara.com/v3/react-native/api/sdk.md): Documentation for the Para SDK in React Native and Expo applications
- [Passkey Error Codes](https://docs.getpara.com/v3/react-native/error-codes.md): Reference for structured passkey error codes in the React Native and Expo SDKs
- [Mobile Examples](https://docs.getpara.com/v3/react-native/examples.md): Explore Para's mobile integration examples for React Native and Expo
- [Account Abstraction](https://docs.getpara.com/v3/react-native/guides/account-abstraction.md): Implement ERC-4337 and EIP-7702 Account Abstraction in React Native with Para
- [Email & Phone Authentication](https://docs.getpara.com/v3/react-native/guides/add-email-phone.md): Authenticate users with email or phone in React Native and Expo using Para's SDK
- [Add Native Passkeys](https://docs.getpara.com/v3/react-native/guides/add-passkeys.md): Add native passkey authentication to your React Native or Expo app for enhanced security
- [Add Password or PIN](https://docs.getpara.com/v3/react-native/guides/add-password-pin.md): Add password or PIN authentication to your React Native or Expo app
- [Social Login](https://docs.getpara.com/v3/react-native/guides/add-social-login.md): Authenticate users with OAuth providers like Google, Apple, and Discord in React Native and Expo
- [Cosmos Support](https://docs.getpara.com/v3/react-native/guides/cosmos.md): Using Cosmos libraries like CosmJS in React Native with Para's SDK
- [Custom Storage with MMKV](https://docs.getpara.com/v3/react-native/guides/custom-storage.md): Configure Para client to use MMKV storage in React Native applications
- [EVM Support](https://docs.getpara.com/v3/react-native/guides/evm.md): Using EVM libraries like Ethers.js and Viem in React Native with Para's SDK
- [Export Private Key](https://docs.getpara.com/v3/react-native/guides/export-private-key.md): Allow your users to export the private key for their wallets.
- [Guest Mode](https://docs.getpara.com/v3/react-native/guides/guest-mode.md): Allow users to use your app via guest wallets without signing up.
- [ParaProvider](https://docs.getpara.com/v3/react-native/guides/hooks/para-provider.md): React Native context provider for Para SDK integration
- [useAccount](https://docs.getpara.com/v3/react-native/guides/hooks/use-account.md): Hook for retrieving the current user's account and connection status
- [useAuthenticateWithEmailOrPhone](https://docs.getpara.com/v3/react-native/guides/hooks/use-authenticate-with-email-or-phone.md): Hook that handles the full email or phone authentication flow in one call
- [useAuthenticateWithOAuth](https://docs.getpara.com/v3/react-native/guides/hooks/use-authenticate-with-o-auth.md): Hook that handles the full OAuth authentication flow in one call
- [useClaimPregenWallets](https://docs.getpara.com/v3/react-native/guides/hooks/use-claim-pregen-wallets.md): Hook for claiming pregenerated wallets after a user signs up
- [useClient](https://docs.getpara.com/v3/react-native/guides/hooks/use-client.md): Hook for accessing the Para client instance
- [useCreateGuestWallets](https://docs.getpara.com/v3/react-native/guides/hooks/use-create-guest-wallets.md): Hook for creating wallets for unauthenticated guest users
- [useCreatePregenWalletPerType](https://docs.getpara.com/v3/react-native/guides/hooks/use-create-pregen-wallet-per-type.md): Hook for creating pregenerated wallets for multiple chain types
- [useCreatePregenWallet](https://docs.getpara.com/v3/react-native/guides/hooks/use-create-pregen-wallet.md): Hook for creating a pregenerated wallet for a user before they sign up
- [useCreateWalletPerType](https://docs.getpara.com/v3/react-native/guides/hooks/use-create-wallet-per-type.md): Hook for creating wallets for multiple chain types at once
- [useCreateWallet](https://docs.getpara.com/v3/react-native/guides/hooks/use-create-wallet.md): Hook for creating a new wallet
- [useEnable2fa](https://docs.getpara.com/v3/react-native/guides/hooks/use-enable-2fa.md): Hook for enabling two-factor authentication with a verification code
- [useExportPrivateKey](https://docs.getpara.com/v3/react-native/guides/hooks/use-export-private-key.md): Hook for exporting a wallet's private key via the Para portal
- [useHasPregenWallet](https://docs.getpara.com/v3/react-native/guides/hooks/use-has-pregen-wallet.md): Hook for checking whether a pregenerated wallet exists for a given ID
- [useIsFullyLoggedIn](https://docs.getpara.com/v3/react-native/guides/hooks/use-is-fully-logged-in.md): Hook for checking whether the user is fully authenticated
- [useIssueJwt](https://docs.getpara.com/v3/react-native/guides/hooks/use-issue-jwt.md): Hook for issuing a JWT token for backend authentication
- [useKeepSessionAlive](https://docs.getpara.com/v3/react-native/guides/hooks/use-keep-session-alive.md): Hook for extending the current session to prevent automatic logout
- [useLoginExternalWallet](https://docs.getpara.com/v3/react-native/guides/hooks/use-login-external-wallet.md): Hook for initiating login with an external wallet via SIWE
- [useLogout](https://docs.getpara.com/v3/react-native/guides/hooks/use-logout.md): Hook for logging out the current user
- [useParaCosmjsSignAndBroadcast](https://docs.getpara.com/v3/react-native/guides/hooks/use-para-cosmjs-sign-and-broadcast.md): Mutation hook for signing and broadcasting Cosmos transactions
- [useParaEthersSendTransaction](https://docs.getpara.com/v3/react-native/guides/hooks/use-para-ethers-send-transaction.md): Mutation hook for sending transactions via an ethers signer
- [useParaEthersSignMessage](https://docs.getpara.com/v3/react-native/guides/hooks/use-para-ethers-sign-message.md): Mutation hook for signing messages via an ethers signer
- [useParaSolanaSignAndSend](https://docs.getpara.com/v3/react-native/guides/hooks/use-para-solana-sign-and-send.md): Mutation hook for signing and sending Solana transactions
- [useParaStatus](https://docs.getpara.com/v3/react-native/guides/hooks/use-para-status.md): Hook for retrieving the initialization status of the Para client
- [useParaStellarSignTransaction](https://docs.getpara.com/v3/react-native/guides/hooks/use-para-stellar-sign-transaction.md): Mutation hook for signing Stellar transactions
- [useParaViemSendTransaction](https://docs.getpara.com/v3/react-native/guides/hooks/use-para-viem-send-transaction.md): Mutation hook for sending transactions via a Viem WalletClient
- [useParaViemSignMessage](https://docs.getpara.com/v3/react-native/guides/hooks/use-para-viem-sign-message.md): Mutation hook for signing messages via a Viem WalletClient
- [useParaViemSignTransaction](https://docs.getpara.com/v3/react-native/guides/hooks/use-para-viem-sign-transaction.md): Mutation hook for signing transactions without broadcasting via a Viem WalletClient
- [useParaViemSignTypedData](https://docs.getpara.com/v3/react-native/guides/hooks/use-para-viem-sign-typed-data.md): Mutation hook for signing EIP-712 typed data via a Viem WalletClient
- [useParaViemWriteContract](https://docs.getpara.com/v3/react-native/guides/hooks/use-para-viem-write-contract.md): Mutation hook for calling contract functions via a Viem WalletClient
- [useResendVerificationCode](https://docs.getpara.com/v3/react-native/guides/hooks/use-resend-verification-code.md): Hook for resending a verification code
- [useSetup2fa](https://docs.getpara.com/v3/react-native/guides/hooks/use-setup-2fa.md): Hook for setting up two-factor authentication
- [useSignMessage](https://docs.getpara.com/v3/react-native/guides/hooks/use-sign-message.md): Hook for signing a message with a wallet
- [useSignTransaction](https://docs.getpara.com/v3/react-native/guides/hooks/use-sign-transaction.md): Hook for signing a transaction with a wallet
- [useSignUpOrLogIn](https://docs.getpara.com/v3/react-native/guides/hooks/use-sign-up-or-log-in.md): Hook for initiating signup or login with email or phone
- [useUpdatePregenWalletIdentifier](https://docs.getpara.com/v3/react-native/guides/hooks/use-update-pregen-wallet-identifier.md): Hook for updating the identifier associated with a pregenerated wallet
- [useVerify2fa](https://docs.getpara.com/v3/react-native/guides/hooks/use-verify-2fa.md): Hook for verifying a two-factor authentication code at login
- [useVerifyExternalWallet](https://docs.getpara.com/v3/react-native/guides/hooks/use-verify-external-wallet.md): Hook for verifying an external wallet login
- [useVerifyFarcaster](https://docs.getpara.com/v3/react-native/guides/hooks/use-verify-farcaster.md): Hook for verifying Farcaster authentication
- [useVerifyNewAccount](https://docs.getpara.com/v3/react-native/guides/hooks/use-verify-new-account.md): Hook for verifying a new account with a verification code
- [useVerifyOAuth](https://docs.getpara.com/v3/react-native/guides/hooks/use-verify-o-auth.md): Hook for verifying OAuth authentication
- [useVerifyTelegram](https://docs.getpara.com/v3/react-native/guides/hooks/use-verify-telegram.md): Hook for verifying Telegram authentication
- [useWaitForLogin](https://docs.getpara.com/v3/react-native/guides/hooks/use-wait-for-login.md): Hook that polls until a login flow is complete
- [useWaitForSignup](https://docs.getpara.com/v3/react-native/guides/hooks/use-wait-for-signup.md): Hook that polls until a signup flow is complete
- [useWaitForWalletCreation](https://docs.getpara.com/v3/react-native/guides/hooks/use-wait-for-wallet-creation.md): Hook that polls until wallet creation is complete
- [useWallet](https://docs.getpara.com/v3/react-native/guides/hooks/use-wallet.md): Hook for retrieving the currently selected wallet
- [Permissions](https://docs.getpara.com/v3/react-native/guides/permissions.md): Handle transaction approval flows in React Native apps
- [Wallet Pregeneration](https://docs.getpara.com/v3/react-native/guides/pregen.md): Create and manage pregenerated wallets for users in React Native and Expo applications
- [JWT Token Management](https://docs.getpara.com/v3/react-native/guides/sessions-jwt.md): Issuing and verifying JWT tokens for Para session attestation
- [React Native Session Management](https://docs.getpara.com/v3/react-native/guides/sessions.md): Guide to managing authentication sessions in Para for React Native applications
- [Solana Support in React Native](https://docs.getpara.com/v3/react-native/guides/solana.md): Using Para with Solana Web3.js and Anchor in React Native applications
- [Claim Staking Rewards](https://docs.getpara.com/v3/react-native/guides/web3-operations/cosmos/claim-rewards.md): Claim accumulated staking rewards from delegated validators
- [Configure RPC Nodes with Cosmos Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/cosmos/configure-rpc.md): Set up and configure Cosmos RPC endpoints and clients using CosmJS
- [Execute Transactions with Cosmos Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/cosmos/execute-transactions.md): Interact with Cosmos modules and execute complex transactions using CosmJS
- [Sponsor Gas Fees on Cosmos](https://docs.getpara.com/v3/react-native/guides/web3-operations/cosmos/gas-sponsorship.md): Learn how to implement gas sponsorship on Cosmos networks using fee grants with Para
- [IBC Cross-Chain Transfers](https://docs.getpara.com/v3/react-native/guides/web3-operations/cosmos/ibc-transfers.md): Transfer tokens between Cosmos chains using Inter-Blockchain Communication
- [Query Wallet Balances with Cosmos Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/cosmos/query-balances.md): Check account balances and token holdings using CosmJS with Para wallets
- [Query Validator Information](https://docs.getpara.com/v3/react-native/guides/web3-operations/cosmos/query-validators.md): Get validator details, commission rates, and staking APY
- [Send Tokens with Cosmos Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/cosmos/send-tokens.md): Transfer native tokens and execute IBC transfers using CosmJS with Para wallets
- [Setup Cosmos Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/cosmos/setup-libraries.md): Install and configure CosmJS for use with Para SDK on Cosmos chains
- [Sign Messages with Cosmos Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/cosmos/sign-messages.md): Sign direct and amino messages using CosmJS with Para wallets
- [Stake Tokens to Validators](https://docs.getpara.com/v3/react-native/guides/web3-operations/cosmos/stake-tokens.md): Delegate tokens to Cosmos validators for staking rewards
- [Verify Signatures with Cosmos Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/cosmos/verify-signatures.md): Verify message and transaction signatures using CosmJS
- [Account Abstraction Integrations](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/account-abstraction.md): Set up smart accounts with Para's unified SDK interface across all supported AA providers on React Native
- [Configure RPC Endpoints](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/configure-rpc.md): Set up custom RPC endpoints and chains with Web3 libraries on React Native
- [Estimate Gas for Transactions](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/estimate-gas.md): Calculate gas costs for transactions including EIP-1559 gas pricing on React Native
- [Execute Transactions](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/execute-transactions.md): Execute arbitrary transactions with lifecycle management using Web3 libraries on React Native
- [Fund Testnet Wallet](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/fund-testnet-wallet.md): Request testnet tokens for a Para wallet using the built-in faucet on React Native
- [Get Transaction Receipt](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/get-transaction-receipt.md): Check transaction status, confirmations, and retrieve receipt details on React Native
- [Interact with Contracts](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/interact-with-contracts.md): Read and write smart contract data and handle events using Web3 libraries on React Native
- [Manage Token Allowances](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/manage-allowances.md): Approve tokens, check allowances, and implement permit signatures on React Native
- [Query Wallet Balances](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/query-balances.md): Check ETH and ERC-20 token balances using Web3 libraries with Para on React Native
- [Send Tokens](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/send-tokens.md): Transfer ETH and ERC-20 tokens using Web3 libraries with Para on React Native
- [Setup Web3 Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/setup-libraries.md): Configure Ethers.js, Viem, or Wagmi to work with Para's secure wallet infrastructure
- [Sign Messages](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/sign-messages.md): Sign plain text messages for authentication or verification with Web3 libraries on React Native
- [Sign Typed Data (EIP-712)](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/sign-typed-data.md): Sign structured data using the EIP-712 standard for improved security and UX on React Native
- [Verify Signatures with EVM Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/verify-signatures.md): Verify message and transaction signatures using Ethers or Viem on React Native
- [Watch Contract Events](https://docs.getpara.com/v3/react-native/guides/web3-operations/evm/watch-events.md): Listen to smart contract events and parse event logs in real-time on React Native
- [Get Wallet Data](https://docs.getpara.com/v3/react-native/guides/web3-operations/get-wallet-address.md): Access wallet addresses and information using Para React Native hooks
- [Sign Messages with Para](https://docs.getpara.com/v3/react-native/guides/web3-operations/sign-with-para.md): Learn how to sign a \"Hello, Para!\" message using the Para React Native SDK
- [Set Compute Units and Priority Fees](https://docs.getpara.com/v3/react-native/guides/web3-operations/solana/compute-units.md): Configure compute budget and priority fees for Solana transactions
- [Configure RPC Endpoints with Solana Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/solana/configure-rpc.md): Set up and configure Solana RPC endpoints and connections using Web3.js or Anchor
- [Execute Transactions with Solana Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/solana/execute-transactions.md): Interact with Solana programs and execute complex transactions using Web3.js or Anchor
- [Get Solana Transaction Status](https://docs.getpara.com/v3/react-native/guides/web3-operations/solana/get-transaction-status.md): Check transaction confirmation status and finality on Solana
- [Interact with Solana Programs](https://docs.getpara.com/v3/react-native/guides/web3-operations/solana/interact-with-programs.md): Call program instructions and work with Anchor IDLs using Para
- [Manage SPL Token Accounts](https://docs.getpara.com/v3/react-native/guides/web3-operations/solana/manage-token-accounts.md): Create, close, and manage SPL token accounts on Solana
- [Query Wallet Balances with Solana Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/solana/query-balances.md): Check SOL and SPL token balances using Solana Web3.js or Anchor with Para wallets
- [Send Tokens with Solana Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/solana/send-tokens.md): Transfer SOL tokens using Solana Web3.js or Anchor with Para wallets
- [Setup Solana Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/solana/setup-libraries.md): Install and configure Solana libraries for use with Para SDK
- [Sign Messages with Solana Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/solana/sign-messages.md): Sign text and binary messages using Solana Web3.js or Anchor with Para
- [Verify Signatures with Solana Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/solana/verify-signatures.md): Verify message and transaction signatures using Solana Web3.js or Anchor
- [Configure Horizon Endpoints with Stellar Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/stellar/configure-rpc.md): Set up and configure Stellar Horizon API endpoints for different networks in React Native
- [Execute Transactions with Stellar Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/stellar/execute-transactions.md): Build and sign complex Stellar transactions including multi-op, fee bumps, and Soroban auth in React Native
- [Query Wallet Balances with Stellar Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/stellar/query-balances.md): Check XLM and token balances using the Stellar SDK with Para wallets in React Native
- [Send Tokens with Stellar Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/stellar/send-tokens.md): Transfer XLM using the Stellar SDK with Para wallets in React Native
- [Setup Stellar Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/stellar/setup-libraries.md): Install and configure the Stellar SDK for use with Para SDK in React Native
- [Sign Messages with Stellar Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/stellar/sign-messages.md): Sign arbitrary bytes for verification using the Stellar SDK with Para in React Native
- [Verify Signatures with Stellar Libraries](https://docs.getpara.com/v3/react-native/guides/web3-operations/stellar/verify-signatures.md): Verify Ed25519 signatures from Stellar addresses in React Native
- [Overview](https://docs.getpara.com/v3/react-native/overview.md): An introduction to mobile integrations with Para
- [React Native Quickstart](https://docs.getpara.com/v3/react-native/quickstart.md): Get started with Para's React Native SDK in minutes
- [Developer Portal Email Branding](https://docs.getpara.com/v3/react-native/setup/developer-portal-email-branding.md): Customize the appearance of Welcome and OTP emails with your brand.
- [Developer Portal Payment Integration](https://docs.getpara.com/v3/react-native/setup/developer-portal-payments.md): Configure payment providers and transaction features to enable crypto buying, selling, and wallet funding for your users. These settings control which options appear in your Para integration.
- [Developer Portal Security Settings](https://docs.getpara.com/v3/react-native/setup/developer-portal-security.md): Configure authentication methods, session management, and transaction permissions
- [Get Your API Key](https://docs.getpara.com/v3/react-native/setup/developer-portal-setup.md): Get your API key and configure your Para integration through the developer portal.
- [Expo](https://docs.getpara.com/v3/react-native/setup/expo.md): Set up the Para SDK in an Expo project.
- [Bare Workflow](https://docs.getpara.com/v3/react-native/setup/react-native.md): Set up the Para SDK in a React Native bare workflow project.
- [React Native and Expo Troubleshooting](https://docs.getpara.com/v3/react-native/troubleshooting.md): Resolving integration issues for Para in React Native and Expo environments
- [Web Examples](https://docs.getpara.com/v3/react/examples.md): Explore Para's web integration examples across popular frameworks
- [Custom Auth UI with React Hooks](https://docs.getpara.com/v3/react/guides/custom-ui-simplified.md): Build custom authentication UI with Para's simplified React hooks that handle the entire auth flow in a single call
- [Custom Auth UI with Web SDK](https://docs.getpara.com/v3/react/guides/custom-ui-web-sdk.md): Build custom authentication UI using the Para Web SDK directly — works with vanilla JS, Vue, Svelte, or any framework
- [Configure Balance Display](https://docs.getpara.com/v3/react/guides/customization/balances.md): Learn how to configure and display balances in the Para Modal, including Aggregated and Custom Asset modes, and use the useProfileBalance hook for programmatic access.
- [How Configuration Works](https://docs.getpara.com/v3/react/guides/customization/configuration.md): Where Para reads configuration from — the partner record, SDK overrides, and deprecated modal props — and how they layer.
- [Configure Authentication](https://docs.getpara.com/v3/react/guides/customization/developer-portal-authentication.md): Configure how users sign in — login methods, OAuth providers, external wallets, 2FA, and guest mode — from the Developer Portal Authentication screen.
- [Developer Portal Email Branding](https://docs.getpara.com/v3/react/guides/customization/developer-portal-email-branding.md): Customize the appearance of Welcome and OTP emails with your brand.
- [Developer Portal Payment Integration](https://docs.getpara.com/v3/react/guides/customization/developer-portal-payments.md): Configure payment providers and transaction features to enable crypto buying, selling, and wallet funding for your users. These settings control which options appear in your Para integration.
- [Developer Portal Security Settings](https://docs.getpara.com/v3/react/guides/customization/developer-portal-security.md): Configure authentication methods, session management, and transaction permissions
- [Get Your API Key](https://docs.getpara.com/v3/react/guides/customization/developer-portal-setup.md): Get your API key and configure your Para integration through the developer portal.
- [Export Private Key](https://docs.getpara.com/v3/react/guides/customization/export-private-key.md): You can allow your users to export the private key for their wallets if they choose, letting them take custody over their assets..
- [Guest Mode](https://docs.getpara.com/v3/react/guides/customization/guest-mode.md): Allow users to use your app via guest wallets without signing up.
- [Configure Authentication](https://docs.getpara.com/v3/react/guides/customization/modal-authentication.md): Configure OAuth providers, email/phone login, authentication layout, and guest mode for the Para Modal.
- [Handle Modal Events](https://docs.getpara.com/v3/react/guides/customization/modal-events.md): Handle modal events, callbacks, and configure advanced modal behavior options.
- [Configure Security](https://docs.getpara.com/v3/react/guides/customization/modal-security.md): Configure two-factor authentication, recovery secrets, and modal step controls for the Para Modal.
- [Style the Modal](https://docs.getpara.com/v3/react/guides/customization/modal-theming.md): Customize the appearance of the Para Modal with colors, fonts, and CSS overrides.
- [Customization Basics](https://docs.getpara.com/v3/react/guides/customization/modal.md): Learn how to customize the appearance and behavior of the Para Modal to match your application's design.
- [Overview](https://docs.getpara.com/v3/react/guides/customization/overview.md): Learn how to customize Para to match your brand and user needs.
- [Connect Cosmos Wallets](https://docs.getpara.com/v3/react/guides/external-wallets/cosmos.md): Learn how to combine the Para Modal with Cosmos wallets.
- [Connect EVM Wallets](https://docs.getpara.com/v3/react/guides/external-wallets/evm.md): Learn how to combine the Para Modal with EVM wallets.
- [Connect Multichain Wallets](https://docs.getpara.com/v3/react/guides/external-wallets/multichain.md): Learn how to combine EVM, Solana, and Cosmos wallets with the Para Modal.
- [Connect Solana Wallets](https://docs.getpara.com/v3/react/guides/external-wallets/solana.md): Learn how to combine the Para Modal with Solana wallets.
- [React Hooks](https://docs.getpara.com/v3/react/guides/hooks.md): State management and SDK interactions using Para's React hooks
- [ParaProvider](https://docs.getpara.com/v3/react/guides/hooks/para-provider.md): React context provider for Para SDK integration
- [useAccount](https://docs.getpara.com/v3/react/guides/hooks/use-account.md): Hook for retrieving the current embedded account and connected external wallets
- [useAddAuthMethod](https://docs.getpara.com/v3/react/guides/hooks/use-add-auth-method.md): React hook for adding a passkey, password, or PIN to an existing user account
- [useClient](https://docs.getpara.com/v3/react/guides/hooks/use-client.md): Hook for accessing the Para client instance
- [useCreateWallet](https://docs.getpara.com/v3/react/guides/hooks/use-create-wallet.md): Hook for creating new wallets for the authenticated user
- [useIssueJwt](https://docs.getpara.com/v3/react/guides/hooks/use-issue-jwt.md): Hook for issuing JWT tokens for session verification
- [useKeepSessionAlive](https://docs.getpara.com/v3/react/guides/hooks/use-keep-session-alive.md): Hook for maintaining active user sessions
- [useLogout](https://docs.getpara.com/v3/react/guides/hooks/use-logout.md): Hook for logging out the current user
- [useModal](https://docs.getpara.com/v3/react/guides/hooks/use-modal.md): Hook for controlling the Para modal
- [useParaCosmjsAminoSigner](https://docs.getpara.com/v3/react/guides/hooks/use-para-cosmjs-amino-signer.md): Hook for retrieving a CosmJS Amino signer for a Para wallet
- [useParaCosmjsProtoSigner](https://docs.getpara.com/v3/react/guides/hooks/use-para-cosmjs-proto-signer.md): Hook for retrieving a CosmJS Proto signer for a Para wallet
- [useParaCosmjsSignAndBroadcast](https://docs.getpara.com/v3/react/guides/hooks/use-para-cosmjs-sign-and-broadcast.md): Mutation hook for signing and broadcasting Cosmos transactions
- [useParaEthersSendTransaction](https://docs.getpara.com/v3/react/guides/hooks/use-para-ethers-send-transaction.md): Mutation hook for sending transactions via an ethers signer
- [useParaEthersSignMessage](https://docs.getpara.com/v3/react/guides/hooks/use-para-ethers-sign-message.md): Mutation hook for signing messages via an ethers signer
- [useParaEthersSigner](https://docs.getpara.com/v3/react/guides/hooks/use-para-ethers-signer.md): Hook for retrieving an ethers.js signer for a Para wallet
- [useParaSolanaSignAndSend](https://docs.getpara.com/v3/react/guides/hooks/use-para-solana-sign-and-send.md): Mutation hook for signing and sending Solana transactions
- [useParaSolanaSigner](https://docs.getpara.com/v3/react/guides/hooks/use-para-solana-signer.md): Hook for retrieving a Solana signer for a Para wallet
- [useParaStellarSignTransaction](https://docs.getpara.com/v3/react/guides/hooks/use-para-stellar-sign-transaction.md): Mutation hook for signing Stellar transactions
- [useParaStellarSigner](https://docs.getpara.com/v3/react/guides/hooks/use-para-stellar-signer.md): Hook for retrieving a Stellar signer for a Para wallet
- [useParaViemAccount](https://docs.getpara.com/v3/react/guides/hooks/use-para-viem-account.md): Hook for retrieving a Viem LocalAccount for a Para wallet
- [useParaViemClient](https://docs.getpara.com/v3/react/guides/hooks/use-para-viem-client.md): Hook for retrieving a Viem WalletClient for a Para wallet
- [useParaViemSendTransaction](https://docs.getpara.com/v3/react/guides/hooks/use-para-viem-send-transaction.md): Mutation hook for sending transactions via a Viem WalletClient
- [useParaViemSignMessage](https://docs.getpara.com/v3/react/guides/hooks/use-para-viem-sign-message.md): Mutation hook for signing messages via a Viem WalletClient
- [useParaViemSignTransaction](https://docs.getpara.com/v3/react/guides/hooks/use-para-viem-sign-transaction.md): Mutation hook for signing transactions without broadcasting via a Viem WalletClient
- [useParaViemSignTypedData](https://docs.getpara.com/v3/react/guides/hooks/use-para-viem-sign-typed-data.md): Mutation hook for signing EIP-712 typed data via a Viem WalletClient
- [useParaViemWriteContract](https://docs.getpara.com/v3/react/guides/hooks/use-para-viem-write-contract.md): Mutation hook for calling contract functions via a Viem WalletClient
- [useRequestFaucet](https://docs.getpara.com/v3/react/guides/hooks/use-request-faucet.md): Hook for requesting testnet tokens for a wallet
- [useSignMessage](https://docs.getpara.com/v3/react/guides/hooks/use-sign-message.md): Hook for signing messages with a wallet
- [useSignTransaction](https://docs.getpara.com/v3/react/guides/hooks/use-sign-transaction.md): Hook for signing blockchain transactions
- [useSignUpOrLogIn](https://docs.getpara.com/v3/react/guides/hooks/use-sign-up-or-login.md): Hook for initiating the authentication flow
- [useStellarSigner](https://docs.getpara.com/v3/react/guides/hooks/use-stellar-signer.md): Hook for retrieving a Stellar signer for a Para wallet
- [useVerifyNewAccount](https://docs.getpara.com/v3/react/guides/hooks/use-verify-new-account.md): Hook for verifying new accounts with verification codes
- [useWalletBalance](https://docs.getpara.com/v3/react/guides/hooks/use-wallet-balance.md): Hook for retrieving the balance of the selected wallet
- [useWalletState](https://docs.getpara.com/v3/react/guides/hooks/use-wallet-state.md): Hook for managing the currently selected wallet
- [useWallet](https://docs.getpara.com/v3/react/guides/hooks/use-wallet.md): Hook for retrieving the currently selected wallet
- [Migrating from Reown to Para](https://docs.getpara.com/v3/react/guides/migration-from-reown.md): Step-by-step guide for migrating your Reown (WalletConnect) application to Para SDK
- [Migrating from Thirdweb to Para](https://docs.getpara.com/v3/react/guides/migration-from-thirdweb.md): Step-by-step guide for migrating your Thirdweb application to Para SDK
- [Migrating from Web3Modal to Para](https://docs.getpara.com/v3/react/guides/migration-from-walletconnect.md): Step-by-step guide for migrating your Web3Modal (WalletConnect) application to Para SDK
- [Migration Guides](https://docs.getpara.com/v3/react/guides/migrations.md): Migrate your existing wallet integration to Para SDK
- [Permissions](https://docs.getpara.com/v3/react/guides/permissions.md): Configure user-facing transaction confirmation dialogs
- [Wallet Pregeneration](https://docs.getpara.com/v3/react/guides/pregen.md): Learn how to create and manage pregenerated wallets for users with Para's SDK
- [React SDK Lite](https://docs.getpara.com/v3/react/guides/react-sdk-lite.md): Use @getpara/react-sdk-lite for a lighter bundle when you only need specific chain support
- [Reown AppKit Integration](https://docs.getpara.com/v3/react/guides/reown-appkit.md): Integrate Para as the wallet provider in Reown AppKit
- [JWT Token Management](https://docs.getpara.com/v3/react/guides/sessions-jwt.md): Issuing and verifying JWT tokens for Para session attestation
- [Session Lifecycle](https://docs.getpara.com/v3/react/guides/sessions-lifecycle.md): Managing the lifecycle of authentication sessions in Para
- [Pregenerated Wallet Sessions](https://docs.getpara.com/v3/react/guides/sessions-pregen.md): Session management for Para pregenerated wallets
- [Session Transfer](https://docs.getpara.com/v3/react/guides/sessions-transfer.md): Exporting Para sessions for server-side operations
- [Web Session Management](https://docs.getpara.com/v3/react/guides/sessions.md): Overview of authentication session management in Para for web applications
- [Upgrade Auth Methods](https://docs.getpara.com/v3/react/guides/upgrade-auth-methods.md): Allow users to add a passkey, password, or PIN to their account for enhanced security
- [Wagmi Connector Integration](https://docs.getpara.com/v3/react/guides/wagmi-connector.md): Use Para as a Wagmi connector to build custom wallet connection interfaces
- [Claim Staking Rewards](https://docs.getpara.com/v3/react/guides/web3-operations/cosmos/claim-rewards.md): Claim accumulated staking rewards from delegated validators
- [Configure RPC Nodes with Cosmos Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/cosmos/configure-rpc.md): Set up and configure Cosmos RPC endpoints and clients using CosmJS
- [Execute Transactions with Cosmos Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/cosmos/execute-transactions.md): Interact with Cosmos modules and execute complex transactions using CosmJS
- [Sponsor Gas Fees on Cosmos](https://docs.getpara.com/v3/react/guides/web3-operations/cosmos/gas-sponsorship.md): Learn how to implement gas sponsorship on Cosmos networks using fee grants with Para
- [IBC Cross-Chain Transfers](https://docs.getpara.com/v3/react/guides/web3-operations/cosmos/ibc-transfers.md): Transfer tokens between Cosmos chains using Inter-Blockchain Communication
- [Query Wallet Balances with Cosmos Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/cosmos/query-balances.md): Check account balances and token holdings using CosmJS with Para wallets
- [Query Validator Information](https://docs.getpara.com/v3/react/guides/web3-operations/cosmos/query-validators.md): Get validator details, commission rates, and staking APY
- [Send Tokens with Cosmos Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/cosmos/send-tokens.md): Transfer native tokens and execute IBC transfers using CosmJS with Para wallets
- [Setup Cosmos Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/cosmos/setup-libraries.md): Install and configure CosmJS for use with Para SDK on Cosmos chains
- [Sign Messages with Cosmos Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/cosmos/sign-messages.md): Sign direct and amino messages using CosmJS with Para wallets
- [Stake Tokens to Validators](https://docs.getpara.com/v3/react/guides/web3-operations/cosmos/stake-tokens.md): Delegate tokens to Cosmos validators for staking rewards
- [Verify Signatures with Cosmos Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/cosmos/verify-signatures.md): Verify message and transaction signatures using CosmJS
- [Account Abstraction Integrations](https://docs.getpara.com/v3/react/guides/web3-operations/evm/account-abstraction.md): Set up smart accounts with Para's unified SDK interface across all supported AA providers
- [Configure RPC Endpoints](https://docs.getpara.com/v3/react/guides/web3-operations/evm/configure-rpc.md): Set up custom RPC endpoints and chains with Web3 libraries
- [Estimate Gas for Transactions](https://docs.getpara.com/v3/react/guides/web3-operations/evm/estimate-gas.md): Calculate gas costs for transactions including EIP-1559 gas pricing
- [Execute Transactions](https://docs.getpara.com/v3/react/guides/web3-operations/evm/execute-transactions.md): Execute arbitrary transactions with lifecycle management using Web3 libraries
- [Fund Testnet Wallet](https://docs.getpara.com/v3/react/guides/web3-operations/evm/fund-testnet-wallet.md): Request testnet tokens for a Para wallet using the built-in faucet
- [Get Transaction Receipt](https://docs.getpara.com/v3/react/guides/web3-operations/evm/get-transaction-receipt.md): Check transaction status, confirmations, and retrieve receipt details
- [Interact with Contracts](https://docs.getpara.com/v3/react/guides/web3-operations/evm/interact-with-contracts.md): Read and write smart contract data and handle events using Web3 libraries
- [Manage Token Allowances](https://docs.getpara.com/v3/react/guides/web3-operations/evm/manage-allowances.md): Approve tokens, check allowances, and implement permit signatures
- [Query Wallet Balances](https://docs.getpara.com/v3/react/guides/web3-operations/evm/query-balances.md): Check ETH and ERC-20 token balances using Web3 libraries with Para
- [Send Tokens](https://docs.getpara.com/v3/react/guides/web3-operations/evm/send-tokens.md): Transfer ETH and ERC-20 tokens using Web3 libraries with Para
- [Setup Web3 Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/evm/setup-libraries.md): Configure Ethers.js, Viem, or Wagmi to work with Para's secure wallet infrastructure
- [Sign Messages](https://docs.getpara.com/v3/react/guides/web3-operations/evm/sign-messages.md): Sign plain text messages for authentication or verification with Web3 libraries
- [Sign Typed Data (EIP-712)](https://docs.getpara.com/v3/react/guides/web3-operations/evm/sign-typed-data.md): Sign structured data using the EIP-712 standard for improved security and UX
- [Verify Signatures with EVM Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/evm/verify-signatures.md): Verify message and transaction signatures using Ethers, Viem, or Wagmi
- [Watch Contract Events](https://docs.getpara.com/v3/react/guides/web3-operations/evm/watch-events.md): Listen to smart contract events and parse event logs in real-time
- [Get Wallet Data](https://docs.getpara.com/v3/react/guides/web3-operations/get-wallet-address.md): Access wallet addresses and information using Para React hooks
- [Query Wallet Balance with Para](https://docs.getpara.com/v3/react/guides/web3-operations/query-wallet-balance.md): Get wallet balances directly using Para's built-in balance methods
- [Sign Messages with Para](https://docs.getpara.com/v3/react/guides/web3-operations/sign-with-para.md): Learn how to sign a \"Hello, Para!\" message using the Para SDK
- [Set Compute Units and Priority Fees](https://docs.getpara.com/v3/react/guides/web3-operations/solana/compute-units.md): Configure compute budget and priority fees for Solana transactions
- [Configure RPC Endpoints with Solana Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/solana/configure-rpc.md): Set up and configure Solana RPC endpoints and connections using Web3.js or Anchor
- [Execute Transactions with Solana Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/solana/execute-transactions.md): Interact with Solana programs and execute complex transactions using Web3.js or Anchor
- [Get Solana Transaction Status](https://docs.getpara.com/v3/react/guides/web3-operations/solana/get-transaction-status.md): Check transaction confirmation status and finality on Solana
- [Interact with Solana Programs](https://docs.getpara.com/v3/react/guides/web3-operations/solana/interact-with-programs.md): Call program instructions and work with Anchor IDLs using Para
- [Manage SPL Token Accounts](https://docs.getpara.com/v3/react/guides/web3-operations/solana/manage-token-accounts.md): Create, close, and manage SPL token accounts on Solana
- [Query Wallet Balances with Solana Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/solana/query-balances.md): Check SOL and SPL token balances using Solana Web3.js or Anchor with Para wallets
- [Send Tokens with Solana Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/solana/send-tokens.md): Transfer SOL tokens using Solana Web3.js or Anchor with Para wallets
- [Setup Solana Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/solana/setup-libraries.md): Install and configure Solana libraries for use with Para SDK
- [SWIG Account Abstraction](https://docs.getpara.com/v3/react/guides/web3-operations/solana/setup-swig.md): Build embedded wallets using SWIG AA provider with Para's infrastructure on Solana
- [Sign Messages with Solana Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/solana/sign-messages.md): Sign text and binary messages using Solana Web3.js or Anchor with Para
- [Verify Signatures with Solana Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/solana/verify-signatures.md): Verify message and transaction signatures using Solana Web3.js or Anchor
- [Configure Horizon Endpoints with Stellar Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/stellar/configure-rpc.md): Set up and configure Stellar Horizon API endpoints for different networks
- [Execute Transactions with Stellar Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/stellar/execute-transactions.md): Build and sign complex Stellar transactions including multi-op, fee bumps, and Soroban auth
- [Query Wallet Balances with Stellar Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/stellar/query-balances.md): Check XLM and token balances using the Stellar SDK with Para wallets
- [Send Tokens with Stellar Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/stellar/send-tokens.md): Transfer XLM using the Stellar SDK with Para wallets
- [Setup Stellar Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/stellar/setup-libraries.md): Install and configure the Stellar SDK for use with Para SDK
- [Sign Messages with Stellar Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/stellar/sign-messages.md): Sign arbitrary bytes for verification using the Stellar SDK with Para
- [Verify Signatures with Stellar Libraries](https://docs.getpara.com/v3/react/guides/web3-operations/stellar/verify-signatures.md): Verify Ed25519 signatures from Stellar addresses
- [Switch Active Wallet](https://docs.getpara.com/v3/react/guides/web3-operations/switch-wallet.md): Change the currently selected wallet for blockchain operations
- [React SDK Overview](https://docs.getpara.com/v3/react/overview.md): Complete guide to integrating Para's React SDK for Web3 authentication and wallet management
- [React SDK Quickstart](https://docs.getpara.com/v3/react/quickstart.md): Get started with Para's React SDK in minutes with our interactive setup guide
- [Para with Next.js](https://docs.getpara.com/v3/react/setup/nextjs.md): A guide to integrate Para into a Next.js application
- [Para with TanStack Start](https://docs.getpara.com/v3/react/setup/tanstack-start.md): A guide to integrate Para SDK with TanStack Start while preserving server-side rendering capabilities.
- [Para with React + Vite](https://docs.getpara.com/v3/react/setup/vite.md): A guide to quickly integrate the Para Modal into your Vite-powered React application.
- [Testing Your Integration](https://docs.getpara.com/v3/react/testing-guide.md): Use test credentials to develop and test your Para integration without creating real users
- [Next.js](https://docs.getpara.com/v3/react/troubleshooting/nextjs.md): Troubleshooting Para integration with Next.js applications
- [React with Vite](https://docs.getpara.com/v3/react/troubleshooting/react-vite.md): Overcoming Para integration challenges in Vite-powered React applications
- [Svelte](https://docs.getpara.com/v3/react/troubleshooting/svelte.md): Overcoming Para integration challenges in Svelte applications
- [TanStack Start Troubleshooting](https://docs.getpara.com/v3/react/troubleshooting/tanstack-start.md): Overcoming Para integration challenges in TanStack Start applications
- [Vue.js Troubleshooting](https://docs.getpara.com/v3/react/troubleshooting/vue.md): Resolving common Para SDK integration challenges with Vue.js applications
- [addCredential](https://docs.getpara.com/v3/references/core/addcredential.md): Returns a URL that the user can visit to add a new auth credential to their account or change to basic login
- [claimPregenWallets](https://docs.getpara.com/v3/references/core/claimpregenwallets.md): Claims pregenerated wallets for the user
- [clearStorage](https://docs.getpara.com/v3/references/core/clearstorage.md): Clears the specified storage type
- [createGuestWallets](https://docs.getpara.com/v3/references/core/createguestwallets.md): Creates guest wallets
- [createPregenWallet](https://docs.getpara.com/v3/references/core/createpregenwallet.md): Creates a pregenerated wallet of a specific type
- [createPregenWalletPerType](https://docs.getpara.com/v3/references/core/createpregenwalletpertype.md): Creates pregenerated wallets for specified types
- [createWallet](https://docs.getpara.com/v3/references/core/createwallet.md): Creates a new wallet
- [createWalletPerType](https://docs.getpara.com/v3/references/core/createwalletpertype.md): Creates wallets for specified types
- [distributeNewWalletShare](https://docs.getpara.com/v3/references/core/distributenewwalletshare.md): Distributes a new wallet share
- [enable2fa](https://docs.getpara.com/v3/references/core/enable2fa.md): Enables two-factor authentication using the provided code
- [exportSession](https://docs.getpara.com/v3/references/core/exportsession.md): Exports the current session data
- [fetchWallets](https://docs.getpara.com/v3/references/core/fetchwallets.md): Fetches wallet entities from the server
- [getAuthInfo](https://docs.getpara.com/v3/references/core/getauthinfo.md): Retrieves the current authentication information for the user
- [getFarcasterConnectUri](https://docs.getpara.com/v3/references/core/getfarcasterconnecturi.md): Generates a Farcaster connect URI for authentication
- [getLinkedAccounts](https://docs.getpara.com/v3/references/core/getlinkedaccounts.md): Retrieves linked accounts for the user
- [getOAuthUrl](https://docs.getpara.com/v3/references/core/getoauthurl.md): Generates an OAuth URL for third-party authentication
- [getPregenWallets](https://docs.getpara.com/v3/references/core/getpregenwallets.md): Retrieves pregenerated wallets
- [getUserShare](https://docs.getpara.com/v3/references/core/getusershare.md): Retrieves the user's share
- [getVerificationToken](https://docs.getpara.com/v3/references/core/getverificationtoken.md): Retrieves a verification token
- [getWalletBalance](https://docs.getpara.com/v3/references/core/getwalletbalance.md): Retrieves the balance for a wallet
- [getWallets](https://docs.getpara.com/v3/references/core/getwallets.md): Retrieves all wallets for the user
- [getWalletsByType](https://docs.getpara.com/v3/references/core/getwalletsbytype.md): Retrieves wallets of a specific type
- [hasPregenWallet](https://docs.getpara.com/v3/references/core/haspregenwallet.md): Checks if a pregenerated wallet exists for the given ID
- [importSession](https://docs.getpara.com/v3/references/core/importsession.md): Imports session data
- [initiateOnRampTransaction](https://docs.getpara.com/v3/references/core/initiateonramptransaction.md): Initiates an on-ramp transaction
- [isFullyLoggedIn](https://docs.getpara.com/v3/references/core/isfullyloggedin.md): Checks if the user is fully logged in
- [isSessionActive](https://docs.getpara.com/v3/references/core/issessionactive.md): Checks if the current session is active
- [issueJwt](https://docs.getpara.com/v3/references/core/issuejwt.md): Issues a JWT token
- [keepSessionAlive](https://docs.getpara.com/v3/references/core/keepsessionalive.md): Keeps the current session alive
- [loginExternalWallet](https://docs.getpara.com/v3/references/core/loginexternalwallet.md): Initiates login using an external wallet
- [logout](https://docs.getpara.com/v3/references/core/logout.md): Logs out the current user
- [refreshSession](https://docs.getpara.com/v3/references/core/refreshsession.md): Refreshes the current session
- [refreshShare](https://docs.getpara.com/v3/references/core/refreshshare.md): Refreshes a wallet share
- [resendVerificationCode](https://docs.getpara.com/v3/references/core/resendverificationcode.md): Resends a verification code for signup, login, or account linking
- [setup2fa](https://docs.getpara.com/v3/references/core/setup2fa.md): Sets up two-factor authentication for the user
- [setUserShare](https://docs.getpara.com/v3/references/core/setusershare.md): Sets the user's share
- [signMessage](https://docs.getpara.com/v3/references/core/signmessage.md): Signs a message using the specified wallet
- [signTransaction](https://docs.getpara.com/v3/references/core/signtransaction.md): Signs a transaction using the specified wallet
- [signUpOrLogIn](https://docs.getpara.com/v3/references/core/signuporlogin.md): Initiates signup or login for a user based on the provided authentication details
- [updatePregenWalletIdentifier](https://docs.getpara.com/v3/references/core/updatepregenwalletidentifier.md): Updates the identifier for a pregenerated wallet
- [verify2fa](https://docs.getpara.com/v3/references/core/verify2fa.md): Verifies two-factor authentication
- [verifyExternalWallet](https://docs.getpara.com/v3/references/core/verifyexternalwallet.md): Verifies an external wallet for authentication
- [verifyFarcaster](https://docs.getpara.com/v3/references/core/verifyfarcaster.md): Verifies Farcaster authentication
- [verifyNewAccount](https://docs.getpara.com/v3/references/core/verifynewaccount.md): Verifies a new account using the provided verification code
- [verifyOAuth](https://docs.getpara.com/v3/references/core/verifyoauth.md): Verifies OAuth authentication
- [verifyTelegram](https://docs.getpara.com/v3/references/core/verifytelegram.md): Verifies Telegram authentication
- [waitForLogin](https://docs.getpara.com/v3/references/core/waitforlogin.md): Polls and waits for the login process to complete
- [waitForSignup](https://docs.getpara.com/v3/references/core/waitforsignup.md): Polls and waits for the signup process to complete
- [waitForWalletCreation](https://docs.getpara.com/v3/references/core/waitforwalletcreation.md): Polls and waits for wallet creation to complete
- [ParaProvider](https://docs.getpara.com/v3/references/hooks/ParaProvider.md): React context provider component that wraps your application to provide access to Para hooks
- [useAccount](https://docs.getpara.com/v3/references/hooks/useAccount.md): React Query hook for retrieving the current embedded account and connected external wallets
- [useAccountLinkInProgress](https://docs.getpara.com/v3/references/hooks/useAccountLinkInProgress.md): Hook for returning the account linking status of the user
- [useAddAuthMethod](https://docs.getpara.com/v3/references/hooks/useAddAuthMethod.md): React hook for adding a new auth method to the user's account
- [useClaimPregenWallets](https://docs.getpara.com/v3/references/hooks/useClaimPregenWallets.md): React hook for claiming pregenerated wallets
- [useClient](https://docs.getpara.com/v3/references/hooks/useClient.md): Hook for retrieving the Para client instance
- [useCreateGuestWallets](https://docs.getpara.com/v3/references/hooks/useCreateGuestWallets.md): React hook for creating guest wallets
- [useCreatePregenWallet](https://docs.getpara.com/v3/references/hooks/useCreatePregenWallet.md): React hook for creating pregenerated wallets
- [useCreatePregenWalletPerType](https://docs.getpara.com/v3/references/hooks/useCreatePregenWalletPerType.md): React hook for creating pregenerated wallets per type
- [useCreateWallet](https://docs.getpara.com/v3/references/hooks/useCreateWallet.md): React hook for creating wallets
- [useCreateWalletPerType](https://docs.getpara.com/v3/references/hooks/useCreateWalletPerType.md): React hook for creating wallets per type
- [useEnable2fa](https://docs.getpara.com/v3/references/hooks/useEnable2fa.md): React hook to enable two-factor authentication (2FA)
- [useHasPregenWallet](https://docs.getpara.com/v3/references/hooks/useHasPregenWallet.md): React hook for checking if a pregenerated wallet exists
- [useIsFullyLoggedIn](https://docs.getpara.com/v3/references/hooks/useIsFullyLoggedIn.md): Hook for returning whether the user is fully logged in with Para
- [useIssueJwt](https://docs.getpara.com/v3/references/hooks/useIssueJwt.md): React hook for issuing a JWT token
- [useKeepSessionAlive](https://docs.getpara.com/v3/references/hooks/useKeepSessionAlive.md): React hook for keeping the session alive
- [useLinkAccount](https://docs.getpara.com/v3/references/hooks/useLinkAccount.md)
- [useLinkedAccounts](https://docs.getpara.com/v3/references/hooks/useLinkedAccounts.md): Hook for returning the linked accounts of the user
- [useLoginExternalWallet](https://docs.getpara.com/v3/references/hooks/useLoginExternalWallet.md)
- [useLogout](https://docs.getpara.com/v3/references/hooks/useLogout.md): React hook for logging out
- [useModal](https://docs.getpara.com/v3/references/hooks/useModal.md)
- [useParaCosmjsAminoSigner](https://docs.getpara.com/v3/references/hooks/useParaCosmjsAminoSigner.md): Hook to retrieve a CosmJS Amino signer for Para Cosmos wallets
- [useParaCosmjsProtoSigner](https://docs.getpara.com/v3/references/hooks/useParaCosmjsProtoSigner.md): Hook to retrieve a CosmJS Proto signer for Para Cosmos wallets
- [useParaEthersSigner](https://docs.getpara.com/v3/references/hooks/useParaEthersSigner.md): Hook to retrieve an ethers.js AbstractSigner for Para EVM wallets
- [useParaSolanaSigner](https://docs.getpara.com/v3/references/hooks/useParaSolanaSigner.md): Hook to retrieve a Solana signer for Para Solana wallets
- [useParaStatus](https://docs.getpara.com/v3/references/hooks/useParaStatus.md)
- [useParaStellarSigner](https://docs.getpara.com/v3/references/hooks/useParaStellarSigner.md): Hook to retrieve a Stellar signer for Para Stellar wallets
- [useParaViemAccount](https://docs.getpara.com/v3/references/hooks/useParaViemAccount.md): Hook to retrieve a Viem LocalAccount for Para EVM wallets
- [useParaViemClient](https://docs.getpara.com/v3/references/hooks/useParaViemClient.md): Hook to create a Viem WalletClient integrated with Para
- [useResendVerificationCode](https://docs.getpara.com/v3/references/hooks/useResendVerificationCode.md)
- [useSetup2fa](https://docs.getpara.com/v3/references/hooks/useSetup2fa.md)
- [useSignMessage](https://docs.getpara.com/v3/references/hooks/useSignMessage.md)
- [useSignTransaction](https://docs.getpara.com/v3/references/hooks/useSignTransaction.md)
- [useSignUpOrLogIn](https://docs.getpara.com/v3/references/hooks/useSignUpOrLogIn.md)
- [useStellarSigner](https://docs.getpara.com/v3/references/hooks/useStellarSigner.md)
- [useUpdatePregenWalletIdentifier](https://docs.getpara.com/v3/references/hooks/useUpdatePregenWalletIdentifier.md)
- [useVerify2fa](https://docs.getpara.com/v3/references/hooks/useVerify2fa.md)
- [useVerifyExternalWallet](https://docs.getpara.com/v3/references/hooks/useVerifyExternalWallet.md)
- [useVerifyFarcaster](https://docs.getpara.com/v3/references/hooks/useVerifyFarcaster.md)
- [useVerifyNewAccount](https://docs.getpara.com/v3/references/hooks/useVerifyNewAccount.md)
- [useVerifyOAuth](https://docs.getpara.com/v3/references/hooks/useVerifyOAuth.md)
- [useVerifyTelegram](https://docs.getpara.com/v3/references/hooks/useVerifyTelegram.md)
- [useWaitForLogin](https://docs.getpara.com/v3/references/hooks/useWaitForLogin.md)
- [useWaitForSignup](https://docs.getpara.com/v3/references/hooks/useWaitForSignup.md)
- [useWaitForWalletCreation](https://docs.getpara.com/v3/references/hooks/useWaitForWalletCreation.md)
- [useWallet](https://docs.getpara.com/v3/references/hooks/useWallet.md): Hook for retrieving the selected wallet
- [useWalletBalance](https://docs.getpara.com/v3/references/hooks/useWalletBalance.md): Hook for retrieving a wallet balance
- [useWalletState](https://docs.getpara.com/v3/references/hooks/useWalletState.md)
- [API Reference](https://docs.getpara.com/v3/references/overview.md): Complete reference documentation for Para SDK methods, hooks, and types
- [AccountLinkError](https://docs.getpara.com/v3/references/types/accountlinkerror.md): Error types for account linking
- [AccountLinkInProgress](https://docs.getpara.com/v3/references/types/accountlinkinprogress.md): Represents an in-progress account link
- [AuthMethod](https://docs.getpara.com/v3/references/types/authmethod.md): Authentication methods
- [AuthState](https://docs.getpara.com/v3/references/types/authstate.md): Union of authentication states: verify, login, signup, or done
- [AuthStateLogin](https://docs.getpara.com/v3/references/types/authstatelogin.md): Authentication state for returning users logging in with passkey, password, or PIN — including full (unshortened) URL variants
- [AuthStateSignup](https://docs.getpara.com/v3/references/types/authstatesignup.md): Authentication state for signup, including portal URLs and their full (unshortened) counterparts
- [AuthStateSignupOrLogin](https://docs.getpara.com/v3/references/types/authstatesignuporlogin.md): Union type representing either the signup or login authentication state
- [AuthStateVerify](https://docs.getpara.com/v3/references/types/authstateverify.md): Authentication state for verification, including portal URLs and their full (unshortened) counterparts
- [AuthStateVerifyOrLogin](https://docs.getpara.com/v3/references/types/authstateverifyorlogin.md): Union type representing either the verify or login authentication state
- [AuthType](https://docs.getpara.com/v3/references/types/authtype.md): Union of authentication types
- [BackupKitEmailProps](https://docs.getpara.com/v3/references/types/backupkitemailprops.md): Properties for backup kit emails
- [BorderRadius](https://docs.getpara.com/v3/references/types/borderradius.md): Border radius options for themes
- [Callbacks](https://docs.getpara.com/v3/references/types/callbacks.md): Event callbacks for Para SDK events
- [ConstructorOpts](https://docs.getpara.com/v3/references/types/constructoropts.md): Options for SDK constructor
- [CoreAuthInfo](https://docs.getpara.com/v3/references/types/coreauthinfo.md): Core authentication information
- [Ctx](https://docs.getpara.com/v3/references/types/ctx.md): Context configuration for the SDK
- [CurrentWalletIds](https://docs.getpara.com/v3/references/types/currentwalletids.md): Partial record of wallet IDs by type
- [EmailTheme](https://docs.getpara.com/v3/references/types/emailtheme.md): Themes for emails
- [EmbeddedWalletType](https://docs.getpara.com/v3/references/types/embeddedwallettype.md): Type for embedded wallets
- [EnabledFlow](https://docs.getpara.com/v3/references/types/enabledflow.md): Enabled flows for on-ramp configurations
- [Environment](https://docs.getpara.com/v3/references/types/environment.md): Available environments for the SDK
- [ExternalWalletConfig](https://docs.getpara.com/v3/references/types/externalwalletconfig.md): Configuration for external wallets
- [ExternalWalletInfo](https://docs.getpara.com/v3/references/types/externalwalletinfo.md): Information for an external wallet
- [ExternalWalletType](https://docs.getpara.com/v3/references/types/externalwallettype.md): Type for external wallets
- [FullSignatureRes](https://docs.getpara.com/v3/references/types/fullsignatureres.md): Full result of a signing operation
- [GetWalletBalanceResponse](https://docs.getpara.com/v3/references/types/getwalletbalanceresponse.md): Response type for wallet balance
- [IssueJwtResponse](https://docs.getpara.com/v3/references/types/issuejwtresponse.md): Response for issuing a JWT
- [LinkedAccounts](https://docs.getpara.com/v3/references/types/linkedaccounts.md): Structure for primary and linked accounts
- [Network](https://docs.getpara.com/v3/references/types/network.md): Supported networks
- [OAuthResponse](https://docs.getpara.com/v3/references/types/oauthresponse.md): Response type for OAuth verification
- [OnRampAsset](https://docs.getpara.com/v3/references/types/onrampasset.md): Supported on-ramp assets
- [OnRampProvider](https://docs.getpara.com/v3/references/types/onrampprovider.md): On-ramp providers
- [OnRampPurchase](https://docs.getpara.com/v3/references/types/onramppurchase.md): Details of an on-ramp purchase
- [OnRampPurchaseCreateParams](https://docs.getpara.com/v3/references/types/onramppurchasecreateparams.md): Parameters for creating an on-ramp purchase
- [OnRampPurchaseStatus](https://docs.getpara.com/v3/references/types/onramppurchasestatus.md): Statuses for on-ramp purchases
- [OnRampPurchaseType](https://docs.getpara.com/v3/references/types/onramppurchasetype.md): Types of on-ramp purchases
- [ParaEvent](https://docs.getpara.com/v3/references/types/paraevent.md): Events emitted by the Para SDK
- [ParaModalProps](https://docs.getpara.com/v3/references/types/paramodalprops.md): Props for the Para modal
- [ParaProviderConfig](https://docs.getpara.com/v3/references/types/paraproviderconfig.md): Configuration for the ParaProvider
- [PartnerEntity](https://docs.getpara.com/v3/references/types/partnerentity.md): Details for a partner entity
- [PollParams](https://docs.getpara.com/v3/references/types/pollparams.md): Parameters for polling operations
- [PregenAuth](https://docs.getpara.com/v3/references/types/pregenauth.md): Authentication type for pregen identifiers
- [Setup2faResponse](https://docs.getpara.com/v3/references/types/setup2faresponse.md): Response for setting up 2FA
- [StorageType](https://docs.getpara.com/v3/references/types/storagetype.md): Types of storage
- [SuccessfulSignatureRes](https://docs.getpara.com/v3/references/types/successfulsignatureres.md): Successful signature result
- [SupportedAccountLinks](https://docs.getpara.com/v3/references/types/supportedaccountlinks.md): Supported account link types
- [SupportedWalletTypes](https://docs.getpara.com/v3/references/types/supportedwallettypes.md): Array of supported wallet types with optional flag
- [TelegramAuthResponse](https://docs.getpara.com/v3/references/types/telegramauthresponse.md): Response from Telegram authentication
- [TExternalWallet](https://docs.getpara.com/v3/references/types/texternalwallet.md): External wallet provider types
- [Theme](https://docs.getpara.com/v3/references/types/theme.md): Theme configuration for the portal
- [TLinkedAccountType](https://docs.getpara.com/v3/references/types/tlinkedaccounttype.md): Types of linked accounts
- [TOAuthMethod](https://docs.getpara.com/v3/references/types/toauthmethod.md): OAuth method types
- [TPregenIdentifierType](https://docs.getpara.com/v3/references/types/tpregenidentifiertype.md): Types of pregen identifiers
- [TWalletScheme](https://docs.getpara.com/v3/references/types/twalletscheme.md): Wallet scheme types
- [TWalletType](https://docs.getpara.com/v3/references/types/twallettype.md): Wallet type union
- [VerifiedAuth](https://docs.getpara.com/v3/references/types/verifiedauth.md): Verified authentication details
- [Verify2faResponse](https://docs.getpara.com/v3/references/types/verify2faresponse.md): Response for verifying 2FA
- [Wallet](https://docs.getpara.com/v3/references/types/wallet.md): Represents a wallet entity
- [WalletEntity](https://docs.getpara.com/v3/references/types/walletentity.md): Server-side wallet entity
- [WalletFilters](https://docs.getpara.com/v3/references/types/walletfilters.md): Filters for selecting wallets
- [Bring your own auth](https://docs.getpara.com/v3/rest/byo-auth.md): Use Para REST API with your own user authentication and a backend signing service
- [Migrate SDK pregen wallets to REST API](https://docs.getpara.com/v3/rest/migrate-from-sdk-pregen.md): Move existing SDK-pregenerated wallets to the REST API so you can sign with just a wallet ID and API key
- [Multiple Wallets per User](https://docs.getpara.com/v3/rest/multi-wallet.md): Create multiple wallets for a single user using custom identifiers
- [REST API](https://docs.getpara.com/v3/rest/overview.md): The recommended way to create and sign with wallets from your backend — pregenerated user wallets, agent wallets, and server-side signing over plain HTTP
- [Permissions](https://docs.getpara.com/v3/rest/permissions.md): Control what transactions your server wallets can sign
- [REST SDK](https://docs.getpara.com/v3/rest/sdk.md): Typed TypeScript client for the REST API — the recommended way to create server-side and agent wallets
- [Setup](https://docs.getpara.com/v3/rest/setup.md): Authenticate and make your first REST request
- [Developer Portal Email Branding](https://docs.getpara.com/v3/rest/setup/developer-portal-email-branding.md): Customize the appearance of Welcome and OTP emails with your brand.
- [Developer Portal Payment Integration](https://docs.getpara.com/v3/rest/setup/developer-portal-payments.md): Configure payment providers and transaction features to enable crypto buying, selling, and wallet funding for your users. These settings control which options appear in your Para integration.
- [Developer Portal Security Settings](https://docs.getpara.com/v3/rest/setup/developer-portal-security.md): Configure authentication methods, session management, and transaction permissions
- [Get Your API Key](https://docs.getpara.com/v3/rest/setup/developer-portal-setup.md): Get your API key and configure your Para integration through the developer portal.
- [Transaction History](https://docs.getpara.com/v3/rest/transaction-history.md): Persisted transaction records, on-chain monitoring, and webhooks for REST API broadcasts
- [Server Examples](https://docs.getpara.com/v3/server/examples.md): Explore Para's server-side integration examples across Node.js, Bun, and Deno
- [Account Abstraction](https://docs.getpara.com/v3/server/guides/account-abstraction.md): Implement ERC-4337 and EIP-7702 Account Abstraction with Para Server SDK
- [Cosmos Integration](https://docs.getpara.com/v3/server/guides/cosmos.md): Use Para Server SDK with Cosmos-based blockchains
- [EVM Integration](https://docs.getpara.com/v3/server/guides/evm.md): Use Para Server SDK with Ethereum and EVM-compatible chains
- [Wallet Pregeneration](https://docs.getpara.com/v3/server/guides/pregen.md): Create and manage server-side pregenerated wallets using Para's Server SDK
- [Session Management](https://docs.getpara.com/v3/server/guides/sessions.md): Manage client sessions in server-side environments with Para Server SDK
- [Solana Integration](https://docs.getpara.com/v3/server/guides/solana.md): Use Para Server SDK with Solana blockchain
- [Stellar Integration](https://docs.getpara.com/v3/server/guides/stellar.md): Use Para Server SDK with Stellar blockchain
- [Para Server SDK](https://docs.getpara.com/v3/server/overview.md): An introduction to server-side integrations with Para
- [Server Setup](https://docs.getpara.com/v3/server/setup.md): Install and configure the Para Server SDK across Node.js, Bun, and Deno environments
- [Developer Portal Email Branding](https://docs.getpara.com/v3/server/setup/developer-portal-email-branding.md): Customize the appearance of Welcome and OTP emails with your brand.
- [Developer Portal Payment Integration](https://docs.getpara.com/v3/server/setup/developer-portal-payments.md): Configure payment providers and transaction features to enable crypto buying, selling, and wallet funding for your users. These settings control which options appear in your Para integration.
- [Developer Portal Security Settings](https://docs.getpara.com/v3/server/setup/developer-portal-security.md): Configure authentication methods, session management, and transaction permissions
- [Get Your API Key](https://docs.getpara.com/v3/server/setup/developer-portal-setup.md): Get your API key and configure your Para integration through the developer portal.
- [Para with SvelteKit](https://docs.getpara.com/v3/svelte/setup/svelte-kit.md): Set up a SvelteKit app with Para's Web SDK and build custom authentication and wallet UI.
- [Para with Svelte + Vite](https://docs.getpara.com/v3/svelte/setup/vite.md): Set up a Svelte + Vite app with Para's Web SDK and build custom authentication and wallet UI.
- [Swift SDK API Reference](https://docs.getpara.com/v3/swift/api/sdk.md): Comprehensive API reference for the Para Swift SDK
- [Mobile Examples](https://docs.getpara.com/v3/swift/examples.md): Explore Para's mobile integration examples for Swift
- [Account Abstraction](https://docs.getpara.com/v3/swift/guides/account-abstraction.md): Gasless and batched EVM transactions on iOS using Alchemy smart accounts backed by Para
- [Cosmos Integration](https://docs.getpara.com/v3/swift/guides/cosmos.md): Sign transactions for Cosmos chains using Para's unified wallet architecture
- [Email & Phone Login](https://docs.getpara.com/v3/swift/guides/email-phone-login.md): Implement Para's unified email and phone authentication flow in Swift.
- [EVM Integration](https://docs.getpara.com/v3/swift/guides/evm.md): Transfer ETH and interact with EVM chains using Para's unified wallet architecture
- [External Wallets](https://docs.getpara.com/v3/swift/guides/external-wallets.md): Instructions for using external wallets with the ParaSwift SDK.
- [Wallet Pregeneration & Claiming](https://docs.getpara.com/v3/swift/guides/pregen.md): Pregenerate and claim wallets in your Swift applications (Coming Soon)
- [Swift Session Management](https://docs.getpara.com/v3/swift/guides/sessions.md): Guide to managing authentication sessions in Para for Swift applications
- [Social Login](https://docs.getpara.com/v3/swift/guides/social-login.md): Instructions for implementing social login with the ParaSwift SDK.
- [Solana Integration](https://docs.getpara.com/v3/swift/guides/solana.md): Sign Solana transactions using Para's unified wallet architecture
- [Stellar Integration](https://docs.getpara.com/v3/swift/guides/stellar.md): Create Stellar wallets and sign Stellar transactions with the Para Swift SDK
- [Swift SDK Overview](https://docs.getpara.com/v3/swift/overview.md): Para Swift SDK documentation for iOS wallet integration
- [Setup](https://docs.getpara.com/v3/swift/setup.md): Step-by-step guide for integrating the Para Swift SDK into your iOS application
- [Developer Portal Email Branding](https://docs.getpara.com/v3/swift/setup/developer-portal-email-branding.md): Customize the appearance of Welcome and OTP emails with your brand.
- [Developer Portal Payment Integration](https://docs.getpara.com/v3/swift/setup/developer-portal-payments.md): Configure payment providers and transaction features to enable crypto buying, selling, and wallet funding for your users. These settings control which options appear in your Para integration.
- [Developer Portal Security Settings](https://docs.getpara.com/v3/swift/setup/developer-portal-security.md): Configure authentication methods, session management, and transaction permissions
- [Get Your API Key](https://docs.getpara.com/v3/swift/setup/developer-portal-setup.md): Get your API key and configure your Para integration through the developer portal.
- [Troubleshooting](https://docs.getpara.com/v3/swift/troubleshooting.md): Solutions for common issues with the Para Swift SDK integration
- [Para with Nuxt 3](https://docs.getpara.com/v3/vue/setup/nuxt.md): Set up a Nuxt 3 app with Para's Web SDK and build custom authentication and wallet UI.
- [Para with Vue + Vite](https://docs.getpara.com/v3/vue/setup/vite.md): Set up a Vue + Vite app with Para's Web SDK and build custom authentication and wallet UI.
- [Integrate Para Wallets with Eliza OS](https://docs.getpara.com/v3/walkthroughs/Eliza.md): Build wallet-enabled AI agents using Para's infrastructure and Eliza OS framework
- [Integrating Para with Rhinestone](https://docs.getpara.com/v3/walkthroughs/Rhinestone.md): Build cross-chain smart accounts using Para SDK with Rhinestone for intent-based transactions and gas abstraction
- [Integrating Para with Squid](https://docs.getpara.com/v3/walkthroughs/Squid.md): Build a cross-chain USDC bridge using Squid Router API with Para SDK for seamless wallet management
- [Integrating Para with thirdweb](https://docs.getpara.com/v3/walkthroughs/Thirdweb.md): Learn how to integrate Para's embedded wallets with thirdweb for smart accounts, gas sponsorship, and in-app payments
- [Integrate x402 with Para](https://docs.getpara.com/v3/walkthroughs/X402.md): Enable micropayments over HTTP using Para's ViemAccount with Coinbase's x402 protocol
- [Integrate Aave v3 with Para](https://docs.getpara.com/v3/walkthroughs/aave.md): Combine Para's wallet infrastructure with Aave's lending protocol to enable seamless borrowing, lending, and yield strategies
- [Stablecoin Yield via Paxos Amplify](https://docs.getpara.com/v3/walkthroughs/amplify.md): Enable stablecoin deposits, withdrawals, and yield strategies using Paxos Amplify's protocol and Para embedded wallets.
- [Integrate Arc Chain with Para](https://docs.getpara.com/v3/walkthroughs/arc.md): This walkthrough explores how to use Para with Arc Chain using Para SDK.
- [Integrate Brale with Para](https://docs.getpara.com/v3/walkthroughs/brale.md): Combine Para's wallet infrastructure with Brale's stablecoin issuance API to enable minting, redeeming, and managing stablecoins.
- [Bulk Wallet Pregeneration for Twitter](https://docs.getpara.com/v3/walkthroughs/bulk-pregeneration.md): Learn how to bulk pregenerate Para wallets for Twitter users and enable seamless wallet claiming
- [Canton Network External Party Onboarding with Para](https://docs.getpara.com/v3/walkthroughs/canton-network.md): Learn how to use Para's React SDK to onboard a Para-managed Solana wallet as a Canton Network external party using the Ed25519 key ownership flow
- [Chrome Extension Integration with Para](https://docs.getpara.com/v3/walkthroughs/chrome-extension-integration.md): Learn how to build Chrome extensions with Para, including state persistence, background workers, and seamless user authentication
- [Aggregated Yield via Compass](https://docs.getpara.com/v3/walkthroughs/compass.md): Add yield, lending, borrowing, and portfolio management to your app using Compass's non-custodial DeFi API and Para embedded wallets.
- [EIP-712 Typed Data Signing with Para](https://docs.getpara.com/v3/walkthroughs/eip712-typed-data-signing.md): Learn how to sign structured, typed data using EIP-712 standard with Para's Ethers integration
- [Ethereum Transfers with Para](https://docs.getpara.com/v3/walkthroughs/ethereum-transfers.md): Learn how to send ETH transactions using Para with both Ethers and Viem libraries
- [Inco Integration](https://docs.getpara.com/v3/walkthroughs/inco.md): Learn how to create a private payment flow using Para SDK with Inco's confidential wrapper for encrypted token transfers.
- [Para + M0 Integration](https://docs.getpara.com/v3/walkthroughs/m0.md): Combine Para's embedded wallets with M0's programmable stablecoin infrastructure
- [Mellow Core Vaults](https://docs.getpara.com/v3/walkthroughs/mellow-core-vaults.md): Integrate deposits, cancellations, claims, redemptions, and fee handling for Mellow Core Vaults with Para-powered viem wallets.
- [Miden Integration](https://docs.getpara.com/v3/walkthroughs/miden.md): Learn how to integrate Para's embedded wallets with the Miden zero-knowledge virtual machine using the official miden-para SDK
- [Automated Migration to Para with MCP](https://docs.getpara.com/v3/walkthroughs/migration-mcp.md): Use AI-powered tooling to automatically migrate your app from Privy, Reown, Web3Modal, or WalletConnect to Para
- [Partner Network](https://docs.getpara.com/v3/walkthroughs/overview.md): Step-by-step guides for integrating Para's wallet infrastructure with partner platforms and protocols
- [Integrating Para with Porto](https://docs.getpara.com/v3/walkthroughs/porto.md): Upgrade Para EOA wallets to Porto Smart Accounts using EIP-7702 for session keys, transaction batching, and gas sponsorship
- [Rootstock Integration](https://docs.getpara.com/v3/walkthroughs/rootstock.md): This walkthrough explores how to use Para in Rootstock Chain using Para SDK.
- [Solana SOL Transfers with Para](https://docs.getpara.com/v3/walkthroughs/solana-transfers.md): Learn how to send SOL transactions using Para with Solana Web3.js, Solana Signers v2, and Coral Anchor libraries

## Para CLI (`@getpara/cli`)

The Para CLI is a developer tool for managing API keys, organizations, projects, and configuration from the terminal.

### Installation

```bash
npm install -g @getpara/cli
```

### Authentication

```bash
para login          # OAuth browser flow with PKCE
para logout         # Clear stored credentials
para auth status    # Check session validity (server-side)
para whoami         # Show user, org, project, environment
```

Sessions are stored at `~/.config/para/credentials.json` (0600 permissions). PROD and BETA share the same developer portal session.

### Configuration

```bash
para config get [key]         # Read config values
para config set <key> <value> # Set config value
para config unset <key>       # Remove config value
para init                     # Create .pararc in current directory
```

Resolution order: CLI flags → environment variables (`PARA_ENVIRONMENT`, `PARA_ORG_ID`, `PARA_PROJECT_ID`) → `.pararc` → global config → defaults.

### Organizations & Projects

```bash
para orgs list                    # List organizations
para orgs switch [org-id]         # Switch active org
para projects list                # List projects
para projects switch [project-id] # Switch active project
para projects create              # Create project (-n, --framework)
para projects update [project-id] # Update project
para projects archive [project-id]# Archive project (keys stop immediately)
para projects restore <project-id># Restore archived project
```

### API Keys

```bash
para keys list                   # List API keys
para keys get <key-id>           # Get key details (--show-secret, --copy)
para keys create                 # Create key (-n, --display-name)
para keys rotate <key-id>        # Rotate key (--secret for secret key)
para keys archive <key-id>       # Revoke key
para keys config [key-id]        # Configure key settings
```

`para keys config` sub-commands: `security`, `branding`, `setup`, `ramps`, `webhooks`. Each accepts flags for non-interactive use.

### Scaffold a Project

```bash
para create [app-name]   # Scaffold Next.js or Expo app with Para SDK
```

Templates: `nextjs`, `expo`. Supports `--networks`, `--email`, `--phone`, `--oauth`, `--wallets`, `--bundle-id`, `--package-manager`, `-y` for non-interactive mode.

### Diagnostics

```bash
para doctor [path]       # Scan for SDK integration issues
```

Checks: API key env var, env var prefix, CSS import, ParaProvider, duplicate ParaModal instances, QueryClient, "use client" directive, version consistency, chain dependencies, deprecated packages. Use `--json` for CI/CD (exits 1 on errors).

### Global Flags

| Flag | Description |
|------|-------------|
| `-e, --environment` | Target environment: `DEV`, `SANDBOX`, `BETA`, `PROD` |
| `--org <id>` | Override active organization |
| `--project <id>` | Override active project |
| `--json` | Output as JSON |
| `--quiet` | Suppress non-essential output |
| `--no-input` | Disable interactive prompts |

### CLI Documentation

See the CLI entries in the Docs section above for full documentation links.