feat: add Quasar variants for compression and oracle examples

Compression examples (cnft-burn, cnft-vault, cutils) ported using raw
invoke()/invoke_signed() for Bubblegum and SPL Account Compression CPI,
matching the approach used in the Anchor versions.

Oracle example (pyth) ported with manual PriceUpdateV2 account data
parsing in Quasar's no_std environment.

Author: mikemaccana-edwardbot

compression/cnft-burn/quasar/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "quasar-cnft-burn"
+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"
+# Direct dependency for invoke_with_bounds — needed for raw CPI with variable
+# proof accounts. quasar-lang re-exports types but not the invoke functions.
+solana-instruction-view = { version = "2", features = ["cpi"] }
+solana-instruction = { version = "3.2.0" }
+
+[dev-dependencies]
+quasar-svm = { version = "0.1" }
+solana-address = { version = "2.2.0", features = ["decode"] }

compression/cnft-burn/quasar/Quasar.toml

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

compression/cnft-burn/quasar/src/instructions/burn_cnft.rs

@@ -0,0 +1,116 @@
+use crate::*;
+use quasar_lang::cpi::{InstructionAccount, InstructionView};
+
+/// Maximum number of proof nodes for the merkle tree.
+/// Concurrent merkle trees support up to depth 30, but typical depth is 14-20.
+const MAX_PROOF_NODES: usize = 24;
+
+/// Total max accounts for the CPI: 7 fixed + proof nodes.
+const MAX_CPI_ACCOUNTS: usize = 7 + MAX_PROOF_NODES;
+
+/// Accounts for burning a compressed NFT via mpl-bubblegum CPI.
+#[derive(Accounts)]
+pub struct BurnCnft<'info> {
+    #[account(mut)]
+    pub leaf_owner: &'info Signer,
+    /// Tree authority PDA (seeds checked by Bubblegum).
+    #[account(mut)]
+    pub tree_authority: &'info UncheckedAccount,
+    /// Merkle tree account modified by the compression program.
+    #[account(mut)]
+    pub merkle_tree: &'info UncheckedAccount,
+    /// SPL Noop log wrapper.
+    pub log_wrapper: &'info UncheckedAccount,
+    /// SPL Account Compression program.
+    #[account(address = SPL_ACCOUNT_COMPRESSION_ID)]
+    pub compression_program: &'info UncheckedAccount,
+    /// mpl-bubblegum program.
+    #[account(address = MPL_BUBBLEGUM_ID)]
+    pub bubblegum_program: &'info UncheckedAccount,
+    pub system_program: &'info Program<System>,
+}
+
+impl<'info> BurnCnft<'info> {
+    pub fn burn_cnft(
+        &self,
+        ctx: &CtxWithRemaining<'info, BurnCnft<'info>>,
+    ) -> Result<(), ProgramError> {
+        // Parse instruction args from raw data:
+        // root(32) + data_hash(32) + creator_hash(32) + nonce(8) + index(4) = 108 bytes
+        let data = ctx.data;
+        if data.len() < 108 {
+            return Err(ProgramError::InvalidInstructionData);
+        }
+
+        // Build instruction data: discriminator + args
+        // 8 + 32 + 32 + 32 + 8 + 4 = 116 bytes
+        let mut ix_data = [0u8; 116];
+        ix_data[0..8].copy_from_slice(&BURN_DISCRIMINATOR);
+        ix_data[8..116].copy_from_slice(&data[0..108]);
+
+        // Collect remaining accounts (proof nodes) into a stack buffer
+        let remaining = ctx.remaining_accounts();
+        let placeholder = self.system_program.to_account_view().clone();
+        let mut proof_views: [AccountView; MAX_PROOF_NODES] =
+            core::array::from_fn(|_| placeholder.clone());
+        let mut proof_count = 0usize;
+        for result in remaining.iter() {
+            if proof_count >= MAX_PROOF_NODES {
+                break;
+            }
+            proof_views[proof_count] = result?;
+            proof_count += 1;
+        }
+
+        let total_accounts = 7 + proof_count;
+
+        // Build instruction account metas.
+        // Layout matches mpl-bubblegum Burn: tree_authority, leaf_owner (signer),
+        // leaf_delegate (= leaf_owner, not signer), merkle_tree, log_wrapper,
+        // compression_program, system_program, then proof nodes.
+        let sys_addr = self.system_program.address();
+        let mut ix_accounts: [InstructionAccount; MAX_CPI_ACCOUNTS] = core::array::from_fn(|_| {
+            InstructionAccount::readonly(sys_addr)
+        });
+
+        ix_accounts[0] = InstructionAccount::readonly(self.tree_authority.address());
+        ix_accounts[1] = InstructionAccount::readonly_signer(self.leaf_owner.address());
+        // leaf_delegate = leaf_owner, not a signer in this call
+        ix_accounts[2] = InstructionAccount::readonly(self.leaf_owner.address());
+        ix_accounts[3] = InstructionAccount::writable(self.merkle_tree.address());
+        ix_accounts[4] = InstructionAccount::readonly(self.log_wrapper.address());
+        ix_accounts[5] = InstructionAccount::readonly(self.compression_program.address());
+        ix_accounts[6] = InstructionAccount::readonly(self.system_program.address());
+
+        for i in 0..proof_count {
+            ix_accounts[7 + i] = InstructionAccount::readonly(proof_views[i].address());
+        }
+
+        // Build account views array for the CPI
+        let sys_view = self.system_program.to_account_view().clone();
+        let mut views: [AccountView; MAX_CPI_ACCOUNTS] = core::array::from_fn(|_| sys_view.clone());
+
+        views[0] = self.tree_authority.to_account_view().clone();
+        views[1] = self.leaf_owner.to_account_view().clone();
+        views[2] = self.leaf_owner.to_account_view().clone(); // leaf_delegate = leaf_owner
+        views[3] = self.merkle_tree.to_account_view().clone();
+        views[4] = self.log_wrapper.to_account_view().clone();
+        views[5] = self.compression_program.to_account_view().clone();
+        views[6] = self.system_program.to_account_view().clone();
+
+        for i in 0..proof_count {
+            views[7 + i] = proof_views[i].clone();
+        }
+
+        let instruction = InstructionView {
+            program_id: &MPL_BUBBLEGUM_ID,
+            data: &ix_data,
+            accounts: &ix_accounts[..total_accounts],
+        };
+
+        solana_instruction_view::cpi::invoke_with_bounds::<MAX_CPI_ACCOUNTS, AccountView>(
+            &instruction,
+            &views[..total_accounts],
+        )
+    }
+}

compression/cnft-burn/quasar/src/instructions/mod.rs

@@ -0,0 +1,2 @@
+pub mod burn_cnft;
+pub use burn_cnft::*;

compression/cnft-burn/quasar/src/lib.rs

@@ -0,0 +1,37 @@
+#![cfg_attr(not(test), no_std)]
+
+use quasar_lang::prelude::*;
+
+mod instructions;
+use instructions::*;
+#[cfg(test)]
+mod tests;
+
+/// Bubblegum Burn instruction discriminator.
+const BURN_DISCRIMINATOR: [u8; 8] = [116, 110, 29, 56, 107, 219, 42, 93];
+
+/// mpl-bubblegum program ID (BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY).
+const MPL_BUBBLEGUM_ID: Address = Address::new_from_array([
+    0x98, 0x8b, 0x80, 0xeb, 0x79, 0x35, 0x28, 0x69, 0xb2, 0x24, 0x74, 0x5f, 0x59, 0xdd, 0xbf,
+    0x8a, 0x26, 0x58, 0xca, 0x13, 0xdc, 0x68, 0x81, 0x21, 0x26, 0x35, 0x1c, 0xae, 0x07, 0xc1,
+    0xa5, 0xa5,
+]);
+
+/// SPL Account Compression program ID (cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK).
+const SPL_ACCOUNT_COMPRESSION_ID: Address = Address::new_from_array([
+    0x09, 0x2a, 0x13, 0xee, 0x95, 0xc4, 0x1c, 0xba, 0x08, 0xa6, 0x7f, 0x5a, 0xc6, 0x7e, 0x8d,
+    0xf7, 0xe1, 0xda, 0x11, 0x62, 0x5e, 0x1d, 0x64, 0x13, 0x7f, 0x8f, 0x4f, 0x23, 0x83, 0x03,
+    0x7f, 0x14,
+]);
+
+declare_id!("C6qxH8n6mZxrrbtMtYWYSp8JR8vkQ55X1o4EBg7twnMv");
+
+#[program]
+mod quasar_cnft_burn {
+    use super::*;
+
+    #[instruction(discriminator = 0)]
+    pub fn burn_cnft(ctx: CtxWithRemaining<BurnCnft>) -> Result<(), ProgramError> {
+        ctx.accounts.burn_cnft(&ctx)
+    }
+}

compression/cnft-burn/quasar/src/tests.rs

@@ -0,0 +1,3 @@
+// Compressed NFT operations require external programs (Bubblegum, SPL Account
+// Compression) that are not available in the quasar-svm test harness. The build
+// itself verifies the CPI instruction construction compiles correctly.

compression/cnft-vault/quasar/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "quasar-cnft-vault"
+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"
+# Direct dependency for invoke_signed_with_bounds — needed for raw CPI with
+# variable proof accounts. quasar-lang re-exports types but not the invoke fns.
+solana-instruction-view = { version = "2", features = ["cpi"] }
+solana-instruction = { version = "3.2.0" }
+
+[dev-dependencies]
+quasar-svm = { version = "0.1" }
+solana-address = { version = "2.2.0", features = ["decode"] }

compression/cnft-vault/quasar/Quasar.toml

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

compression/cnft-vault/quasar/src/instructions/mod.rs

@@ -0,0 +1,5 @@
+pub mod withdraw;
+pub use withdraw::*;
+
+pub mod withdraw_two;
+pub use withdraw_two::*;