pub fn parse_idl<P: AsRef<Path>>(idl_path: P) -> Result<IdlData>Examples found in repository?
examples/parse_idl.rs (line 16)
9fn main() {
10 println!("=== Solify IDL Parser ===\n");
11
12 let idl_path = concat!(env!("CARGO_MANIFEST_DIR"), "/idls/counter_program.json");
13
14 println!(" Reading IDL from: {}", idl_path);
15
16 let idl_data = match parse_idl(idl_path) {
17 Ok(data) => data,
18 Err(e) => {
19 eprintln!("Error parsing IDL: {}", e);
20 return;
21 }
22 };
23
24 println!("Successfully parsed IDL!\n");
25 println!("\n{:#?}\n", idl_data);
26
27 println!("Program: {} (v{})", idl_data.name, idl_data.version);
28 println!("Instructions: {}", idl_data.instructions.len());
29 println!("Accounts: {}", idl_data.accounts.len());
30 println!("Types: {}", idl_data.types.len());
31 println!();
32
33 println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
34 println!("Available Instructions:");
35 println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
36 for (i, instr) in idl_data.instructions.iter().enumerate() {
37 println!(" {}. {}", i + 1, instr.name);
38 }
39 println!();
40
41
42 println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
43 println!("Instruction Details:");
44 println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
45 for (i, instr) in idl_data.instructions.iter().enumerate() {
46 println!(" {}. {}", i+1, instr.name);
47 println!(" Accounts: {}", instr.accounts.len());
48 for account in &instr.accounts {
49 let mut flags = Vec::new();
50 if account.is_mut { flags.push("mut"); }
51 if account.is_signer { flags.push("signer"); }
52 if account.pda.is_some() { flags.push("PDA"); }
53
54 let flags_str = if flags.is_empty() {
55 String::new()
56 } else {
57 format!(" [{}]", flags.join(", "))
58 };
59
60 println!(" • {}{}", account.name, flags_str);
61
62 if let Some(pda) = &account.pda {
63 println!(" PDA Seeds:");
64 for seed in &pda.seeds {
65 match seed.kind.as_str() {
66 "const" => {
67 // Display const seeds with their value
68 if seed.value.starts_with("0x") {
69 println!(" - const: {}", seed.value);
70 } else {
71 println!(" - const: \"{}\"", seed.value);
72 }
73 }
74 "account" => println!(" - account: {}", seed.path),
75 "arg" => println!(" - arg: {}", seed.path),
76 _ => println!(" - {}: {}", seed.kind, seed.path),
77 }
78 }
79 if !pda.program.is_empty() {
80 println!(" Program: {}", pda.program);
81 }
82 }
83 }
84 println!("\n Arguments ({}):", instr.args.len());
85 for arg in &instr.args {
86 println!(" • {}: {}", arg.name, arg.field_type);
87 }
88 let pdas = get_pda_accounts(instr);
89 let signers = get_signer_accounts(instr);
90 let writable = get_writable_accounts(instr);
91
92 println!("\n Analysis:");
93 println!(" PDAs: {} {:?}", pdas.len(), pdas);
94 println!(" Signers: {} {:?}", signers.len(), signers);
95 println!(" Writable: {} {:?}", writable.len(), writable);
96 }
97
98 if !idl_data.types.is_empty() {
99 println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
100 println!(" Type Definitions:");
101 println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
102 for type_def in &idl_data.types {
103 println!(" • {} ({})", type_def.name, type_def.kind);
104 println!(" Fields: {}", type_def.fields.join(", "));
105 }
106 }
107
108 if !idl_data.errors.is_empty() {
109 println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
110 println!(" Error Definitions ({}):", idl_data.errors.len());
111 println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
112 for error in &idl_data.errors {
113 println!(" • {} (code: {})", error.name, error.code);
114 println!(" {}", error.msg);
115 }
116 }
117
118 if !idl_data.constants.is_empty() {
119 println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
120 println!(" Constants ({}):", idl_data.constants.len());
121 println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
122 for constant in &idl_data.constants {
123 println!(" • {}: {} = {}", constant.name, constant.constant_type, constant.value);
124 }
125 }
126
127 if !idl_data.events.is_empty() {
128 println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
129 println!(" Events ({}):", idl_data.events.len());
130 println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
131 for event in &idl_data.events {
132 println!(" • {}", event.name);
133 if !event.fields.is_empty() {
134 println!(" Fields:");
135 for field in &event.fields {
136 println!(" - {}: {}", field.name, field.field_type);
137 }
138 }
139 }
140 }
141
142 // println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━-------------------");
143 // println!("On chain analysis:");
144 // println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━--------------------");
145
146 // let execution_order: [String; 4] = [
147 // String::from("initialize"),
148 // String::from("increment"),
149 // String::from("decrement"),
150 // String::from("set")
151 // ];
152 // let program_id: String = String::from("FBiayQZWoTdQFUvPk1WJZUJqFLh9eLke89xGaFHCpAfN");
153
154 // let analyzer = DependencyAnalyzer::new();
155 // let tests = analyzer.analyze_dependencies(&idl_data, &execution_order, program_id).unwrap();
156 // println!("Test metadata: {:#?}", tests);
157}