Keychain

Solana Keychain fornisce un'interfaccia unificata per la firma delle transazioni Solana su più backend di gestione delle chiavi. Sviluppa in locale con una chiave in memoria, poi passa alla gestione enterprise delle chiavi, HSM cloud o servizi di wallet gestiti in produzione, senza riscrivere il codice di firma.

Perché Keychain?

• Interfaccia Unica: Un'unica interfaccia di base SolanaSigner su tutti i backend, più una capability per ciascun backend: firma, riscrittura e firma, oppure firma e broadcast
• Cambio di Backend: Cambia i provider di gestione delle chiavi tramite configurazione; i punti di chiamata cambiano solo quando il nuovo backend ha una capability diversa (modalità native di Crossmint e Fordefi)
• Paga solo ciò che usi: i feature flag di Rust, i pacchetti npm per singolo backend, gli extra di Python e i moduli Go per singolo backend includono solo i backend di cui hai bisogno
• Sottoposto ad audit: Rust, TypeScript, Python e Go sottoposti ad audit da parte di OtterSec (il backend Ledger opt-in era fuori ambito); un precedente audit di Accretion ha coperto Rust e TypeScript. Consulta lo stato degli audit.

Architettura

• Linguaggi: Rust, TypeScript, Python e Go, in parità di funzionalità (il backend Ledger è disponibile solo per Rust)
• Interfaccia: base SolanaSigner (pubkey, sign_message, is_available) più esattamente una capability per backend: TransactionSigner, ModifyingSigner o SendingSigner
• Backend: Memory, Vault, AWS KMS, GCP KMS, Privy, Turnkey, Fireblocks, CDP, Crossmint, Dfns, Openfort, Para, Utila, Fordefi, Ledger (solo Rust, opt-in, non sottoposto ad audit)
• Compatibilità: @solana/kit e @solana/signers 8.1+ (TypeScript) | solana-sdk 2.x, 3.x o 4.x tramite le feature sdk-v2 / sdk-v3 / sdk-v4 (Rust; le transazioni v1 richiedono sdk-v4) | solders (Python) | solana-go v2 (Go)

Backend Supportati

I backend coprono lo sviluppo locale, la gestione delle chiavi self-hosted e cloud, e servizi di wallet gestiti o MPC. Consulta Scegliere un backend per confrontare i modelli di custodia e scegliere quello più adatto.

Avvio rapido

Rust

Installa il crate Rust:

cargo add solana-keychain

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

• Guida Rust - Installazione completa e configurazione del backend
• Crates.io - Crate Rust

TypeScript

Installa il pacchetto TypeScript:

pnpm add @solana/keychain

Utilizzo di 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
);

• Guida TypeScript - Pacchetti @solana/keychain
• Pacchetto npm - Pacchetto npm

Per installare un signer di Keychain su un client Kit come payer o identity, usa @solana/keychain-kit-plugin (le modalità native di Crossmint e Fordefi sono escluse, poiché riscrivono le transazioni).

Python

Installa il pacchetto (i backend più pesanti sono forniti come extra, ad esempio solana-keychain[aws-kms]):

pip install solana-keychain

Utilizzo di 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)

• Guida Python - Installazione completa, extra e configurazione del backend
• PyPI - Pacchetto Python

Go

Ogni backend è un modulo Go a sé stante, quindi scarichi solo i backend che importi:

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

Utilizzo di 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)

• Guida Go - Moduli, capability e configurazione del backend
• pkg.go.dev - Riferimento Go

Prossimi passi

Sorgente

• Repository GitHub
• Cronologia delle versioni
• Modello di sicurezza
• Migrazione alla 2.0

Sviluppato e mantenuto dalla Solana Foundation. Distribuito sotto licenza MIT.