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

# Para

> Use a Para MPC wallet as the owner of a Rhinestone smart account.

Para provides non-custodial MPC wallets. Para signatures can use recovery bytes `0` and `1`, while EVM smart account validation expects `27` and `28`. Always adapt a Para viem account with `wrapParaAccount`.

## Prerequisites

* A Para project and API key
* A React application
* A backend that issues short-lived Rhinestone JWTs

<Steps>
  <Step title="Install the dependencies">
    ```bash theme={null}
    npm install @getpara/react-sdk @tanstack/react-query @rhinestone/sdk viem
    ```
  </Step>

  <Step title="Configure Para">
    ```tsx theme={null}
    'use client'

    import { Environment, ParaProvider } from '@getpara/react-sdk'
    import '@getpara/react-sdk/styles.css'
    import { QueryClient, QueryClientProvider } from '@tanstack/react-query'

    const queryClient = new QueryClient()

    export function Providers({ children }: { children: React.ReactNode }) {
      return (
        <QueryClientProvider client={queryClient}>
          <ParaProvider
            paraClientConfig={{
              apiKey: process.env.NEXT_PUBLIC_PARA_API_KEY!,
              env: Environment.BETA,
            }}
          >
            {children}
          </ParaProvider>
        </QueryClientProvider>
      )
    }
    ```

    Choose the Para environment that matches your project. The example uses Para's beta environment. Configure the application name and branding in the Para developer portal.
  </Step>

  <Step title="Configure browser authentication">
    The Para client credential identifies your Para application. It does not replace Rhinestone authentication. Keep `RHINESTONE_API_KEY` on your server and give the browser short-lived JWTs:

    ```ts theme={null}
    import { RhinestoneSDK } from '@rhinestone/sdk'

    export const rhinestone = new RhinestoneSDK({
      auth: {
        mode: 'experimental_jwt',
        accessToken: async () => {
          const response = await fetch('/api/auth/access-token', {
            credentials: 'include',
          })
          if (!response.ok) throw new Error('Unable to authenticate with Rhinestone')
          return ((await response.json()) as { token: string }).token
        },
      },
    })
    ```

    See [security](/wallets/custom-signer/integration/security) for secure token issuance.
  </Step>

  <Step title="Wrap the Para account">
    Get the authenticated viem account and wallet ID from Para. Pass both to `wrapParaAccount`, then use the result as the ECDSA owner.

    ```tsx theme={null}
    import { useWallet } from '@getpara/react-sdk'
    import { useViemAccount } from '@getpara/react-sdk/evm/hooks'
    import { wrapParaAccount } from '@rhinestone/sdk/utils'
    import { rhinestone } from './rhinestone'

    export function ConnectRhinestoneButton() {
      const { data: wallet } = useWallet()
      const { viemAccount } = useViemAccount()

      async function connect() {
        if (!viemAccount || !wallet?.id) return

        const owner = wrapParaAccount(viemAccount, wallet.id)
        const account = await rhinestone.createAccount({
          owners: { type: 'ecdsa', accounts: [owner] },
        })

        console.log(account.getAddress())
      }

      return <button onClick={connect}>Create account</button>
    }
    ```

    <Warning>
      Do not pass the unwrapped Para account to Rhinestone. Its recovery byte can make an otherwise valid signature fail onchain.
    </Warning>
  </Step>
</Steps>

For sponsored transactions, follow [sponsorship setup](/transactions/sponsorship/set-up). For the transaction lifecycle, continue to [send a transaction](/transactions/multichain/send-a-transaction).

See the [Para documentation](https://developer.getpara.com/) for authentication and wallet recovery settings.