Rust | Solana

安装

将 solana-keychain 添加到您的 Cargo.toml 中，仅启用所需的后端：

Cargo.toml

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

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

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

功能标志

功能	描述
`memory`	本地 keypair 签名（默认）
`vault`	HashiCorp Vault Transit 引擎
`aws_kms`	AWS KMS（Ed25519）
`gcp_kms`	GCP Cloud KMS（Ed25519）
`privy`	Privy 嵌入式钱包
`turnkey`	Turnkey API
`fireblocks`	Fireblocks MPC
`cdp`	Coinbase 开发者平台
`crossmint`	Crossmint 托管钱包
`dfns`	Dfns 钱包基础设施
`openfort`	Openfort 嵌入式钱包
`para`	Para MPC 钱包
`utila`	Utila MPC 托管
`fordefi`	Fordefi MPC 托管
`all`	启用所有后端

基本用法

所有签名器都实现了 SolanaSigner trait：

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,...]")?;

HashiCorp Vault

用于自托管 HSM 与 Transit 引擎：

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
)?;

AWS KMS

用于使用 AWS KMS Ed25519 密钥的云原生签名：

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?;

Privy

用于嵌入式钱包签名：

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?;

Turnkey

用于非托管签名：

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
)?;

Fireblocks

用于机构级 MPC 签名：

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?;

GCP KMS

用于使用 GCP Cloud KMS Ed25519 密钥进行云原生签名：

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?;

CDP（Coinbase 开发者平台）

用于 Coinbase 托管钱包签名：

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
)?;

Crossmint

用于 Crossmint 托管钱包签名：

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?;

Dfns

用于 Dfns 钱包基础设施签名：

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?;

Para

用于 Para MPC 钱包签名：

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?;

Fordefi

用于 Fordefi MPC 托管签名。API 请求通过从 private_key_pem 解析的 ECDSA P-256 请求签名进行身份验证；若需将该密钥保存在 KMS/HSM 中，请实现 FordefiRequestSigner 并使用 Signer::from_fordefi_with_signer。

Fordefi 有两种签名模式。设置 chain 以启用原生 Solana 模式，在该模式下，Fordefi 可能会替换区块哈希或手续费，并自行广播交易。将 chain 保留为 None 则启用黑盒模式，在该模式下，Fordefi 对原始字节进行签名，由您自行广播交易。

use solana_keychain::{
    Signer, FordefiSignerConfig, SolanaChainUniqueId, FordefiSolanaFee, FordefiPriorityLevel,
};

let config = FordefiSignerConfig {
    access_token: "api_token".to_string(),
    vault_id: "vault_uuid".to_string(),
    private_key_pem: std::fs::read_to_string("./secret/private.pem")?,
    public_key: "base58_public_key".to_string(), // Solana vault address
    chain: Some(SolanaChainUniqueId::SolanaDevnet), // None for black box mode
    fee: Some(FordefiSolanaFee::Priority {
        priority_level: FordefiPriorityLevel::Medium,
    }),
    api_base_url: None,       // Default: https://api.fordefi.com
    poll_interval_ms: None,   // Default: 2000
    max_poll_attempts: None,  // Default: 50
    http_client_config: None, // Default HTTP timeouts
};

let signer = Signer::from_fordefi(config)?;

统一签名器枚举

使用 Signer 枚举在运行时选择后端：

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();

添加自定义签名器

请参阅添加签名器指南以集成其他密钥管理服务。

Table of Contents