clean clean clean

Author: Perelyn-sama

tokens/spl-token-minter/steel/api/src/consts.rs

@@ -1,19 +1,2 @@
-use const_crypto::ed25519;
-use solana_program::pubkey::Pubkey;
-
-/// The seed of the mint account PDA.
-pub const MINT: &[u8] = b"mint";
-
-/// Noise for deriving the mint pda
-pub const MINT_NOISE: [u8; 16] = [
-    89, 157, 88, 232, 243, 249, 197, 132, 199, 49, 19, 234, 91, 94, 150, 41,
-];
-
 /// The seed of the metadata account PDA.
 pub const METADATA: &[u8] = b"metadata";
-
-/// The bump of the mint account.
-pub const MINT_BUMP: u8 = ed25519::derive_program_address(&[MINT, &MINT_NOISE], &PROGRAM_ID).1;
-
-/// Program id for const pda derivations
-const PROGRAM_ID: [u8; 32] = unsafe { *(&crate::id() as *const Pubkey as *const [u8; 32]) };

tokens/spl-token-minter/steel/api/src/error.rs

@@ -1,12 +1,10 @@
 pub mod consts;
-pub mod error;
 pub mod instruction;
 pub mod sdk;
 pub mod utils;
 
 pub mod prelude {
     pub use crate::consts::*;
-    pub use crate::error::*;
     pub use crate::instruction::*;
     pub use crate::sdk::*;
     pub use crate::utils::*;

tokens/spl-token-minter/steel/api/src/lib.rs

@@ -4,25 +4,21 @@ use crate::prelude::*;
 
 pub fn create(
     payer: Pubkey,
+    mint: Pubkey,
     token_name: [u8; 32],
     token_symbol: [u8; 8],
     token_uri: [u8; 64],
 ) -> Instruction {
-    let mint_pda = Pubkey::find_program_address(&[MINT, MINT_NOISE.as_slice()], &crate::ID);
     let metadata_pda = Pubkey::find_program_address(
-        &[
-            METADATA,
-            mpl_token_metadata::ID.as_ref(),
-            mint_pda.0.as_ref(),
-        ],
+        &[METADATA, mpl_token_metadata::ID.as_ref(), mint.as_ref()],
         &mpl_token_metadata::ID,
     );
 
     Instruction {
         program_id: crate::ID,
         accounts: vec![
             AccountMeta::new(payer, true),
-            AccountMeta::new(mint_pda.0, false),
+            AccountMeta::new(mint, true),
             AccountMeta::new(metadata_pda.0, false),
             AccountMeta::new_readonly(system_program::ID, false),
             AccountMeta::new_readonly(spl_token::ID, false),
@@ -40,16 +36,16 @@ pub fn create(
 pub fn mint(
     mint_authority: Pubkey,
     recipient: Pubkey,
+    mint: Pubkey,
     associated_token_account: Pubkey,
     quantity: u64,
 ) -> Instruction {
-    let mint_pda = Pubkey::find_program_address(&[MINT, MINT_NOISE.as_slice()], &crate::ID);
     Instruction {
         program_id: crate::ID,
         accounts: vec![
             AccountMeta::new(mint_authority, true),
             AccountMeta::new(recipient, false),
-            AccountMeta::new(mint_pda.0, false),
+            AccountMeta::new(mint, false),
             AccountMeta::new(associated_token_account, false),
             AccountMeta::new_readonly(spl_token::ID, false),
             AccountMeta::new_readonly(spl_associated_token_account::ID, false),

tokens/spl-token-minter/steel/api/src/sdk.rs

@@ -29,29 +29,40 @@ pub fn process_create(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResul
     //
     msg!("Creating mint account...");
     msg!("Mint: {}", mint_info.key);
-    allocate_account_with_bump(
-        mint_info,
-        system_program,
-        payer_info,
-        Mint::LEN,
-        &spl_token::ID,
-        &[MINT, MINT_NOISE.as_slice()],
-        MINT_BUMP,
+    solana_program::program::invoke(
+        &solana_program::system_instruction::create_account(
+            payer_info.key,
+            mint_info.key,
+            (solana_program::rent::Rent::get()?).minimum_balance(Mint::LEN),
+            Mint::LEN as u64,
+            token_program.key,
+        ),
+        &[
+            mint_info.clone(),
+            payer_info.clone(),
+            system_program.clone(),
+            token_program.clone(),
+        ],
     )?;
 
     // Now initialize that account as a Mint (standard Mint)
     //
     msg!("Initializing mint account...");
     msg!("Mint: {}", mint_info.key);
-    initialize_mint_signed_with_bump(
-        mint_info,
-        payer_info,
-        None,
-        token_program,
-        rent_sysvar,
-        9, // 9 Decimals for the default SPL Token standard
-        &[MINT, MINT_NOISE.as_slice()],
-        MINT_BUMP,
+    solana_program::program::invoke(
+        &spl_token::instruction::initialize_mint(
+            token_program.key,
+            mint_info.key,
+            payer_info.key,
+            Some(payer_info.key),
+            9, // 9 Decimals for the default SPL Token standard
+        )?,
+        &[
+            mint_info.clone(),
+            payer_info.clone(),
+            token_program.clone(),
+            rent_sysvar.clone(),
+        ],
     )?;
 
     // Now create the account for that Mint's metadata

tokens/spl-token-minter/steel/program/src/create.rs

@@ -13,7 +13,6 @@ pub fn process_mint(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResult
     else {
         return Err(ProgramError::NotEnoughAccountKeys);
     };
-
     mint_authority_info.is_signer()?;
     mint_info.as_mint()?;
     token_program.is_program(&spl_token::ID)?;

tokens/spl-token-minter/steel/program/src/mint.rs

@@ -2,7 +2,6 @@ use solana_program::hash::Hash;
 use solana_program_test::{processor, BanksClient, ProgramTest};
 use solana_sdk::{signature::Keypair, signer::Signer, transaction::Transaction};
 use spl_token_minter_api::prelude::*;
-use steel::*;
 
 async fn setup() -> (BanksClient, Keypair, Hash) {
     let mut program_test = ProgramTest::new(
@@ -21,29 +20,38 @@ async fn setup() -> (BanksClient, Keypair, Hash) {
 async fn run_test() {
     // Setup test
     let (mut banks, payer, blockhash) = setup().await;
+    let mint_keypair = Keypair::new();
 
     let name = str_to_bytes::<32>("Solana Gold");
     let symbol = str_to_bytes::<8>("GOLDSOL");
     let uri = str_to_bytes::<64>("https://raw.githubusercontent.com/solana-developers/program-examples/new-examples/tokens/tokens/.assets/spl-token.json");
 
     // Submit create transaction.
-    let ix = create(payer.pubkey(), name, symbol, uri);
-    let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
+    let ix = create(payer.pubkey(), mint_keypair.pubkey(), name, symbol, uri);
+    let tx = Transaction::new_signed_with_payer(
+        &[ix],
+        Some(&payer.pubkey()),
+        &[&payer, &mint_keypair],
+        blockhash,
+    );
     let res = banks.process_transaction(tx).await;
     assert!(res.is_ok());
 
-    let mint_pda =
-        Pubkey::find_program_address(&[MINT, MINT_NOISE.as_slice()], &spl_token_minter_api::ID);
-
     let recipient = Keypair::new();
 
     let to_ata = spl_associated_token_account::get_associated_token_address(
         &recipient.pubkey(),
-        &mint_pda.0,
+        &mint_keypair.pubkey(),
     );
 
     // Submit mint transaction.
-    let ix = mint(payer.pubkey(), recipient.pubkey(), to_ata, 100);
+    let ix = mint(
+        payer.pubkey(),
+        recipient.pubkey(),
+        mint_keypair.pubkey(),
+        to_ata,
+        100,
+    );
     let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
     let res = banks.process_transaction(tx).await;
     assert!(res.is_ok());

tokens/spl-token-minter/steel/program/tests/test.rs

@@ -38,27 +38,19 @@ describe("SPL Token Minter", () => {
     `${require("node:os").homedir()}/.config/solana/id.json`,
   );
 
-  const MINT = Buffer.from("mint");
-  const MINT_NOISE = Buffer.from([
-    89, 157, 88, 232, 243, 249, 197, 132, 199, 49, 19, 234, 91, 94, 150, 41,
-  ]);
+  const mintKeypair: Keypair = Keypair.generate();
 
   const PROGRAM_ID = new PublicKey(
     "8V26fyhrQobKbvkRCV3KvT6jZQLzviovdARfGrw8kUdG",
   );
 
   it("Create SPL Token", async () => {
     try {
-      const [mintPDA] = PublicKey.findProgramAddressSync(
-        [MINT, MINT_NOISE],
-        PROGRAM_ID,
-      );
-
       const [metadataPDA] = PublicKey.findProgramAddressSync(
         [
           Buffer.from("metadata"),
           TOKEN_METADATA_PROGRAM_ID.toBuffer(),
-          mintPDA.toBuffer(),
+          mintKeypair.publicKey.toBuffer(),
         ],
         TOKEN_METADATA_PROGRAM_ID,
       );
@@ -72,7 +64,7 @@ describe("SPL Token Minter", () => {
       const createTokenIx = new TransactionInstruction({
         keys: [
           { pubkey: payer.publicKey, isSigner: true, isWritable: true },
-          { pubkey: mintPDA, isSigner: false, isWritable: true },
+          { pubkey: mintKeypair.publicKey, isSigner: true, isWritable: true },
           { pubkey: metadataPDA, isSigner: false, isWritable: true },
           {
             pubkey: SystemProgram.programId,
@@ -94,7 +86,7 @@ describe("SPL Token Minter", () => {
       const signature = await sendAndConfirmTransaction(
         connection,
         new Transaction().add(createTokenIx),
-        [payer],
+        [payer, mintKeypair],
         { skipPreflight: true },
       );
       console.log("Create transaction:", signature);
@@ -108,13 +100,8 @@ describe("SPL Token Minter", () => {
 
   it("Mint tokens", async () => {
     try {
-      const [mintPDA] = PublicKey.findProgramAddressSync(
-        [MINT, MINT_NOISE],
-        PROGRAM_ID,
-      );
-
       const recipientATA = await getAssociatedTokenAddress(
-        mintPDA,
+        mintKeypair.publicKey,
         payer.publicKey,
       );
 
@@ -126,7 +113,7 @@ describe("SPL Token Minter", () => {
             payer.publicKey, // Payer
             recipientATA, // ATA Address
             payer.publicKey, // Owner
-            mintPDA, // Mint
+            mintKeypair.publicKey, // Mint
           ),
         );
       }
@@ -137,7 +124,7 @@ describe("SPL Token Minter", () => {
         keys: [
           { pubkey: payer.publicKey, isSigner: true, isWritable: true }, // mint_authority
           { pubkey: payer.publicKey, isSigner: false, isWritable: false }, // recipient
-          { pubkey: mintPDA, isSigner: false, isWritable: true }, // mint_pda must be writable
+          { pubkey: mintKeypair.publicKey, isSigner: false, isWritable: true }, // mint_pda must be writable
           { pubkey: recipientATA, isSigner: false, isWritable: true }, // associated_token_account must be writable
           { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }, // spl_token::ID
           {