Criar uma Token Account
Como criar uma token account com a extensão Confidential Transfer
A extensão Confidential Transfer permite transferências privadas de tokens adicionando estado extra à token account. Esta seção explica como criar uma token account com esta extensão habilitada.
O diagrama a seguir mostra os passos envolvidos na criação de uma token account com a extensão Confidential Transfer:
Estado da Token Account com Confidential Transfer
A extensão adiciona o estado ConfidentialTransferAccount à token account:
#[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,}
O ConfidentialTransferAccount
contém vários campos para gerenciar
transferências confidenciais:
-
approved: O status de aprovação da conta para transferências confidenciais. Se a configuração
auto_approve_new_accounts
da mint account estiver definida comotrue
, todas as token accounts são automaticamente aprovadas para transferências confidenciais. -
elgamal_pubkey: A chave pública ElGamal usada para criptografar saldos e valores de transferência.
-
pending_balance_lo: Os 16 bits inferiores criptografados do saldo pendente. O saldo é dividido em partes alta e baixa para uma descriptografia eficiente.
-
pending_balance_hi: Os 48 bits superiores criptografados do saldo pendente. O saldo é dividido em partes alta e baixa para uma descriptografia eficiente.
-
available_balance: O saldo criptografado disponível para transferências.
-
decryptable_available_balance: O saldo disponível criptografado com uma chave Advanced Encryption Standard (AES) para descriptografia eficiente pelo proprietário da conta.
-
allow_confidential_credits: Se verdadeiro, permite transferências confidenciais recebidas.
-
allow_non_confidential_credits: Se verdadeiro, permite transferências não confidenciais recebidas.
-
pending_balance_credit_counter: Conta os créditos de saldo pendente recebidos de instruções de depósito e transferência.
-
maximum_pending_balance_credit_counter: O limite de contagem de créditos pendentes antes de exigir uma instrução
ApplyPendingBalance
para converter o saldo pendente em saldo disponível. -
expected_pending_balance_credit_counter: O valor
pending_balance_credit_counter
fornecido pelo cliente através dos dados de instrução na última vez que a instruçãoApplyPendingBalance
foi processada. -
actual_pending_balance_credit_counter: O valor
pending_balance_credit_counter
na token account no momento em que a última instruçãoApplyPendingBalance
foi processada.
Saldo pendente vs saldo disponível
Os saldos confidenciais são separados em saldos pendentes e disponíveis para prevenir ataques DoS. Sem essa separação, um atacante poderia enviar tokens repetidamente para uma token account, bloqueando a capacidade do proprietário da token account de transferir tokens. O proprietário da token account não conseguiria transferir tokens porque o saldo criptografado mudaria entre o momento em que a transação é enviada e quando é processada, resultando em uma transação falha.
Todos os depósitos e valores de transferência são inicialmente adicionados ao
saldo pendente. Os proprietários de token account devem usar a instrução
ApplyPendingBalance
para converter o saldo pendente em saldo disponível.
Transferências recebidas ou depósitos não afetam o saldo disponível de uma token
account.
Divisão alta/baixa do saldo pendente
O saldo pendente confidencial é dividido em pending_balance_lo
e
pending_balance_hi
porque a descriptografia ElGamal requer mais computação
para números maiores. Você pode encontrar a implementação da aritmética de texto
cifrado
aqui,
que é usada na instrução ApplyPendingBalance
aqui.
Contadores de crédito de saldo pendente
Ao chamar a instrução ApplyPendingBalance
para converter o saldo pendente
em saldo disponível:
-
O cliente consulta os saldos pendentes e disponíveis atuais, criptografa a soma, e fornece um
decryptable_available_balance
criptografado usando a chave AES do proprietário da token account. -
Os contadores de crédito pendente esperado e real rastreiam mudanças no valor do contador entre o momento em que a instrução
ApplyPendingBalance
é criada e processada:expected_pending_balance_credit_counter
: O valorpending_balance_credit_counter
quando o cliente cria a instruçãoApplyPendingBalance
actual_pending_balance_credit_counter
: O valorpending_balance_credit_counter
na token account no momento em que a instruçãoApplyPendingBalance
é processada
Contadores esperados/reais correspondentes indicam que o
decryptable_available_balance
corresponde ao available_balance
.
Ao buscar o estado de uma token account para ler o
decryptable_available_balance
, valores diferentes nos contadores
esperados/reais exigem que o cliente procure instruções recentes de
depósito/transferência que correspondam à diferença do contador para calcular o
saldo correto.
Processo de reconciliação de saldo
Quando os contadores de saldo pendente esperados e reais diferem, siga estas
etapas para reconciliar o decryptable_available_balance
:
- Comece com o
decryptable_available_balance
da token account - Busque as transações mais recentes, incluindo instruções de depósito e
transferência até a diferença do contador (real - esperado):
- Adicione quantias públicas das instruções de depósito
- Descriptografe e adicione quantias de texto cifrado de destino das instruções de transferência
Instruções necessárias
Criar uma token account com a extensão Confidential Transfer requer três instruções:
-
Criar a Token Account: Invocar a instrução
AssociatedTokenAccountInstruction:Create
do Associated Token Program para criar a token account. -
Realocar espaço da conta: Invocar a instrução
TokenInstruction::Reallocate
do Token Extensions Program para adicionar espaço para o estadoConfidentialTransferAccount
. -
Configurar transferências confidenciais: Invocar a instrução ConfidentialTransferInstruction::ConfigureAccount do Token Extensions Program para inicializar o estado
ConfidentialTransferAccount
.
Apenas o proprietário da token account pode configurar uma token account para transferências confidenciais.
A instrução ConfigureAccount
requer geração do lado do cliente de chaves
de criptografia e dados de prova que só podem ser gerados pelo proprietário da
token account.
O PubkeyValidityProofData
cria uma prova que verifica se uma chave ElGamal
é válida. Para detalhes de implementação, veja:
Código de exemplo
O código a seguir demonstra como criar uma Associated Token Account com a extensão Confidential Transfer.
Para executar o exemplo, inicie um validador local com o Token Extensions Program clonado da mainnet usando o seguinte comando. Você deve ter a CLI da Solana instalada para iniciar o validador local.
$solana-test-validator --clone-upgradeable-program TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb --url https://api.mainnet-beta.solana.com -r
No momento da escrita, as Transferências Confidenciais não estão habilitadas no validator local padrão. Você deve clonar o Token Extensions Program da mainnet para executar o código de exemplo.
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?