Wallet Pregeneration

For new server-side wallet creation, use the REST API instead. It covers the same use cases (pre-created user wallets, agent wallets, server-side signing) without requiring you to store, encrypt, and restore user shares or run an MPC ceremony per signature. This guide covers SDK-based pregeneration for existing integrations and for flows that need direct user-share control. To move an existing integration, see Migrate SDK pregen wallets to REST API.

Pregenerated wallets let your server create wallets before a user authenticates with Para. The flow works by creating a wallet associated with an identifier of your choice (email, phone, username, or custom ID). Para then provides you with the user share of the 2/2 MPC key, which you must securely store on your server until it’s either claimed by a user or used for signing operations. Because your server holds the user share, SDK pregeneration is the right choice only when you need that control directly — for example, signing with SDK ecosystem integrations (Ethers, Viem, Solana, CosmJS) before the wallet is claimed, or exporting key material through client flows.

Creating a Pregenerated Wallet

import { Para as ParaServer } from "@getpara/server-sdk";

const paraServer = new ParaServer("YOUR_API_KEY");
const pregenId = { email: "user@example.com" };

const hasWallet = await paraServer.hasPregenWallet({
  pregenId,
});

if (!hasWallet) {
  await paraServer.createPregenWallet({
    type: "EVM",
    pregenId,
  });
}

import { Para as ParaServer } from "@getpara/server-sdk";

const paraServer = new ParaServer("YOUR_API_KEY", {
  disableWebSockets: true
});
const pregenId = { email: "user@example.com" };

const hasWallet = await paraServer.hasPregenWallet({
  pregenId,
});

if (!hasWallet) {
  await paraServer.createPregenWallet({
    type: "EVM",
    pregenId,
  });
}

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

const paraServer = new ParaServer("YOUR_API_KEY", {
  disableWebSockets: true
});
const pregenId = { email: "user@example.com" };

const hasWallet = await paraServer.hasPregenWallet({
  pregenId,
});

if (!hasWallet) {
  await paraServer.createPregenWallet({
    type: WalletType.EVM,
    pregenId,
  });
}

Method Parameters

object

Show properties

TWalletType

required

The type of wallet to create ('EVM', 'SOLANA', 'COSMOS', or 'STELLAR').

PregenAuth

required

The identifier for the new wallet. The pregenId must be an object of the form:

| { email: string; }
| { phone: `+${number}`; }
| { farcasterUsername: string; }
| { telegramUserId: string; }
| { discordUsername: string; }
| { xUsername: string; }
| { customId: string; }

The identifier can be an email or phone number, a third-party user ID (for Farcaster, Telegram, Discord, or X), or a custom ID relevant to your application. Choose an identifier that works best for your application architecture.

After creating a pregenerated wallet, you must securely store the user share. This component is critical for the wallet’s operation and security.

const userShare = await paraServer.getUserShare();
const encryptedUserShare = await encryptUserShare(userShare);
await database.pregenWallets.save({
  walletId,
  encryptedUserShare,
});

You must securely store this user share in your backend, associated with the user’s identifier. If this share is lost, the wallet becomes permanently inaccessible.

Secure Storage Best Practices

We strongly recommend implementing robust encryption for user shares both in transit and at rest. Consider using a high-entropy encryption key with AES-GCM encryption. Do not store encryption keys in the same database as the encrypted data.

Para offers pre-launch security reviews for teams in the Growth tier or above. Reach out to the Para team for assistance with your implementation!

Storage Security Recommendations

Encrypt user shares in-transit and at-rest
Implement access controls for your share database
Maintain regular database backups to prevent data loss
Create disaster recovery processes for compromise scenarios
Have a key rotation plan in case of security incidents
Complete security fire drills before launching

Using a Pregenerated Wallet

To use a pregenerated wallet for blockchain operations, you need to:

Retrieve the encrypted user share from your database
Decrypt the user share
Load it into your Para client instance

const encryptedUserShare = await database.getUserShare(walletId);
const userShare = decryptUserShare(encryptedUserShare);

await paraServer.setUserShare(userShare);

When implementing setUserShare in API routes or serverless functions, it’s critical to create a new Para client instance for each request. This prevents different users’ shares from conflicting with each other. Creating a new Para client has minimal overhead and won’t impact request performance.

Signing Operations

Once the user share is loaded, you can test the wallet functionality by signing a message. However, for production use, we recommend using the blockchain library integrations described in the next section.

const messageBase64 = Buffer.from("Hello, World!").toString('base64');
const signature = await paraServer.signMessage({
  walletId,
  messageBase64,
});

Using with Blockchain Libraries

Pregenerated wallets work seamlessly with all blockchain integration libraries. Here are some examples:

Wallet Claiming Flow

Claiming pregenerated wallets must be done client-side with the Para Client SDK. The Server SDK does not support the key rotation operations required for wallet claiming.

For applications that need to transfer ownership of pregenerated wallets to users, implement a client-side claiming flow. Your backend still prepares the stored user share for the authenticating identifier before the client receives it.

Look up the stored pregenerated wallet from the authenticating identifier
Decrypt and load the stored user share into a fresh server-side Para client
Update the pregenerated wallet identifier if it was created with a custom ID
Return the updated user share to the client
Let the client SDK load the share and claim the wallet

import { Para as ParaServer } from "@getpara/server-sdk";

export async function preparePregenClaim(email: string) {
  const wallet = await getPregenWalletByEmail(email);
  const para = new ParaServer(process.env.PARA_API_KEY!);
  const userShare = await decryptUserShare(wallet.encryptedUserShare);

  await para.setUserShare(userShare);
  await para.updatePregenWalletIdentifier({
    walletId: wallet.walletId,
    newPregenId: { email },
  });

  return {
    userShare: await para.getUserShare(),
  };
}

Calling setUserShare before updatePregenWalletIdentifier lets the server SDK update the wallet metadata in the loaded share. Return that updated share to the client so the loaded wallet identifier matches the user’s auth identifier during claim.

For a comprehensive guide on implementing the claiming flow, refer to our web documentation:

Core Pregeneration Methods

Show Server SDK Pregeneration Methods

function

Create a new pregenerated wallet for an identifier

function

Check if a pregenerated wallet exists for an identifier

function

Retrieve pregenerated wallets for a given identifier

Get the user share that must be securely stored

Load a previously stored user share

function

Update the identifier of a pregenerated wallet

Best Practices

Choose appropriate identifiers that align with your application architecture
Implement robust encryption for user share storage
Create backup systems to prevent data loss
Use a separate database for user share storage with enhanced security
Monitor for suspicious activity in your pregenerated wallet systems
Implement rate-limiting to prevent abuse of wallet creation
Document your recovery procedures for security incidents
Consider multi-region replication for high-availability systems

Example Implementation

Here’s a reference example demonstrating the creation and secure storage of pregenerated wallets:

Community Showcase

Check out some novel use cases of pregenerated wallets created by our community:

Get Started

Set Up Project

Manage Sessions

Use Pregeneration

Sign from Server

Add Advanced Features

Wallet Pregeneration

Creating a Pregenerated Wallet

Method Parameters

Secure Storage Best Practices

Storage Security Recommendations

Using a Pregenerated Wallet

Signing Operations

Using with Blockchain Libraries

Wallet Claiming Flow

Core Pregeneration Methods

Best Practices

Example Implementation

Community Showcase

​Creating a Pregenerated Wallet

​Method Parameters

​Securing the User Share

​Secure Storage Best Practices

​Storage Security Recommendations

​Using a Pregenerated Wallet

​Signing Operations

​Using with Blockchain Libraries

​Wallet Claiming Flow

​Core Pregeneration Methods

​Best Practices

​Example Implementation

​Community Showcase

Creating a Pregenerated Wallet

Method Parameters

Securing the User Share

Secure Storage Best Practices

Storage Security Recommendations

Using a Pregenerated Wallet

Signing Operations

Using with Blockchain Libraries

Wallet Claiming Flow

Core Pregeneration Methods

Best Practices

Example Implementation

Community Showcase