Token mint oluşturma

Gizli Transfer uzantısıyla mint nasıl oluşturulur

Gizli Transfer uzantısı, mint account'a ekstra durum bilgisi ekleyerek özel token transferlerini mümkün kılar. Bu bölümde, bu uzantı etkinleştirilmiş bir token mint'inin nasıl oluşturulacağı açıklanmaktadır.

Aşağıdaki diyagram, Gizli Transfer uzantısıyla bir mint oluşturma adımlarını göstermektedir:

Create Mint with Confidential Transfer Extension

Gizli Transfer Mint Durumu

Uzantı, mint account'a ConfidentialTransferMint durumunu ekler:

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,
}

ConfidentialTransferMint üç yapılandırma alanı içerir:

authority: Mint için gizli transfer ayarlarını değiştirme ve otomatik onay devre dışı bırakıldığında yeni gizli hesapları onaylama iznine sahip olan hesap.
auto_approve_new_accounts: True olarak ayarlandığında, kullanıcılar varsayılan olarak gizli transferler etkin şekilde token account'lar oluşturabilir. False olduğunda, yetki sahibinin her yeni token account'ı gizli transferler için kullanılmadan önce onaylaması gerekir.
auditor_elgamal_pubkey: Gizli işlemlerdeki transfer miktarlarının şifresini çözebilen, genel kamuoyundan gizliliği korurken uyumluluk mekanizması sağlayan isteğe bağlı bir denetçi.

Gerekli Talimatlar

Gizli Transfer etkinleştirilmiş bir mint oluşturmak, tek bir işlemde üç talimat gerektirir:

Mint Account Oluşturma: mint account'ı oluşturmak için System Program'ın CreateAccount talimatını çağırın.
Gizli Transfer Uzantısını Başlatma: Mint için ConfidentialTransferMint durumunu yapılandırmak amacıyla Token Extensions Program'ın ConfidentialTransferInstruction::InitializeMint talimatını çağırın.
Mint'i Başlatma: Standart mint durumunu başlatmak için Token Extensions Program'ın Instruction::InitializeMint talimatını çağırın.

Bu talimatları manuel olarak yazabilirsiniz, ancak spl_token_client crate'i, aşağıdaki örnekte gösterildiği gibi tek bir fonksiyon çağrısında üç talimatı da içeren bir işlem oluşturup gönderen create_mint metodunu sağlar.

Örnek Kod

Aşağıdaki kod, Gizli Transfer uzantısıyla nasıl mint oluşturulacağını göstermektedir.

Gizli transferler, mainnet ve devnet üzerinde etkinleştirilmiş olan ZK ElGamal Proof programına bağlıdır. Standart bir solana-test-validator bunu etkinleştirmez; ancak Surfpool gibi mainnet'i çatallayan yerel bir validator etkinleştirir. Örneği, fonlanmış bir ödeyici ile bu ortamlardan birinde çalıştırın (kod devnet kullanır) ve yer tutucu mint ile hesap adreslerini kendi adreslerinizle değiştirin.

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