Keychain

Solana Keychain zapewnia ujednolicony interfejs do podpisywania transakcji Solana na wielu backendach zarządzania kluczami. Twórz lokalnie z kluczem w pamięci, a następnie przełącz się na enterprise zarządzanie kluczami, chmurowe HSM lub zarządzane usługi portfeli w środowisku produkcyjnym, bez przepisywania kodu podpisywania.

Dlaczego Keychain?

• Jeden interfejs: Jeden bazowy interfejs SolanaSigner dla wszystkich backendów oraz jedna capability na backend: podpisanie, przepisanie i podpisanie albo podpisanie i rozgłoszenie
• Wymiana backendów: Zmieniaj dostawców zarządzania kluczami przez konfigurację; miejsca wywołań zmieniają się tylko wtedy, gdy nowy backend ma inną capability (natywne tryby Crossmint i Fordefi)
• Płać tylko za to, czego używasz: Flagi funkcji (feature flags) w Rust, pakiety npm dla poszczególnych backendów, dodatki (extras) w Pythonie i moduły Go dla poszczególnych backendów obejmują tylko te backendy, których potrzebujesz
• Audyt: Rust, TypeScript, Python i Go zostały zaudytowane przez OtterSec (opcjonalny backend Ledger był poza zakresem); wcześniejszy audyt Accretion obejmował Rust i TypeScript. Zobacz status audytu.

Architektura

• Języki: Rust, TypeScript, Python i Go, z zachowaniem parytetu funkcji (backend Ledger jest dostępny tylko w Rust)
• Interfejs: bazowy SolanaSigner (pubkey, sign_message, is_available) oraz dokładnie jedna capability na backend: TransactionSigner, ModifyingSigner lub SendingSigner
• Backendy: Memory, Vault, AWS KMS, GCP KMS, Privy, Turnkey, Fireblocks, CDP, Crossmint, Dfns, Openfort, Para, Utila, Fordefi, Ledger (tylko Rust, opcjonalny, bez audytu)
• Kompatybilność: @solana/kit i @solana/signers 8.1+ (TypeScript) | solana-sdk 2.x, 3.x lub 4.x przez funkcje sdk-v2 / sdk-v3 / sdk-v4 (Rust; transakcje v1 wymagają sdk-v4) | solders (Python) | solana-go v2 (Go)

Obsługiwane backendy

Backendy obejmują lokalny rozwój, samodzielnie hostowane i chmurowe zarządzanie kluczami oraz zarządzane usługi portfeli MPC. Zobacz Wybór backendu, aby porównać modele powiernicze i wybrać odpowiedni.

Szybki start

Rust

Zainstaluj crate Rust:

cargo add solana-keychain

Podstawowe użycie:

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

• Przewodnik po Rust - Pełna instalacja i konfiguracja backendu
• Crates.io - Crate Rust

TypeScript

Zainstaluj pakiet TypeScript:

pnpm add @solana/keychain

Podstawowe użycie:

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

• Przewodnik po TypeScript - @solana/keychain pakiety
• Pakiet npm - Pakiet npm

Aby zainstalować signer Keychain w kliencie Kit jako jego payer lub identity, użyj @solana/keychain-kit-plugin (natywne tryby Crossmint i Fordefi są wyłączone, ponieważ przepisują transakcje).

Python

Zainstaluj pakiet (cięższe backendy są dostarczane jako dodatki extras, na przykład solana-keychain[aws-kms]):

pip install solana-keychain

Podstawowe użycie:

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)

• Przewodnik po Pythonie - Pełna instalacja, extras i konfiguracja backendów
• PyPI - pakiet Pythona

Go

Każdy backend to osobny moduł Go, więc pobierasz tylko te backendy, które importujesz:

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

Podstawowe użycie:

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)

• Przewodnik po Go - Moduły, capability i konfiguracja backendów
• pkg.go.dev - dokumentacja Go

Następne kroki

Źródło

• Repozytorium GitHub
• Historia wydań
• Model bezpieczeństwa
• Migracja do wersji 2.0

Zbudowane i utrzymywane przez Solana Foundation. Licencjonowane na warunkach MIT.