Keychain

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

Pourquoi Keychain ?

• Interface unique : Une interface de base SolanaSigner sur tous les backends, plus une capacité par backend : signer, réécrire puis signer, ou signer puis diffuser
• Changement de backend : Changez de fournisseur de gestion de clés via la configuration ; les sites d'appel ne changent que lorsque 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, était hors périmètre) ; un audit antérieur d'Accretion couvrait Rust et TypeScript. Consultez l'état des audits.

Architecture

• Langages : Rust, TypeScript, Python et Go, à parité (le backend Ledger est disponible uniquement 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é : Compatible @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 en tant que 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 du backend
• PyPI - Package Python

Go

Chaque backend est son propre module Go, 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 du backend
• 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.