tokens: add Quasar ports for pda-mint-authority and token-fundraiser

pda-mint-authority: PDA as mint authority with signed minting
token-fundraiser: crowdfunding with initialize, contribute, check, refund

Both build with quasar build and pass cargo test.

Author: mikemaccana-edwardbot

tokens/pda-mint-authority/quasar/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "quasar-pda-mint-authority"
+version = "0.1.0"
+edition = "2021"
+
+# Standalone workspace — not part of the root program-examples workspace.
+[workspace]
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+check-cfg = [
+    'cfg(target_os, values("solana"))',
+]
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[features]
+alloc = []
+client = []
+debug = []
+
+[dependencies]
+quasar-lang = "0.0"
+quasar-spl = "0.0"
+solana-instruction = { version = "3.2.0" }
+
+[dev-dependencies]
+quasar-svm = { version = "0.1" }
+spl-token-interface = { version = "2.0.0" }
+solana-program-pack = { version = "3.1.0" }

tokens/pda-mint-authority/quasar/Quasar.toml

@@ -0,0 +1,21 @@
+[project]
+name = "quasar_pda_mint_authority"
+
+[toolchain]
+type = "solana"
+
+[testing]
+language = "rust"
+
+[testing.rust]
+framework = "quasar-svm"
+
+[testing.rust.test]
+program = "cargo"
+args = [
+    "test",
+    "tests::",
+]
+
+[clients]
+languages = ["rust"]

tokens/pda-mint-authority/quasar/src/lib.rs

@@ -0,0 +1,86 @@
+#![cfg_attr(not(test), no_std)]
+
+use quasar_lang::prelude::*;
+use quasar_spl::{Mint, Token, TokenCpi};
+
+#[cfg(test)]
+mod tests;
+
+declare_id!("22222222222222222222222222222222222222222222");
+
+/// Demonstrates using a PDA as the mint authority for an SPL token.
+///
+/// The mint account itself is at a PDA address derived from `["mint"]`.
+/// The same PDA serves as both the mint address AND the mint authority,
+/// so minting requires PDA signing.
+///
+/// The Anchor version uses Metaplex for on-chain metadata. Quasar does not have
+/// a Metaplex integration crate, so this example focuses on the PDA-as-authority
+/// pattern.
+#[program]
+mod quasar_pda_mint_authority {
+    use super::*;
+
+    /// Create a token mint at a PDA. The PDA is its own mint authority.
+    #[instruction(discriminator = 0)]
+    pub fn create_mint(ctx: Ctx<CreateMint>, _decimals: u8) -> Result<(), ProgramError> {
+        ctx.accounts.create_mint()
+    }
+
+    /// Mint tokens using the PDA mint authority.
+    #[instruction(discriminator = 1)]
+    pub fn mint_tokens(ctx: Ctx<MintTokens>, amount: u64) -> Result<(), ProgramError> {
+        ctx.accounts.mint_tokens(amount, ctx.bumps.mint)
+    }
+}
+
+/// Create the mint at a PDA. The mint authority is the mint PDA itself.
+#[derive(Accounts)]
+pub struct CreateMint<'info> {
+    #[account(mut)]
+    pub payer: &'info Signer,
+    /// The mint account at PDA ["mint"]. Its authority is set to itself.
+    #[account(mut, init, payer = payer, seeds = [b"mint"], bump, mint::decimals = 9, mint::authority = mint)]
+    pub mint: &'info mut Account<Mint>,
+    pub rent: &'info Sysvar<Rent>,
+    pub token_program: &'info Program<Token>,
+    pub system_program: &'info Program<System>,
+}
+
+impl CreateMint<'_> {
+    #[inline(always)]
+    pub fn create_mint(&self) -> Result<(), ProgramError> {
+        // Mint is created and initialised by Quasar's #[account(init)].
+        Ok(())
+    }
+}
+
+/// Mint tokens to a token account, signing with the PDA mint authority.
+#[derive(Accounts)]
+pub struct MintTokens<'info> {
+    #[account(mut)]
+    pub payer: &'info Signer,
+    /// The PDA mint whose authority is itself.
+    #[account(mut, seeds = [b"mint"], bump)]
+    pub mint: &'info mut Account<Mint>,
+    /// Recipient token account (must already exist).
+    #[account(mut)]
+    pub token_account: &'info mut Account<Token>,
+    pub token_program: &'info Program<Token>,
+}
+
+impl MintTokens<'_> {
+    #[inline(always)]
+    pub fn mint_tokens(&mut self, amount: u64, mint_bump: u8) -> Result<(), ProgramError> {
+        // The PDA mint is its own authority. Build signer seeds.
+        let bump = [mint_bump];
+        let seeds: &[Seed] = &[
+            Seed::from(b"mint" as &[u8]),
+            Seed::from(&bump as &[u8]),
+        ];
+
+        self.token_program
+            .mint_to(self.mint, self.token_account, self.mint, amount)
+            .invoke_signed(seeds)
+    }
+}

tokens/pda-mint-authority/quasar/src/tests.rs

@@ -0,0 +1,134 @@
+extern crate std;
+use {
+    alloc::vec,
+    quasar_svm::{Account, Instruction, Pubkey, QuasarSvm},
+    spl_token_interface::state::{Account as TokenAccount, AccountState, Mint},
+    std::println,
+};
+
+fn setup() -> QuasarSvm {
+    let elf = std::fs::read("target/deploy/quasar_pda_mint_authority.so").unwrap();
+    QuasarSvm::new()
+        .with_program(&crate::ID, &elf)
+        .with_token_program()
+}
+
+fn signer(address: Pubkey) -> Account {
+    quasar_svm::token::create_keyed_system_account(&address, 1_000_000_000)
+}
+
+fn empty(address: Pubkey) -> Account {
+    Account {
+        address,
+        lamports: 0,
+        data: vec![],
+        owner: quasar_svm::system_program::ID,
+        executable: false,
+    }
+}
+
+fn mint_account(address: Pubkey, authority: Pubkey) -> Account {
+    quasar_svm::token::create_keyed_mint_account(
+        &address,
+        &Mint {
+            mint_authority: Some(authority).into(),
+            supply: 0,
+            decimals: 9,
+            is_initialized: true,
+            freeze_authority: None.into(),
+        },
+    )
+}
+
+fn token_account(address: Pubkey, mint: Pubkey, owner: Pubkey, amount: u64) -> Account {
+    quasar_svm::token::create_keyed_token_account(
+        &address,
+        &TokenAccount {
+            mint,
+            owner,
+            amount,
+            state: AccountState::Initialized,
+            ..TokenAccount::default()
+        },
+    )
+}
+
+/// Build create_mint instruction data.
+/// Wire format: [discriminator: u8 = 0] [decimals: u8]
+fn build_create_mint_data(decimals: u8) -> Vec<u8> {
+    vec![0u8, decimals]
+}
+
+/// Build mint_tokens instruction data.
+/// Wire format: [discriminator: u8 = 1] [amount: u64 LE]
+fn build_mint_tokens_data(amount: u64) -> Vec<u8> {
+    let mut data = vec![1u8];
+    data.extend_from_slice(&amount.to_le_bytes());
+    data
+}
+
+#[test]
+fn test_create_mint() {
+    let mut svm = setup();
+
+    let payer = Pubkey::new_unique();
+    let (mint_pda, _) = Pubkey::find_program_address(&[b"mint"], &crate::ID);
+    let token_program = quasar_svm::SPL_TOKEN_PROGRAM_ID;
+    let system_program = quasar_svm::system_program::ID;
+    let rent = quasar_svm::solana_sdk_ids::sysvar::rent::ID;
+
+    let data = build_create_mint_data(9);
+
+    let instruction = Instruction {
+        program_id: crate::ID,
+        accounts: vec![
+            solana_instruction::AccountMeta::new(payer.into(), true),
+            solana_instruction::AccountMeta::new(mint_pda.into(), false),
+            solana_instruction::AccountMeta::new_readonly(rent.into(), false),
+            solana_instruction::AccountMeta::new_readonly(token_program.into(), false),
+            solana_instruction::AccountMeta::new_readonly(system_program.into(), false),
+        ],
+        data,
+    };
+
+    let result = svm.process_instruction(&instruction, &[signer(payer), empty(mint_pda)]);
+    assert!(result.is_ok(), "create_mint failed: {:?}", result.raw_result);
+    println!("  CREATE MINT CU: {}", result.compute_units_consumed);
+}
+
+#[test]
+fn test_mint_with_pda_authority() {
+    let mut svm = setup();
+
+    let payer = Pubkey::new_unique();
+    let (mint_pda, _) = Pubkey::find_program_address(&[b"mint"], &crate::ID);
+    let token_addr = Pubkey::new_unique();
+    let token_program = quasar_svm::SPL_TOKEN_PROGRAM_ID;
+
+    let amount = 1_000_000_000u64;
+    let data = build_mint_tokens_data(amount);
+
+    let instruction = Instruction {
+        program_id: crate::ID,
+        accounts: vec![
+            solana_instruction::AccountMeta::new(payer.into(), true),
+            solana_instruction::AccountMeta::new(mint_pda.into(), false),
+            solana_instruction::AccountMeta::new(token_addr.into(), false),
+            solana_instruction::AccountMeta::new_readonly(token_program.into(), false),
+        ],
+        data,
+    };
+
+    let result = svm.process_instruction(
+        &instruction,
+        &[
+            signer(payer),
+            // The mint authority is the mint_pda itself
+            mint_account(mint_pda, mint_pda),
+            token_account(token_addr, mint_pda, payer, 0),
+        ],
+    );
+
+    assert!(result.is_ok(), "mint_tokens failed: {:?}", result.raw_result);
+    println!("  MINT WITH PDA CU: {}", result.compute_units_consumed);
+}

tokens/token-fundraiser/quasar/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "quasar-token-fundraiser"
+version = "0.1.0"
+edition = "2021"
+
+# Standalone workspace — not part of the root program-examples workspace.
+[workspace]
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+check-cfg = [
+    'cfg(target_os, values("solana"))',
+]
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[features]
+alloc = []
+client = []
+debug = []
+
+[dependencies]
+quasar-lang = "0.0"
+quasar-spl = "0.0"
+solana-instruction = { version = "3.2.0" }
+
+[dev-dependencies]
+quasar-svm = { version = "0.1" }
+spl-token-interface = { version = "2.0.0" }
+solana-program-pack = { version = "3.1.0" }

tokens/token-fundraiser/quasar/Quasar.toml

@@ -0,0 +1,21 @@
+[project]
+name = "quasar_token_fundraiser"
+
+[toolchain]
+type = "solana"
+
+[testing]
+language = "rust"
+
+[testing.rust]
+framework = "quasar-svm"
+
+[testing.rust.test]
+program = "cargo"
+args = [
+    "test",
+    "tests::",
+]
+
+[clients]
+languages = ["rust"]

tokens/token-fundraiser/quasar/src/instructions/check_contributions.rs

@@ -0,0 +1,56 @@
+use {
+    crate::state::Fundraiser,
+    quasar_lang::prelude::*,
+    quasar_spl::{Token, TokenCpi},
+};
+
+#[derive(Accounts)]
+pub struct CheckContributions<'info> {
+    #[account(mut)]
+    pub maker: &'info Signer,
+    #[account(
+        mut,
+        has_one = maker,
+        close = maker,
+        seeds = [b"fundraiser", maker],
+        bump = fundraiser.bump
+    )]
+    pub fundraiser: &'info mut Account<Fundraiser>,
+    #[account(mut)]
+    pub vault: &'info mut Account<Token>,
+    #[account(mut)]
+    pub maker_ta: &'info mut Account<Token>,
+    pub token_program: &'info Program<Token>,
+}
+
+impl CheckContributions<'_> {
+    #[inline(always)]
+    pub fn check_contributions(&mut self, fundraiser_bump: u8) -> Result<(), ProgramError> {
+        // Verify the target was met
+        require!(
+            self.fundraiser.current_amount >= self.fundraiser.amount_to_raise,
+            ProgramError::Custom(0) // TargetNotMet
+        );
+
+        let maker_key = self.fundraiser.maker;
+        let bump = [fundraiser_bump];
+        let seeds: &[Seed] = &[
+            Seed::from(b"fundraiser" as &[u8]),
+            Seed::from(maker_key.as_ref()),
+            Seed::from(&bump as &[u8]),
+        ];
+
+        // Transfer all vault funds to the maker
+        let vault_amount = self.vault.amount();
+        self.token_program
+            .transfer(self.vault, self.maker_ta, self.fundraiser, vault_amount)
+            .invoke_signed(seeds)?;
+
+        // Close the vault token account
+        self.token_program
+            .close_account(self.vault, self.maker, self.fundraiser)
+            .invoke_signed(seeds)?;
+
+        Ok(())
+    }
+}