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 :

Create Token Account with Confidential Transfer Extension

État du compte de jetons de transfert confidentiel

L'extension ajoute l'état ConfidentialTransferAccount au compte de jetons :

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,
}

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 comme true, 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'instruction ApplyPendingBalance 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 instruction ApplyPendingBalance 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 :

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

  2. 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 valeur pending_balance_credit_counter lorsque le client crée l'instruction ApplyPendingBalance
    • actual_pending_balance_credit_counter : La valeur pending_balance_credit_counter sur le compte de jetons au moment où l'instruction ApplyPendingBalance 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 :

  1. Commencez avec le decryptable_available_balance du compte de jeton
  2. 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 :

  1. Créer le compte de jeton : Invoquer l'instruction AssociatedTokenAccountInstruction:Create du Programme de Jeton Associé pour créer le compte de jeton.

  2. Réallouer l'espace du compte : Invoquer l'instruction TokenInstruction::Reallocate du Programme d'Extension de Jeton pour ajouter de l'espace pour l'état ConfidentialTransferAccount.

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

Terminal
$
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 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?

Table des matières

Modifier la page