Een token account aanmaken

// Imports: dependencies used by this example.

// The native ZK ElGamal Proof program verifies the proof on chain.
const ZK_PROOF_PROGRAM_ID: Pubkey =
    solana_pubkey::pubkey!("ZkE1Gama1Proof11111111111111111111111111111");

fn main() -> Result<()> {
    // Use a cluster whose ZK ElGamal Proof program is enabled (mainnet, devnet).
    let rpc_client = RpcClient::new_with_commitment(
        String::from("https://api.devnet.solana.com"),
        CommitmentConfig::confirmed(),
    );

    // The Solana CLI default keypair, used as fee payer, mint authority, and
    // token account owner.
    let payer = load_keypair()?;
    let decimals: u8 = 2;

    // Setup: create a confidential mint for the token account.
    let mint = create_confidential_mint(&rpc_client, &payer, decimals)?;

    let token_account = get_associated_token_address_with_program_id(
        &payer.pubkey(),
        &mint,
        &spl_token_2022::id(),
    );

    // 1. Create the associated token account.
    let create_ata_ix = create_associated_token_account(
        &payer.pubkey(), // funding account
        &payer.pubkey(), // token account owner
        &mint,
        &spl_token_2022::id(),
    );

    // 2. Add space for the ConfidentialTransferAccount extension.
    let realloc_ix = reallocate(
        &spl_token_2022::id(),
        &token_account,
        &payer.pubkey(), // payer
        &payer.pubkey(), // owner
        &[&payer.pubkey()],
        &[ExtensionType::ConfidentialTransferAccount],
    )?;

    // 3. Derive the owner's ElGamal keypair and AES key from a signature over
    //    the token account address. The same signer and address always derive
    //    the same keys, so the owner can recover them from their wallet.
    let (elgamal_keypair, aes_key) = derive_confidential_keys(&payer, &token_account.to_bytes())
        .map_err(|e| anyhow::anyhow!("derive confidential keys: {e}"))?;

    // Initial decryptable available balance of 0, encrypted with the AES key.
    let decryptable_balance: PodAeCiphertext = aes_key.encrypt(0).into();
    let maximum_pending_balance_credit_counter: u64 = 65_536;

    // 4. Generate the pubkey-validity proof, then pre-verify it into a context
    //    state account owned by the ZK ElGamal Proof program. configure_account
    //    references the verified proof by account, so no proof bytes travel in
    //    the token instruction itself.
    let proof_data = build_pubkey_validity_proof_data(&elgamal_keypair)
        .map_err(|e| anyhow::anyhow!("generate pubkey validity proof: {e}"))?;

    let proof_account = Keypair::new();
    let context_state_size = size_of::<ProofContextState<PubkeyValidityProofContext>>();
    let context_state_rent =
        rpc_client.get_minimum_balance_for_rent_exemption(context_state_size)?;

    let create_proof_account_ix = system_instruction::create_account(
        &payer.pubkey(),
        &proof_account.pubkey(),
        context_state_rent,
        context_state_size as u64,
        &ZK_PROOF_PROGRAM_ID,
    );

    let proof_account_address: Address = proof_account.pubkey().to_bytes().into();
    let owner_address: Address = payer.pubkey().to_bytes().into();
    let verify_proof_ix = ProofInstruction::VerifyPubkeyValidity.encode_verify_proof(
        Some(ContextStateInfo {
            context_state_account: &proof_account_address,
            context_state_authority: &owner_address,
        }),
        &proof_data,
    );

    // 5. Configure the account, pointing at the pre-verified proof account.
    let proof_location: ProofLocation<PubkeyValidityProofData> =
        ProofLocation::ContextStateAccount(&proof_account.pubkey());
    let configure_account_ixs = configure_account(
        &spl_token_2022::id(),
        &token_account,
        &mint,
        &decryptable_balance,
        maximum_pending_balance_credit_counter,
        &payer.pubkey(), // owner
        &[],
        proof_location,
    )?;

    // Everything fits in a single transaction.
    let mut instructions = vec![
        create_ata_ix,
        realloc_ix,
        create_proof_account_ix,
        verify_proof_ix,
    ];
    instructions.extend(configure_account_ixs);

    let blockhash = rpc_client.get_latest_blockhash()?;
    let transaction = Transaction::new_signed_with_payer(
        &instructions,
        Some(&payer.pubkey()),
        &[&payer, &proof_account],
        blockhash,
    );

    let signature = rpc_client.send_and_confirm_transaction(&transaction)?;
    println!("Enabled Confidential Balances on token account {token_account}: {signature}");

    Ok(())
}

// Setup: helper function to create the confidential mint.

// Imports: dependencies used by this example.

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 decimals = 2;

// Setup: create a confidential mint for the token account.
const mint = await createConfidentialMint(client, owner, decimals);

const [tokenAccount] = await findAssociatedTokenPda({
  owner: owner.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS,
  mint
});

// Derive recoverable ElGamal and AES keys bound to (owner, mint). Re-deriving
// from the same wallet always yields the same keys, so the owner can recover
// them rather than having to back up a separate secret.
const derivedElGamal = await deriveElGamalKeypairForOwnerMint({
  signer: owner,
  owner: owner.address,
  mint
});
const elgamalKeypair = ElGamalKeypair.fromSecretKey(
  ElGamalSecretKey.fromBytes(derivedElGamal.secretKey)
);
const aesKey = AeKey.fromBytes(
  await deriveAeKeyForOwnerMint({ signer: owner, owner: owner.address, mint })
);

// Build the create-ATA + reallocate + verify-proof + configure plan, then send.
// The helper returns an instruction plan because the steps may span more than
// one transaction.
const plan = await getCreateConfidentialTransferAccountInstructionPlan({
  rpc: client.rpc,
  payer: owner,
  owner,
  mint,
  elgamalKeypair,
  aesKey
});

const result = await client.sendTransaction(plan);
console.log(
  `Enabled Confidential Balances on token account ${tokenAccount}: ${result.context.signature}`
);

// Setup: helper function to create the confidential mint.