Crear un token mint

El ZK ElGamal Program está temporalmente deshabilitado en mainnet y devnet mientras se somete a una auditoría de seguridad. Esto significa que la extensión de transferencias confidenciales no está disponible actualmente. Aunque los conceptos siguen siendo válidos, los ejemplos de código no se ejecutarán.

Cómo crear un mint con la extensión de Transferencia Confidencial

La extensión de Transferencia Confidencial permite transferencias de tokens privadas al agregar estado adicional a la cuenta del mint. Esta sección explica cómo crear un token mint con esta extensión habilitada.

El siguiente diagrama muestra los pasos involucrados en la creación de un mint con la extensión de Transferencia Confidencial:

Create Mint with Confidential Transfer Extension

Estado del mint de Transferencia Confidencial

La extensión agrega el estado ConfidentialTransferMint a la cuenta del mint:

Confidential Mint State

#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
pub struct ConfidentialTransferMint {
    /// Authority to modify the `ConfidentialTransferMint` configuration and to
    /// approve new accounts (if `auto_approve_new_accounts` is true)
    ///
    /// The legacy Token Multisig account is not supported as the authority
    pub authority: OptionalNonZeroPubkey,

    /// Indicate if newly configured accounts must be approved by the
    /// `authority` before they may be used by the user.
    ///
    /// * If `true`, no approval is required and new accounts may be used
    ///   immediately
    /// * If `false`, the authority must approve newly configured accounts (see
    ///   `ConfidentialTransferInstruction::ConfigureAccount`)
    pub auto_approve_new_accounts: PodBool,

    /// Authority to decode any transfer amount in a confidential transfer.
    pub auditor_elgamal_pubkey: OptionalNonZeroElGamalPubkey,
}

El ConfidentialTransferMint contiene tres campos de configuración:

authority: La cuenta que tiene permiso para cambiar la configuración de transferencia confidencial para el mint y aprobar nuevas cuentas confidenciales si la aprobación automática está deshabilitada.
auto_approve_new_accounts: Cuando se establece en true, los usuarios pueden crear token accounts con transferencias confidenciales habilitadas por defecto. Cuando es false, la autoridad debe aprobar cada nueva token account antes de que pueda usarse para transferencias confidenciales.
auditor_elgamal_pubkey: Un auditor opcional que puede descifrar los montos de transferencia en transacciones confidenciales, proporcionando un mecanismo de cumplimiento mientras se mantiene la privacidad del público en general.

Instrucciones requeridas

Crear un mint con Transferencia Confidencial habilitada requiere tres instrucciones en una sola transacción:

Crear la cuenta del mint: Invoca la instrucción CreateAccount del System Program para crear la cuenta del mint.
Inicializar extensión de Transferencia Confidencial: Invoca la instrucción ConfidentialTransferInstruction::InitializeMint del Token Extension Program para configurar el estado ConfidentialTransferMint para el mint.
Inicializar Mint: Invoca la instrucción Instruction::InitializeMint del Token Extension Program para inicializar el estado estándar del mint.

Si bien podrías escribir estas instrucciones manualmente, el crate spl_token_client proporciona un método create_mint que construye y envía una transacción con las tres instrucciones en una sola llamada de función, como se demuestra en el ejemplo a continuación.

Código de ejemplo

El siguiente código demuestra cómo crear un mint con la extensión de Transferencia Confidencial.

Para ejecutar el ejemplo, inicia un validador local con el Token Extension Program clonado desde mainnet usando el siguiente comando. Debes tener la CLI de Solana instalada para iniciar el validador local.

Terminal

$ solana-test-validator --clone-upgradeable-program TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb --url https://api.mainnet.solana.com -r

Al momento de escribir esto, las Transferencias Confidenciales no están habilitadas en el validador local predeterminado. Debes clonar el Token Extension Program de mainnet para ejecutar el código de ejemplo.

use anyhow::{Context, Result};
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_sdk::{
    commitment_config::CommitmentConfig,
    signature::{Keypair, Signer},
};
use spl_token_client::{
    client::{ProgramRpcClient, ProgramRpcClientSendTransaction},
    spl_token_2022::id as token_2022_program_id,
    token::{ExtensionInitializationParams, Token},
};
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<()> {
    // Create connection to local test validator
    let rpc_client = 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(Arc::new(rpc_client), 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
    // 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?;

    // Print results for user verification
    println!("Mint Address: {}", mint.pubkey());
    println!("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)
}

Crear un token mint

Cómo crear un mint con la extensión de Transferencia Confidencial

Estado del mint de Transferencia Confidencial

Instrucciones requeridas

Código de ejemplo

Tabla de Contenidos