Privy RS

https://docs.rs/privy-rs/0.1.0-alpha.3
Admin
Privy RS is a Rust SDK for the Privy API that provides wallet operations, cryptographic key...
Tokens:2,497
Snippets:11
Trust Score:9.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Handle Errors with Privy SDK (Rust)

Source: https://context7.com/context7/rs_privy-rs_0_1_0-alpha_3/llms.txt

Provides an example of robust error handling for API calls, network issues, and authentication failures when using the privy-rs SDK. It demonstrates using `match` statements to propagate and display errors during client creation, wallet creation, and message signing.

```rust
use privy_rs::{AuthorizationContext, PrivyClient};
use privy_rs::generated::types::*;
use std::env;

#[tokio::main]
async fn main() {
    let client = match PrivyClient::new(
        env::var("PRIVY_APP_ID").unwrap_or_default(),
        env::var("PRIVY_APP_SECRET").unwrap_or_default(),
    ) {
        Ok(c) => c,
        Err(e) => {
            eprintln!("Failed to create client: {}", e);
            return;
        }
    };

    let wallet_result = client
        .wallets()
        .create(
            None,
            &CreateWalletBody {
                chain_type: WalletChainType::Ethereum,
                additional_signers: None,
                owner: None,
                owner_id: Some("user-error-test".to_string()),
                policy_ids: vec![],
            },
        )
        .await;

    match wallet_result {
        Ok(wallet) => {
            println!("Wallet created: {}", wallet.id);

            let sign_result = client
                .wallets()
                .ethereum()
                .sign_message(
                    &wallet.id,
                    "Test message",
                    &AuthorizationContext::new(),
                    None,
                )
                .await;

            match sign_result {
                Ok(sig) => println!("Signed: {}", sig.signature),
                Err(e) => eprintln!("Sign failed: {}", e),
            }
        }
        Err(e) => eprintln!("Wallet creation failed: {}", e),
    }
}
```

--------------------------------

### Rust: Initialize PrivyClient

Source: https://docs.rs/privy-rs/0.1.0-alpha.3/crates/privy-rs

This snippet demonstrates how to initialize the PrivyClient using environment variables for the PRIVY_APP_ID and PRIVY_APP_SECRET. This client is the entry point for interacting with the Privy API.

```rust
use privy_rs::PrivyClient;

let client = PrivyClient::new(
    env::var("PRIVY_APP_ID").unwrap(),
    env::var("PRIVY_APP_SECRET").unwrap(),
)?;
```

--------------------------------

### Initialize PrivyClient in Rust

Source: https://context7.com/context7/rs_privy-rs_0_1_0-alpha_3/llms.txt

Initializes a PrivyClient instance using application ID and secret from environment variables. This client is the entry point for all Privy API services. It requires the 'tokio' runtime and 'privy_rs' crate.

```rust
use privy_rs::PrivyClient;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PrivyClient::new(
        env::var("PRIVY_APP_ID").unwrap(),
        env::var("PRIVY_APP_SECRET").unwrap(),
    )?;

    println!("Privy client initialized successfully");
    Ok(())
}
```

--------------------------------

### Create Ethereum and Solana Wallets in Rust

Source: https://context7.com/context7/rs_privy-rs_0_1_0-alpha_3/llms.txt

Demonstrates creating both Ethereum and Solana embedded wallets using the PrivyClient. It specifies the chain type and an owner ID for the wallets. The function returns wallet details including ID and address.

```rust
use privy_rs::generated::types::*;
use privy_rs::PrivyClient;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PrivyClient::new(
        env::var("PRIVY_APP_ID").unwrap(),
        env::var("PRIVY_APP_SECRET").unwrap(),
    )?;

    // Create an Ethereum wallet
    let eth_wallet = client
        .wallets()
        .create(
            None,
            &CreateWalletBody {
                chain_type: WalletChainType::Ethereum,
                additional_signers: None,
                owner: None,
                owner_id: Some("user-123".to_string()),
                policy_ids: vec![],
            },
        )
        .await?;

    println!("Created Ethereum wallet: {}", eth_wallet.id);
    println!("Wallet address: {}", eth_wallet.address);

    // Create a Solana wallet
    let sol_wallet = client
        .wallets()
        .create(
            None,
            &CreateWalletBody {
                chain_type: WalletChainType::Solana,
                additional_signers: None,
                owner: None,
                owner_id: Some("user-123".to_string()),
                policy_ids: vec![],
            },
        )
        .await?;

    println!("Created Solana wallet: {}", sol_wallet.id);
    println!("Wallet address: {}", sol_wallet.address);

    Ok(())
}
```

--------------------------------

### Rust: Sign a message on Ethereum using Privy

Source: https://docs.rs/privy-rs/0.1.0-alpha.3/crates/privy-rs

This snippet shows how to sign a UTF-8 message on the Ethereum network using the Privy SDK. It utilizes the Ethereum service from the client and requires an AuthorizationContext.

```rust
use privy_rs::{AuthorizationContext};

let ethereum_service = client.wallets().ethereum();
let auth_ctx = AuthorizationContext::new();

// Sign a UTF-8 message
let result = ethereum_service
    .sign_message(
        &wallet.id,
        "Hello, Ethereum!",
        &auth_ctx,
        None, // no idempotency key
    )
    .await?;
```

--------------------------------

### Sign Solana Message with Privy SDK (Rust)

Source: https://context7.com/context7/rs_privy-rs_0_1_0-alpha_3/llms.txt

Demonstrates signing a base64-encoded message using a Solana embedded wallet via the privy-rs SDK. It covers client initialization, wallet creation, and the signing process, including idempotency support. Requires PRIVY_APP_ID and PRIVY_APP_SECRET environment variables.

```rust
use privy_rs::{AuthorizationContext, PrivyClient};
use privy_rs::generated::types::*;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PrivyClient::new(
        env::var("PRIVY_APP_ID").unwrap(),
        env::var("PRIVY_APP_SECRET").unwrap(),
    )?;

    // Create a Solana wallet first
    let wallet = client
        .wallets()
        .create(
            None,
            &CreateWalletBody {
                chain_type: WalletChainType::Solana,
                additional_signers: None,
                owner: None,
                owner_id: Some("user-789".to_string()),
                policy_ids: vec![],
            },
        )
        .await?;

    let solana_service = client.wallets().solana();
    let auth_ctx = AuthorizationContext::new();

    // Base64 encode your message first
    let message = base64::encode("Hello, Solana! Proving ownership with signature.");
    let signature = solana_service
        .sign_message(
            &wallet.id,
            &message,
            &auth_ctx,
            Some("unique-request-id-sol-456"),
        )
        .await?;

    println!("Solana message signed successfully");
    println!("Signature: {}", signature.signature);
    println!("Transaction hash: {:?}", signature.transaction_hash);

    Ok(())
}
```

--------------------------------

### Access Wallet Services via Privy SDK (Rust)

Source: https://context7.com/context7/rs_privy-rs_0_1_0-alpha_3/llms.txt

Illustrates how to navigate the privy-rs SDK's hierarchical service structure to access different blockchain operations. Shows accessing general wallet services and then chain-specific services like Ethereum and Solana.

```rust
use privy_rs::PrivyClient;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PrivyClient::new(
        env::var("PRIVY_APP_ID").unwrap(),
        env::var("PRIVY_APP_SECRET").unwrap(),
    )?;

    // Access general wallet operations
    let wallet_service = client.wallets();

    // Access Ethereum-specific operations
    let ethereum_service = wallet_service.ethereum();

    // Access Solana-specific operations
    let solana_service = wallet_service.solana();

    println!("All services initialized and ready");

    // Example: List or manage wallets using wallet_service
    // Example: Sign Ethereum transactions using ethereum_service
    // Example: Sign Solana transactions using solana_service

    Ok(())
}
```

--------------------------------

### Rust: Sign a message on Solana using Privy

Source: https://docs.rs/privy-rs/0.1.0-alpha.3/crates/privy-rs

This snippet demonstrates how to sign a message on the Solana network using the Privy SDK. The message must be Base64 encoded first, and an optional idempotency key can be provided.

```rust
use privy_rs::{AuthorizationContext};

let solana_service = client.wallets().solana();
let auth_ctx = AuthorizationContext::new();

// Base64 encode your message first
let message = base64::encode("Hello, Solana!");
let signature = solana_service
    .sign_message(
        &wallet.id, // make sure to use a solana wallet
        &message,
        &auth_ctx,
        Some("unique-request-id-456"),
    )
    .await?;
```

--------------------------------

### Rust: Create a new wallet with Privy

Source: https://docs.rs/privy-rs/0.1.0-alpha.3/crates/privy-rs

This snippet illustrates how to create a new wallet using the PrivyClient. It specifies the chain type as Ethereum and requires a CreateWalletBody struct to be passed.

```rust
use privy_rs::generated::types::*;

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

--------------------------------

### Sign Message on Ethereum in Rust

Source: https://context7.com/context7/rs_privy-rs_0_1_0-alpha_3/llms.txt

Signs an arbitrary UTF-8 message using an Ethereum embedded wallet. It first creates a wallet if one doesn't exist, then uses the `sign_message` method with an authorization context and an optional idempotency key. The output includes the signature and wallet ID.

```rust
use privy_rs::{AuthorizationContext, PrivyClient};
use privy_rs::generated::types::*;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PrivyClient::new(
        env::var("PRIVY_APP_ID").unwrap(),
        env::var("PRIVY_APP_SECRET").unwrap(),
    )?;

    // Create an Ethereum wallet first
    let wallet = client
        .wallets()
        .create(
            None,
            &CreateWalletBody {
                chain_type: WalletChainType::Ethereum,
                additional_signers: None,
                owner: None,
                owner_id: Some("user-456".to_string()),
                policy_ids: vec![],
            },
        )
        .await?;

    let ethereum_service = client.wallets().ethereum();
    let auth_ctx = AuthorizationContext::new();

    // Sign a UTF-8 message
    let result = ethereum_service
        .sign_message(
            &wallet.id,
            "Hello, Ethereum! This message proves wallet ownership.",
            &auth_ctx,
            Some("idempotency-key-eth-001"), // Optional idempotency key
        )
        .await?;

    println!("Message signed successfully");
    println!("Signature: {}", result.signature);
    println!("Wallet ID: {}", result.wallet_id);

    Ok(())
}
```

--------------------------------

### Rust: Add privy-rs dependency to Cargo.toml

Source: https://docs.rs/privy-rs/0.1.0-alpha.3/crates/privy-rs

This snippet shows how to add the privy-rs crate as a dependency in your Rust project's Cargo.toml file to include its functionality.

```rust
[dependencies]
privy-rs = "0.1.0-alpha"
```
Tokens:
Raw