neo-types 0.14.0

Neo N3 Core Types for Smart Contract Development
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

// Copyright (c) 2025-2026 R3E Network
// Licensed under the MIT License

use std::string::String;
use std::vec::Vec;

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

#[cfg(feature = "serde")]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct ManifestExtraMetadata {
    #[serde(default)]
    version: String,
    #[serde(default)]
    author: String,
    #[serde(default)]
    email: String,
    #[serde(default)]
    description: String,
}

#[cfg(feature = "serde")]
fn default_version() -> String {
    "1.0.0".to_string()
}

#[cfg(feature = "serde")]
fn default_author() -> String {
    "neo-devpack".to_string()
}

/// Neo N3 Contract Manifest
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize))]
pub struct NeoContractManifest {
    pub name: String,
    #[cfg_attr(feature = "serde", serde(default = "default_version"))]
    pub version: String,
    #[cfg_attr(feature = "serde", serde(default = "default_author"))]
    pub author: String,
    #[cfg_attr(feature = "serde", serde(default))]
    pub email: String,
    #[cfg_attr(feature = "serde", serde(default))]
    pub description: String,
    pub abi: NeoContractABI,
    pub permissions: Vec<NeoContractPermission>,
    pub trusts: Vec<String>,
    #[cfg_attr(feature = "serde", serde(alias = "supportedstandards", default))]
    pub supported_standards: Vec<String>,
}

#[cfg(feature = "serde")]
impl<'de> Deserialize<'de> for NeoContractManifest {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[derive(Deserialize)]
        struct RawManifest {
            name: String,
            #[serde(default = "default_version")]
            version: String,
            #[serde(default = "default_author")]
            author: String,
            #[serde(default)]
            email: String,
            #[serde(default)]
            description: String,
            abi: NeoContractABI,
            permissions: Vec<NeoContractPermission>,
            trusts: Vec<String>,
            #[serde(alias = "supportedstandards", default)]
            supported_standards: Vec<String>,
            #[serde(default)]
            extra: Option<ManifestExtraMetadata>,
        }

        let raw = RawManifest::deserialize(deserializer)?;
        let mut version = raw.version;
        let mut author = raw.author;
        let mut email = raw.email;
        let mut description = raw.description;

        if let Some(extra) = raw.extra {
            if version == default_version() && !extra.version.is_empty() {
                version = extra.version;
            }
            if author == default_author() && !extra.author.is_empty() {
                author = extra.author;
            }
            if email.is_empty() && !extra.email.is_empty() {
                email = extra.email;
            }
            if description.is_empty() && !extra.description.is_empty() {
                description = extra.description;
            }
        }

        Ok(Self {
            name: raw.name,
            version,
            author,
            email,
            description,
            abi: raw.abi,
            permissions: raw.permissions,
            trusts: raw.trusts,
            supported_standards: raw.supported_standards,
        })
    }
}

/// Neo N3 Contract ABI
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct NeoContractABI {
    pub hash: String,
    pub methods: Vec<NeoContractMethod>,
    pub events: Vec<NeoContractEvent>,
}

// NOTE: this SDK-side, (de)serialize-capable ABI type mirrors the compiler's
// serialize-only `ManifestMethod`/`ManifestParameter` in `wasm-neovm`. Both
// model the same Neo N3 ABI spec and must evolve together; a shared `neo-abi`
// crate is the tracked path to unifying them.

/// Neo N3 Contract Method
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct NeoContractMethod {
    pub name: String,
    pub parameters: Vec<NeoContractParameter>,
    #[cfg_attr(feature = "serde", serde(rename = "returntype"))]
    pub return_type: String,
    pub offset: u32,
    pub safe: bool,
}

/// Neo N3 Contract Event
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct NeoContractEvent {
    pub name: String,
    pub parameters: Vec<NeoContractParameter>,
}

/// Neo N3 Contract Parameter
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct NeoContractParameter {
    pub name: String,
    pub r#type: String,
}

/// Neo N3 Contract Permission
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct NeoContractPermission {
    pub contract: String,
    pub methods: Vec<String>,
}