shank-parse 0.1.1

A proc-macro crate that generates Rust client code from Shank/Anchor IDL JSON files for Solana programs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

# shank-parse

[![Crates.io](https://img.shields.io/crates/v/shank-parse.svg)](https://crates.io/crates/shank-parse)
[![Docs.rs](https://docs.rs/shank-parse/badge.svg)](https://docs.rs/shank-parse)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

A proc-macro crate that generates type-safe Rust client code at compile time from [Shank](https://github.com/metaplex-foundation/shank) / Anchor IDL JSON files for Solana programs.

---

## Features

- **Zero boilerplate** — point the macro at an IDL file and get fully-typed instruction builders, account deserializers, event decoders, and a program-ID constant.
- **Compile-time code generation** — the IDL is read and transformed during `cargo build`; no runtime overhead.
- **Supports Shank & Anchor IDL format** — works with any IDL that follows the common Shank/Anchor JSON schema.
- **Submodule layout** — generated code is organized into `instructions`, `accounts`, `events`, and `types` submodules.

---

## Installation

Add both crates to your `Cargo.toml`:

```toml
[dependencies]
shank-parse = "0.1"
solana-sdk = "3"
```

---

## Usage

Place your IDL JSON file anywhere inside your crate (e.g. `idl/my_program.json`) and invoke the macro once:

```rust
shank_parse::shank_parse!("idl/my_program.json");
```

The path is resolved relative to your crate's root (`CARGO_MANIFEST_DIR`).

### Example — Counter program

Given `idl/counter.json` (a Shank IDL with an `InitCounter` and `IncreaseCounter` instruction):

```rust
shank_parse::shank_parse!("idl/counter.json");

use counter::accounts::Counter;
use counter::instructions::init_counter;
use counter::ID;

fn main() {
    // Program-ID constant derived from metadata.address in the IDL
    println!("Program ID: {}", ID);

    // Build an InitCounter instruction
    let ix = init_counter(
        payer,
        counter_key,
        system_program::ID,
        InitCounterArgs { initial_value: 0 },
    );
}
```

### Generated submodules

| Submodule | Contents |
|---|---|
| `<program>::instructions` | Instruction builder functions and argument structs |
| `<program>::accounts` | Account structs with `from_account_data` deserializers |
| `<program>::events` | Event structs with discriminant-based decoding |
| `<program>::types` | Shared domain enums used across instructions |
| `<program>::ID` | `Pubkey` constant from `metadata.address` in the IDL |

---

## IDL format

The macro expects a JSON file following the Shank/Anchor IDL schema:

```json
{
  "version": "0.1.0",
  "name": "counter",
  "instructions": [...],
  "accounts": [...],
  "types": [...],
  "errors": [...],
  "metadata": { "address": "<base58 program id>" }
}
```

---

## Workspace layout

```
shank-parse/
├── lib/          # shank-parse — the public-facing crate
└── macro/        # shank-parse-macro — the proc-macro implementation
```

---

## License

MIT — see [LICENSE](LICENSE).