Rust

[dependencies]
# Memory signer only (default)
solana-keychain = "0.5"

# Or specify backends explicitly
solana-keychain = { version = "0.5", default-features = false, features = ["vault", "aws_kms"] }

# All backends
solana-keychain = { version = "0.5", features = ["all"] }

use solana_keychain::{SolanaSigner, Signer, SignerError, SignTransactionResult};
use solana_sdk::transaction::Transaction;

async fn sign_transaction(
    signer: &impl SolanaSigner,
    tx: &mut Transaction,
) -> Result<(), SignerError> {
    // Get the signer's public key
    let pubkey = signer.pubkey();
    println!("Signing with: {}", pubkey);

    // Check availability (useful for remote signers)
    if !signer.is_available().await {
        return Err(SignerError::NotAvailable("Signer offline".into()));
    }

    // Sign the transaction — returns Complete or Partial
    let result = signer.sign_transaction(tx).await?;
    let (base64_tx, signature) = result.into_signed_transaction();
    println!("Signature: {}", signature);

    Ok(())
}

use solana_keychain::Signer;

// From base58 private key
let signer = Signer::from_memory("base58_private_key")?;

// From JSON file path
let signer = Signer::from_memory("/path/to/keypair.json")?;

// From byte array string
let signer = Signer::from_memory("[1,2,3,...]")?;

use solana_keychain::Signer;

let signer = Signer::from_vault(
    "https://vault.example.com:8200".to_string(), // Vault address
    "hvs.xxxxx".to_string(),                      // Vault token
    "my-solana-key".to_string(),                  // Key name in Transit
    "base58_public_key".to_string(),              // Expected public key
    None,                                         // Default HTTP timeouts
)?;

use solana_keychain::Signer;

let signer = Signer::from_aws_kms(
    "alias/my-solana-key".to_string(),   // KMS key ID or alias
    "base58_public_key".to_string(),     // Expected public key
    Some("us-east-1".to_string()),       // Region (optional)
).await?;

use solana_keychain::Signer;

let signer = Signer::from_privy(
    "app_id".to_string(),      // Privy app ID
    "app_secret".to_string(),  // Privy app secret
    "wallet_id".to_string(),   // Wallet ID
    None,                      // Default HTTP timeouts
).await?;

use solana_keychain::Signer;

let signer = Signer::from_turnkey(
    "api_public_key".to_string(),   // Turnkey API public key
    "api_private_key".to_string(),  // Turnkey API private key
    "org_id".to_string(),           // Organization ID
    "private_key_id".to_string(),   // Private key ID in Turnkey
    "base58_public_key".to_string(),// Expected public key
    None,                           // Default HTTP timeouts
)?;

use solana_keychain::{Signer, FireblocksSignerConfig};

let config = FireblocksSignerConfig {
    api_key: "api_key".to_string(),
    private_key_pem: "-----BEGIN RSA PRIVATE KEY-----\n...".to_string(),
    vault_account_id: "0".to_string(),
    asset_id: "SOL".to_string(), // or "SOL_TEST" for devnet
};

let signer = Signer::from_fireblocks(config).await?;

use solana_keychain::Signer;

let signer = Signer::from_gcp_kms(
    "projects/my-project/locations/us-east1/keyRings/my-ring/cryptoKeys/my-key/cryptoKeyVersions/1".to_string(),
    "base58_public_key".to_string(),
).await?;

use solana_keychain::Signer;

let signer = Signer::from_cdp(
    "api_key_id".to_string(),     // CDP API key ID
    "api_key_secret".to_string(), // CDP API private key (base64 Ed25519)
    "wallet_secret".to_string(),  // CDP wallet secret (base64 PKCS#8 DER)
    "base58_address".to_string(), // Solana account address
    None,                         // Default HTTP timeouts
)?;

use solana_keychain::{Signer, CrossmintSignerConfig};

let config = CrossmintSignerConfig {
    api_key: "api_key".to_string(),
    wallet_locator: "wallet_locator".to_string(),
    signer_secret: None,
    signer: None,
    api_base_url: None,
    poll_interval_ms: None,
    max_poll_attempts: None,
};

let signer = Signer::from_crossmint(config).await?;

use solana_keychain::{Signer, DfnsSignerConfig};

let config = DfnsSignerConfig {
    auth_token: "auth_token".to_string(),
    cred_id: "cred_id".to_string(),
    private_key_pem: "-----BEGIN EC PRIVATE KEY-----\n...".to_string(),
    app_id: "app_id".to_string(),
    wallet_id: "wallet_id".to_string(),
    api_base_url: None,
    http_client_config: None,
};

let signer = Signer::from_dfns(config).await?;

use solana_keychain::Signer;

let signer = Signer::from_para(
    "api_key".to_string(),   // Para API key
    "wallet_id".to_string(), // Para wallet ID
    None,                    // Default API base URL
).await?;

use solana_keychain::{Signer, SolanaSigner, SignerError};

async fn get_signer(backend: &str) -> Result<Signer, SignerError> {
    match backend {
        "memory" => Signer::from_memory("base58_key"),
        "vault" => Signer::from_vault(/* ... */),
        "kms" => Signer::from_aws_kms(/* ... */).await,
        _ => Err(SignerError::ConfigError("Unknown backend".into())),
    }
}

// Use it generically
let signer = get_signer("kms").await?;
let pubkey = signer.pubkey();