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:

Create Token Account with Confidential Transfer Extension

Estado da Token Account com Confidential Transfer

A extensão adiciona o estado ConfidentialTransferAccount à token account:

Confidential Token Account State
#[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 encryption
pub 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 balance
pub decryptable_available_balance: DecryptableBalance,
/// If `false`, the extended account rejects any incoming confidential
/// transfers
pub allow_confidential_credits: PodBool,
/// If `false`, the base account rejects any incoming transfers
pub 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 executed
pub maximum_pending_balance_credit_counter: PodU64,
/// The `expected_pending_balance_credit_counter` value that was included in
/// the last `ApplyPendingBalance` instruction
pub expected_pending_balance_credit_counter: PodU64,
/// The actual `pending_balance_credit_counter` when the last
/// `ApplyPendingBalance` instruction was executed
pub 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 como true, 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ção ApplyPendingBalance foi processada.

  • actual_pending_balance_credit_counter: O valor pending_balance_credit_counter na token account no momento em que a última instrução ApplyPendingBalance 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:

  1. 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.

  2. 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 valor pending_balance_credit_counter quando o cliente cria a instrução ApplyPendingBalance
    • actual_pending_balance_credit_counter: O valor pending_balance_credit_counter na token account no momento em que a instrução ApplyPendingBalance é 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:

  1. Comece com o decryptable_available_balance da token account
  2. 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:

  1. Criar a Token Account: Invocar a instrução AssociatedTokenAccountInstruction:Create do Associated Token Program para criar a token account.

  2. Realocar espaço da conta: Invocar a instrução TokenInstruction::Reallocate do Token Extensions Program para adicionar espaço para o estado ConfidentialTransferAccount.

  3. 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.

Terminal
$
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 validator
let 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 keypair
let payer = Arc::new(load_keypair()?);
println!("Using payer: {}", payer.pubkey());
// Generate a new keypair to use as the address of the token mint
let mint = Keypair::new();
println!("Mint keypair generated: {}", mint.pubkey());
// Set up program client for Token client
let program_client = ProgramRpcClient::new(rpc_client.clone(), ProgramRpcClientSendTransaction);
// Number of decimals for the mint
let decimals = 9;
// Create a token client for the Token-2022 program
// This provides high-level methods for token operations
let 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 mint
Some(decimals), // Number of decimal places
payer.clone(), // Fee payer for transactions (cloning Arc, not keypair)
);
// Create extension initialization parameters for the mint
// The ConfidentialTransferMint extension enables confidential (private) transfers of tokens
let extension_initialization_params =
vec![ExtensionInitializationParams::ConfidentialTransferMint {
authority: Some(payer.pubkey()), // Authority that can modify confidential transfer settings
auto_approve_new_accounts: true, // Automatically approve new confidential accounts
auditor_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 mint
let transaction_signature = token
.create_mint(
&payer.pubkey(), // Mint authority - can mint new tokens
Some(&payer.pubkey()), // Freeze authority - can freeze token accounts
extension_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 owner
let 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 account
let 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 extension
let 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 account
let 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 executed
let maximum_pending_balance_credit_counter = 65536;
// Initial token balance is 0
let decryptable_balance = aes_key.encrypt(0);
// Generate the proof data client-side
let proof_data = PubkeyValidityProofData::new(&elgamal_keypair)
.map_err(|_| anyhow::anyhow!("Failed to generate proof data"))?;
// Indicate that proof is included in the same transaction
let proof_location =
ProofLocation::InstructionOffset(1.try_into()?, ProofData::InstructionData(&proof_data));
// Step 4: Create instructions to configure the account for confidential transfers
let configure_account_instructions = configure_account(
&token_2022_program_id(), // Program ID
&token_account_pubkey, // Token account
&mint.pubkey(), // Mint
&decryptable_balance.into(), // Initial balance
maximum_pending_balance_credit_counter, // Maximum pending balance credit counter
&payer.pubkey(), // Token Account Owner
&[], // Additional signers
proof_location, // Proof location
)?;
// Combine all instructions
let mut instructions = vec![
create_associated_token_account_instruction,
reallocate_instruction,
];
instructions.extend(configure_account_instructions);
// Create and send the transaction
let 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 tools
fn load_keypair() -> Result<Keypair> {
// Get the default keypair path
let 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 bytes
let 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 keypair
let keypair = Keypair::from_bytes(&keypair_bytes)?;
Ok(keypair)
}
Click to execute the code.

Is this page helpful?

Índice

Editar Página