fix: sdk macros

.github/workflows/sdk-tests.yml

@@ -50,7 +50,7 @@ jobs:
           - program: native
             sub-tests: '["cargo-test-sbf -p sdk-native-test", "cargo-test-sbf -p sdk-v1-native-test", "cargo-test-sbf -p sdk-light-token-test", "cargo-test-sbf -p client-test"]'
           - program: anchor & pinocchio
-            sub-tests: '["cargo-test-sbf -p sdk-anchor-test", "cargo-test-sbf -p sdk-compressible-test", "cargo-test-sbf -p csdk-anchor-derived-test", "cargo-test-sbf -p csdk-anchor-full-derived-test", "cargo-test-sbf -p sdk-pinocchio-v1-test", "cargo-test-sbf -p sdk-pinocchio-v2-test", "cargo-test-sbf -p pinocchio-nostd-test"]'
+            sub-tests: '["cargo-test-sbf -p sdk-anchor-test", "cargo-test-sbf -p sdk-compressible-test", "cargo-test-sbf -p csdk-anchor-derived-test", "cargo-test-sbf -p csdk-anchor-full-derived-test", "cargo-test-sbf -p sdk-pinocchio-v1-test", "cargo-test-sbf -p sdk-pinocchio-v2-test", "cargo-test-sbf -p pinocchio-nostd-test", "cargo-test-sbf -p single-mint-test", "cargo-test-sbf -p single-pda-test", "cargo-test-sbf -p single-ata-test", "cargo-test-sbf -p single-token-test"]'
           - program: token test
             sub-tests: '["cargo-test-sbf -p sdk-token-test"]'
           - program: sdk-libs

Cargo.toml

@@ -57,6 +57,10 @@ members = [
     "sdk-tests/sdk-light-token-test",
     "sdk-tests/csdk-anchor-full-derived-test",
     "sdk-tests/csdk-anchor-full-derived-test-sdk",
+    "sdk-tests/single-mint-test",
+    "sdk-tests/single-pda-test",
+    "sdk-tests/single-ata-test",
+    "sdk-tests/single-token-test",
     "forester-utils",
     "forester",
     "sparse-merkle-tree",

program-libs/token-interface/tests/token/spl_compat.rs

@@ -1,3 +1,4 @@
+#![cfg(feature = "test-only")]
 //! Tests token solana account - spl token account layout compatibility
 //!
 //! Tests:

program-libs/token-interface/tests/token/zero_copy_new.rs

@@ -1,3 +1,4 @@
+#![cfg(feature = "test-only")]
 //! Contains functional zero copy tests for:
 //! - ZeroCopyNew
 //!

sdk-libs/macros/src/light_pdas/account/decompress_context.rs

@@ -101,6 +101,18 @@ pub fn generate_decompress_context_trait_impl(
         })
         .collect();
 
+    // For mint-only programs (no PDA variants), add an arm for the Empty variant
+    let empty_variant_arm = if pda_ctx_seeds.is_empty() {
+        quote! {
+            // Mint-only programs have an Empty variant that should never be decompressed
+            LightAccountVariant::Empty => {
+                return std::result::Result::Err(solana_program_error::ProgramError::InvalidAccountData);
+            }
+        }
+    } else {
+        quote! {}
+    };
+
     let packed_token_variant_ident = format_ident!("Packed{}", token_variant_ident);
 
     Ok(quote! {
@@ -177,6 +189,7 @@ pub fn generate_decompress_context_trait_impl(
                         LightAccountVariant::CTokenData(_) => {
                             return std::result::Result::Err(light_sdk::error::LightSdkError::UnexpectedUnpackedVariant.into());
                         }
+                        #empty_variant_arm
                     }
                 }
 

sdk-libs/macros/src/light_pdas/account/utils.rs

@@ -104,13 +104,57 @@ pub(crate) fn is_pubkey_type(ty: &Type) -> bool {
     }
 }
 
-/// Generates an empty TokenAccountVariant enum.
+/// Generates placeholder TokenAccountVariant and PackedTokenAccountVariant enums.
 ///
 /// This is used when no token accounts are specified in compressible instructions.
+/// We use a placeholder variant since Rust doesn't support empty enums with #[repr(u8)].
 pub(crate) fn generate_empty_ctoken_enum() -> proc_macro2::TokenStream {
     quote::quote! {
         #[derive(anchor_lang::AnchorSerialize, anchor_lang::AnchorDeserialize, Debug, Clone, Copy)]
         #[repr(u8)]
-        pub enum TokenAccountVariant {}
+        pub enum TokenAccountVariant {
+            /// Placeholder variant for programs without token accounts
+            Empty = 0,
+        }
+
+        #[derive(anchor_lang::AnchorSerialize, anchor_lang::AnchorDeserialize, Debug, Clone, Copy)]
+        #[repr(u8)]
+        pub enum PackedTokenAccountVariant {
+            /// Placeholder variant for programs without token accounts
+            Empty = 0,
+        }
+
+        impl light_token::pack::Pack for TokenAccountVariant {
+            type Packed = PackedTokenAccountVariant;
+            fn pack(&self, _remaining_accounts: &mut light_sdk::instruction::PackedAccounts) -> std::result::Result<Self::Packed, solana_program_error::ProgramError> {
+                Ok(PackedTokenAccountVariant::Empty)
+            }
+        }
+
+        impl light_token::pack::Unpack for PackedTokenAccountVariant {
+            type Unpacked = TokenAccountVariant;
+            fn unpack(&self, _remaining_accounts: &[solana_account_info::AccountInfo]) -> std::result::Result<Self::Unpacked, solana_program_error::ProgramError> {
+                Ok(TokenAccountVariant::Empty)
+            }
+        }
+
+        impl light_sdk::interface::TokenSeedProvider for TokenAccountVariant {
+            fn get_seeds(&self, _program_id: &Pubkey) -> std::result::Result<(Vec<Vec<u8>>, Pubkey), solana_program_error::ProgramError> {
+                Err(solana_program_error::ProgramError::InvalidAccountData)
+            }
+
+            fn get_authority_seeds(&self, _program_id: &Pubkey) -> std::result::Result<(Vec<Vec<u8>>, Pubkey), solana_program_error::ProgramError> {
+                Err(solana_program_error::ProgramError::InvalidAccountData)
+            }
+        }
+
+        impl light_sdk::interface::IntoCTokenVariant<LightAccountVariant, light_token::compat::TokenData> for TokenAccountVariant {
+            fn into_ctoken_variant(self, _token_data: light_token::compat::TokenData) -> LightAccountVariant {
+                // This function should never be called for programs without token accounts.
+                // The Empty variant only exists in mint-only programs (no PDAs).
+                // For programs with PDAs but no tokens, this impl exists only to satisfy trait bounds.
+                unreachable!("into_ctoken_variant called on program without token accounts")
+            }
+        }
     }
 }

sdk-libs/macros/src/light_pdas/program/decompress.rs

@@ -6,7 +6,7 @@
 
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
-use syn::{Ident, Result, Type};
+use syn::{Ident, Result};
 
 use super::{
     expr_traversal::transform_expr_for_ctx_seeds,
@@ -30,8 +30,6 @@ pub(super) struct DecompressBuilder {
     pda_ctx_seeds: Vec<PdaCtxSeedInfo>,
     /// Token variant identifier (e.g., TokenAccountVariant).
     token_variant_ident: Ident,
-    /// Account types that can be decompressed.
-    account_types: Vec<Type>,
     /// PDA seed specifications.
     pda_seeds: Option<Vec<TokenSeedSpec>>,
 }
@@ -42,18 +40,15 @@ impl DecompressBuilder {
     /// # Arguments
     /// * `pda_ctx_seeds` - PDA context seed information for each variant
     /// * `token_variant_ident` - Token variant identifier
-    /// * `account_types` - Account types that can be decompressed
     /// * `pda_seeds` - PDA seed specifications
     pub fn new(
         pda_ctx_seeds: Vec<PdaCtxSeedInfo>,
         token_variant_ident: Ident,
-        account_types: Vec<Type>,
         pda_seeds: Option<Vec<TokenSeedSpec>>,
     ) -> Self {
         Self {
             pda_ctx_seeds,
             token_variant_ident,
-            account_types,
             pda_seeds,
         }
     }
@@ -161,15 +156,34 @@ impl DecompressBuilder {
     }
 
     /// Generate PDA seed provider implementations.
+    /// Returns empty Vec for mint-only or token-only programs that have no PDA seeds.
     pub fn generate_seed_provider_impls(&self) -> Result<Vec<TokenStream>> {
-        let pda_seed_specs = self.pda_seeds.as_ref().ok_or_else(|| {
-            let span_source = self
-                .account_types
-                .first()
-                .map(|t| quote::quote!(#t))
-                .unwrap_or_else(|| quote::quote!(unknown));
-            super::parsing::macro_error!(span_source, "No seed specifications provided")
-        })?;
+        // For mint-only or token-only programs, there are no PDA seeds - return empty Vec
+        let pda_seed_specs = match self.pda_seeds.as_ref() {
+            Some(specs) if !specs.is_empty() => specs,
+            _ => {
+                // Fail fast if pda_ctx_seeds has variants but pda_seeds is missing
+                if !self.pda_ctx_seeds.is_empty() {
+                    let variant_names: Vec<_> = self
+                        .pda_ctx_seeds
+                        .iter()
+                        .map(|v| v.variant_name.to_string())
+                        .collect();
+                    return Err(syn::Error::new(
+                        proc_macro2::Span::call_site(),
+                        format!(
+                            "generate_seed_provider_impls: pda_seeds is None/empty but \
+                             pda_ctx_seeds contains {} variant(s): [{}]. \
+                             Each pda_ctx_seeds variant requires a corresponding PDA seed \
+                             specification in pda_seeds.",
+                            self.pda_ctx_seeds.len(),
+                            variant_names.join(", ")
+                        ),
+                    ));
+                }
+                return Ok(Vec::new());
+            }
+        };
 
         let mut results = Vec::with_capacity(self.pda_ctx_seeds.len());