tokens: add Quasar ports for create-token, transfer-tokens, and escrow

create-token: mint creation and minting (no Metaplex metadata)
transfer-tokens: mint_to and transfer SPL token operations
escrow: full make/take/refund with PDA vault, has_one checks, close

All three build with quasar build and pass cargo test.

Author: mikemaccana-edwardbot

tokens/create-token/quasar/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "quasar-create-token"
+version = "0.1.0"
+edition = "2021"
+
+# Standalone workspace — not part of the root program-examples workspace.
+# Quasar uses a different resolver and dependency tree.
+[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/create-token/quasar/Quasar.toml

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

tokens/create-token/quasar/src/lib.rs

@@ -0,0 +1,73 @@
+#![cfg_attr(not(test), no_std)]
+
+use quasar_lang::prelude::*;
+use quasar_spl::{Mint, Token, TokenCpi};
+
+#[cfg(test)]
+mod tests;
+
+declare_id!("22222222222222222222222222222222222222222222");
+
+/// Creates a token mint and mints initial tokens to the creator's token account.
+///
+/// The Anchor version uses Metaplex for on-chain metadata. Quasar does not have
+/// a Metaplex integration crate, so this example focuses on the core SPL Token
+/// operations: creating a mint and minting tokens.
+#[program]
+mod quasar_create_token {
+    use super::*;
+
+    /// Create a new token mint (account init handled by Quasar's `#[account(init)]`).
+    #[instruction(discriminator = 0)]
+    pub fn create_token(ctx: Ctx<CreateToken>, _decimals: u8) -> Result<(), ProgramError> {
+        ctx.accounts.create_token()
+    }
+
+    /// Mint tokens to the creator's token account.
+    #[instruction(discriminator = 1)]
+    pub fn mint_tokens(ctx: Ctx<MintTokens>, amount: u64) -> Result<(), ProgramError> {
+        ctx.accounts.mint_tokens(amount)
+    }
+}
+
+/// Accounts for creating a new token mint.
+/// Quasar's `#[account(init)]` handles the create_account + initialize_mint CPI.
+#[derive(Accounts)]
+pub struct CreateToken<'info> {
+    #[account(mut)]
+    pub payer: &'info Signer,
+    #[account(mut, init, payer = payer, mint::decimals = 9, mint::authority = payer)]
+    pub mint: &'info mut Account<Mint>,
+    pub rent: &'info Sysvar<Rent>,
+    pub token_program: &'info Program<Token>,
+    pub system_program: &'info Program<System>,
+}
+
+impl CreateToken<'_> {
+    #[inline(always)]
+    pub fn create_token(&self) -> Result<(), ProgramError> {
+        // Mint account is created and initialised by Quasar's account init.
+        Ok(())
+    }
+}
+
+/// Accounts for minting tokens to an existing token account.
+#[derive(Accounts)]
+pub struct MintTokens<'info> {
+    #[account(mut)]
+    pub authority: &'info Signer,
+    #[account(mut)]
+    pub mint: &'info mut Account<Mint>,
+    #[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) -> Result<(), ProgramError> {
+        self.token_program
+            .mint_to(self.mint, self.token_account, self.authority, amount)
+            .invoke()
+    }
+}

tokens/create-token/quasar/src/tests.rs

@@ -0,0 +1,145 @@
+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_create_token.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(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()
+        },
+    )
+}
+
+/// Mark specific account indices as signers.
+fn with_signers(mut ix: Instruction, indices: &[usize]) -> Instruction {
+    for &i in indices {
+        ix.accounts[i].is_signer = true;
+    }
+    ix
+}
+
+/// Build create_token instruction data.
+/// Wire format: [discriminator: u8 = 0] [decimals: u8]
+fn build_create_token_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_token() {
+    let mut svm = setup();
+
+    let payer = Pubkey::new_unique();
+    let mint_address = Pubkey::new_unique();
+    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_token_data(9);
+
+    let instruction = Instruction {
+        program_id: crate::ID,
+        accounts: vec![
+            solana_instruction::AccountMeta::new(payer.into(), true),
+            solana_instruction::AccountMeta::new(mint_address.into(), true),
+            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_address)],
+    );
+
+    assert!(result.is_ok(), "create_token failed: {:?}", result.raw_result);
+    println!("  CREATE TOKEN CU: {}", result.compute_units_consumed);
+}
+
+#[test]
+fn test_mint_tokens() {
+    let mut svm = setup();
+
+    let authority = Pubkey::new_unique();
+    let mint_address = Pubkey::new_unique();
+    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(authority.into(), true),
+            solana_instruction::AccountMeta::new(mint_address.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(authority),
+            mint(mint_address, authority),
+            token_account(token_addr, mint_address, authority, 0),
+        ],
+    );
+
+    assert!(result.is_ok(), "mint_tokens failed: {:?}", result.raw_result);
+    println!("  MINT TOKENS CU: {}", result.compute_units_consumed);
+}

tokens/escrow/quasar/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "quasar-escrow"
+version = "0.1.0"
+edition = "2021"
+
+# Standalone workspace — not part of the root program-examples workspace.
+# Quasar uses a different resolver and dependency tree.
+[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-address = { version = "2.2.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/escrow/quasar/Quasar.toml

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

tokens/escrow/quasar/src/instructions/make.rs

@@ -0,0 +1,46 @@
+use {
+    crate::state::Escrow,
+    quasar_lang::prelude::*,
+    quasar_spl::{Mint, Token, TokenCpi},
+};
+
+#[derive(Accounts)]
+pub struct Make<'info> {
+    #[account(mut)]
+    pub maker: &'info Signer,
+    #[account(mut, init, payer = maker, seeds = [b"escrow", maker], bump)]
+    pub escrow: &'info mut Account<Escrow>,
+    pub mint_a: &'info Account<Mint>,
+    pub mint_b: &'info Account<Mint>,
+    #[account(mut)]
+    pub maker_ta_a: &'info mut Account<Token>,
+    #[account(mut, init_if_needed, payer = maker, token::mint = mint_b, token::authority = maker)]
+    pub maker_ta_b: &'info mut Account<Token>,
+    #[account(mut, init_if_needed, payer = maker, token::mint = mint_a, token::authority = escrow)]
+    pub vault_ta_a: &'info mut Account<Token>,
+    pub rent: &'info Sysvar<Rent>,
+    pub token_program: &'info Program<Token>,
+    pub system_program: &'info Program<System>,
+}
+
+impl Make<'_> {
+    #[inline(always)]
+    pub fn make_escrow(&mut self, receive: u64, bumps: &MakeBumps) -> Result<(), ProgramError> {
+        self.escrow.set_inner(
+            *self.maker.address(),
+            *self.mint_a.address(),
+            *self.mint_b.address(),
+            *self.maker_ta_b.address(),
+            receive,
+            bumps.escrow,
+        );
+        Ok(())
+    }
+
+    #[inline(always)]
+    pub fn deposit_tokens(&mut self, amount: u64) -> Result<(), ProgramError> {
+        self.token_program
+            .transfer(self.maker_ta_a, self.vault_ta_a, self.maker, amount)
+            .invoke()
+    }
+}

tokens/escrow/quasar/src/instructions/mod.rs

@@ -0,0 +1,8 @@
+pub mod make;
+pub use make::*;
+
+pub mod take;
+pub use take::*;
+
+pub mod refund;
+pub use refund::*;