Adding ShankAccounts Macro

EXAMPLE_USAGE.md

@@ -0,0 +1,64 @@
+# ShankAccounts with Optional Account Support
+
+This demonstrates the improved ShankAccounts implementation with proper optional account handling.
+
+## Example Program Structure
+
+```rust
+use shank::ShankAccounts;
+
+// Program ID - normally created by declare_id! macro
+pub const ID: [u8; 32] = [1; 32];
+
+#[derive(ShankAccounts)]
+pub struct CreateVaultAccounts<'info> {
+    #[account(mut, signer, desc = "The payer and authority")]
+    pub payer: &'info AccountInfo<'info>,
+
+    #[account(mut, desc = "The vault account to create")]
+    pub vault: &'info AccountInfo<'info>,
+
+    #[account(optional, desc = "Optional new authority")]
+    pub optional_authority: Option<&'info AccountInfo<'info>>,
+
+    #[account(desc = "System program")]
+    pub system_program: &'info AccountInfo<'info>,
+}
+```
+
+## Usage
+
+```rust
+// When optional account is provided:
+let accounts = [payer, vault, authority_account, system_program];
+let ctx = CreateVaultAccounts::context(&accounts);
+assert!(ctx.accounts.optional_authority.is_some());
+
+// When optional account is NOT provided (pass program ID as placeholder):
+let accounts = [payer, vault, program_id_placeholder, system_program];
+let ctx = CreateVaultAccounts::context(&accounts);
+assert!(ctx.accounts.optional_authority.is_none());
+```
+
+## Key Features
+
+1. **Ergonomic API**: No need to pass program ID parameter - uses `crate::ID` automatically
+2. **Type Safety**: Optional accounts use `Option<&AccountInfo>` types
+3. **Runtime Detection**: Checks if `account.key == crate::ID` to determine None/Some
+4. **IDL Generation**: Proper `"isOptional": true` flags in generated IDL
+5. **Remaining Accounts**: Automatically handles extra accounts beyond the struct definition
+
+## IDL Output
+
+```json
+{
+  "accounts": [
+    {"name": "payer", "isMut": true, "isSigner": true, "docs": ["The payer and authority"]},
+    {"name": "vault", "isMut": true, "isSigner": false, "docs": ["The vault account to create"]}, 
+    {"name": "optionalAuthority", "isMut": false, "isSigner": false, "isOptional": true, "docs": ["Optional new authority"]},
+    {"name": "systemProgram", "isMut": false, "isSigner": false, "docs": ["System program"]}
+  ]
+}
+```
+
+This follows Solana's modern optional accounts pattern where missing optional accounts are represented by the program ID.

shank-idl/ACCOUNTS_STRUCT_IDL.md

@@ -0,0 +1,130 @@
+# ShankAccounts IDL Generation
+
+This document explains the current state of IDL generation for the new `ShankAccounts` macro and outlines the expected future improvements.
+
+## Current Behavior
+
+As of the initial implementation, the `ShankAccounts` macro generates placeholder entries in the IDL instead of expanding the individual accounts from the struct. This is due to the TODO item in `shank-idl/src/idl_instruction.rs` at line 58.
+
+### Current IDL Output
+
+When using `#[accounts(StructName)]` with a `ShankAccounts` struct:
+
+```rust
+#[derive(ShankAccounts)]
+pub struct CreateVaultAccounts<'info> {
+    #[account(mut, signer, desc = "The payer and authority")]
+    pub payer: AccountInfo<'info>,
+
+    #[account(mut, desc = "The vault account to create")]
+    pub vault: AccountInfo<'info>,
+
+    #[account(desc = "System program")]
+    pub system_program: AccountInfo<'info>,
+}
+
+#[derive(ShankInstruction)]
+pub enum VaultInstruction {
+    #[accounts(CreateVaultAccounts)]
+    CreateVault { seed: String },
+}
+```
+
+Currently generates:
+
+```json
+{
+  "instructions": [
+    {
+      "name": "CreateVault",
+      "accounts": [
+        {
+          "name": "__accounts_struct_CreateVaultAccounts",
+          "isMut": false,
+          "isSigner": false,
+          "docs": ["Accounts defined by struct: CreateVaultAccounts"]
+        }
+      ]
+    }
+  ]
+}
+```
+
+## Expected Future Behavior
+
+The IDL generation should be enhanced to resolve `AccountsSource::Struct` and expand the individual accounts from the `ShankAccounts` struct.
+
+### Expected IDL Output
+
+The same code should generate:
+
+```json
+{
+  "instructions": [
+    {
+      "name": "CreateVault",
+      "accounts": [
+        {
+          "name": "payer",
+          "isMut": true,
+          "isSigner": true,
+          "docs": ["The payer and authority"]
+        },
+        {
+          "name": "vault",
+          "isMut": true,
+          "isSigner": false,
+          "docs": ["The vault account to create"]
+        },
+        {
+          "name": "system_program",
+          "isMut": false,
+          "isSigner": false,
+          "docs": ["System program"]
+        }
+      ]
+    }
+  ]
+}
+```
+
+## Implementation Requirements
+
+To achieve the expected behavior, the following changes are needed:
+
+1. **Resolve AccountsSource::Struct**: The IDL generation logic in `shank-idl/src/idl_instruction.rs` needs to handle `AccountsSource::Struct` by looking up the referenced struct and extracting its account metadata.
+
+2. **Access ShankAccounts Metadata**: The IDL generator needs to call the `__shank_accounts()` method generated by the `ShankAccounts` macro to get the account metadata.
+
+3. **Convert Account Metadata**: Transform the account metadata from the `ShankAccounts` format into the IDL `InstructionAccount` format.
+
+## Current Test Coverage
+
+The following tests verify the current placeholder behavior:
+
+- `instruction_from_single_file_with_simple_accounts_struct`
+- `instruction_from_single_file_with_accounts_struct`
+- `instruction_from_single_file_with_complex_accounts_struct`
+
+These tests should be updated when the IDL generation is enhanced to match the expected behavior.
+
+## Benefits of Full Implementation
+
+Once fully implemented, the `ShankAccounts` system will provide:
+
+1. **Single Source of Truth**: Account definitions in one place used for both runtime and IDL generation
+2. **Type Safety**: Compile-time verification of account usage
+3. **Anchor-like DX**: Familiar developer experience for Anchor users
+4. **Backward Compatibility**: Existing shank programs continue to work unchanged
+5. **Complete IDL**: Full account information in generated IDLs for tooling consumption
+
+## Macro Integration
+
+The `ShankAccounts` macro generates the `__shank_accounts()` method that returns account metadata in this format:
+
+```rust
+Vec<(u32, &'static str, bool, bool, bool, bool, Option<String>)>
+// (index, name, writable, signer, optional_signer, optional, description)
+```
+
+This metadata should be consumed by the IDL generator to produce the expanded account list.

shank-idl/src/accounts_extraction.rs

@@ -0,0 +1,149 @@
+use anyhow::{format_err, Result};
+use std::collections::HashMap;
+
+use shank_macro_impl::{
+    instruction::InstructionAccount,
+    parsers::get_derive_attr,
+    syn::{ItemStruct, Path, Field, Fields, Type},
+    DERIVE_ACCOUNTS_ATTR,
+};
+
+/// Extract ShankAccounts structs and their metadata
+pub fn extract_shank_accounts_structs<'a>(
+    structs: impl Iterator<Item = &'a ItemStruct>,
+) -> Result<HashMap<String, Vec<InstructionAccount>>> {
+    let mut accounts_map = HashMap::new();
+
+    for struct_item in structs {
+        if let Some(_attr) = get_derive_attr(&struct_item.attrs, DERIVE_ACCOUNTS_ATTR) {
+            let struct_name = struct_item.ident.to_string();
+            let accounts = extract_accounts_from_struct(struct_item)?;
+            accounts_map.insert(struct_name, accounts);
+        }
+    }
+
+    Ok(accounts_map)
+}
+
+/// Extract individual accounts from a ShankAccounts struct by calling its __shank_accounts method
+fn extract_accounts_from_struct(struct_item: &ItemStruct) -> Result<Vec<InstructionAccount>> {
+    // This is where we need to get the account metadata.
+    // The challenge is that at parse time, we can't execute the __shank_accounts() method.
+    // We need to parse the struct fields and their #[account(...)] attributes directly.
+
+    let struct_name = &struct_item.ident;
+
+    // Parse the struct fields and extract account information
+    let mut accounts = Vec::new();
+
+    if let Fields::Named(fields) = &struct_item.fields {
+        for (index, field) in fields.named.iter().enumerate() {
+            let _field_name = field.ident.as_ref()
+                .ok_or_else(|| format_err!("Field without name in struct {}", struct_name))?;
+
+            // Parse the #[account(...)] attributes on this field
+            let account = parse_account_attributes(field, index)?;
+            accounts.push(account);
+        }
+    } else {
+        return Err(format_err!(
+            "ShankAccounts struct {} must have named fields",
+            struct_name
+        ));
+    }
+
+    Ok(accounts)
+}
+
+/// Parse #[account(...)] attributes from a struct field
+fn parse_account_attributes(field: &Field, index: usize) -> Result<InstructionAccount> {
+    let field_name = field.ident.as_ref().unwrap().to_string();
+
+    // Initialize default values
+    let mut writable = false;
+    let mut signer = false;
+    let mut optional = false;
+    let mut optional_signer = false;
+    let mut desc: Option<String> = None;
+
+    // Check if the field type is Option<&AccountInfo> to detect optional typing
+    let has_option_type = if let Type::Path(type_path) = &field.ty {
+        if let Some(segment) = type_path.path.segments.first() {
+            segment.ident == "Option"
+        } else {
+            false
+        }
+    } else {
+        false
+    };
+
+    // Parse #[account(...)] attributes
+    for attr in &field.attrs {
+        if attr.path.is_ident("account") {
+            // Use a simple string-based parsing approach for now
+            // This is a simplified version - in production we'd want more robust parsing
+            let tokens_str = attr.tokens.to_string();
+
+            // Simple parsing of common attributes
+            if tokens_str.contains("mut") || tokens_str.contains("writable") {
+                writable = true;
+            }
+            if tokens_str.contains("signer") {
+                signer = true;
+            }
+            if tokens_str.contains("optional_signer") {
+                optional_signer = true;
+            } else if tokens_str.contains("optional") {
+                optional = true;
+            }
+
+            // Extract description using simple regex-like approach
+            if let Some(desc_start) = tokens_str.find("desc = \"") {
+                let desc_content = &tokens_str[desc_start + 8..];
+                if let Some(desc_end) = desc_content.find('"') {
+                    desc = Some(desc_content[..desc_end].to_string());
+                }
+            }
+        }
+    }
+
+    // Handle interaction between Option<> types and attribute flags:
+    // - If has Option<> type and optional_signer attribute: only set optional_signer = true
+    // - If has Option<> type and optional attribute: set optional = true  
+    // - If has Option<> type but no attribute: default to optional = true
+    if has_option_type && !optional && !optional_signer {
+        // If Option<> type but no explicit optional/optional_signer attribute,
+        // assume it's a regular optional account
+        optional = true;
+    }
+
+    // For optional_signer accounts, ensure the regular optional flag is not set
+    // The IDL should use is_optional_signer=true, is_optional=false for these
+    if optional_signer {
+        optional = false;
+    }
+
+    Ok(InstructionAccount {
+        index: Some(index as u32),
+        ident: field.ident.as_ref().unwrap().clone(),
+        name: field_name,
+        writable,
+        signer,
+        optional_signer,
+        optional,
+        desc,
+    })
+}
+
+/// Resolve accounts for a given struct path
+pub fn resolve_accounts_for_struct_path<'a>(
+    accounts_map: &'a HashMap<String, Vec<InstructionAccount>>,
+    struct_path: &Path,
+) -> Option<&'a Vec<InstructionAccount>> {
+    let struct_name = struct_path
+        .segments
+        .last()
+        .map(|seg| seg.ident.to_string())?;
+
+    accounts_map.get(&struct_name)
+}

shank-idl/src/file.rs

@@ -6,6 +6,7 @@ use std::{
 };
 
 use crate::{
+    accounts_extraction::extract_shank_accounts_structs,
     idl::{Idl, IdlConst, IdlEvent, IdlState},
     idl_error_code::IdlErrorCode,
     idl_instruction::{IdlInstruction, IdlInstructions},
@@ -107,6 +108,9 @@ fn accounts(ctx: &CrateContext) -> Result<Vec<IdlTypeDefinition>> {
 }
 
 fn instructions(ctx: &CrateContext) -> Result<Vec<IdlInstruction>> {
+    // Extract ShankAccounts structs first
+    let shank_accounts = extract_shank_accounts_structs(ctx.structs())?;
+
     let instruction_enums =
         extract_instruction_enums(ctx.enums()).map_err(parse_error_into)?;
 
@@ -116,7 +120,8 @@ fn instructions(ctx: &CrateContext) -> Result<Vec<IdlInstruction>> {
     // TODO(thlorenz): Better way to combine those if we don't do the above.
 
     for ix in instruction_enums {
-        let idl_instructions: IdlInstructions = ix.try_into()?;
+        // Pass the ShankAccounts information to the IDL conversion
+        let idl_instructions: IdlInstructions = IdlInstructions::try_into_with_accounts(ix, &shank_accounts)?;
         for ix in idl_instructions.0 {
             instructions.push(ix);
         }