Créer un compte de jetons
Comment créer un compte de jetons avec l'extension de transfert confidentiel
L'extension de transfert confidentiel permet des transferts de jetons privés en ajoutant des états supplémentaires au compte de jetons. Cette section explique comment créer un compte de jetons avec cette extension activée.
Le diagramme suivant montre les étapes impliquées dans la création d'un compte de jetons avec l'extension de transfert confidentiel :
État du compte de jetons de transfert confidentiel
L'extension ajoute l'état ConfidentialTransferAccount au compte de jetons :
#[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,}
Le ConfidentialTransferAccount
contient plusieurs champs pour gérer les
transferts confidentiels :
-
approved : L'état d'approbation du compte pour les transferts confidentiels. Si la configuration
auto_approve_new_accounts
du compte d'émission est définie commetrue
, tous les comptes de jetons sont automatiquement approuvés pour les transferts confidentiels. -
elgamal_pubkey : La clé publique ElGamal utilisée pour chiffrer les soldes et les montants de transfert.
-
pending_balance_lo : Les 16 bits inférieurs chiffrés du solde en attente. Le solde est divisé en parties haute et basse pour un déchiffrement efficace.
-
pending_balance_hi : Les 48 bits supérieurs chiffrés du solde en attente. Le solde est divisé en parties haute et basse pour un déchiffrement efficace.
-
available_balance : Le solde chiffré disponible pour les transferts.
-
decryptable_available_balance : Le solde disponible chiffré avec une clé Advanced Encryption Standard (AES) pour un déchiffrement efficace par le propriétaire du compte.
-
allow_confidential_credits : Si vrai, permet les transferts confidentiels entrants.
-
allow_non_confidential_credits : Si vrai, permet les transferts non confidentiels entrants.
-
pending_balance_credit_counter : Compte les crédits de solde en attente entrants provenant des instructions de dépôt et de transfert.
-
maximum_pending_balance_credit_counter : La limite de comptage des crédits en attente avant de nécessiter une instruction
ApplyPendingBalance
pour convertir le solde en attente en solde disponible. -
expected_pending_balance_credit_counter : La valeur
pending_balance_credit_counter
fournie par le client via les données d'instruction la dernière fois que l'instructionApplyPendingBalance
a été traitée. -
actual_pending_balance_credit_counter : La valeur
pending_balance_credit_counter
sur le compte de jetons au moment où la dernière instructionApplyPendingBalance
a été traitée.
Solde en attente vs solde disponible
Les soldes confidentiels sont séparés en soldes en attente et disponibles pour prévenir les attaques par déni de service. Sans cette séparation, un attaquant pourrait envoyer répétitivement des jetons à un compte de jetons, bloquant la capacité du propriétaire du compte à transférer des jetons. Le propriétaire du compte de jetons serait incapable de transférer des jetons car le solde chiffré changerait entre le moment où la transaction est soumise et celui où elle est traitée, entraînant l'échec de la transaction.
Tous les dépôts et montants de transfert sont initialement ajoutés au solde en
attente. Les propriétaires de comptes de jetons doivent utiliser l'instruction
ApplyPendingBalance
pour convertir le solde en attente en solde
disponible. Les transferts entrants ou dépôts n'affectent pas le solde
disponible d'un compte de jetons.
Division haute/basse du solde en attente
Le solde confidentiel en attente est divisé en pending_balance_lo
et
pending_balance_hi
car le déchiffrement ElGamal nécessite plus de calculs pour
les grands nombres. Vous pouvez trouver l'implémentation arithmétique du texte
chiffré
ici,
qui est utilisée dans l'instruction ApplyPendingBalance
ici.
Compteurs de crédit du solde en attente
Lors de l'appel à l'instruction ApplyPendingBalance
pour convertir le
solde en attente en solde disponible :
-
Le client consulte les soldes actuels en attente et disponibles, chiffre la somme, et fournit un
decryptable_available_balance
chiffré à l'aide de la clé AES du propriétaire du compte de jetons. -
Les compteurs de crédit en attente attendus et réels suivent les changements de la valeur du compteur entre le moment où l'instruction
ApplyPendingBalance
est créée et traitée :expected_pending_balance_credit_counter
: La valeurpending_balance_credit_counter
lorsque le client crée l'instructionApplyPendingBalance
actual_pending_balance_credit_counter
: La valeurpending_balance_credit_counter
sur le compte de jetons au moment où l'instructionApplyPendingBalance
est traitée
Des compteurs attendus/réels correspondants indiquent que le
decryptable_available_balance
correspond au available_balance
.
Lors de la récupération de l'état d'un compte de jeton pour lire le
decryptable_available_balance
, des valeurs différentes des compteurs
attendus/réels exigent que le client recherche les instructions récentes de
dépôt/transfert correspondant à la différence de compteur pour calculer le solde
correct.
Processus de rapprochement des soldes
Lorsque les compteurs de solde en attente attendus et réels diffèrent, suivez
ces étapes pour rapprocher le decryptable_available_balance
:
- Commencez avec le
decryptable_available_balance
du compte de jeton - Récupérez les transactions les plus récentes incluant les instructions de
dépôt et de transfert jusqu'à la différence de compteur (réel - attendu) :
- Ajoutez les montants publics des instructions de dépôt
- Déchiffrez et ajoutez les montants chiffrés de destination des instructions de transfert
Instructions requises
La création d'un compte de jeton avec l'extension Confidential Transfer nécessite trois instructions :
-
Créer le compte de jeton : Invoquer l'instruction
AssociatedTokenAccountInstruction:Create
du Programme de Jeton Associé pour créer le compte de jeton. -
Réallouer l'espace du compte : Invoquer l'instruction
TokenInstruction::Reallocate
du Programme d'Extension de Jeton pour ajouter de l'espace pour l'étatConfidentialTransferAccount
. -
Configurer les transferts confidentiels : Invoquer l'instruction ConfidentialTransferInstruction::ConfigureAccount du Programme d'Extension de Jeton pour initialiser l'état
ConfidentialTransferAccount
.
Seul le propriétaire du compte de jeton peut configurer un compte de jeton pour les transferts confidentiels.
L'instruction ConfigureAccount
nécessite la génération côté client de clés
de chiffrement et de données de preuve qui ne peuvent être générées que par le
propriétaire du compte de jeton.
Le PubkeyValidityProofData
crée une preuve qui vérifie qu'une clé ElGamal
est valide. Pour les détails d'implémentation, voir :
Exemple de code
Le code suivant démontre comment créer un Compte de Jeton Associé avec l'extension Confidential Transfer.
Pour exécuter l'exemple, démarrez un validateur local avec le Programme d'Extension de Jeton cloné depuis le réseau principal en utilisant la commande suivante. Vous devez avoir installé le CLI Solana pour démarrer le validateur local.
$solana-test-validator --clone-upgradeable-program TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb --url https://api.mainnet-beta.solana.com -r
Au moment de la rédaction, les Transferts Confidentiels ne sont pas activés sur le validateur local par défaut. Vous devez cloner le Programme d'Extension de Token du réseau principal pour exécuter le code d'exemple.
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?