feat: add Quasar variants for hello-solana, counter, and transfer-sol

Add Quasar framework implementations alongside existing Anchor, native,
and Pinocchio variants for three basic examples:

- hello-solana: logs a greeting and the program ID
- counter: initialize + increment with PDA-derived state
- transfer-sol: CPI transfer via system program + direct lamport manipulation

Each is a standalone Cargo project (not in root workspace) with:
- Program source using quasar-lang macros
- Auto-generated client crate via quasar build
- Tests using quasar-svm

All examples build with 'quasar build' and pass 'quasar test'.

Author: mikemaccana-edwardbot

basics/counter/quasar/.gitignore

@@ -0,0 +1,12 @@
+# Build artifacts
+/target
+
+# Dependencies
+node_modules
+
+# Environment
+.env
+.env.*
+
+# OS
+.DS_Store

basics/counter/quasar/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "quasar-counter"
+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"]
+
+[features]
+alloc = []
+client = []
+debug = []
+
+[dependencies]
+quasar-lang = "0.0"
+solana-instruction = { version = "3.2.0" }
+
+[dev-dependencies]
+quasar-counter-client = { path = "target/client/rust/quasar-counter-client" }
+quasar-svm = { version = "0.1" }
+solana-account = { version = "3.4.0" }
+solana-address = { version = "2.2.0", features = ["decode"] }
+solana-instruction = { version = "3.2.0", features = ["bincode"] }
+solana-pubkey = { version = "4.1.0" }

basics/counter/quasar/Quasar.toml

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

basics/counter/quasar/src/instructions/increment.rs

@@ -0,0 +1,20 @@
+use {
+    crate::state::Counter,
+    quasar_lang::prelude::*,
+};
+
+/// Accounts for incrementing a counter.
+#[derive(Accounts)]
+pub struct Increment<'info> {
+    #[account(mut)]
+    pub counter: &'info mut Account<Counter>,
+}
+
+impl<'info> Increment<'info> {
+    #[inline(always)]
+    pub fn increment(&mut self) -> Result<(), ProgramError> {
+        let current: u64 = self.counter.count.into();
+        self.counter.count = PodU64::from(current.checked_add(1).unwrap());
+        Ok(())
+    }
+}

basics/counter/quasar/src/instructions/initialize_counter.rs

@@ -0,0 +1,23 @@
+use {
+    crate::state::Counter,
+    quasar_lang::prelude::*,
+};
+
+/// Accounts for creating a new counter.
+/// The counter is derived as a PDA from ["counter", payer] seeds.
+#[derive(Accounts)]
+pub struct InitializeCounter<'info> {
+    #[account(mut)]
+    pub payer: &'info mut Signer,
+    #[account(mut, init, payer = payer, seeds = [b"counter", payer], bump)]
+    pub counter: &'info mut Account<Counter>,
+    pub system_program: &'info Program<System>,
+}
+
+impl<'info> InitializeCounter<'info> {
+    #[inline(always)]
+    pub fn initialize_counter(&mut self) -> Result<(), ProgramError> {
+        self.counter.set_inner(0u64);
+        Ok(())
+    }
+}

basics/counter/quasar/src/instructions/mod.rs

@@ -0,0 +1,5 @@
+pub mod initialize_counter;
+pub mod increment;
+
+pub use initialize_counter::*;
+pub use increment::*;

basics/counter/quasar/src/lib.rs

@@ -0,0 +1,26 @@
+#![cfg_attr(not(test), no_std)]
+
+use quasar_lang::prelude::*;
+
+mod instructions;
+use instructions::*;
+mod state;
+#[cfg(test)]
+mod tests;
+
+declare_id!("HYSDBQLVUSMRQKQZxfKJwDy5PPrZb7bvuBLaWfbcYhEP");
+
+#[program]
+mod quasar_counter {
+    use super::*;
+
+    #[instruction(discriminator = 0)]
+    pub fn initialize_counter(ctx: Ctx<InitializeCounter>) -> Result<(), ProgramError> {
+        ctx.accounts.initialize_counter()
+    }
+
+    #[instruction(discriminator = 1)]
+    pub fn increment(ctx: Ctx<Increment>) -> Result<(), ProgramError> {
+        ctx.accounts.increment()
+    }
+}

basics/counter/quasar/src/state.rs

@@ -0,0 +1,7 @@
+use quasar_lang::prelude::*;
+
+/// On-chain counter account.
+#[account(discriminator = 1)]
+pub struct Counter {
+    pub count: u64,
+}

basics/counter/quasar/src/tests.rs

@@ -0,0 +1,107 @@
+use quasar_svm::{Account, Instruction, Pubkey, QuasarSvm};
+use solana_address::Address;
+
+use quasar_counter_client::{InitializeCounterInstruction, IncrementInstruction};
+
+fn setup() -> QuasarSvm {
+    let elf = include_bytes!("../target/deploy/quasar_counter.so");
+    QuasarSvm::new().with_program(&Pubkey::from(crate::ID), elf)
+}
+
+fn signer(address: Pubkey) -> Account {
+    quasar_svm::token::create_keyed_system_account(&address, 10_000_000_000)
+}
+
+fn empty(address: Pubkey) -> Account {
+    Account {
+        address,
+        lamports: 0,
+        data: vec![],
+        owner: quasar_svm::system_program::ID,
+        executable: false,
+    }
+}
+
+#[test]
+fn test_initialize_counter() {
+    let mut svm = setup();
+
+    let payer = Pubkey::new_unique();
+    let system_program = quasar_svm::system_program::ID;
+
+    // Derive the counter PDA from ["counter", payer].
+    let (counter, _) = Pubkey::find_program_address(
+        &[b"counter", payer.as_ref()],
+        &Pubkey::from(crate::ID),
+    );
+
+    let instruction: Instruction = InitializeCounterInstruction {
+        payer: Address::from(payer.to_bytes()),
+        counter: Address::from(counter.to_bytes()),
+        system_program: Address::from(system_program.to_bytes()),
+    }
+    .into();
+
+    let result = svm.process_instruction(
+        &instruction,
+        &[signer(payer), empty(counter)],
+    );
+
+    result.assert_success();
+
+    // Verify the counter account was created with count = 0.
+    let counter_account = result.account(&counter).unwrap();
+    // Data: 1 byte discriminator (1) + 8 bytes u64 (0)
+    assert_eq!(counter_account.data.len(), 9);
+    assert_eq!(counter_account.data[0], 1); // discriminator
+    assert_eq!(&counter_account.data[1..], &[0u8; 8]); // count = 0
+}
+
+#[test]
+fn test_increment() {
+    let mut svm = setup();
+
+    let payer = Pubkey::new_unique();
+    let system_program = quasar_svm::system_program::ID;
+
+    // Derive the counter PDA.
+    let (counter, _) = Pubkey::find_program_address(
+        &[b"counter", payer.as_ref()],
+        &Pubkey::from(crate::ID),
+    );
+
+    // First, initialise the counter.
+    let init_instruction: Instruction = InitializeCounterInstruction {
+        payer: Address::from(payer.to_bytes()),
+        counter: Address::from(counter.to_bytes()),
+        system_program: Address::from(system_program.to_bytes()),
+    }
+    .into();
+
+    let result = svm.process_instruction(
+        &init_instruction,
+        &[signer(payer), empty(counter)],
+    );
+    result.assert_success();
+
+    // Grab updated accounts after init.
+    let counter_after_init = result.account(&counter).unwrap().clone();
+
+    // Increment the counter.
+    let increment_instruction: Instruction = IncrementInstruction {
+        counter: Address::from(counter.to_bytes()),
+    }
+    .into();
+
+    let result = svm.process_instruction(
+        &increment_instruction,
+        &[counter_after_init],
+    );
+    result.assert_success();
+
+    // Verify count = 1.
+    let counter_account = result.account(&counter).unwrap();
+    let count_bytes: [u8; 8] = counter_account.data[1..9].try_into().unwrap();
+    let count = u64::from_le_bytes(count_bytes);
+    assert_eq!(count, 1, "counter should be 1 after one increment");
+}

basics/hello-solana/quasar/.gitignore

@@ -0,0 +1,12 @@
+# Build artifacts
+/target
+
+# Dependencies
+node_modules
+
+# Environment
+.env
+.env.*
+
+# OS
+.DS_Store