Déposer des tokens

Comment déposer des tokens vers le solde en attente confidentiel

Avant que les tokens puissent être transférés de manière confidentielle, le solde public de tokens doit être converti en solde confidentiel. Cette conversion s'effectue en deux étapes :

Solde en attente confidentiel : Dans un premier temps, les tokens sont « déposés » depuis le solde public vers un solde confidentiel « en attente ».
Solde disponible confidentiel : Le solde en attente est ensuite « appliqué » au solde disponible, rendant les tokens disponibles pour les transferts confidentiels.

Cette section explique la première étape : le dépôt du solde public de tokens vers le solde en attente confidentiel.

Le diagramme suivant illustre les étapes du dépôt de tokens depuis le solde public vers le solde en attente confidentiel :

Deposit Tokens

Instruction requise

Pour convertir un solde public en solde en attente confidentiel, invoquez l'instruction ConfidentialTransferInstruction::Deposit. Le montant maximum par instruction de dépôt est limité à 2^48.

La crate spl_token_client fournit une méthode confidential_transfer_deposit qui construit et envoie une transaction avec l'instruction Deposit, comme illustré dans l'exemple ci-dessous.

Exemple de code

L'exemple suivant montre comment déposer un solde public de tokens vers un solde en attente confidentiel.

Les transferts confidentiels dépendent du programme ZK ElGamal Proof, qui est activé sur le mainnet et le devnet. Un solana-test-validator standard ne l'active pas, mais un validator local avec fork du mainnet tel que Surfpool le fait. Exécutez l'exemple sur l'un d'eux (le code utilise le devnet) avec un compte payeur approvisionné, et remplacez les adresses fictives de mint et de compte par les vôtres.

Rust



const ZK_PROOF_PROGRAM_ID: Pubkey =
    solana_pubkey::pubkey!("ZkE1Gama1Proof11111111111111111111111111111");

fn main() -> Result<()> {
    let rpc_client = RpcClient::new_with_commitment(
        String::from("https://api.devnet.solana.com"),
        CommitmentConfig::confirmed(),
    );

    // Owner = fee payer = token account owner. The setup below configures the
    // account for confidential transfers (see "Create a Token Account").
    let owner = load_keypair()?;
    let amount: u64 = 100;
    let decimals: u8 = 2;

    // Setup: create a confidential token account with public tokens.
    let (mint, token_account) = setup_deposit_account(&rpc_client, &owner, amount, decimals)?;

    // Deposit moves tokens from the public balance into the pending confidential
    // balance. No proof is required. The tokens land in the pending balance and
    // must be applied (see "Apply Pending Balance") before they can be spent.
    let deposit_ix = deposit(
        &spl_token_2022::id(),
        &token_account,
        &mint,
        amount,
        decimals,
        &owner.pubkey(),
        &[&owner.pubkey()],
    )?;

    let blockhash = rpc_client.get_latest_blockhash()?;
    let transaction =
        Transaction::new_signed_with_payer(&[deposit_ix], Some(&owner.pubkey()), &[&owner], blockhash);
    let signature = rpc_client.send_and_confirm_transaction(&transaction)?;
    println!("Deposited {amount} tokens to the pending confidential balance: {signature}");
    Ok(())
}

Typescript



const client = await createClient()
  .use(signerFromFile(join(homedir(), ".config/solana/id.json")))
  .use(
    solanaRpc({
      rpcUrl: "https://api.devnet.solana.com"
    })
  );

// The Solana CLI default keypair, used as fee payer, mint authority, and
// token account owner.
const owner = client.payer;
const amount = 100n;
const decimals = 2;

// Setup: create a confidential mint and token account with public tokens.
const mint = await createConfidentialMint(client, owner, decimals);
const token = await createConfidentialTokenAccount(client, owner, mint);
await mintPublicTokens(client, owner, mint, token, amount);

// Deposit moves public tokens into the pending confidential balance. No proof
// is required; the tokens must then be applied before they can be spent.
const depositInstruction = getConfidentialDepositInstruction({
  token,
  mint,
  authority: owner,
  amount,
  decimals
});

const result = await client.sendTransaction([depositInstruction]);
console.log(
  `Deposited ${amount} tokens to the pending confidential balance: ${result.context.signature}`
);