complete steel tests

Author: Perelyn-sama

tokens/spl-token-minter/steel/api/Cargo.toml

@@ -12,3 +12,4 @@ thiserror.workspace = true
 spl-token.workspace = true
 mpl-token-metadata.workspace = true
 const-crypto.workspace = true
+spl-associated-token-account.workspace = true

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

@@ -19,7 +19,7 @@ pub struct Create {
 #[repr(C)]
 #[derive(Clone, Copy, Debug, Pod, Zeroable)]
 pub struct Mint {
-    pub amount: [u8; 8],
+    pub quantity: [u8; 8],
 }
 
 instruction!(SteelInstruction, Mint);

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

@@ -39,19 +39,28 @@ pub fn create(
         .to_bytes(),
     }
 }
-pub fn mint(signer: Pubkey, to: Pubkey, authority: Pubkey, amount: u64) -> Instruction {
+pub fn mint(
+    signer: Pubkey,
+    recipient: Pubkey,
+    associated_token_account: Pubkey,
+    authority: 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(signer, true),
+            AccountMeta::new(recipient, false),
             AccountMeta::new(mint_pda.0, false),
-            AccountMeta::new(to, false),
+            AccountMeta::new(associated_token_account, false),
             AccountMeta::new(authority, false),
             AccountMeta::new_readonly(spl_token::ID, false),
+            AccountMeta::new_readonly(spl_associated_token_account::ID, false),
+            AccountMeta::new_readonly(system_program::ID, false),
         ],
         data: Mint {
-            amount: amount.to_le_bytes(),
+            quantity: quantity.to_le_bytes(),
         }
         .to_bytes(),
     }

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

@@ -24,13 +24,6 @@ pub fn process_create(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResul
     system_program.is_program(&system_program::ID)?;
     token_program.is_program(&spl_token::ID)?;
     rent_sysvar.is_sysvar(&sysvar::rent::ID)?;
-    msg!("metadata program key {}", metadata_program.key);
-    msg!("metadata program ID {}", mpl_token_metadata::ID);
-    // metadata_program.is_program(&mpl_token_metadata::ID)?;
-
-    if metadata_program.key.ne(&mpl_token_metadata::ID) {
-        return Err(ProgramError::InvalidAccountData);
-    }
 
     // First create the account for the Mint
     //

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

@@ -5,37 +5,53 @@ use steel::*;
 pub fn process_mint(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResult {
     // parse args.
     let args = Mint::try_from_bytes(data)?;
-    let amount = u64::from_le_bytes(args.amount);
+    let quantity = u64::from_le_bytes(args.quantity);
 
     // Load accounts.
-    let [signer_info, mint_info, to_info, authority_info, token_program] = accounts else {
+    let [signer_info, recipient_info, mint_info, associated_token_account_info, authority_info, token_program, associated_token_program, system_program] =
+        accounts
+    else {
         return Err(ProgramError::NotEnoughAccountKeys);
     };
 
-    msg!("Minting tokens to associated token account...");
-    msg!("Mint: {:?}", mint_info);
-    msg!("Token Address: {:?}", &to_info);
-
-    // validation
     signer_info.is_signer()?;
     mint_info.as_mint()?;
     token_program.is_program(&spl_token::ID)?;
 
-    to_info.as_associated_token_account(signer_info.key, mint_info.key)?;
+    if associated_token_account_info.lamports() == 0 {
+        msg!("Creating associated token account...");
+        create_associated_token_account(
+            signer_info,
+            recipient_info,
+            associated_token_account_info,
+            mint_info,
+            system_program,
+            token_program,
+            associated_token_program,
+        )?;
+    } else {
+        msg!("Associated token account exists.");
+    }
+    msg!(
+        "Associated Token Address: {}",
+        associated_token_account_info.key
+    );
+
+    msg!("Minting {} tokens to associated token account...", quantity);
 
     solana_program::program::invoke(
         &spl_token::instruction::mint_to(
             &spl_token::id(),
             mint_info.key,
-            to_info.key,
+            associated_token_account_info.key,
             authority_info.key,
             &[authority_info.key],
-            amount,
+            quantity,
         )?,
         &[
             token_program.clone(),
             mint_info.clone(),
-            to_info.clone(),
+            associated_token_account_info.clone(),
             authority_info.clone(),
         ],
     )?;

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

@@ -34,37 +34,23 @@ async fn run_test() {
 
     let mint_pda =
         Pubkey::find_program_address(&[MINT, MINT_NOISE.as_slice()], &spl_token_minter_api::ID);
-    // dbg!(mint_pda);
-    // let to_ata =
-    // spl_associated_token_account::get_associated_token_address(&payer.pubkey(), &mint_pda.0);
-    let to_ata = spl_associated_token_account::get_associated_token_address_with_program_id(
-        &payer.pubkey(),
+
+    let recipient = Keypair::new();
+
+    let to_ata = spl_associated_token_account::get_associated_token_address(
+        &recipient.pubkey(),
         &mint_pda.0,
-        &spl_token::ID,
     );
-    // dbg!(to_ata);
 
     // Submit mint transaction.
-    let ix = mint(payer.pubkey(), to_ata, payer.pubkey(), 100);
+    let ix = mint(
+        payer.pubkey(),
+        recipient.pubkey(),
+        to_ata,
+        payer.pubkey(),
+        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());
-
-    // // Verify counter was initialized.
-    // let counter_address = counter_pda().0;
-    // let counter_account = banks.get_account(counter_address).await.unwrap().unwrap();
-    // let counter = Counter::try_from_bytes(&counter_account.data).unwrap();
-    // assert_eq!(counter_account.owner, steel_api::ID);
-    // assert_eq!(counter.value, 0);
-
-    // // Submit add transaction.
-    // let ix = add(payer.pubkey(), 42);
-    // let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
-    // let res = banks.process_transaction(tx).await;
-    // assert!(res.is_ok());
-
-    // // Verify counter was incremented.
-    // let counter_account = banks.get_account(counter_address).await.unwrap().unwrap();
-    // let counter = Counter::try_from_bytes(&counter_account.data).unwrap();
-    // assert_eq!(counter.value, 42);
 }