Luo token mint

Kuinka luoda mint Confidential Balancesin kanssa

Confidential Balances mahdollistaa yksityiset tokensiirrot lisäämällä ylimääräistä tilaa mint accountiin. Tässä osiossa selitetään, kuinka luodaan token mint tarvittava laajennus käytössä.

Seuraava kaavio näyttää vaiheet, joita tarvitaan mintin luomiseen Confidential Balances -laajennuksen kanssa:

Create Mint with Confidential Balances

Confidential Balances -mintin tila

Laajennus lisää ConfidentialTransferMint -tilan mint account -tilille:

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 sisältää kolme konfiguraatiokenttää:

authority: Tili, jolla on lupa muuttaa Confidential Balances -asetuksia mintille ja hyväksyä uudet luottamukselliset tilit, jos automaattinen hyväksyntä on poistettu käytöstä.
auto_approve_new_accounts: Kun asetettu arvoon true, käyttäjät voivat luoda token accounteja, joissa Confidential Balances on oletuksena käytössä. Kun arvo on false, authority täytyy hyväksyä jokainen uusi token account ennen kuin sitä voidaan käyttää luottamuksellisiin siirtoihin.
auditor_elgamal_pubkey: Valinnainen tarkastaja, joka voi purkaa siirtomäärät luottamuksellisissa transaktioissa tarjoten vaatimustenmukaisuusmekanismin samalla säilyttäen yksityisyyden suurelta yleisöltä.

Vaaditut käskyt

Mintin luominen Confidential Balances käytössä vaatii kolme ohjetta yhdessä transaktiossa:

Luo Mint Account: Kutsu System Program'n CreateAccount -käskyä luodaksesi mint account -tilin.
Alusta Confidential Balances: Kutsu Token Extension Programin ConfidentialTransferInstruction::InitializeMint -ohjetta määrittääksesi ConfidentialTransferMint -tilan mintille.
Alusta Mint: Kutsu Token Extensions Program'n Instruction::InitializeMint -käskyä alustaaksesi tavanomaisen mint-tilan.

Vaikka voisit kirjoittaa nämä käskyt manuaalisesti, spl_token_client -paketti tarjoaa create_mint -metodin, joka rakentaa ja lähettää transaktion kaikilla kolmella käskyllä yhdessä funktiokutsussa, kuten alla olevassa esimerkissä on osoitettu.

Esimerkkikoodi

Seuraava koodi näyttää, kuinka luodaan mint Confidential Balances käytössä.

Confidential Balances riippuu ZK ElGamal Proof -ohjelmasta, joka on käytössä mainnetissä ja devnetissä. Tavallinen solana-test-validator ei ota sitä käyttöön, mutta mainnet-haarukoiva paikallinen validator, kuten Surfpool, tekee niin. Aja esimerkki jotain näistä vasten (koodi käyttää devnetiä) rahoitetulla maksajalla ja korvaa paikkamerkkinä toimivat mint- ja tiliosoitteet omillasi.

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