Keychain

Solana Keychain bietet eine einheitliche Schnittstelle zum Signieren von Solana-Transaktionen über mehrere Key-Management-Backends hinweg. Entwickeln Sie lokal mit einem In-Memory- Schlüssel und wechseln Sie in der Produktion zu Enterprise-Key-Management, Cloud-HSMs oder Managed-Wallet- Diensten, ohne Ihren Signaturcode neu schreiben zu müssen.

Warum Keychain?

• Eine Schnittstelle: Eine SolanaSigner-Basisschnittstelle für alle Backends, plus eine Capability pro Backend: Signieren, Umschreiben und Signieren oder Signieren und Senden
• Backends austauschen: Wechseln Sie den Anbieter für das Key Management per Konfiguration; Aufrufstellen ändern sich nur, wenn das neue Backend eine andere Capability hat (native Modi von Crossmint und Fordefi)
• Zahlen Sie nur für das, was Sie nutzen: Rust-Feature-Flags, npm-Pakete pro Backend, Python- Extras und Go-Module pro Backend enthalten nur die Backends, die Sie benötigen
• Geprüft: Rust, TypeScript, Python und Go wurden von OtterSec auditiert (das optionale Ledger-Backend lag außerhalb des Umfangs); ein früheres Audit von Accretion deckte Rust und TypeScript ab. Siehe Audit-Status.

Architektur

• Sprachen: Rust, TypeScript, Python und Go, mit gleichem Funktionsumfang (das Ledger-Backend gibt es nur für Rust)
• Schnittstelle: SolanaSigner-Basis (pubkey, sign_message, is_available) plus genau eine Capability pro Backend: TransactionSigner, ModifyingSigner oder SendingSigner
• Backends: Memory, Vault, AWS KMS, GCP KMS, Privy, Turnkey, Fireblocks, CDP, Crossmint, Dfns, Openfort, Para, Utila, Fordefi, Ledger (nur Rust, optional, nicht auditiert)
• Kompatibilität: @solana/kit und @solana/signers 8.1+ (TypeScript) | solana-sdk 2.x, 3.x oder 4.x über die Features sdk-v2 / sdk-v3 / sdk-v4 (Rust; v1-Transaktionen benötigen sdk-v4) | solders (Python) | solana-go v2 (Go)

Unterstützte Backends

Die Backends umfassen lokale Entwicklung, selbst gehostetes und cloudbasiertes Key-Management sowie verwaltete oder MPC-Wallet-Dienste. Siehe Backend auswählen, um Custody- Modelle zu vergleichen und das passende auszuwählen.

Schnellstart

Rust

Installiere das Rust-Crate:

cargo add solana-keychain

Grundlegende Verwendung:

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

• Rust-Leitfaden - Vollständige Installation und Backend-Konfiguration
• Crates.io - Rust-Crate

TypeScript

Installiere das TypeScript-Paket:

pnpm add @solana/keychain

Grundlegende Verwendung:

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

• TypeScript-Leitfaden - @solana/keychain Pakete
• npm-Paket - npm-Paket

Um einen Keychain-Signer in einem Kit-Client als payer oder identity zu installieren, verwenden Sie @solana/keychain-kit-plugin (die nativen Modi von Crossmint und Fordefi sind ausgeschlossen, da sie Transaktionen umschreiben).

Python

Installieren Sie das Paket (umfangreichere Backends werden als Extras ausgeliefert, zum Beispiel solana-keychain[aws-kms]):

pip install solana-keychain

Grundlegende Verwendung:

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)

• Python-Leitfaden – Vollständige Installation, Extras und Backend-Konfiguration
• PyPI – Python-Paket

Go

Jedes Backend ist ein eigenes Go-Modul, sodass Sie nur die Backends einbinden, die Sie importieren:

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

Grundlegende Verwendung:

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)

• Go-Leitfaden – Module, Capabilities und Backend-Konfiguration
• pkg.go.dev – Go-Referenz

Nächste Schritte

Quelle

• GitHub-Repository
• Versionsverlauf
• Sicherheitsmodell
• Migration auf 2.0

Entwickelt und gepflegt von der Solana Foundation. Lizenziert unter MIT.