Deposita token

Come depositare token nel saldo in sospeso confidenziale

Prima che i token possano essere trasferiti in modo confidenziale, il saldo pubblico dei token deve essere convertito in un saldo confidenziale. Questa conversione avviene in due fasi:

Saldo in Sospeso Confidenziale: Inizialmente, i token vengono "depositati" dal saldo pubblico a un saldo confidenziale "in sospeso".
Saldo Disponibile Confidenziale: Il saldo in sospeso viene quindi "applicato" al saldo disponibile, rendendo i token disponibili per i trasferimenti confidenziali.

Questa sezione spiega la prima fase: il deposito del saldo pubblico dei token nel saldo in sospeso confidenziale.

Il seguente diagramma mostra i passaggi necessari per depositare token dal saldo pubblico al saldo in sospeso confidenziale:

Deposit Tokens

Istruzione Richiesta

Per convertire un saldo pubblico in un saldo in sospeso confidenziale, invocare l' istruzione ConfidentialTransferInstruction::Deposit. L'importo massimo per istruzione di deposito è limitato a 2^48.

Il crate spl_token_client fornisce un metodo confidential_transfer_deposit che costruisce e invia una transazione con l'istruzione Deposit, come dimostrato nell'esempio seguente.

Codice di Esempio

Il seguente esempio mostra come depositare il saldo pubblico dei token nel saldo in sospeso confidenziale.

I trasferimenti confidenziali dipendono dal programma ZK ElGamal Proof, abilitato su mainnet e devnet. Un solana-test-validator standard non lo abilita, ma un validator locale con fork di mainnet come Surfpool sì. Eseguire l'esempio su uno di questi ambienti (il codice utilizza devnet) con un payer finanziato, e sostituire gli indirizzi segnaposto di mint e account con i propri.

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