Keychain

Solana Keychain fournit une interface unifiée pour signer des transactions Solana via plusieurs backends de gestion de clés. Développez en local avec une clé en mémoire, puis passez à une gestion de clés d'entreprise, à des HSM cloud ou à des services de portefeuille gérés en production, sans avoir à réécrire votre code de signature.

Pourquoi Keychain ?

• Interface unique : une seule interface de base SolanaSigner pour tous les backends, plus une capacité par backend : signer, réécrire puis signer, ou signer puis diffuser
• Changez de backend : modifiez de fournisseur de gestion de clés via la configuration ; les points d'appel ne changent que si le nouveau backend offre une capacité différente (modes natifs de Crossmint et Fordefi)
• Ne payez que ce que vous utilisez : les feature flags Rust, les packages npm par backend, les extras Python et les modules Go par backend n'incluent que les backends dont vous avez besoin
• Audité : Rust, TypeScript, Python et Go audités par OtterSec (le backend Ledger, optionnel, n'était pas inclus dans le périmètre) ; un audit antérieur d'Accretion couvrait Rust et TypeScript. Voir l'état des audits.

Architecture

• Langages : Rust, TypeScript, Python et Go, à parité (le backend Ledger n'existe qu'en Rust)
• Interface : base SolanaSigner (pubkey, sign_message, is_available) plus exactement une capacité par backend : TransactionSigner, ModifyingSigner ou SendingSigner
• Backends : Memory, Vault, AWS KMS, GCP KMS, Privy, Turnkey, Fireblocks, CDP, Crossmint, Dfns, Openfort, Para, Utila, Fordefi, Ledger (Rust uniquement, optionnel, non audité)
• Compatibilité : @solana/kit et @solana/signers 8.1+ (TypeScript) | solana-sdk 2.x, 3.x ou 4.x via les features sdk-v2 / sdk-v3 / sdk-v4 (Rust ; les transactions v1 nécessitent sdk-v4) | solders (Python) | solana-go v2 (Go)

Backends pris en charge

Les backends couvrent le développement local, la gestion de clés auto-hébergée et cloud, ainsi que les services de portefeuille gérés ou MPC. Consultez Choisir un backend pour comparer les modèles de garde et choisir le plus adapté.

Démarrage rapide

Rust

Installez le crate Rust :

cargo add solana-keychain

Utilisation de base :

use solana_keychain::{Signer, SolanaSigner};

// Create a signer from any backend
let signer = Signer::from_memory("base58_private_key")?;
let pubkey = signer.pubkey();

// Transaction signing is a capability; `tx` is a VersionedTransaction
if let Some(tx_signer) = signer.as_transaction_signer() {
    let result = tx_signer.sign_transaction(&mut tx).await?;
}

// Or let the umbrella route any backend shape and supply the RPC hop yourself
let signature = signer
    .sign_and_send(&mut tx, |encoded| async move { broadcast(encoded).await })
    .await?;

• Guide Rust - Installation complète et configuration du backend
• Crates.io - Crate Rust

TypeScript

Installez le package TypeScript :

pnpm add @solana/keychain

Utilisation de base :

import { createKeychainSigner } from "@solana/keychain";
import { signTransactionWithSigners } from "@solana/signers";

// Create any signer via the unified factory
const signer = await createKeychainSigner({
  backend: "vault",
  vaultAddr: "https://vault.example.com:8200",
  vaultToken: "hvs.xxxxx",
  keyName: "my-solana-key",
  publicKey: "base58_public_key"
});

// Sign an already-compiled transaction
const signedTx = await signTransactionWithSigners(
  [signer],
  compiledTransaction
);

• Guide TypeScript - Packages @solana/keychain
• Package npm - Package npm

Pour installer un signataire Keychain sur un client Kit comme payer ou identity, utilisez @solana/keychain-kit-plugin (les modes natifs de Crossmint et Fordefi sont exclus, car ils réécrivent les transactions).

Python

Installez le package (les backends les plus lourds sont fournis sous forme d'extras, par exemple solana-keychain[aws-kms]) :

pip install solana-keychain

Utilisation de base :

import os

from solana_keychain import VaultSignerConfig, create_vault_signer

signer = await create_vault_signer(
    VaultSignerConfig(
        api_base_url="https://vault.example.com:8200",
        token=os.environ["VAULT_TOKEN"],
        key_name="my-solana-key",
        public_key="base58_public_key",
    )
)

# tx is a solders VersionedTransaction
result = await signer.sign_transaction(tx)

• Guide Python - Installation complète, extras et configuration des backends
• PyPI - package Python

Go

Chaque backend est un module Go distinct : vous ne récupérez donc que les backends que vous importez :

go get github.com/solana-foundation/solana-keychain/go/signers/vault/v2@latest

Utilisation de base :

import "github.com/solana-foundation/solana-keychain/go/signers/vault/v2"

signer, err := vault.New(vault.Config{
	VaultAddr: "https://vault.example.com:8200",
	Token:     os.Getenv("VAULT_TOKEN"),
	KeyName:   "my-solana-key",
	Pubkey:    "base58_public_key",
})
if err != nil {
	return err
}

// tx is a *solana.Transaction from solana-go v2
res, err := signer.SignTransaction(ctx, tx)

• Guide Go - Modules, capacités et configuration des backends
• pkg.go.dev - Référence Go

Prochaines étapes

Source

• Dépôt GitHub
• Historique des versions
• Modèle de sécurité
• Migration vers la version 2.0

Construit et maintenu par la Solana Foundation. Distribué sous licence MIT.