add steel test

Author: Perelyn-sama

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

@@ -8,7 +8,7 @@ edition = "2021"
 license = "Apache-2.0"
 homepage = ""
 documentation = ""
-respository = ""
+repository = ""
 readme = "./README.md"
 keywords = ["solana"]
 
@@ -21,3 +21,7 @@ steel = { version = "2.0", features = ["spl"] }
 thiserror = "1.0"
 spl-token = "^4"
 mpl-token-metadata = { version = "4.1.2" }
+const-crypto = "0.1.0"
+spl-associated-token-account = { version = "^2.3", features = [
+    "no-entrypoint",
+] }

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

@@ -11,3 +11,4 @@ steel.workspace = true
 thiserror.workspace = true
 spl-token.workspace = true
 mpl-token-metadata.workspace = true
+const-crypto.workspace = true

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

@@ -1,3 +1,6 @@
+use const_crypto::ed25519;
+use solana_program::pubkey::Pubkey;
+
 /// The seed of the mint account PDA.
 pub const MINT: &[u8] = b"mint";
 
@@ -8,3 +11,9 @@ pub const MINT_NOISE: [u8; 16] = [
 
 /// 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/lib.rs

@@ -2,12 +2,14 @@ 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::*;
 }
 
 use steel::*;

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

@@ -5,23 +5,10 @@ use crate::prelude::*;
 pub fn create(
     payer: Pubkey,
     mint_authority: Pubkey,
-    token_name: String,
-    token_symbol: String,
-    token_uri: String,
+    token_name: [u8; 32],
+    token_symbol: [u8; 8],
+    token_uri: [u8; 64],
 ) -> Instruction {
-    let token_name_bytes: [u8; 32] = token_name
-        .as_bytes()
-        .try_into()
-        .expect("String wrong length, expected 32 bytes");
-    let token_symbol_bytes: [u8; 8] = token_symbol
-        .as_bytes()
-        .try_into()
-        .expect("String wrong length, expected 32 bytes");
-    let token_uri_bytes: [u8; 64] = token_uri
-        .as_bytes()
-        .try_into()
-        .expect("String wrong length, expected 32 bytes");
-
     let mint_pda = Pubkey::find_program_address(&[MINT, MINT_NOISE.as_slice()], &crate::ID);
     let metadata_pda = Pubkey::find_program_address(
         &[
@@ -45,25 +32,20 @@ pub fn create(
             AccountMeta::new_readonly(sysvar::rent::ID, false),
         ],
         data: Create {
-            token_name: token_name_bytes,
-            token_symbol: token_symbol_bytes,
-            token_uri: token_uri_bytes,
+            token_name,
+            token_symbol,
+            token_uri,
         }
         .to_bytes(),
     }
 }
-pub fn mint(
-    signer: Pubkey,
-    mint: Pubkey,
-    to: Pubkey,
-    authority: Pubkey,
-    amount: u64,
-) -> Instruction {
+pub fn mint(signer: Pubkey, to: Pubkey, authority: Pubkey, amount: 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(mint, false),
+            AccountMeta::new(mint_pda.0, false),
             AccountMeta::new(to, false),
             AccountMeta::new(authority, false),
             AccountMeta::new_readonly(spl_token::ID, false),

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

@@ -0,0 +1,6 @@
+pub fn str_to_bytes<const N: usize>(str: &str) -> [u8; N] {
+    let mut str_bytes = [0u8; N];
+    let copy_len = str.len().min(N);
+    str_bytes[..copy_len].copy_from_slice(&str.as_bytes()[..copy_len]);
+    str_bytes
+}

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

@@ -12,10 +12,11 @@ solana-program.workspace = true
 steel.workspace = true
 spl-token.workspace = true
 mpl-token-metadata.workspace = true
+spl-associated-token-account.workspace = true
 
 
 [dev-dependencies]
-bs64 = "0.1.2"
+base64 = "0.21"
 rand = "0.8.5"
 solana-program-test = "1.18"
 solana-sdk = "1.18"

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

@@ -12,63 +12,64 @@ pub fn process_create(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResul
     let token_uri = String::from_utf8(args.token_uri.to_vec()).expect("Invalid UTF-8");
 
     // Load accounts.
-    let [payer_info, mint_info, mint_authority_info, metadata_info, token_program, system_program, rent_sysvar, token_metadata_program] =
+    let [payer_info, mint_info, mint_authority_info, metadata_info, system_program, token_program, metadata_program, rent_sysvar] =
         accounts
     else {
         return Err(ProgramError::NotEnoughAccountKeys);
     };
 
     // validation
     payer_info.is_signer()?;
-    mint_info.as_mint()?;
-    token_program.is_program(&spl_token::ID)?;
-    rent_sysvar.is_sysvar(&sysvar::rent::ID)?;
+    mint_info.is_empty()?.is_writable()?;
     system_program.is_program(&system_program::ID)?;
     token_program.is_program(&spl_token::ID)?;
-    token_metadata_program.is_program(&mpl_token_metadata::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
     //
     msg!("Creating mint account...");
     msg!("Mint: {}", mint_info.key);
-    allocate_account(
+    allocate_account_with_bump(
         mint_info,
         system_program,
         payer_info,
         Mint::LEN,
         &spl_token::ID,
         &[MINT, MINT_NOISE.as_slice()],
+        MINT_BUMP,
     )?;
 
     // Now initialize that account as a Mint (standard Mint)
     //
     msg!("Initializing mint account...");
     msg!("Mint: {}", mint_info.key);
-    solana_program::program::invoke(
-        &spl_token::instruction::initialize_mint(
-            &spl_token::ID,
-            mint_info.key,
-            mint_authority_info.key,
-            Some(mint_authority_info.key),
-            9, // 9 Decimals for the default SPL Token standard,
-        )?,
-        &[
-            token_program.clone(),
-            mint_info.clone(),
-            mint_authority_info.clone(),
-            rent_sysvar.clone(),
-        ],
+    initialize_mint_signed_with_bump(
+        mint_info,
+        mint_authority_info,
+        None,
+        token_program,
+        rent_sysvar,
+        9, // 9 Decimals for the default SPL Token standard
+        &[MINT, MINT_NOISE.as_slice()],
+        MINT_BUMP,
     )?;
 
     // Now create the account for that Mint's metadata
     //
     msg!("Creating metadata account...");
     msg!("Metadata account address: {}", metadata_info.key);
     mpl_token_metadata::instructions::CreateMetadataAccountV3Cpi {
-        __program: token_metadata_program,
+        __program: metadata_program,
         metadata: metadata_info,
         mint: mint_info,
+        // mint_authority: mint_authority_info,
         mint_authority: mint_authority_info,
         payer: payer_info,
         update_authority: (payer_info, true),

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

@@ -23,8 +23,6 @@ pub fn process_mint(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResult
 
     to_info.as_associated_token_account(signer_info.key, mint_info.key)?;
 
-    token_program.is_program(&spl_token::ID)?;
-
     solana_program::program::invoke(
         &spl_token::instruction::mint_to(
             &spl_token::id(),

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

@@ -1,15 +1,18 @@
-use steel_api::prelude::*;
 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(
-        "steel",
-        steel_api::ID,
-        processor!(steel_program::process_instruction),
+        "spl_token_minter_program",
+        spl_token_minter_api::ID,
+        processor!(spl_token_minter_program::process_instruction),
     );
+
+    program_test.add_program("token_metadata", mpl_token_metadata::ID, None);
+
     program_test.prefer_bpf(true);
     program_test.start().await
 }
@@ -19,28 +22,49 @@ async fn run_test() {
     // Setup test
     let (mut banks, payer, blockhash) = setup().await;
 
-    // Submit initialize transaction.
-    let ix = initialize(payer.pubkey());
+    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(), payer.pubkey(), name, symbol, uri);
     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);
+    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(),
+        &mint_pda.0,
+        &spl_token::ID,
+    );
+    // dbg!(to_ata);
 
-    // Submit add transaction.
-    let ix = add(payer.pubkey(), 42);
+    // Submit mint transaction.
+    let ix = mint(payer.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 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);
-}
+    // // 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);
+}