solores 0.7.0

Solana IDL to Rust client / CPI interface generator
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
110
111
112
113
114
115

use std::io::Write;

use serde::Serialize;
use toml::{map::Map, Value};

use crate::{idl_format::IdlFormat, utils::open_file_create_overwrite, Args};

pub const BORSH_CRATE: &str = "borsh";
pub const BYTEMUCK_CRATE: &str = "bytemuck";
pub const SERDE_CRATE: &str = "serde";
pub const SOLANA_PROGRAM_CRATE: &str = "solana-program";
pub const THISERROR_CRATE: &str = "thiserror";
pub const NUM_DERIVE_CRATE: &str = "num-derive";
pub const NUM_TRAITS_CRATE: &str = "num-traits";

pub fn write_cargotoml(args: &Args, idl: &dyn IdlFormat) -> std::io::Result<()> {
    let cargo_toml = CargoToml::from_args_and_idl(args, idl);
    let cargo_toml_str = toml::to_string(&cargo_toml).unwrap();

    let path = args.output_dir.join("Cargo.toml");
    let mut file = open_file_create_overwrite(path)?;
    file.write_all(cargo_toml_str.as_bytes())?;
    file.flush()
}

#[derive(Serialize)]
pub struct CargoToml<'a> {
    pub package: Package<'a>,
    pub dependencies: Map<String, Value>,
}

impl<'a> CargoToml<'a> {
    pub fn from_args_and_idl(args: &'a Args, idl: &'a dyn IdlFormat) -> Self {
        Self {
            package: Package {
                name: &args.output_crate_name,
                version: idl.program_version(),
                edition: "2021",
            },
            dependencies: idl.dependencies(args),
        }
    }
}

#[derive(Serialize)]
pub struct Package<'a> {
    pub name: &'a str,
    pub version: &'a str,
    pub edition: &'a str,
}

/// Contained str value is the version string arg.
/// e.g. "^1.16", "workspace = true"
pub struct DependencyValue<'a>(pub &'a str);

impl From<DependencyValue<'_>> for Map<String, Value> {
    fn from(value: DependencyValue) -> Self {
        match toml::from_str::<Map<_, _>>(value.0) {
            Ok(m) => m, // "workspace = true"
            Err(_) => {
                let mut map = Map::new();
                map.insert("version".into(), value.0.into());
                map
            }
        }
    }
}

impl From<DependencyValue<'_>> for Value {
    fn from(value: DependencyValue) -> Self {
        Value::Table(value.into())
    }
}

pub struct OptionalDependencyValue<T>(pub T);

impl<T: Into<Map<String, Value>>> From<OptionalDependencyValue<T>> for Map<String, Value> {
    fn from(value: OptionalDependencyValue<T>) -> Self {
        let mut map = value.0.into();
        map.insert("optional".into(), true.into());
        map
    }
}

impl<T: Into<Map<String, Value>>> From<OptionalDependencyValue<T>> for Value {
    fn from(value: OptionalDependencyValue<T>) -> Self {
        Value::Table(value.into())
    }
}

/// Contained str value is the version string arg.
/// e.g. "^1.16", "workspace = true"
pub struct FeaturesDependencyValue<T> {
    pub dependency: T,
    pub features: Vec<String>,
}

impl<T: Into<Map<String, Value>>> From<FeaturesDependencyValue<T>> for Map<String, Value> {
    fn from(
        FeaturesDependencyValue {
            dependency,
            features,
        }: FeaturesDependencyValue<T>,
    ) -> Self {
        let mut map = dependency.into();
        map.insert("features".into(), features.into());
        map
    }
}

impl<T: Into<Map<String, Value>>> From<FeaturesDependencyValue<T>> for Value {
    fn from(value: FeaturesDependencyValue<T>) -> Self {
        Value::Table(value.into())
    }
}