# 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` |

### Wallet Connector Packages (for bulk pregen)

| 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;
  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. 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
```

---

## 4. 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);
}, []);
```

---

## 5. 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"
);
```

---

## 6. Wallet Pre-generation (Server-Side)

### 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]
);
```

---

## 7. 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.

---

## 8. 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`.

---

## 9. 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();
```

---

## 10. 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`.

---

## 11. 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.

---

## 12. 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).

---

## 13. REST API Direct Usage

For server-to-server integrations without the SDK, use the REST API directly.

### 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)
```

### Create Wallet Request

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

- `type`: `"EVM"` | `"SOLANA"` | `"COSMOS"`
- `userIdentifierType`: `"EMAIL"` | `"PHONE"` | `"CUSTOM_ID"` | `"GUEST_ID"` | `"TELEGRAM"` | `"DISCORD"` | `"TWITTER"`
- `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;
}
```

---

## 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.

### 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 (requires `@getpara/viem-v2-integration` as a dependency):

- `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

- [Command Reference](https://docs.getpara.com/v2/cli/commands.md): Complete reference for all Para CLI commands
- [Installation & Setup](https://docs.getpara.com/v2/cli/installation.md): Install the Para CLI and authenticate with your developer account
- [Para CLI](https://docs.getpara.com/v2/cli/overview.md): Manage API keys, organizations, projects, and configuration from your terminal
- [How Para Works](https://docs.getpara.com/v2/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/v2/concepts/compliance.md): Para's audit history, compliance posture, and regulatory classification for security and compliance teams
- [Key Management](https://docs.getpara.com/v2/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/v2/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/v2/concepts/permissions.md): Control exactly what each application can do with a user's wallet: scoped, transparent, and enforced server-side
- [Security](https://docs.getpara.com/v2/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/v2/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/v2/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/v2/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/v2/developer-tools/ai-tooling/overview.md): Connect Para to AI assistants, code editors, and agentic workflows
- [Developer Tools](https://docs.getpara.com/v2/developer-tools/overview.md): CLI, AI integrations, and automation tools for building with Para
- [Flutter SDK API](https://docs.getpara.com/v2/flutter/api/sdk.md): Complete API reference for Para Flutter SDK v2, including authentication, wallet management, and blockchain operations. Updated for 2.0.0 with comprehensive multi-chain support and passkey authentication.
- [Mobile Examples](https://docs.getpara.com/v2/flutter/examples.md): Explore Para's mobile integration examples for Flutter
- [Cosmos Integration](https://docs.getpara.com/v2/flutter/guides/cosmos.md): Sign transactions for Cosmos chains using Para's unified wallet architecture
- [EVM Integration](https://docs.getpara.com/v2/flutter/guides/evm.md): Transfer ETH and interact with EVM chains using Para's unified wallet architecture
- [External Wallets](https://docs.getpara.com/v2/flutter/guides/external-wallets.md): Connect and authenticate users with external wallets like MetaMask and Phantom in Flutter.
- [Wallet Pregeneration](https://docs.getpara.com/v2/flutter/guides/pregen.md): Create and manage pregenerated wallets for users in Flutter applications
- [Flutter Session Management](https://docs.getpara.com/v2/flutter/guides/sessions.md): Guide to managing authentication sessions in Para for Flutter applications
- [Social Login](https://docs.getpara.com/v2/flutter/guides/social-login.md): Hook Para social login into the unified Flutter auth flow
- [Solana Integration](https://docs.getpara.com/v2/flutter/guides/solana.md): Sign Solana transactions using Para's unified wallet architecture
- [Flutter SDK Overview](https://docs.getpara.com/v2/flutter/overview.md): Para Flutter SDK documentation for cross-platform wallet integration
- [Setup](https://docs.getpara.com/v2/flutter/setup.md): Step-by-step guide for integrating the Para Flutter SDK into your mobile application
- [Flutter Troubleshooting Guide](https://docs.getpara.com/v2/flutter/troubleshooting.md): Common issues and solutions when integrating Para with Flutter applications
- [Account Abstraction](https://docs.getpara.com/v2/general/account-abstraction.md): Explore account abstraction integration options with Para across different platforms
- [Go Live Checklist](https://docs.getpara.com/v2/general/checklist.md): A checklist to help you go live with the Para SDK.
- [Glossary](https://docs.getpara.com/v2/general/glossary.md): Glossary of key terms.
- [iOS App Store Submission](https://docs.getpara.com/v2/general/ios-app-store-submission.md): A friendly checklist to get your Para-powered iOS app through App Review without surprises.
- [Migrating from Capsule to Para](https://docs.getpara.com/v2/general/migration-from-capsule.md): Guide for migrating from @usecapsule/* packages to @getpara/* packages
- [Wallet Pregeneration](https://docs.getpara.com/v2/general/pregen.md): Overview of generating pregenerated wallets for Para
- [Deploy Para Integration to Production](https://docs.getpara.com/v2/general/production-deployment.md): Transition your Para integration from development to production with updated configurations and security settings
- [Telegram Bots & Mini-Apps](https://docs.getpara.com/v2/general/telegram.md): A user-friendly guide to quickly integrate Telegram Apps
- [Troubleshooting](https://docs.getpara.com/v2/general/troubleshooting.md): Something not working quite right? This is the section for you!
- [User Data Management](https://docs.getpara.com/v2/general/user-data.md): A comprehensive guide to managing user data when integrating Para into your application
- [Webhooks](https://docs.getpara.com/v2/general/webhooks.md): Receive real-time notifications when events occur in your Para integration
- [Chain Support](https://docs.getpara.com/v2/introduction/chain-support.md): Build on any supported chain.
- [Changelog](https://docs.getpara.com/v2/introduction/changelog.md): Release notes and version history for Para Web SDK
- [Examples Hub](https://docs.getpara.com/v2/introduction/examples.md): Explore Para's examples hub for integration patterns across web, mobile, and specific use cases
- [Framework Support](https://docs.getpara.com/v2/introduction/framework-support.md): Supported Features Across Para's Frameworks
- [Migrating from Para v1.x to v2.0](https://docs.getpara.com/v2/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/v2/introduction/migration-to-para.md): Already have some users in another auth or wallet system? Para makes it easy to migrate!
- [Welcome](https://docs.getpara.com/v2/introduction/welcome.md): Para is the most comprehensive wallet and authentication suite for crypto and fintech developers.
- [What's New in Para v2.0](https://docs.getpara.com/v2/introduction/whats-new.md): A high-level overview of new features and improvements in Para v2.0
- [React Native & Expo SDK](https://docs.getpara.com/v2/react-native/api/sdk.md): Documentation for the Para SDK in React Native and Expo applications
- [Mobile Examples](https://docs.getpara.com/v2/react-native/examples.md): Explore Para's mobile integration examples for React Native and Expo
- [Account Abstraction](https://docs.getpara.com/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/react-native/guides/custom-storage.md): Configure Para client to use MMKV storage in React Native applications
- [EVM Support](https://docs.getpara.com/v2/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/v2/react-native/guides/export-private-key.md): Allow your users to export the private key for their wallets.
- [Guest Mode](https://docs.getpara.com/v2/react-native/guides/guest-mode.md): Allow users to use your app via guest wallets without signing up.
- [ParaProvider](https://docs.getpara.com/v2/react-native/guides/hooks/para-provider.md): React Native context provider for Para SDK integration
- [useAccount](https://docs.getpara.com/v2/react-native/guides/hooks/use-account.md): Hook for retrieving the current user's account and connection status
- [useAuthenticateWithEmailOrPhone](https://docs.getpara.com/v2/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/v2/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/v2/react-native/guides/hooks/use-claim-pregen-wallets.md): Hook for claiming pregenerated wallets after a user signs up
- [useClient](https://docs.getpara.com/v2/react-native/guides/hooks/use-client.md): Hook for accessing the Para client instance
- [useCreateGuestWallets](https://docs.getpara.com/v2/react-native/guides/hooks/use-create-guest-wallets.md): Hook for creating wallets for unauthenticated guest users
- [useCreatePregenWalletPerType](https://docs.getpara.com/v2/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/v2/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/v2/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/v2/react-native/guides/hooks/use-create-wallet.md): Hook for creating a new wallet
- [useEnable2fa](https://docs.getpara.com/v2/react-native/guides/hooks/use-enable-2fa.md): Hook for enabling two-factor authentication with a verification code
- [useExportPrivateKey](https://docs.getpara.com/v2/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/v2/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/v2/react-native/guides/hooks/use-is-fully-logged-in.md): Hook for checking whether the user is fully authenticated
- [useIssueJwt](https://docs.getpara.com/v2/react-native/guides/hooks/use-issue-jwt.md): Hook for issuing a JWT token for backend authentication
- [useKeepSessionAlive](https://docs.getpara.com/v2/react-native/guides/hooks/use-keep-session-alive.md): Hook for extending the current session to prevent automatic logout
- [useLoginExternalWallet](https://docs.getpara.com/v2/react-native/guides/hooks/use-login-external-wallet.md): Hook for initiating login with an external wallet via SIWE
- [useLogout](https://docs.getpara.com/v2/react-native/guides/hooks/use-logout.md): Hook for logging out the current user
- [useParaStatus](https://docs.getpara.com/v2/react-native/guides/hooks/use-para-status.md): Hook for retrieving the initialization status of the Para client
- [useResendVerificationCode](https://docs.getpara.com/v2/react-native/guides/hooks/use-resend-verification-code.md): Hook for resending a verification code
- [useSetup2fa](https://docs.getpara.com/v2/react-native/guides/hooks/use-setup-2fa.md): Hook for setting up two-factor authentication
- [useSignMessage](https://docs.getpara.com/v2/react-native/guides/hooks/use-sign-message.md): Hook for signing a message with a wallet
- [useSignTransaction](https://docs.getpara.com/v2/react-native/guides/hooks/use-sign-transaction.md): Hook for signing a transaction with a wallet
- [useSignUpOrLogIn](https://docs.getpara.com/v2/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/v2/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/v2/react-native/guides/hooks/use-verify-2fa.md): Hook for verifying a two-factor authentication code at login
- [useVerifyExternalWallet](https://docs.getpara.com/v2/react-native/guides/hooks/use-verify-external-wallet.md): Hook for verifying an external wallet login
- [useVerifyFarcaster](https://docs.getpara.com/v2/react-native/guides/hooks/use-verify-farcaster.md): Hook for verifying Farcaster authentication
- [useVerifyNewAccount](https://docs.getpara.com/v2/react-native/guides/hooks/use-verify-new-account.md): Hook for verifying a new account with a verification code
- [useVerifyOAuth](https://docs.getpara.com/v2/react-native/guides/hooks/use-verify-o-auth.md): Hook for verifying OAuth authentication
- [useVerifyTelegram](https://docs.getpara.com/v2/react-native/guides/hooks/use-verify-telegram.md): Hook for verifying Telegram authentication
- [useWaitForLogin](https://docs.getpara.com/v2/react-native/guides/hooks/use-wait-for-login.md): Hook that polls until a login flow is complete
- [useWaitForSignup](https://docs.getpara.com/v2/react-native/guides/hooks/use-wait-for-signup.md): Hook that polls until a signup flow is complete
- [useWaitForWalletCreation](https://docs.getpara.com/v2/react-native/guides/hooks/use-wait-for-wallet-creation.md): Hook that polls until wallet creation is complete
- [useWallet](https://docs.getpara.com/v2/react-native/guides/hooks/use-wallet.md): Hook for retrieving the currently selected wallet
- [Permissions](https://docs.getpara.com/v2/react-native/guides/permissions.md): Handle transaction approval flows in React Native apps
- [Wallet Pregeneration](https://docs.getpara.com/v2/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/v2/react-native/guides/sessions-jwt.md): Issuing and verifying JWT tokens for Para session attestation
- [React Native Session Management](https://docs.getpara.com/v2/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/v2/react-native/guides/solana.md): Using Para with Solana Web3.js and Anchor in React Native applications
- [Claim Staking Rewards](https://docs.getpara.com/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/react-native/guides/web3-operations/cosmos/setup-libraries.md): Install and configure CosmJS for use with Para SDK on Cosmos chains in React Native
- [Sign Messages with Cosmos Libraries](https://docs.getpara.com/v2/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/v2/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/v2/react-native/guides/web3-operations/cosmos/verify-signatures.md): Verify message and transaction signatures using CosmJS
- [Account Abstraction Integrations](https://docs.getpara.com/v2/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/v2/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/v2/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/v2/react-native/guides/web3-operations/evm/execute-transactions.md): Execute arbitrary transactions with lifecycle management using Web3 libraries on React Native
- [Get Transaction Receipt](https://docs.getpara.com/v2/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/v2/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/v2/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/v2/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/v2/react-native/guides/web3-operations/evm/send-tokens.md): Transfer ETH and ERC-20 tokens using Web3 libraries with Para on React Native
- [Setup EVM Libraries](https://docs.getpara.com/v2/react-native/guides/web3-operations/evm/setup-libraries.md): Configure Ethers.js or Viem to work with Para's secure wallet infrastructure on React Native
- [Sign Messages](https://docs.getpara.com/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/react-native/guides/web3-operations/solana/setup-libraries.md): Install and configure Solana Web3.js, @solana/kit, or Anchor for use with Para SDK on React Native
- [Sign Messages with Solana Libraries](https://docs.getpara.com/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/react-native/guides/web3-operations/stellar/verify-signatures.md): Verify Ed25519 signatures from Stellar addresses in React Native
- [Overview](https://docs.getpara.com/v2/react-native/overview.md): An introduction to mobile integrations with Para
- [React Native Quickstart](https://docs.getpara.com/v2/react-native/quickstart.md): Get started with Para's React Native SDK in minutes
- [Expo](https://docs.getpara.com/v2/react-native/setup/expo.md): Set up the Para SDK in an Expo project.
- [Bare Workflow](https://docs.getpara.com/v2/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/v2/react-native/troubleshooting.md): Resolving integration issues for Para in React Native and Expo environments
- [Web Examples](https://docs.getpara.com/v2/react/examples.md): Explore Para's web integration examples across popular frameworks
- [Account Linking](https://docs.getpara.com/v2/react/guides/account-linking.md): Allow your users to link their external accounts with their Para account
- [Configure Content Security Policy (CSP)](https://docs.getpara.com/v2/react/guides/csp.md): Configure Content Security Policy for Para SDK in Next.js and Vite applications
- [Custom Chains](https://docs.getpara.com/v2/react/guides/custom-chains.md): Learn how to use custom EVM, SVM, or Cosmos chains in your application
- [Custom Auth UI with React Hooks](https://docs.getpara.com/v2/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/v2/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/v2/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.
- [Developer Portal Email Branding](https://docs.getpara.com/v2/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/v2/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/v2/react/guides/customization/developer-portal-security.md): Configure authentication methods, session management, and transaction permissions
- [Get Your API Key](https://docs.getpara.com/v2/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/v2/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/v2/react/guides/customization/guest-mode.md): Allow users to use your app via guest wallets without signing up.
- [Configure Authentication](https://docs.getpara.com/v2/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/v2/react/guides/customization/modal-events.md): Handle modal events, callbacks, and configure advanced modal behavior options.
- [Configure Security](https://docs.getpara.com/v2/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/v2/react/guides/customization/modal-theming.md): Customize the appearance of the Para Modal with themes, colors, fonts, and custom palettes.
- [Customization Basics](https://docs.getpara.com/v2/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/v2/react/guides/customization/overview.md): Learn how to customize Para to match your brand and user needs.
- [Modal Customization](https://docs.getpara.com/v2/react/guides/customizing.md): Learn how to customize Para for your application
- [Cosmos Wallets With React SDK Lite](https://docs.getpara.com/v2/react/guides/external-wallets/cosmos-lite.md)
- [Connect Cosmos Wallets](https://docs.getpara.com/v2/react/guides/external-wallets/cosmos.md): Learn how to combine the Para Modal with Cosmos wallets.
- [EVM Wallets With React SDK Lite](https://docs.getpara.com/v2/react/guides/external-wallets/evm-lite.md)
- [Connect EVM Wallets](https://docs.getpara.com/v2/react/guides/external-wallets/evm.md): Learn how to combine the Para Modal with EVM wallets.
- [Connect Multichain Wallets](https://docs.getpara.com/v2/react/guides/external-wallets/multichain.md): Learn how to combine EVM, Solana, and Cosmos wallets with the Para Modal.
- [Overview](https://docs.getpara.com/v2/react/guides/external-wallets/overview.md): Learn how to use Para with external wallets like MetaMask, Phantom, and Keplr.
- [Solana Wallets With React SDK Lite](https://docs.getpara.com/v2/react/guides/external-wallets/solana-lite.md)
- [Connect Solana Wallets](https://docs.getpara.com/v2/react/guides/external-wallets/solana.md): Learn how to combine the Para Modal with Solana wallets.
- [React Hooks](https://docs.getpara.com/v2/react/guides/hooks.md): State management and SDK interactions using Para's React hooks
- [ParaProvider](https://docs.getpara.com/v2/react/guides/hooks/para-provider.md): React context provider for Para SDK integration
- [useAccount](https://docs.getpara.com/v2/react/guides/hooks/use-account.md): Hook for retrieving the current embedded account and connected external wallets
- [useAddAuthMethod](https://docs.getpara.com/v2/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/v2/react/guides/hooks/use-client.md): Hook for accessing the Para client instance
- [useCosmjsAminoSigner](https://docs.getpara.com/v2/react/guides/hooks/use-cosmjs-amino-signer.md): Hook for retrieving a Cosmjs Amino signer for a Para wallet
- [useCosmjsProtoSigner](https://docs.getpara.com/v2/react/guides/hooks/use-cosmjs-proto-signer.md): Hook for retrieving a Cosmjs Proto signer for a Para wallet
- [useCreateWallet](https://docs.getpara.com/v2/react/guides/hooks/use-create-wallet.md): Hook for creating new wallets for the authenticated user
- [useIssueJwt](https://docs.getpara.com/v2/react/guides/hooks/use-issue-jwt.md): Hook for issuing JWT tokens for session verification
- [useKeepSessionAlive](https://docs.getpara.com/v2/react/guides/hooks/use-keep-session-alive.md): Hook for maintaining active user sessions
- [useLogout](https://docs.getpara.com/v2/react/guides/hooks/use-logout.md): Hook for logging out the current user
- [useModal](https://docs.getpara.com/v2/react/guides/hooks/use-modal.md): Hook for controlling the Para modal
- [useSignMessage](https://docs.getpara.com/v2/react/guides/hooks/use-sign-message.md): Hook for signing messages with a wallet
- [useSignTransaction](https://docs.getpara.com/v2/react/guides/hooks/use-sign-transaction.md): Hook for signing blockchain transactions
- [useSignUpOrLogIn](https://docs.getpara.com/v2/react/guides/hooks/use-sign-up-or-login.md): Hook for initiating the authentication flow
- [useSolanaSigner](https://docs.getpara.com/v2/react/guides/hooks/use-solana-signer.md): Hook for retrieving a Solana signer for a Para wallet
- [useStellarSigner](https://docs.getpara.com/v2/react/guides/hooks/use-stellar-signer.md): Hook for retrieving a Stellar signer for a Para wallet
- [useVerifyNewAccount](https://docs.getpara.com/v2/react/guides/hooks/use-verify-new-account.md): Hook for verifying new accounts with verification codes
- [useViemAccount](https://docs.getpara.com/v2/react/guides/hooks/use-viem-account.md): Hook for retrieving a Viem account for a Para wallet
- [useViemClient](https://docs.getpara.com/v2/react/guides/hooks/use-viem-client.md): Hook for retrieving a Viem client for a Viem client for a Para wallet
- [useWalletBalance](https://docs.getpara.com/v2/react/guides/hooks/use-wallet-balance.md): Hook for retrieving the balance of the selected wallet
- [useWalletState](https://docs.getpara.com/v2/react/guides/hooks/use-wallet-state.md): Hook for managing the currently selected wallet
- [useWallet](https://docs.getpara.com/v2/react/guides/hooks/use-wallet.md): Hook for retrieving the currently selected wallet
- [Migrating from Reown to Para](https://docs.getpara.com/v2/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/v2/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/v2/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/v2/react/guides/migrations.md): Migrate your existing wallet integration to Para SDK
- [Permissions](https://docs.getpara.com/v2/react/guides/permissions.md): Configure user-facing transaction confirmation dialogs
- [Wallet Pregeneration](https://docs.getpara.com/v2/react/guides/pregen.md): Learn how to create and manage pregenerated wallets for users with Para's SDK
- [Reown AppKit Integration](https://docs.getpara.com/v2/react/guides/reown-appkit.md): Integrate Para as the wallet provider in Reown AppKit
- [JWT Token Management](https://docs.getpara.com/v2/react/guides/sessions-jwt.md): Issuing and verifying JWT tokens for Para session attestation
- [Session Lifecycle](https://docs.getpara.com/v2/react/guides/sessions-lifecycle.md): Managing the lifecycle of authentication sessions in Para
- [Pregenerated Wallet Sessions](https://docs.getpara.com/v2/react/guides/sessions-pregen.md): Session management for Para pregenerated wallets
- [Session Transfer](https://docs.getpara.com/v2/react/guides/sessions-transfer.md): Exporting Para sessions for server-side operations
- [Web Session Management](https://docs.getpara.com/v2/react/guides/sessions.md): Overview of authentication session management in Para for web applications
- [Upgrade Auth Methods](https://docs.getpara.com/v2/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/v2/react/guides/wagmi-connector.md): Use Para as a Wagmi connector to build custom wallet connection interfaces
- [Claim Staking Rewards](https://docs.getpara.com/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/react/guides/web3-operations/cosmos/verify-signatures.md): Verify message and transaction signatures using CosmJS
- [Account Abstraction Integrations](https://docs.getpara.com/v2/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/v2/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/v2/react/guides/web3-operations/evm/estimate-gas.md): Calculate gas costs for transactions including EIP-1559 gas pricing
- [Execute Transactions](https://docs.getpara.com/v2/react/guides/web3-operations/evm/execute-transactions.md): Execute arbitrary transactions with lifecycle management using Web3 libraries
- [Get Transaction Receipt](https://docs.getpara.com/v2/react/guides/web3-operations/evm/get-transaction-receipt.md): Check transaction status, confirmations, and retrieve receipt details
- [Interact with Contracts](https://docs.getpara.com/v2/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/v2/react/guides/web3-operations/evm/manage-allowances.md): Approve tokens, check allowances, and implement permit signatures
- [Query Wallet Balances](https://docs.getpara.com/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/react/guides/web3-operations/solana/setup-libraries.md): Install and configure Solana Web3.js or Anchor for use with Para SDK
- [SWIG Account Abstraction](https://docs.getpara.com/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/react/guides/web3-operations/stellar/send-tokens.md): Transfer XLM using the Stellar SDK with Para wallets
- [Setup Stellar Libraries](https://docs.getpara.com/v2/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/v2/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/v2/react/guides/web3-operations/stellar/verify-signatures.md): Verify Ed25519 signatures from Stellar addresses
- [Switch Active Wallet](https://docs.getpara.com/v2/react/guides/web3-operations/switch-wallet.md): Change the currently selected wallet for blockchain operations
- [React SDK Overview](https://docs.getpara.com/v2/react/overview.md): Complete guide to integrating Para's React SDK for Web3 authentication and wallet management
- [React SDK Quickstart](https://docs.getpara.com/v2/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/v2/react/setup/nextjs.md): A guide to integrate Para into a Next.js application
- [Para with TanStack Start](https://docs.getpara.com/v2/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/v2/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/v2/react/testing-guide.md): Use test credentials to develop and test your Para integration without creating real users
- [CRA with CRACO](https://docs.getpara.com/v2/react/troubleshooting/cra.md): Navigating Para integration complexities in CRA projects using CRACO
- [Next.js](https://docs.getpara.com/v2/react/troubleshooting/nextjs.md): Troubleshooting Para integration with Next.js applications
- [React with Vite](https://docs.getpara.com/v2/react/troubleshooting/react-vite.md): Overcoming Para integration challenges in Vite-powered React applications
- [Svelte](https://docs.getpara.com/v2/react/troubleshooting/svelte.md): Overcoming Para integration challenges in Svelte applications
- [TanStack Start Troubleshooting](https://docs.getpara.com/v2/react/troubleshooting/tanstack-start.md): Overcoming Para integration challenges in TanStack Start applications
- [Vue.js Troubleshooting](https://docs.getpara.com/v2/react/troubleshooting/vue.md): Resolving common Para SDK integration challenges with Vue.js applications
- [addCredential](https://docs.getpara.com/v2/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/v2/references/core/claimpregenwallets.md): Claims pregenerated wallets for the user
- [clearStorage](https://docs.getpara.com/v2/references/core/clearstorage.md): Clears the specified storage type
- [createGuestWallets](https://docs.getpara.com/v2/references/core/createguestwallets.md): Creates guest wallets
- [createPregenWallet](https://docs.getpara.com/v2/references/core/createpregenwallet.md): Creates a pregenerated wallet of a specific type
- [createPregenWalletPerType](https://docs.getpara.com/v2/references/core/createpregenwalletpertype.md): Creates pregenerated wallets for specified types
- [createWallet](https://docs.getpara.com/v2/references/core/createwallet.md): Creates a new wallet
- [createWalletPerType](https://docs.getpara.com/v2/references/core/createwalletpertype.md): Creates wallets for specified types
- [distributeNewWalletShare](https://docs.getpara.com/v2/references/core/distributenewwalletshare.md): Distributes a new wallet share
- [enable2fa](https://docs.getpara.com/v2/references/core/enable2fa.md): Enables two-factor authentication using the provided code
- [exportSession](https://docs.getpara.com/v2/references/core/exportsession.md): Exports the current session data
- [fetchWallets](https://docs.getpara.com/v2/references/core/fetchwallets.md): Fetches wallet entities from the server
- [getAuthInfo](https://docs.getpara.com/v2/references/core/getauthinfo.md): Retrieves the current authentication information for the user
- [getFarcasterConnectUri](https://docs.getpara.com/v2/references/core/getfarcasterconnecturi.md): Generates a Farcaster connect URI for authentication
- [getLinkedAccounts](https://docs.getpara.com/v2/references/core/getlinkedaccounts.md): Retrieves linked accounts for the user
- [getOAuthUrl](https://docs.getpara.com/v2/references/core/getoauthurl.md): Generates an OAuth URL for third-party authentication
- [getPregenWallets](https://docs.getpara.com/v2/references/core/getpregenwallets.md): Retrieves pregenerated wallets
- [getUserShare](https://docs.getpara.com/v2/references/core/getusershare.md): Retrieves the user's share
- [getVerificationToken](https://docs.getpara.com/v2/references/core/getverificationtoken.md): Retrieves a verification token
- [getWalletBalance](https://docs.getpara.com/v2/references/core/getwalletbalance.md): Retrieves the balance for a wallet
- [getWallets](https://docs.getpara.com/v2/references/core/getwallets.md): Retrieves all wallets for the user
- [getWalletsByType](https://docs.getpara.com/v2/references/core/getwalletsbytype.md): Retrieves wallets of a specific type
- [hasPregenWallet](https://docs.getpara.com/v2/references/core/haspregenwallet.md): Checks if a pregenerated wallet exists for the given ID
- [importSession](https://docs.getpara.com/v2/references/core/importsession.md): Imports session data
- [initiateOnRampTransaction](https://docs.getpara.com/v2/references/core/initiateonramptransaction.md): Initiates an on-ramp transaction
- [isFullyLoggedIn](https://docs.getpara.com/v2/references/core/isfullyloggedin.md): Checks if the user is fully logged in
- [isSessionActive](https://docs.getpara.com/v2/references/core/issessionactive.md): Checks if the current session is active
- [issueJwt](https://docs.getpara.com/v2/references/core/issuejwt.md): Issues a JWT token
- [keepSessionAlive](https://docs.getpara.com/v2/references/core/keepsessionalive.md): Keeps the current session alive
- [loginExternalWallet](https://docs.getpara.com/v2/references/core/loginexternalwallet.md): Initiates login using an external wallet
- [logout](https://docs.getpara.com/v2/references/core/logout.md): Logs out the current user
- [refreshSession](https://docs.getpara.com/v2/references/core/refreshsession.md): Refreshes the current session
- [refreshShare](https://docs.getpara.com/v2/references/core/refreshshare.md): Refreshes a wallet share
- [resendVerificationCode](https://docs.getpara.com/v2/references/core/resendverificationcode.md): Resends a verification code for signup, login, or account linking
- [setup2fa](https://docs.getpara.com/v2/references/core/setup2fa.md): Sets up two-factor authentication for the user
- [setUserShare](https://docs.getpara.com/v2/references/core/setusershare.md): Sets the user's share
- [signMessage](https://docs.getpara.com/v2/references/core/signmessage.md): Signs a message using the specified wallet
- [signTransaction](https://docs.getpara.com/v2/references/core/signtransaction.md): Signs a transaction using the specified wallet
- [signUpOrLogIn](https://docs.getpara.com/v2/references/core/signuporlogin.md): Initiates signup or login for a user based on the provided authentication details
- [updatePregenWalletIdentifier](https://docs.getpara.com/v2/references/core/updatepregenwalletidentifier.md): Updates the identifier for a pregenerated wallet
- [verify2fa](https://docs.getpara.com/v2/references/core/verify2fa.md): Verifies two-factor authentication
- [verifyExternalWallet](https://docs.getpara.com/v2/references/core/verifyexternalwallet.md): Verifies an external wallet for authentication
- [verifyFarcaster](https://docs.getpara.com/v2/references/core/verifyfarcaster.md): Verifies Farcaster authentication
- [verifyNewAccount](https://docs.getpara.com/v2/references/core/verifynewaccount.md): Verifies a new account using the provided verification code
- [verifyOAuth](https://docs.getpara.com/v2/references/core/verifyoauth.md): Verifies OAuth authentication
- [verifyTelegram](https://docs.getpara.com/v2/references/core/verifytelegram.md): Verifies Telegram authentication
- [waitForLogin](https://docs.getpara.com/v2/references/core/waitforlogin.md): Polls and waits for the login process to complete
- [waitForSignup](https://docs.getpara.com/v2/references/core/waitforsignup.md): Polls and waits for the signup process to complete
- [waitForWalletCreation](https://docs.getpara.com/v2/references/core/waitforwalletcreation.md): Polls and waits for wallet creation to complete
- [ParaProvider](https://docs.getpara.com/v2/references/hooks/ParaProvider.md): React context provider component that wraps your application to provide access to Para hooks
- [useAccount](https://docs.getpara.com/v2/references/hooks/useAccount.md): React Query hook for retrieving the current embedded account and connected external wallets
- [useAccountLinkInProgress](https://docs.getpara.com/v2/references/hooks/useAccountLinkInProgress.md): Hook for returning the account linking status of the user
- [useAddAuthMethod](https://docs.getpara.com/v2/references/hooks/useAddAuthMethod.md): React hook for adding a new auth method to the user's account
- [useClaimPregenWallets](https://docs.getpara.com/v2/references/hooks/useClaimPregenWallets.md): React hook for claiming pregenerated wallets
- [useClient](https://docs.getpara.com/v2/references/hooks/useClient.md): Hook for retrieving the Para client instance
- [useCosmjsAminoSigner](https://docs.getpara.com/v2/references/hooks/useCosmjsAminoSigner.md): Hook to retrieve a CosmJS Amino signer for Para Cosmos wallets
- [useCosmjsProtoSigner](https://docs.getpara.com/v2/references/hooks/useCosmjsProtoSigner.md): Hook to retrieve a CosmJS Proto signer for Para Cosmos wallets
- [useCreateGuestWallets](https://docs.getpara.com/v2/references/hooks/useCreateGuestWallets.md): React hook for creating guest wallets
- [useCreatePregenWallet](https://docs.getpara.com/v2/references/hooks/useCreatePregenWallet.md): React hook for creating pregenerated wallets
- [useCreatePregenWalletPerType](https://docs.getpara.com/v2/references/hooks/useCreatePregenWalletPerType.md): React hook for creating pregenerated wallets per type
- [useCreateWallet](https://docs.getpara.com/v2/references/hooks/useCreateWallet.md): React hook for creating wallets
- [useCreateWalletPerType](https://docs.getpara.com/v2/references/hooks/useCreateWalletPerType.md): React hook for creating wallets per type
- [useEnable2fa](https://docs.getpara.com/v2/references/hooks/useEnable2fa.md): React hook to enable two-factor authentication (2FA)
- [useHasPregenWallet](https://docs.getpara.com/v2/references/hooks/useHasPregenWallet.md): React hook for checking if a pregenerated wallet exists
- [useIsFullyLoggedIn](https://docs.getpara.com/v2/references/hooks/useIsFullyLoggedIn.md): Hook for returning whether the user is fully logged in with Para
- [useIssueJwt](https://docs.getpara.com/v2/references/hooks/useIssueJwt.md): React hook for issuing a JWT token
- [useKeepSessionAlive](https://docs.getpara.com/v2/references/hooks/useKeepSessionAlive.md): React hook for keeping the session alive
- [useLinkAccount](https://docs.getpara.com/v2/references/hooks/useLinkAccount.md)
- [useLinkedAccounts](https://docs.getpara.com/v2/references/hooks/useLinkedAccounts.md): Hook for returning the linked accounts of the user
- [useLoginExternalWallet](https://docs.getpara.com/v2/references/hooks/useLoginExternalWallet.md)
- [useLogout](https://docs.getpara.com/v2/references/hooks/useLogout.md): React hook for logging out
- [useModal](https://docs.getpara.com/v2/references/hooks/useModal.md)
- [useParaStatus](https://docs.getpara.com/v2/references/hooks/useParaStatus.md)
- [useResendVerificationCode](https://docs.getpara.com/v2/references/hooks/useResendVerificationCode.md)
- [useSetup2fa](https://docs.getpara.com/v2/references/hooks/useSetup2fa.md)
- [useSignMessage](https://docs.getpara.com/v2/references/hooks/useSignMessage.md)
- [useSignTransaction](https://docs.getpara.com/v2/references/hooks/useSignTransaction.md)
- [useSignUpOrLogIn](https://docs.getpara.com/v2/references/hooks/useSignUpOrLogIn.md)
- [useSolanaSigner](https://docs.getpara.com/v2/references/hooks/useSolanaSigner.md)
- [useStellarSigner](https://docs.getpara.com/v2/references/hooks/useStellarSigner.md)
- [useUpdatePregenWalletIdentifier](https://docs.getpara.com/v2/references/hooks/useUpdatePregenWalletIdentifier.md)
- [useVerify2fa](https://docs.getpara.com/v2/references/hooks/useVerify2fa.md)
- [useVerifyExternalWallet](https://docs.getpara.com/v2/references/hooks/useVerifyExternalWallet.md)
- [useVerifyFarcaster](https://docs.getpara.com/v2/references/hooks/useVerifyFarcaster.md)
- [useVerifyNewAccount](https://docs.getpara.com/v2/references/hooks/useVerifyNewAccount.md)
- [useVerifyOAuth](https://docs.getpara.com/v2/references/hooks/useVerifyOAuth.md)
- [useVerifyTelegram](https://docs.getpara.com/v2/references/hooks/useVerifyTelegram.md)
- [useViemAccount](https://docs.getpara.com/v2/references/hooks/useViemAccount.md)
- [useViemClient](https://docs.getpara.com/v2/references/hooks/useViemClient.md)
- [useWaitForLogin](https://docs.getpara.com/v2/references/hooks/useWaitForLogin.md)
- [useWaitForSignup](https://docs.getpara.com/v2/references/hooks/useWaitForSignup.md)
- [useWaitForWalletCreation](https://docs.getpara.com/v2/references/hooks/useWaitForWalletCreation.md)
- [useWallet](https://docs.getpara.com/v2/references/hooks/useWallet.md): Hook for retrieving the selected wallet
- [useWalletBalance](https://docs.getpara.com/v2/references/hooks/useWalletBalance.md): Hook for retrieving a wallet balance
- [useWalletState](https://docs.getpara.com/v2/references/hooks/useWalletState.md)
- [API Reference](https://docs.getpara.com/v2/references/overview.md): Complete reference documentation for Para SDK methods, hooks, and types
- [AccountLinkError](https://docs.getpara.com/v2/references/types/accountlinkerror.md): Error types for account linking
- [AccountLinkInProgress](https://docs.getpara.com/v2/references/types/accountlinkinprogress.md): Represents an in-progress account link
- [AuthMethod](https://docs.getpara.com/v2/references/types/authmethod.md): Authentication methods
- [AuthState](https://docs.getpara.com/v2/references/types/authstate.md): Union of authentication states: verify, login, or signup
- [AuthStateSignup](https://docs.getpara.com/v2/references/types/authstatesignup.md): The authentication state for signup
- [AuthStateSignupOrLogin](https://docs.getpara.com/v2/references/types/authstatesignuporlogin.md): Union type for signup or login authentication states
- [AuthStateVerify](https://docs.getpara.com/v2/references/types/authstateverify.md): The authentication state for verification
- [AuthStateVerifyOrLogin](https://docs.getpara.com/v2/references/types/authstateverifyorlogin.md): Union type for verify or login authentication states
- [AuthType](https://docs.getpara.com/v2/references/types/authtype.md): Union of authentication types
- [BackupKitEmailProps](https://docs.getpara.com/v2/references/types/backupkitemailprops.md): Properties for backup kit emails
- [BorderRadius](https://docs.getpara.com/v2/references/types/borderradius.md): Border radius options for themes
- [Callbacks](https://docs.getpara.com/v2/references/types/callbacks.md): Event callbacks for Para SDK events
- [ConstructorOpts](https://docs.getpara.com/v2/references/types/constructoropts.md): Options for SDK constructor
- [CoreAuthInfo](https://docs.getpara.com/v2/references/types/coreauthinfo.md): Core authentication information
- [Ctx](https://docs.getpara.com/v2/references/types/ctx.md): Context configuration for the SDK
- [CurrentWalletIds](https://docs.getpara.com/v2/references/types/currentwalletids.md): Partial record of wallet IDs by type
- [EmailTheme](https://docs.getpara.com/v2/references/types/emailtheme.md): Themes for emails
- [EmbeddedWalletType](https://docs.getpara.com/v2/references/types/embeddedwallettype.md): Type for embedded wallets
- [EnabledFlow](https://docs.getpara.com/v2/references/types/enabledflow.md): Enabled flows for on-ramp configurations
- [Environment](https://docs.getpara.com/v2/references/types/environment.md): Available environments for the SDK
- [ExternalWalletConfig](https://docs.getpara.com/v2/references/types/externalwalletconfig.md): Configuration for external wallets
- [ExternalWalletInfo](https://docs.getpara.com/v2/references/types/externalwalletinfo.md): Information for an external wallet
- [ExternalWalletType](https://docs.getpara.com/v2/references/types/externalwallettype.md): Type for external wallets
- [FullSignatureRes](https://docs.getpara.com/v2/references/types/fullsignatureres.md): Full result of a signing operation
- [GetWalletBalanceResponse](https://docs.getpara.com/v2/references/types/getwalletbalanceresponse.md): Response type for wallet balance
- [IssueJwtResponse](https://docs.getpara.com/v2/references/types/issuejwtresponse.md): Response for issuing a JWT
- [LinkedAccounts](https://docs.getpara.com/v2/references/types/linkedaccounts.md): Structure for primary and linked accounts
- [Network](https://docs.getpara.com/v2/references/types/network.md): Supported networks
- [OAuthResponse](https://docs.getpara.com/v2/references/types/oauthresponse.md): Response type for OAuth verification
- [OnRampAsset](https://docs.getpara.com/v2/references/types/onrampasset.md): Supported on-ramp assets
- [OnRampProvider](https://docs.getpara.com/v2/references/types/onrampprovider.md): On-ramp providers
- [OnRampPurchase](https://docs.getpara.com/v2/references/types/onramppurchase.md): Details of an on-ramp purchase
- [OnRampPurchaseCreateParams](https://docs.getpara.com/v2/references/types/onramppurchasecreateparams.md): Parameters for creating an on-ramp purchase
- [OnRampPurchaseStatus](https://docs.getpara.com/v2/references/types/onramppurchasestatus.md): Statuses for on-ramp purchases
- [OnRampPurchaseType](https://docs.getpara.com/v2/references/types/onramppurchasetype.md): Types of on-ramp purchases
- [ParaEvent](https://docs.getpara.com/v2/references/types/paraevent.md): Events emitted by the Para SDK
- [ParaModalProps](https://docs.getpara.com/v2/references/types/paramodalprops.md): Props for the Para modal
- [ParaProviderConfig](https://docs.getpara.com/v2/references/types/paraproviderconfig.md): Configuration for the ParaProvider
- [PartnerEntity](https://docs.getpara.com/v2/references/types/partnerentity.md): Details for a partner entity
- [PollParams](https://docs.getpara.com/v2/references/types/pollparams.md): Parameters for polling operations
- [PregenAuth](https://docs.getpara.com/v2/references/types/pregenauth.md): Authentication type for pregen identifiers
- [Setup2faResponse](https://docs.getpara.com/v2/references/types/setup2faresponse.md): Response for setting up 2FA
- [StorageType](https://docs.getpara.com/v2/references/types/storagetype.md): Types of storage
- [SuccessfulSignatureRes](https://docs.getpara.com/v2/references/types/successfulsignatureres.md): Successful signature result
- [SupportedAccountLinks](https://docs.getpara.com/v2/references/types/supportedaccountlinks.md): Supported account link types
- [SupportedWalletTypes](https://docs.getpara.com/v2/references/types/supportedwallettypes.md): Array of supported wallet types with optional flag
- [TelegramAuthResponse](https://docs.getpara.com/v2/references/types/telegramauthresponse.md): Response from Telegram authentication
- [TExternalWallet](https://docs.getpara.com/v2/references/types/texternalwallet.md): External wallet provider types
- [Theme](https://docs.getpara.com/v2/references/types/theme.md): Theme configuration for the portal
- [TLinkedAccountType](https://docs.getpara.com/v2/references/types/tlinkedaccounttype.md): Types of linked accounts
- [TOAuthMethod](https://docs.getpara.com/v2/references/types/toauthmethod.md): OAuth method types
- [TPregenIdentifierType](https://docs.getpara.com/v2/references/types/tpregenidentifiertype.md): Types of pregen identifiers
- [TWalletScheme](https://docs.getpara.com/v2/references/types/twalletscheme.md): Wallet scheme types
- [TWalletType](https://docs.getpara.com/v2/references/types/twallettype.md): Wallet type union
- [VerifiedAuth](https://docs.getpara.com/v2/references/types/verifiedauth.md): Verified authentication details
- [Verify2faResponse](https://docs.getpara.com/v2/references/types/verify2faresponse.md): Response for verifying 2FA
- [Wallet](https://docs.getpara.com/v2/references/types/wallet.md): Represents a wallet entity
- [WalletEntity](https://docs.getpara.com/v2/references/types/walletentity.md): Server-side wallet entity
- [WalletFilters](https://docs.getpara.com/v2/references/types/walletfilters.md): Filters for selecting wallets
- [Migrate SDK pregen wallets to REST API](https://docs.getpara.com/v2/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/v2/rest/multi-wallet.md): Create multiple wallets for a single user using custom identifiers
- [REST API](https://docs.getpara.com/v2/rest/overview.md): Server-to-server wallet and signing over HTTP
- [Setup](https://docs.getpara.com/v2/rest/setup.md): Authenticate and make your first REST request
- [Server Examples](https://docs.getpara.com/v2/server/examples.md): Explore Para's server-side integration examples across Node.js, Bun, and Deno
- [Account Abstraction](https://docs.getpara.com/v2/server/guides/account-abstraction.md): Implement ERC-4337 and EIP-7702 Account Abstraction with Para Server SDK
- [Cosmos Integration](https://docs.getpara.com/v2/server/guides/cosmos.md): Use Para Server SDK with Cosmos-based blockchains
- [EVM Integration](https://docs.getpara.com/v2/server/guides/evm.md): Use Para Server SDK with Ethereum and EVM-compatible chains
- [Wallet Pregeneration](https://docs.getpara.com/v2/server/guides/pregen.md): Create and manage server-side pregenerated wallets using Para's Server SDK
- [Session Management](https://docs.getpara.com/v2/server/guides/sessions.md): Manage client sessions in server-side environments with Para Server SDK
- [Solana Integration](https://docs.getpara.com/v2/server/guides/solana.md): Use Para Server SDK with Solana blockchain
- [Stellar Integration](https://docs.getpara.com/v2/server/guides/stellar.md): Use Para Server SDK with Stellar blockchain
- [Para Server SDK](https://docs.getpara.com/v2/server/overview.md): An introduction to server-side integrations with Para
- [Server Setup](https://docs.getpara.com/v2/server/setup.md): Install and configure the Para Server SDK across Node.js, Bun, and Deno environments
- [Server Troubleshooting](https://docs.getpara.com/v2/server/troubleshooting.md): Common issues and solutions for Para Server SDK
- [Para + Svelte](https://docs.getpara.com/v2/svelte/setup/overview.md): Discover options for using Para with Svelte.
- [Para with SvelteKit](https://docs.getpara.com/v2/svelte/setup/svelte-kit.md): A user-friendly guide to integrate the React-based Para Modal into your SvelteKit application.
- [Para with Svelte + Vite](https://docs.getpara.com/v2/svelte/setup/vite.md)
- [Swift SDK API Reference](https://docs.getpara.com/v2/swift/api/sdk.md): Comprehensive API reference for the Para Swift SDK (v2.0.0 Alpha)
- [Mobile Examples](https://docs.getpara.com/v2/swift/examples.md): Explore Para's mobile integration examples for Swift
- [Cosmos Integration](https://docs.getpara.com/v2/swift/guides/cosmos.md): Sign transactions for Cosmos chains using Para's unified wallet architecture
- [Email & Phone Login](https://docs.getpara.com/v2/swift/guides/email-phone-login.md): Implement Para's unified email and phone authentication flow in Swift.
- [EVM Integration](https://docs.getpara.com/v2/swift/guides/evm.md): Transfer ETH and interact with EVM chains using Para's unified wallet architecture
- [External Wallets](https://docs.getpara.com/v2/swift/guides/external-wallets.md): Instructions for using external wallets with the ParaSwift SDK.
- [Wallet Pregeneration & Claiming](https://docs.getpara.com/v2/swift/guides/pregen.md): Pregenerate and claim wallets in your Swift applications (Coming Soon)
- [Swift Session Management](https://docs.getpara.com/v2/swift/guides/sessions.md): Guide to managing authentication sessions in Para for Swift applications
- [Social Login](https://docs.getpara.com/v2/swift/guides/social-login.md): Instructions for implementing social login with the ParaSwift SDK.
- [Solana Integration](https://docs.getpara.com/v2/swift/guides/solana.md): Sign Solana transactions using Para's unified wallet architecture
- [Swift SDK Overview](https://docs.getpara.com/v2/swift/overview.md): Para Swift SDK documentation for iOS wallet integration
- [Setup](https://docs.getpara.com/v2/swift/setup.md): Step-by-step guide for integrating the Para Swift SDK into your iOS application
- [Troubleshooting](https://docs.getpara.com/v2/swift/troubleshooting.md): Solutions for common issues with the Para Swift SDK integration
- [Para with Nuxt 3](https://docs.getpara.com/v2/vue/setup/nuxt.md): A guide to integrate the Para Modal (React-based) into your Nuxt 3 application.
- [Para + Vue](https://docs.getpara.com/v2/vue/setup/overview.md): Discover options for using Para with Vue.
- [Para with Vue + Vite](https://docs.getpara.com/v2/vue/setup/vite.md): A guide to integrate the Para Modal (React-based) into your Vue application powered by Vite.
- [Integrate Para Wallets with Eliza OS](https://docs.getpara.com/v2/walkthroughs/Eliza.md): Build wallet-enabled AI agents using Para's infrastructure and Eliza OS framework
- [Integrating Para with Rhinestone](https://docs.getpara.com/v2/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/v2/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/v2/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/v2/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/v2/walkthroughs/aave.md): Combine Para's wallet infrastructure with Aave's lending protocol to enable seamless borrowing, lending, and yield strategies
- [Integrate Arc Chain with Para](https://docs.getpara.com/v2/walkthroughs/arc.md): This walkthrough explores how to use Para with Arc Chain using Para SDK.
- [Integrate Brale with Para](https://docs.getpara.com/v2/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/v2/walkthroughs/bulk-pregeneration.md): Learn how to bulk pregenerate Para wallets for Twitter users and enable seamless wallet claiming
- [Chrome Extension Integration with Para](https://docs.getpara.com/v2/walkthroughs/chrome-extension-integration.md): Learn how to build Chrome extensions with Para, including state persistence, background workers, and seamless user authentication
- [EIP-712 Typed Data Signing with Para](https://docs.getpara.com/v2/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/v2/walkthroughs/ethereum-transfers.md): Learn how to send ETH transactions using Para with both Ethers and Viem libraries
- [Inco Integration](https://docs.getpara.com/v2/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/v2/walkthroughs/m0.md): Combine Para's embedded wallets with M0's programmable stablecoin infrastructure
- [Miden Integration](https://docs.getpara.com/v2/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/v2/walkthroughs/migration-mcp.md): Use AI-powered tooling to automatically migrate your app from Privy, Reown, Web3Modal, or WalletConnect to Para
- [Para Walkthroughs & Modules](https://docs.getpara.com/v2/walkthroughs/overview.md): Step-by-step guides for integrating Para's wallet infrastructure with popular platforms and protocols
- [Integrating Para with Porto](https://docs.getpara.com/v2/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/v2/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/v2/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, 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.