Depositar tokens

Cómo depositar tokens en el saldo pendiente confidencial

Antes de que los tokens puedan transferirse de forma confidencial, el saldo público de tokens debe convertirse en un saldo confidencial. Esta conversión ocurre en dos etapas:

Saldo Pendiente Confidencial: Inicialmente, los tokens se "depositan" desde el saldo público a un saldo confidencial "pendiente".
Saldo Disponible Confidencial: El saldo pendiente se "aplica" luego al saldo disponible, haciendo que los tokens estén disponibles para transferencias confidenciales.

Esta sección explica la primera etapa: depositar el saldo público de tokens en el saldo pendiente confidencial.

El siguiente diagrama muestra los pasos involucrados en el depósito de tokens desde el saldo público al saldo pendiente confidencial:

Deposit Tokens

Instrucción Requerida

Para convertir un saldo público en un saldo pendiente confidencial, invoca la instrucción ConfidentialTransferInstruction::Deposit. El monto máximo por instrucción de depósito está limitado a 2^48.

El crate spl_token_client proporciona un método confidential_transfer_deposit que construye y envía una transacción con la instrucción Deposit, como se demuestra en el ejemplo a continuación.

Código de Ejemplo

El siguiente ejemplo demuestra cómo depositar el saldo público de tokens en el saldo pendiente confidencial.

Las transferencias confidenciales dependen del programa ZK ElGamal Proof, que está habilitado en mainnet y devnet. Un solana-test-validator estándar no lo habilita, pero un validator local con bifurcación de mainnet como Surfpool sí lo hace. Ejecuta el ejemplo con uno de ellos (el código usa devnet) con un pagador con fondos, y reemplaza las direcciones de mint y cuenta de marcador de posición con las tuyas propias.

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}`
);