Struct PrivyClient 

pub struct PrivyClient {
    pub jwt_exchange: JwtExchange,
    /* private fields */
}

Privy client for interacting with the Privy API.

This provides access to global operations like user and wallet management. For wallet-specific operations, use TypedWallet<T> instances created via the wallet() method.

Errors

The api calls that require a signature to run will return a PrivySignedApiError while the others will return a normal PrivyApiError.

Fields

jwt_exchange: JwtExchange

A store of all jwt operations for this client

Implementations

impl PrivyClient

pub fn new(app_id: String, app_secret: String) -> Result<Self, PrivyCreateError>

Create a new PrivyClient

Usage

let ctx = AuthorizationContext::new();
ctx.push(PrivateKey(my_key));

Errors

This can fail for two reasons, either the app_id or app_secret are not valid headers, or that the underlying http client could not be created.

pub fn new_from_env() -> Result<Self, PrivyCreateError>

Create a new PrivyClient from environment variables

Errors

This can fail for three reasons, either the app_id or app_secret are not valid headers, or that the underlying http client could not be created, or that the environment variables are not set.

Examples found in repository

examples/delete_user.rs (line 32)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Initialize client from environment variables
    let client = PrivyClient::new_from_env()?;

    tracing::info!("initialized privy client from environment");

    let user = client.users().delete("cmf56qacr01qpl90brxql83lx").await?;

    tracing::info!("deleted user: {:?}", user);

    Ok(())
}

examples/get_wallet.rs (line 34)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Get wallet ID from environment and initialize client
    let wallet_id =
        std::env::var("PRIVY_WALLET_ID").expect("PRIVY_WALLET_ID environment variable not set");
    let client = PrivyClient::new_from_env()?;

    tracing::info!(
        "initialized privy client from environment, wallet_id: {}",
        wallet_id
    );

    let wallet = client.wallets().get(&wallet_id).await?;

    tracing::info!("got wallet: {:?}", wallet);

    Ok(())
}

examples/get_transaction.rs (line 34)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Get transaction ID from environment and initialize client
    let transaction_id = std::env::var("PRIVY_TRANSACTION_ID")
        .expect("PRIVY_TRANSACTION_ID environment variable not set");
    let client = PrivyClient::new_from_env()?;

    tracing::info!(
        "initialized privy client from environment, transaction_id: {}",
        transaction_id
    );

    let transaction = client.transactions().get(&transaction_id).await?;

    tracing::info!("got transaction: {:?}", transaction);

    Ok(())
}

examples/jwt_authentication.rs (line 35)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Get JWT from environment and initialize client
    let user_jwt =
        std::env::var("PRIVY_USER_JWT").expect("PRIVY_USER_JWT environment variable not set");
    let client = PrivyClient::new_from_env()?;

    tracing::info!("initialized privy client from environment");

    let jwt_auth = client
        .wallets()
        .authenticate_with_jwt(&AuthenticateBody {
            user_jwt,
            encryption_type: None,
            recipient_public_key: None,
        })
        .await?;

    tracing::info!("got jwt auth: {:?}", jwt_auth);

    Ok(())
}

examples/create_wallet.rs (line 35)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Initialize client from environment variables
    let client = PrivyClient::new_from_env()?;

    tracing::info!("initialized privy client from environment");

    let wallet = client
        .wallets()
        .create(
            None,
            &CreateWalletBody {
                chain_type: WalletChainType::Solana,
                additional_signers: None,
                owner: None,
                owner_id: None,
                policy_ids: vec![],
            },
        )
        .await?;

    tracing::info!("got new wallet: {:?}", wallet);

    Ok(())
}

examples/get_wallets.rs (line 37)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Get additional environment variables and initialize client
    let wallet_id =
        std::env::var("PRIVY_WALLET_ID").expect("PRIVY_WALLET_ID environment variable not set");
    let public_key =
        std::env::var("PRIVY_PUBLIC_KEY").expect("PRIVY_PUBLIC_KEY environment variable not set");
    let client = PrivyClient::new_from_env()?;

    tracing::info!(
        "initialized privy client from environment, wallet_id: {}, public_key: {}",
        wallet_id,
        public_key
    );

    let wallets = client.wallets().list(None, None, Some(5.0), None).await?;

    tracing::info!("got wallets: {:?}", wallets);

    Ok(())
}

Additional examples can be found in:

• examples/search_users.rs
• examples/wallet_balance.rs
• examples/wallet_transactions.rs
• examples/create_user.rs
• examples/wallet_export.rs
• examples/wallet_raw_sign.rs
• examples/update_wallet.rs
• examples/wallet_rpc.rs
• examples/quorum_wallet.rs

pub fn new_with_options( app_id: String, app_secret: String, options: PrivyClientOptions, ) -> Result<Self, PrivyCreateError>

Create a new PrivyClient with a custom url

Errors

This can fail for two reasons, either the app_id or app_secret are not valid headers, or that the underlying http client could not be created.

pub fn utils(&self) -> Utils

Returns a new [Utils] instance

pub fn app_id(&self) -> &str

Returns the app id for the client

pub fn base_url(&self) -> &str

Returns the base url for the client

impl PrivyClient

pub fn wallets(&self) -> WalletsClient

Access the wallets client

Examples found in repository

examples/get_wallet.rs (line 41)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Get wallet ID from environment and initialize client
    let wallet_id =
        std::env::var("PRIVY_WALLET_ID").expect("PRIVY_WALLET_ID environment variable not set");
    let client = PrivyClient::new_from_env()?;

    tracing::info!(
        "initialized privy client from environment, wallet_id: {}",
        wallet_id
    );

    let wallet = client.wallets().get(&wallet_id).await?;

    tracing::info!("got wallet: {:?}", wallet);

    Ok(())
}

examples/jwt_authentication.rs (line 40)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Get JWT from environment and initialize client
    let user_jwt =
        std::env::var("PRIVY_USER_JWT").expect("PRIVY_USER_JWT environment variable not set");
    let client = PrivyClient::new_from_env()?;

    tracing::info!("initialized privy client from environment");

    let jwt_auth = client
        .wallets()
        .authenticate_with_jwt(&AuthenticateBody {
            user_jwt,
            encryption_type: None,
            recipient_public_key: None,
        })
        .await?;

    tracing::info!("got jwt auth: {:?}", jwt_auth);

    Ok(())
}

examples/create_wallet.rs (line 40)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Initialize client from environment variables
    let client = PrivyClient::new_from_env()?;

    tracing::info!("initialized privy client from environment");

    let wallet = client
        .wallets()
        .create(
            None,
            &CreateWalletBody {
                chain_type: WalletChainType::Solana,
                additional_signers: None,
                owner: None,
                owner_id: None,
                policy_ids: vec![],
            },
        )
        .await?;

    tracing::info!("got new wallet: {:?}", wallet);

    Ok(())
}

examples/get_wallets.rs (line 45)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Get additional environment variables and initialize client
    let wallet_id =
        std::env::var("PRIVY_WALLET_ID").expect("PRIVY_WALLET_ID environment variable not set");
    let public_key =
        std::env::var("PRIVY_PUBLIC_KEY").expect("PRIVY_PUBLIC_KEY environment variable not set");
    let client = PrivyClient::new_from_env()?;

    tracing::info!(
        "initialized privy client from environment, wallet_id: {}, public_key: {}",
        wallet_id,
        public_key
    );

    let wallets = client.wallets().list(None, None, Some(5.0), None).await?;

    tracing::info!("got wallets: {:?}", wallets);

    Ok(())
}

examples/wallet_balance.rs (line 49)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Get wallet ID from environment and initialize client
    let wallet_id =
        std::env::var("PRIVY_WALLET_ID").expect("PRIVY_WALLET_ID environment variable not set");
    let client = PrivyClient::new_from_env()?;

    tracing::info!(
        "initialized privy client from environment, wallet_id: {}",
        wallet_id
    );

    // Get SOL balance on Solana
    let balance = client
        .wallets()
        .balance()
        .get(
            &wallet_id,
            &GetWalletBalanceAsset::String(GetWalletBalanceAssetString::Sol),
            &GetWalletBalanceChain::String(GetWalletBalanceChainString::Solana),
            Some(GetWalletBalanceIncludeCurrency::Usd),
        )
        .await?;

    tracing::info!("got wallet balance: {:?}", balance);

    Ok(())
}

examples/wallet_transactions.rs (line 48)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Get wallet ID from environment and initialize client
    let wallet_id =
        std::env::var("PRIVY_WALLET_ID").expect("PRIVY_WALLET_ID environment variable not set");
    let client = PrivyClient::new_from_env()?;

    tracing::info!(
        "initialized privy client from environment, wallet_id: {}",
        wallet_id
    );

    // Get SOL transactions on Solana mainnet
    let transactions = client
        .wallets()
        .transactions()
        .get(
            &wallet_id,
            &WalletTransactionsAsset::String(WalletTransactionsAssetString::Sol),
            WalletTransactionsChain::Base,
            None,       // No cursor for first page
            Some(10.0), // Limit to 10 transactions,
            None,
        )
        .await?;

    tracing::info!("got wallet transactions: {:?}", transactions);

    Ok(())
}

Additional examples can be found in:

• examples/wallet_export.rs
• examples/wallet_raw_sign.rs
• examples/update_wallet.rs
• examples/wallet_rpc.rs
• examples/quorum_wallet.rs

pub fn users(&self) -> UsersClient

Access the users client

Examples found in repository

examples/delete_user.rs (line 36)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Initialize client from environment variables
    let client = PrivyClient::new_from_env()?;

    tracing::info!("initialized privy client from environment");

    let user = client.users().delete("cmf56qacr01qpl90brxql83lx").await?;

    tracing::info!("deleted user: {:?}", user);

    Ok(())
}

examples/search_users.rs (line 43)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Get search term from environment and initialize client
    let search_term =
        std::env::var("PRIVY_SEARCH_TERM").unwrap_or_else(|_| "alex@arlyon.dev".to_string());
    let client = PrivyClient::new_from_env()?;

    tracing::info!(
        "initialized privy client from environment, search_term: {}",
        search_term
    );

    // Search for users by email address or other criteria
    let search_result = client
        .users()
        // TODO: search term rename is not working
        .search(&SearchUsersBody::Variant0 { search_term })
        .await?;

    tracing::info!("search result: {:?}", search_result);

    Ok(())
}

examples/create_user.rs (line 42)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Initialize client from environment variables
    let client = PrivyClient::new_from_env()?;

    tracing::info!("initialized privy client from environment");

    let user = client
        .users()
        .create(&CreateUserBody {
            linked_accounts: vec![
                LinkedAccountInput::EmailInput(LinkedAccountEmailInput {
                    address: "alex@arlyon.dev".into(),
                    type_: LinkedAccountEmailInputType::Email,
                }),
                LinkedAccountInput::CustomJwtInput(LinkedAccountCustomJwtInput {
                    custom_user_id: "alex@arlyon.dev".try_into().unwrap(),
                    type_: LinkedAccountCustomJwtInputType::CustomAuth,
                }),
            ],
            custom_metadata: None,
            wallets: vec![],
        })
        .await?;

    tracing::info!("got new user: {:?}", user);

    Ok(())
}

pub fn policies(&self) -> PoliciesClient

Access the policies client

pub fn transactions(&self) -> TransactionsClient

Access the transactions client

Examples found in repository

examples/get_transaction.rs (line 41)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Get transaction ID from environment and initialize client
    let transaction_id = std::env::var("PRIVY_TRANSACTION_ID")
        .expect("PRIVY_TRANSACTION_ID environment variable not set");
    let client = PrivyClient::new_from_env()?;

    tracing::info!(
        "initialized privy client from environment, transaction_id: {}",
        transaction_id
    );

    let transaction = client.transactions().get(&transaction_id).await?;

    tracing::info!("got transaction: {:?}", transaction);

    Ok(())
}

pub fn key_quorums(&self) -> KeyQuorumsClient

Access the key_quorums client

Examples found in repository

examples/quorum_wallet.rs (line 84)

async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    // Initialize client from environment variables
    let client = PrivyClient::new_from_env()?;

    tracing::info!("initialized privy client from environment");

    // Generate unique identifiers for this example run
    let timestamp = std::time::SystemTime::now()
        .duration_since(std::time::SystemTime::UNIX_EPOCH)?
        .as_secs();
    let wallet_idempotency_key = format!("quorum-wallet-{}", Uuid::new_v4());

    tracing::info!("Starting quorum wallet example");

    // Step 1: Generate three P-256 private keys for quorum
    tracing::info!("Generating three P-256 private keys for 2-of-3 quorum");
    let mut rng = rand::thread_rng();
    let key1 = SecretKey::<p256::NistP256>::random(&mut rng);
    let key2 = SecretKey::<p256::NistP256>::random(&mut rng);
    let key3 = SecretKey::<p256::NistP256>::random(&mut rng);

    let pubkey1 = key1.public_key().to_string();
    let pubkey2 = key2.public_key().to_string();
    let pubkey3 = key3.public_key().to_string();

    tracing::info!("Generated public keys:");
    tracing::info!("Key 1: {}", pubkey1);
    tracing::info!("Key 2: {}", pubkey2);
    tracing::info!("Key 3: {}", pubkey3);

    // Step 2: Create a 2-of-3 key quorum
    tracing::info!("Creating 2-of-3 key quorum");

    let quorum_display_name =
        CreateKeyQuorumBodyDisplayName::try_from(format!("Quorum Example {timestamp}").as_str())?;

    let quorum_body = CreateKeyQuorumBody {
        authorization_threshold: Some(2.0), // 2-of-3 threshold
        display_name: Some(quorum_display_name),
        public_keys: vec![pubkey1, pubkey2, pubkey3],
        user_ids: vec![],
    };

    let key_quorum = client.key_quorums().create(&quorum_body).await?;

    tracing::info!("Created key quorum with ID: {}", key_quorum.id);
    tracing::info!("Quorum threshold: {:?}", key_quorum.authorization_threshold);

    // Step 3: Create a new Ethereum wallet owned by the quorum
    tracing::info!(
        "Creating new Ethereum wallet owned by quorum with idempotency key: {}",
        wallet_idempotency_key
    );

    let create_body = CreateWalletBody {
        chain_type: WalletChainType::Ethereum,
        additional_signers: None,
        owner: None,
        owner_id: Some(key_quorum.id.parse().unwrap()),
        policy_ids: vec![],
    };

    let wallet = client
        .wallets()
        .create(Some(&wallet_idempotency_key), &create_body)
        .await?;

    tracing::info!("Created wallet with ID: {}", wallet.id);
    tracing::info!("Wallet address: {}", wallet.address);
    tracing::info!("Wallet owner ID: {:?}", wallet.owner_id);

    // Step 4: Test signing with only one key (should fail)
    tracing::info!("Testing wallet export with only one key (should fail due to quorum threshold)");

    let single_key_ctx = AuthorizationContext::new().push(PrivateKey(
        key1.to_sec1_pem(der::pem::LineEnding::LF)
            .unwrap()
            .as_str()
            .to_owned(),
    ));

    let single_key_result = client.wallets().export(&wallet.id, &single_key_ctx).await;

    match single_key_result {
        Err(err) => {
            tracing::info!(
                "✓ Single key authorization correctly failed as expected: {:?}",
                err
            );
        }
        Ok(_) => {
            tracing::error!("✗ Single key authorization should have failed but succeeded!");
            return Err(anyhow::anyhow!(
                "Single key authorization should have failed due to quorum threshold"
            ));
        }
    }

    // Step 5: Test signing with two keys (should succeed)
    tracing::info!("Testing wallet export with two keys (should succeed)");

    let two_key_ctx = single_key_ctx.push(PrivateKey(
        key2.to_sec1_pem(der::pem::LineEnding::LF)
            .unwrap()
            .as_str()
            .to_owned(),
    ));

    let two_key_result = client.wallets().export(&wallet.id, &two_key_ctx).await;

    match two_key_result {
        Ok(export_result) => {
            tracing::info!("✓ Two key authorization succeeded as expected");
            tracing::info!("Exported private key length: {} bytes", export_result.len());
        }
        Err(err) => {
            tracing::error!("✗ Two key authorization failed unexpectedly: {:?}", err);
            return Err(anyhow::anyhow!(
                "Two key authorization should have succeeded"
            ));
        }
    }

    Ok(())
}

pub fn fiat(&self) -> FiatClient

Access the fiat client

Trait Implementations

impl Clone for PrivyClient

fn clone(&self) -> PrivyClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PrivyClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.