Utwórz konto tokena
Jak utworzyć konto tokena z rozszerzeniem Confidential Transfer
Rozszerzenie Confidential Transfer umożliwia prywatne transfery tokenów poprzez dodanie dodatkowego stanu do konta tokena. W tej sekcji wyjaśniono, jak utworzyć konto tokena z włączonym tym rozszerzeniem.
Poniższy diagram przedstawia kroki związane z tworzeniem konta tokena z rozszerzeniem Confidential Transfer:
Stan konta tokena Confidential Transfer
Rozszerzenie dodaje stan ConfidentialTransferAccount do konta tokena:
#[repr(C)]#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]pub struct ConfidentialTransferAccount {/// `true` if this account has been approved for use. All confidential/// transfer operations for the account will fail until approval is/// granted.pub approved: PodBool,/// The public key associated with ElGamal encryptionpub elgamal_pubkey: PodElGamalPubkey,/// The low 16 bits of the pending balance (encrypted by `elgamal_pubkey`)pub pending_balance_lo: EncryptedBalance,/// The high 48 bits of the pending balance (encrypted by `elgamal_pubkey`)pub pending_balance_hi: EncryptedBalance,/// The available balance (encrypted by `encryption_pubkey`)pub available_balance: EncryptedBalance,/// The decryptable available balancepub decryptable_available_balance: DecryptableBalance,/// If `false`, the extended account rejects any incoming confidential/// transferspub allow_confidential_credits: PodBool,/// If `false`, the base account rejects any incoming transferspub allow_non_confidential_credits: PodBool,/// The total number of `Deposit` and `Transfer` instructions that have/// credited `pending_balance`pub pending_balance_credit_counter: PodU64,/// The maximum number of `Deposit` and `Transfer` instructions that can/// credit `pending_balance` before the `ApplyPendingBalance`/// instruction is executedpub maximum_pending_balance_credit_counter: PodU64,/// The `expected_pending_balance_credit_counter` value that was included in/// the last `ApplyPendingBalance` instructionpub expected_pending_balance_credit_counter: PodU64,/// The actual `pending_balance_credit_counter` when the last/// `ApplyPendingBalance` instruction was executedpub actual_pending_balance_credit_counter: PodU64,}
ConfidentialTransferAccount
zawiera kilka pól do zarządzania poufnością
transferów:
-
approved: Status zatwierdzenia konta dla poufnych transferów. Jeśli konfiguracja konta mint
auto_approve_new_accounts
jest ustawiona jakotrue
, wszystkie konta tokenów są automatycznie zatwierdzane do poufnych transferów. -
elgamal_pubkey: Klucz publiczny ElGamal używany do szyfrowania sald i kwot transferów.
-
pending_balance_lo: Zaszyfrowane dolne 16 bitów oczekującego salda. Saldo jest podzielone na części wysoką i niską dla efektywnego odszyfrowania.
-
pending_balance_hi: Zaszyfrowane górne 48 bitów oczekującego salda. Saldo jest podzielone na części wysoką i niską dla efektywnego odszyfrowania.
-
available_balance: Zaszyfrowane saldo dostępne do transferów.
-
decryptable_available_balance: Dostępne saldo zaszyfrowane za pomocą klucza Advanced Encryption Standard (AES) dla efektywnego odszyfrowania przez właściciela konta.
-
allow_confidential_credits: Jeśli prawda, pozwala na przychodzące poufne transfery.
-
allow_non_confidential_credits: Jeśli prawda, pozwala na przychodzące niepoufne transfery.
-
pending_balance_credit_counter: Liczy przychodzące oczekujące kredyty salda z instrukcji depozytu i transferu.
-
maximum_pending_balance_credit_counter: Limit liczby oczekujących kredytów przed wymaganiem instrukcji
ApplyPendingBalance
do konwersji oczekującego salda na dostępne saldo. -
expected_pending_balance_credit_counter: Wartość
pending_balance_credit_counter
dostarczona przez klienta za pomocą danych instrukcji podczas ostatniego przetwarzania instrukcjiApplyPendingBalance
. -
actual_pending_balance_credit_counter: Wartość
pending_balance_credit_counter
na koncie tokena w momencie ostatniego przetwarzania instrukcjiApplyPendingBalance
.
Saldo oczekujące a saldo dostępne
Poufne salda są podzielone na salda oczekujące i dostępne, aby zapobiec atakom DoS. Bez tego podziału atakujący mógłby wielokrotnie przesyłać tokeny na konto tokena, blokując możliwość ich transferu przez właściciela konta. Właściciel konta tokena nie mógłby przenieść tokenów, ponieważ zaszyfrowane saldo zmieniałoby się między momentem przesłania transakcji a jej przetworzeniem, co skutkowałoby nieudaną transakcją.
Wszystkie depozyty i kwoty transferów są początkowo dodawane do salda
oczekującego. Właściciele kont tokenów muszą użyć instrukcji
ApplyPendingBalance
, aby przekonwertować saldo oczekujące na saldo
dostępne. Przychodzące transfery lub depozyty nie wpływają na dostępne saldo
konta tokena.
Podział salda oczekującego na wysokie/niskie
Poufne saldo oczekujące jest podzielone na pending_balance_lo
i
pending_balance_hi
, ponieważ deszyfrowanie ElGamala wymaga więcej obliczeń dla
większych liczb. Implementację arytmetyki szyfrogramów można znaleźć
tutaj,
która jest używana w instrukcji ApplyPendingBalance
tutaj.
Liczniki kredytowe salda oczekującego
Podczas wywoływania instrukcji ApplyPendingBalance
w celu konwersji salda
oczekującego na saldo dostępne:
-
Klient sprawdza bieżące salda oczekujące i dostępne, szyfruje sumę i dostarcza
decryptable_available_balance
zaszyfrowane za pomocą klucza AES właściciela konta tokena. -
Oczekiwane i rzeczywiste liczniki kredytowe śledzą zmiany wartości licznika między momentem utworzenia a przetworzenia instrukcji
ApplyPendingBalance
:expected_pending_balance_credit_counter
: Wartośćpending_balance_credit_counter
w momencie tworzenia instrukcjiApplyPendingBalance
przez klientaactual_pending_balance_credit_counter
: Wartośćpending_balance_credit_counter
na koncie tokena w momencie przetwarzania instrukcjiApplyPendingBalance
.
Dopasowanie oczekiwanych/rzeczywistych liczników wskazuje, że
decryptable_available_balance
odpowiada available_balance
.
Podczas pobierania stanu konta tokena w celu odczytania
decryptable_available_balance
, różne wartości liczników
oczekiwanych/rzeczywistych wymagają od klienta wyszukania ostatnich instrukcji
wpłat/przelewów odpowiadających różnicy liczników, aby obliczyć poprawne saldo.
Proces uzgadniania salda
Gdy liczniki oczekiwanego i rzeczywistego salda różnią się, wykonaj następujące
kroki, aby uzgodnić decryptable_available_balance
:
- Zacznij od
decryptable_available_balance
z konta tokena - Pobierz najnowsze transakcje, w tym instrukcje wpłat i przelewów,
odpowiadające różnicy liczników (rzeczywiste - oczekiwane):
- Dodaj publiczne kwoty z instrukcji wpłat
- Odszyfruj i dodaj zaszyfrowane kwoty docelowe z instrukcji przelewów
Wymagane instrukcje
Utworzenie konta tokena z rozszerzeniem Confidential Transfer wymaga trzech instrukcji:
-
Utwórz konto tokena: Wywołaj instrukcję
AssociatedTokenAccountInstruction:Create
programu Associated Token Program, aby utworzyć konto tokena. -
Zmień rozmiar przestrzeni konta: Wywołaj instrukcję
TokenInstruction::Reallocate
programu Token Extension Program, aby dodać przestrzeń dla stanuConfidentialTransferAccount
. -
Skonfiguruj poufne transfery: Wywołaj instrukcję ConfidentialTransferInstruction::ConfigureAccount programu Token Extension Program, aby zainicjalizować stan
ConfidentialTransferAccount
.
Tylko właściciel konta tokena może skonfigurować konto tokena do poufnych transferów.
Instrukcja ConfigureAccount
wymaga generowania po stronie klienta kluczy
szyfrowania i danych dowodowych, które mogą być generowane wyłącznie przez
właściciela konta tokena.
Instrukcja PubkeyValidityProofData
tworzy dowód, który weryfikuje, że
klucz ElGamala jest ważny. Szczegóły implementacji można znaleźć tutaj:
Przykładowy kod
Poniższy kod demonstruje, jak utworzyć powiązane konto tokena z rozszerzeniem Confidential Transfer.
Aby uruchomić przykład, uruchom lokalny walidator z programem Token Extension Program sklonowanym z mainnetu za pomocą następującego polecenia. Musisz mieć zainstalowane Solana CLI, aby uruchomić lokalny walidator.
$solana-test-validator --clone-upgradeable-program TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb --url https://api.mainnet-beta.solana.com -r
W momencie pisania tego tekstu, Poufne Transfery nie są włączone na domyślnym lokalnym validatorze. Musisz sklonować główną wersję Token Extensions Program, aby uruchomić przykładowy kod.
use anyhow::{Context, Result};use solana_client::nonblocking::rpc_client::RpcClient;use solana_sdk::{commitment_config::CommitmentConfig,signature::{Keypair, Signer},transaction::Transaction,};use spl_associated_token_account::{get_associated_token_address_with_program_id, instruction::create_associated_token_account,};use spl_token_client::{client::{ProgramRpcClient, ProgramRpcClientSendTransaction},spl_token_2022::{extension::{confidential_transfer::instruction::{configure_account, PubkeyValidityProofData},ExtensionType,},id as token_2022_program_id,instruction::reallocate,solana_zk_sdk::encryption::{auth_encryption::*, elgamal::*},},token::{ExtensionInitializationParams, Token},};use spl_token_confidential_transfer_proof_extraction::instruction::{ProofData, ProofLocation};use std::sync::Arc;#[tokio::main]async fn main() -> Result<()> {// Create connection to local test validatorlet rpc_client = Arc::new(RpcClient::new_with_commitment(String::from("http://localhost:8899"),CommitmentConfig::confirmed(),));// Load the default Solana CLI keypair to use as the fee payer// This will be the wallet paying for the transaction fees// Use Arc to prevent multiple clones of the keypairlet payer = Arc::new(load_keypair()?);println!("Using payer: {}", payer.pubkey());// Generate a new keypair to use as the address of the token mintlet mint = Keypair::new();println!("Mint keypair generated: {}", mint.pubkey());// Set up program client for Token clientlet program_client = ProgramRpcClient::new(rpc_client.clone(), ProgramRpcClientSendTransaction);// Number of decimals for the mintlet decimals = 9;// Create a token client for the Token-2022 program// This provides high-level methods for token operationslet token = Token::new(Arc::new(program_client),&token_2022_program_id(), // Use the Token-2022 program (newer version with extensions)&mint.pubkey(), // Address of the new token mintSome(decimals), // Number of decimal placespayer.clone(), // Fee payer for transactions (cloning Arc, not keypair));// Create extension initialization parameters for the mint// The ConfidentialTransferMint extension enables confidential (private) transfers of tokenslet extension_initialization_params =vec![ExtensionInitializationParams::ConfidentialTransferMint {authority: Some(payer.pubkey()), // Authority that can modify confidential transfer settingsauto_approve_new_accounts: true, // Automatically approve new confidential accountsauditor_elgamal_pubkey: None, // Optional auditor ElGamal public key}];// Create and initialize the mint with the ConfidentialTransferMint extension// This sends a transaction to create the new token mintlet transaction_signature = token.create_mint(&payer.pubkey(), // Mint authority - can mint new tokensSome(&payer.pubkey()), // Freeze authority - can freeze token accountsextension_initialization_params, // Add the ConfidentialTransferMint extension&[&mint], // Mint keypair needed as signer).await?;println!("Mint Address: {}", mint.pubkey());println!("Mint Creation Transaction Signature: {}",transaction_signature);// ===== Create and configure token account for confidential transfers =====println!("\nCreate and configure token account for confidential transfers");// Get the associated token account address for the ownerlet token_account_pubkey = get_associated_token_address_with_program_id(&payer.pubkey(), // Token account owner&mint.pubkey(), // Mint&token_2022_program_id(), // Token program ID);println!("Token Account Address: {}", token_account_pubkey);// Step 1: Create the associated token accountlet create_associated_token_account_instruction = create_associated_token_account(&payer.pubkey(), // Funding account&payer.pubkey(), // Token account owner&mint.pubkey(), // Mint&token_2022_program_id(), // Token program ID);// Step 2: Reallocate the token account to include space for the ConfidentialTransferAccount extensionlet reallocate_instruction = reallocate(&token_2022_program_id(), // Token program ID&token_account_pubkey, // Token account&payer.pubkey(), // Payer&payer.pubkey(), // Token account owner&[&payer.pubkey()], // Signers&[ExtensionType::ConfidentialTransferAccount], // Extension to reallocate space for)?;// Step 3: Generate the ElGamal keypair and AES key for token accountlet elgamal_keypair = ElGamalKeypair::new_from_signer(&payer, &token_account_pubkey.to_bytes()).expect("Failed to create ElGamal keypair");let aes_key = AeKey::new_from_signer(&payer, &token_account_pubkey.to_bytes()).expect("Failed to create AES key");// The maximum number of Deposit and Transfer instructions that can// credit pending_balance before the ApplyPendingBalance instruction is executedlet maximum_pending_balance_credit_counter = 65536;// Initial token balance is 0let decryptable_balance = aes_key.encrypt(0);// Generate the proof data client-sidelet proof_data = PubkeyValidityProofData::new(&elgamal_keypair).map_err(|_| anyhow::anyhow!("Failed to generate proof data"))?;// Indicate that proof is included in the same transactionlet proof_location =ProofLocation::InstructionOffset(1.try_into()?, ProofData::InstructionData(&proof_data));// Step 4: Create instructions to configure the account for confidential transferslet configure_account_instructions = configure_account(&token_2022_program_id(), // Program ID&token_account_pubkey, // Token account&mint.pubkey(), // Mint&decryptable_balance.into(), // Initial balancemaximum_pending_balance_credit_counter, // Maximum pending balance credit counter&payer.pubkey(), // Token Account Owner&[], // Additional signersproof_location, // Proof location)?;// Combine all instructionslet mut instructions = vec![create_associated_token_account_instruction,reallocate_instruction,];instructions.extend(configure_account_instructions);// Create and send the transactionlet recent_blockhash = rpc_client.get_latest_blockhash().await?;let transaction = Transaction::new_signed_with_payer(&instructions,Some(&payer.pubkey()),&[&payer],recent_blockhash,);let transaction_signature = rpc_client.send_and_confirm_transaction(&transaction).await?;println!("Create Token Account Transaction Signature: {}",transaction_signature);Ok(())}// Load the keypair from the default Solana CLI keypair path (~/.config/solana/id.json)// This enables using the same wallet as the Solana CLI toolsfn load_keypair() -> Result<Keypair> {// Get the default keypair pathlet keypair_path = dirs::home_dir().context("Could not find home directory")?.join(".config/solana/id.json");// Read the keypair file directly into bytes using serde_json// The keypair file is a JSON array of byteslet file = std::fs::File::open(&keypair_path)?;let keypair_bytes: Vec<u8> = serde_json::from_reader(file)?;// Create keypair from the loaded bytes// This converts the byte array into a keypairlet keypair = Keypair::from_bytes(&keypair_bytes)?;Ok(keypair)}
Is this page helpful?