⚡️ Instead of creating our own IDL try to use the anchors

Cargo.toml

@@ -9,6 +9,7 @@ resolver = "1"
 anchor-client = ">=0.29.0"
 anchor-syn = ">=0.29.0"
 anchor-lang = ">=0.29.0"
+anchor-lang-idl-spec = "0.1.0"
 
 
 # SOLANA

crates/cli/src/command.rs

@@ -11,7 +11,7 @@ mod test;
 pub use test::test;
 
 mod init;
-pub use init::{init, SnapshotsType, TestsType};
+pub use init::{init, TestsType};
 
 mod clean;
 pub use clean::clean;

crates/cli/src/command/build.rs

@@ -22,6 +22,6 @@ pub async fn build(root: Option<String>) {
             }
         }
     };
-    let mut generator: TestGenerator = TestGenerator::new_with_root(root, false);
+    let mut generator: TestGenerator = TestGenerator::new_with_root(root);
     generator.build().await?;
 }

crates/cli/src/command/fuzz.rs

@@ -6,8 +6,6 @@ use trident_client::___private::{Commander, TestGenerator};
 
 use crate::_discover;
 
-use super::SnapshotsType;
-
 pub const TRIDENT_TOML: &str = "Trident.toml";
 
 #[derive(Subcommand)]
@@ -29,10 +27,7 @@ pub enum FuzzCommand {
         crash_file_path: String,
     },
     /// Add new fuzz test. Explicit fuzz test name is not yet supported. Implicit name is fuzz_ID, where ID is automatically derived.
-    Add {
-        #[clap(default_value = "file")]
-        snapshots_type: SnapshotsType,
-    },
+    Add,
 }
 
 #[throws]
@@ -69,13 +64,8 @@ pub async fn fuzz(root: Option<String>, subcmd: FuzzCommand) {
             commander.run_fuzzer_debug(target, crash_file_path).await?;
         }
 
-        FuzzCommand::Add { snapshots_type } => {
-            // generate generator with root so that we do not need to again
-            // look for root within the generator
-            let mut generator = match snapshots_type {
-                SnapshotsType::Macro => TestGenerator::new_with_root(root, false),
-                SnapshotsType::File => TestGenerator::new_with_root(root, true),
-            };
+        FuzzCommand::Add => {
+            let mut generator = TestGenerator::new_with_root(root);
             generator.add_fuzz_test().await?;
         }
     };

crates/cli/src/command/init.rs

@@ -13,25 +13,17 @@ pub enum TestsType {
     Fuzz,
     Poc,
 }
-#[derive(ValueEnum, Clone)]
-pub enum SnapshotsType {
-    Macro,
-    File,
-}
 
 #[throws]
-pub async fn init(tests_type: TestsType, snapshots_type: SnapshotsType) {
+pub async fn init(tests_type: TestsType) {
     // look for Anchor.toml
     let root = if let Some(r) = _discover(ANCHOR_TOML)? {
         r
     } else {
         bail!("It does not seem that Anchor is initialized because the Anchor.toml file was not found in any parent directory!");
     };
 
-    let mut generator: TestGenerator = match snapshots_type {
-        SnapshotsType::Macro => TestGenerator::new_with_root(root, false),
-        SnapshotsType::File => TestGenerator::new_with_root(root, true),
-    };
+    let mut generator: TestGenerator = TestGenerator::new_with_root(root);
 
     match tests_type {
         TestsType::Poc => {

crates/cli/src/lib.rs

@@ -1,7 +1,7 @@
 use anyhow::Error;
 use anyhow::{Context, Result};
 use clap::{Parser, Subcommand};
-use command::{SnapshotsType, TestsType};
+use command::TestsType;
 use fehler::throws;
 
 // subcommand functions to call and nested subcommands
@@ -50,9 +50,6 @@ enum Command {
         /// Specifies the types of tests for which the frameworks should be initialized.
         #[clap(default_value = "fuzz")]
         tests_type: TestsType,
-        /// Specifies type of Accounts Snapshots, i.e used derive macro or generated file
-        #[clap(default_value = "file")]
-        snapshots_type: SnapshotsType,
     },
     /// Removes target contents except for KeyPair and removes hfuzz_target folder
     Clean,
@@ -67,10 +64,7 @@ pub async fn start() {
         Command::KeyPair { subcmd } => command::keypair(subcmd)?,
         Command::Test { root } => command::test(root).await?,
         Command::Fuzz { root, subcmd } => command::fuzz(root, subcmd).await?,
-        Command::Init {
-            tests_type,
-            snapshots_type,
-        } => command::init(tests_type, snapshots_type).await?,
+        Command::Init { tests_type } => command::init(tests_type).await?,
         Command::Clean => command::clean().await?,
     }
 }

crates/client/Cargo.toml

@@ -29,6 +29,7 @@ trident-fuzz = { path = "../fuzz", version = "0.1.0" }
 anchor-lang = { workspace = true, features = ["init-if-needed"] }
 anchor-syn = { workspace = true }
 anchor-client = { workspace = true, features = ["async"] }
+anchor-lang-idl-spec = { workspace = true }
 
 # SOLANA
 solana-sdk = { workspace = true }
@@ -71,3 +72,4 @@ quinn-proto = { version = "0.10.6", features = ["arbitrary"] }
 pathdiff = "0.2.1"
 indicatif = "0.17.8"
 regex = "1.10.3"
+convert_case = "0.6.0"

crates/client/src/anchor_idl.rs

@@ -0,0 +1,60 @@
+use anchor_lang_idl_spec::Idl;
+use cargo_metadata::Package;
+use convert_case::{Case, Casing};
+
+use std::error::Error;
+use std::fs::{self, File};
+use std::io::Read;
+use std::path::PathBuf;
+
+pub fn load_idls(
+    dir_path: PathBuf,
+    program_packages: &[Package],
+) -> Result<Vec<Idl>, Box<dyn Error>> {
+    let mut idls = Vec::new();
+
+    let package_names: Vec<String> = program_packages
+        .iter()
+        .map(|package| {
+            let name = &package.name;
+            name.to_case(Case::Snake)
+        })
+        .collect();
+
+    // Read the directory and iterate over each entry
+    for entry in fs::read_dir(dir_path)? {
+        let entry = entry?;
+        let path = entry.path();
+        let idl_name = entry.file_name();
+        let idl_name_str = idl_name.to_str().unwrap();
+
+        // Only process .json files
+        if path.is_file() && path.extension().and_then(|ext| ext.to_str()) == Some("json") {
+            // Remove the .json extension to get the package name
+            let package_name = idl_name_str.trim_end_matches(".json");
+
+            // Check if the package name is in the list of known packages
+            if package_names.iter().any(|name| name == package_name) {
+                // Open the file in read-only mode
+                let mut file = File::open(&path)?;
+
+                // Read the file contents into a string
+                let mut json_content = String::new();
+                file.read_to_string(&mut json_content)?;
+
+                // Parse the string of data into an Idl struct
+                match serde_json::from_str::<Idl>(&json_content) {
+                    Ok(parsed_idl) => {
+                        idls.push(parsed_idl);
+                    }
+                    Err(e) => {
+                        eprintln!("Failed to parse {}: {}", path.display(), e);
+                        // Continue to the next file on failure
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(idls)
+}