Tokens storten

Tokens storten naar vertrouwelijk uitstaand saldo

Voordat tokens vertrouwelijk kunnen worden overgedragen, moet het publieke tokensaldo worden omgezet naar een vertrouwelijk saldo. Deze omzetting verloopt in twee fasen:

Vertrouwelijk uitstaand saldo: Aanvankelijk worden tokens "gestort" van het publieke saldo naar een "uitstaand" vertrouwelijk saldo.
Vertrouwelijk beschikbaar saldo: Het uitstaande saldo wordt vervolgens "toegepast" op het beschikbare saldo, waardoor de tokens beschikbaar worden voor vertrouwelijke overdrachten.

Dit gedeelte legt de eerste fase uit: het publieke tokensaldo storten naar het vertrouwelijk uitstaand saldo.

Het volgende diagram toont de stappen voor het storten van tokens van het publieke saldo naar het vertrouwelijk uitstaand saldo:

Deposit Tokens

Vereiste instructie

Om een publiek saldo om te zetten naar een vertrouwelijk uitstaand saldo, roept u de ConfidentialTransferInstruction::Deposit instructie aan. Het maximale bedrag per storting is beperkt tot 2^48.

De spl_token_client-crate biedt een confidential_transfer_deposit-methode die een transactie met de Deposit-instructie bouwt en verstuurt, zoals gedemonstreerd in het onderstaande voorbeeld.

Voorbeeldcode

Het volgende voorbeeld laat zien hoe u een publiek tokensaldo stort naar het vertrouwelijk uitstaand saldo.

Vertrouwelijke overdrachten zijn afhankelijk van het ZK ElGamal Proof-programma, dat is ingeschakeld op mainnet en devnet. Een standaard solana-test-validator schakelt dit niet in, maar een lokale validator die mainnet forkt, zoals Surfpool, wel. Voer het voorbeeld uit op een van deze omgevingen (de code gebruikt devnet) met een gefinancierde betaler, en vervang de tijdelijke mint- en accountadressen door uw eigen adressen.

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