Een token mint aanmaken

Hoe maak je een mint aan met Confidential Balances

Confidential Balances maakt privé-tokenoverdrachten mogelijk door extra toestand toe te voegen aan de mint account. In dit gedeelte wordt uitgelegd hoe je een token mint aanmaakt met de vereiste extensie ingeschakeld.

Het volgende diagram toont de stappen voor het aanmaken van een mint met de Confidential Balances-extensie:

Create Mint with Confidential Balances

Confidential Balances Mint-toestand

De extensie voegt de ConfidentialTransferMint status toe aan de mint account:

Confidential Mint State

#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
pub struct ConfidentialTransferMint {
    /// Authority to modify the `ConfidentialTransferMint` configuration and to
    /// approve new accounts (if `auto_approve_new_accounts` is true)
    ///
    /// The legacy Token Multisig account is not supported as the authority
    pub authority: OptionalNonZeroPubkey,

    /// Indicate if newly configured accounts must be approved by the
    /// `authority` before they may be used by the user.
    ///
    /// * If `true`, no approval is required and new accounts may be used
    ///   immediately
    /// * If `false`, the authority must approve newly configured accounts (see
    ///   `ConfidentialTransferInstruction::ConfigureAccount`)
    pub auto_approve_new_accounts: PodBool,

    /// Authority to decode any transfer amount in a confidential transfer.
    pub auditor_elgamal_pubkey: OptionalNonZeroElGamalPubkey,
}

De ConfidentialTransferMint bevat drie configuratievelden:

authority: Het account dat toestemming heeft om de Confidential Balances- instellingen voor de mint te wijzigen en nieuwe vertrouwelijke accounts goed te keuren als automatische goedkeuring is uitgeschakeld.
auto_approve_new_accounts: Wanneer ingesteld op true, kunnen gebruikers token accounts aanmaken met Confidential Balances standaard ingeschakeld. Wanneer false, moet de authority elk nieuw token account goedkeuren voordat het gebruikt kan worden voor vertrouwelijke overdrachten.
auditor_elgamal_pubkey: Een optionele auditor die overdrachtsbedag in vertrouwelijke transacties kan ontsleutelen, wat een nalevingsmechanisme biedt terwijl de privacy ten opzichte van het grote publiek wordt gewaarborgd.

Vereiste instructies

Het aanmaken van een mint met Confidential Balances ingeschakeld vereist drie instructies in één enkele transactie:

Maak het Mint Account aan: Roep de instructie CreateAccount van het System Program aan om de mint account aan te maken.
Confidential Balances initialiseren: Roep de instructie ConfidentialTransferInstruction::InitializeMint van het Token Extension Program aan om de ConfidentialTransferMint-toestand voor de mint te configureren.
Initialiseer Mint: Roep de instructie Instruction::InitializeMint van het Token Extensions Program aan om de standaard mintstatus te initialiseren.

Hoewel je deze instructies handmatig kunt schrijven, biedt de spl_token_client-crate een create_mint-methode die een transactie met alle drie de instructies opbouwt en verstuurt in één enkele functieaanroep, zoals gedemonstreerd in het onderstaande voorbeeld.

Voorbeeldcode

De volgende code laat zien hoe je een mint aanmaakt met Confidential Balances ingeschakeld.

Confidential Balances is 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 tegen een van deze omgevingen (de code gebruikt devnet) met een gefinancierde betaler, en vervang de tijdelijke aanduidingen voor mint- en accountadressen door je eigen adressen.

Rust



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

    let payer = load_keypair()?;
    let mint = Keypair::new();
    let decimals: u8 = 2;

    // Allocate space for a mint that carries the ConfidentialTransferMint
    // extension, then fund it for rent exemption.
    let space =
        ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::ConfidentialTransferMint])?;
    let rent = rpc_client.get_minimum_balance_for_rent_exemption(space)?;

    // The auditor ElGamal key lets the issuer decrypt transfer amounts for
    // compliance. Persist this key. Pass `None` to create a mint with no auditor.
    let auditor = ElGamalKeypair::new_rand();
    let auditor_pubkey: PodElGamalPubkey = (*auditor.pubkey()).into();

    let create_account_ix = system_instruction::create_account(
        &payer.pubkey(),
        &mint.pubkey(),
        rent,
        space as u64,
        &spl_token_2022::id(),
    );

    // The confidential-transfer extension must be initialized before the base
    // mint and cannot be added later.
    let init_confidential_ix = initialize_confidential_transfer_mint(
        &spl_token_2022::id(),
        &mint.pubkey(),
        Some(payer.pubkey()), // authority that can update confidential settings
        true,                 // auto-approve new accounts
        Some(auditor_pubkey),
    )?;

    let init_mint_ix = initialize_mint_base(
        &spl_token_2022::id(),
        &mint.pubkey(),
        &payer.pubkey(), // mint authority
        None,            // freeze authority
        decimals,
    )?;

    let blockhash = rpc_client.get_latest_blockhash()?;
    let transaction = Transaction::new_signed_with_payer(
        &[create_account_ix, init_confidential_ix, init_mint_ix],
        Some(&payer.pubkey()),
        &[&payer, &mint],
        blockhash,
    );
    let signature = rpc_client.send_and_confirm_transaction(&transaction)?;
    println!("Created confidential mint {}: {signature}", mint.pubkey());
    Ok(())
}

fn load_keypair() -> Result<Keypair> {
    let keypair_path = dirs::home_dir()
        .context("could not find home directory")?
        .join(".config/solana/id.json");
    let bytes: Vec<u8> = serde_json::from_reader(std::fs::File::open(keypair_path)?)?;
    let mut secret = [0u8; 32];
    secret.copy_from_slice(&bytes[0..32]);
    Ok(Keypair::new_from_array(secret))
}

Typescript



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

const mint = await generateKeyPairSigner();

// The auditor ElGamal key lets the issuer decrypt transfer amounts for
// compliance. Persist it; omit `auditorElgamalPubkey` to create a mint with no
// auditor.
const auditor = await deriveElGamalKeypairForOwnerMint({
  signer: payer,
  owner: payer.address,
  mint: mint.address
});

const plan = getCreateMintInstructionPlan({
  payer,
  newMint: mint,
  decimals: 2,
  mintAuthority: payer,
  extensions: [
    {
      __kind: "ConfidentialTransferMint",
      authority: some(payer.address),
      autoApproveNewAccounts: true,
      auditorElgamalPubkey: some(auditor.elgamalPubkey)
    }
  ]
});

const result = await client.sendTransaction(plan);

console.log(
  `Created confidential mint ${mint.address}: ${result.context.signature}`
);