1mod error;
2
3use serde_json::Value;
4
5use crate::error::Error;
6
7#[cfg(feature = "dashpay")]
8pub use dashpay_contract;
9
10#[cfg(feature = "dpns")]
11pub use dpns_contract;
12
13#[cfg(feature = "feature-flags")]
14pub use feature_flags_contract;
15
16#[cfg(feature = "keyword-search")]
17pub use keyword_search_contract;
18
19#[cfg(feature = "masternode-rewards")]
20pub use masternode_reward_shares_contract;
21
22use platform_value::Identifier;
23use platform_version::version::PlatformVersion;
24
25#[cfg(feature = "token-history")]
26pub use token_history_contract;
27
28#[cfg(feature = "wallet-utils")]
29pub use wallet_utils_contract;
30
31#[cfg(feature = "withdrawals")]
32pub use withdrawals_contract;
33
34#[repr(u8)]
35#[derive(PartialEq, Eq, Clone, Copy, Debug, Ord, PartialOrd, Hash)]
36pub enum SystemDataContract {
37 Withdrawals = 0,
38 MasternodeRewards = 1,
39 FeatureFlags = 2,
40 DPNS = 3,
41 Dashpay = 4,
42 WalletUtils = 5,
43 TokenHistory = 6,
44 KeywordSearch = 7,
45}
46
47pub struct DataContractSource {
48 pub id_bytes: [u8; 32],
49 pub owner_id_bytes: [u8; 32],
50 pub version: u32,
51 pub definitions: Option<Value>,
52 pub document_schemas: Value,
53}
54
55impl SystemDataContract {
56 pub fn id(&self) -> Identifier {
57 let bytes = match self {
58 #[cfg(feature = "withdrawals")]
59 SystemDataContract::Withdrawals => withdrawals_contract::ID_BYTES,
60 #[cfg(not(feature = "withdrawals"))]
61 SystemDataContract::Withdrawals => [
62 54, 98, 187, 97, 225, 127, 174, 62, 162, 148, 207, 96, 49, 151, 251, 10, 171, 109,
63 81, 24, 11, 216, 182, 16, 76, 73, 68, 166, 47, 226, 217, 127,
64 ],
65
66 #[cfg(feature = "masternode-rewards")]
67 SystemDataContract::MasternodeRewards => masternode_reward_shares_contract::ID_BYTES,
68 #[cfg(not(feature = "masternode-rewards"))]
69 SystemDataContract::MasternodeRewards => [
70 12, 172, 226, 5, 36, 102, 147, 167, 200, 21, 101, 35, 98, 13, 170, 147, 125, 47,
71 34, 71, 147, 68, 99, 238, 176, 31, 247, 33, 149, 144, 149, 140,
72 ],
73
74 #[cfg(feature = "feature-flags")]
75 SystemDataContract::FeatureFlags => feature_flags_contract::ID_BYTES,
76 #[cfg(not(feature = "feature-flags"))]
77 SystemDataContract::FeatureFlags => [
78 245, 172, 216, 200, 193, 110, 185, 172, 40, 110, 7, 132, 190, 86, 127, 80, 9, 244,
79 86, 26, 243, 212, 255, 2, 91, 7, 90, 243, 68, 55, 152, 34,
80 ],
81
82 #[cfg(feature = "dpns")]
83 SystemDataContract::DPNS => dpns_contract::ID_BYTES,
84 #[cfg(not(feature = "dpns"))]
85 SystemDataContract::DPNS => [
86 230, 104, 198, 89, 175, 102, 174, 225, 231, 44, 24, 109, 222, 123, 91, 126, 10, 29,
87 113, 42, 9, 196, 13, 87, 33, 246, 34, 191, 83, 197, 49, 85,
88 ],
89
90 #[cfg(feature = "dashpay")]
91 SystemDataContract::Dashpay => dashpay_contract::ID_BYTES,
92 #[cfg(not(feature = "dashpay"))]
93 SystemDataContract::Dashpay => [
94 162, 161, 180, 172, 111, 239, 34, 234, 42, 26, 104, 232, 18, 54, 68, 179, 87, 135,
95 95, 107, 65, 44, 24, 16, 146, 129, 193, 70, 231, 178, 113, 188,
96 ],
97
98 #[cfg(feature = "wallet-utils")]
99 SystemDataContract::WalletUtils => wallet_utils_contract::ID_BYTES,
100 #[cfg(not(feature = "wallet-utils"))]
101 SystemDataContract::WalletUtils => [
102 92, 20, 14, 101, 92, 2, 101, 187, 194, 168, 8, 113, 109, 225, 132, 121, 133, 19,
103 89, 24, 173, 81, 205, 253, 11, 118, 102, 75, 169, 91, 163, 124,
104 ],
105
106 #[cfg(feature = "token-history")]
107 SystemDataContract::TokenHistory => token_history_contract::ID_BYTES,
108 #[cfg(not(feature = "token-history"))]
109 SystemDataContract::TokenHistory => [
110 45, 67, 89, 21, 34, 216, 145, 78, 156, 243, 17, 58, 202, 190, 13, 92, 61, 40, 122,
111 201, 84, 99, 187, 110, 233, 128, 63, 48, 172, 29, 210, 108,
112 ],
113
114 #[cfg(feature = "keyword-search")]
115 SystemDataContract::KeywordSearch => keyword_search_contract::ID_BYTES,
116 #[cfg(not(feature = "keyword-search"))]
117 SystemDataContract::KeywordSearch => [
118 92, 20, 14, 101, 92, 2, 101, 187, 194, 168, 8, 113, 109, 225, 132, 121, 133, 19,
119 89, 24, 173, 81, 205, 253, 11, 118, 102, 75, 169, 91, 163, 124,
120 ],
121 };
122 Identifier::new(bytes)
123 }
124 pub fn source(self, platform_version: &PlatformVersion) -> Result<DataContractSource, Error> {
126 match self {
127 #[cfg(feature = "withdrawals")]
128 SystemDataContract::Withdrawals => Ok(DataContractSource {
129 id_bytes: withdrawals_contract::ID_BYTES,
130 owner_id_bytes: withdrawals_contract::OWNER_ID_BYTES,
131 version: platform_version.system_data_contracts.withdrawals as u32,
132 definitions: withdrawals_contract::load_definitions(platform_version)?,
133 document_schemas: withdrawals_contract::load_documents_schemas(platform_version)?,
134 }),
135 #[cfg(not(feature = "withdrawals"))]
136 SystemDataContract::Withdrawals => Err(Error::ContractNotIncluded("withdrawals")),
137
138 #[cfg(feature = "masternode-rewards")]
139 SystemDataContract::MasternodeRewards => Ok(DataContractSource {
140 id_bytes: masternode_reward_shares_contract::ID_BYTES,
141 owner_id_bytes: masternode_reward_shares_contract::OWNER_ID_BYTES,
142 version: platform_version
143 .system_data_contracts
144 .masternode_reward_shares as u32,
145 definitions: masternode_reward_shares_contract::load_definitions(platform_version)?,
146 document_schemas: masternode_reward_shares_contract::load_documents_schemas(
147 platform_version,
148 )?,
149 }),
150 #[cfg(not(feature = "masternode-rewards"))]
151 SystemDataContract::MasternodeRewards => {
152 Err(Error::ContractNotIncluded("masternode-rewards"))
153 }
154
155 #[cfg(feature = "feature-flags")]
156 SystemDataContract::FeatureFlags => Ok(DataContractSource {
157 id_bytes: feature_flags_contract::ID_BYTES,
158 owner_id_bytes: feature_flags_contract::OWNER_ID_BYTES,
159 version: platform_version.system_data_contracts.feature_flags as u32,
160 definitions: feature_flags_contract::load_definitions(platform_version)?,
161 document_schemas: feature_flags_contract::load_documents_schemas(platform_version)?,
162 }),
163 #[cfg(not(feature = "feature-flags"))]
164 SystemDataContract::FeatureFlags => Err(Error::ContractNotIncluded("feature-flags")),
165
166 #[cfg(feature = "dpns")]
167 SystemDataContract::DPNS => Ok(DataContractSource {
168 id_bytes: dpns_contract::ID_BYTES,
169 owner_id_bytes: dpns_contract::OWNER_ID_BYTES,
170 version: platform_version.system_data_contracts.dpns as u32,
171 definitions: dpns_contract::load_definitions(platform_version)?,
172 document_schemas: dpns_contract::load_documents_schemas(platform_version)?,
173 }),
174 #[cfg(not(feature = "dpns"))]
175 SystemDataContract::DPNS => Err(Error::ContractNotIncluded("dpns")),
176
177 #[cfg(feature = "dashpay")]
178 SystemDataContract::Dashpay => Ok(DataContractSource {
179 id_bytes: dashpay_contract::ID_BYTES,
180 owner_id_bytes: dashpay_contract::OWNER_ID_BYTES,
181 version: platform_version.system_data_contracts.dashpay as u32,
182 definitions: dashpay_contract::load_definitions(platform_version)?,
183 document_schemas: dashpay_contract::load_documents_schemas(platform_version)?,
184 }),
185 #[cfg(not(feature = "dashpay"))]
186 SystemDataContract::Dashpay => Err(Error::ContractNotIncluded("dashpay")),
187
188 #[cfg(feature = "wallet-utils")]
189 SystemDataContract::WalletUtils => Ok(DataContractSource {
190 id_bytes: wallet_utils_contract::ID_BYTES,
191 owner_id_bytes: wallet_utils_contract::OWNER_ID_BYTES,
192 version: platform_version.system_data_contracts.wallet as u32,
193 definitions: wallet_utils_contract::load_definitions(platform_version)?,
194 document_schemas: wallet_utils_contract::load_documents_schemas(platform_version)?,
195 }),
196 #[cfg(not(feature = "wallet-utils"))]
197 SystemDataContract::WalletUtils => Err(Error::ContractNotIncluded("wallet-utils")),
198
199 #[cfg(feature = "token-history")]
200 SystemDataContract::TokenHistory => Ok(DataContractSource {
201 id_bytes: token_history_contract::ID_BYTES,
202 owner_id_bytes: token_history_contract::OWNER_ID_BYTES,
203 version: platform_version.system_data_contracts.token_history as u32,
204 definitions: token_history_contract::load_definitions(platform_version)?,
205 document_schemas: token_history_contract::load_documents_schemas(platform_version)?,
206 }),
207 #[cfg(not(feature = "token-history"))]
208 SystemDataContract::TokenHistory => Err(Error::ContractNotIncluded("token-history")),
209
210 #[cfg(feature = "keyword-search")]
211 SystemDataContract::KeywordSearch => Ok(DataContractSource {
212 id_bytes: keyword_search_contract::ID_BYTES,
213 owner_id_bytes: keyword_search_contract::OWNER_ID_BYTES,
214 version: platform_version.system_data_contracts.keyword_search as u32,
215 definitions: keyword_search_contract::load_definitions(platform_version)?,
216 document_schemas: keyword_search_contract::load_documents_schemas(
217 platform_version,
218 )?,
219 }),
220 #[cfg(not(feature = "keyword-search"))]
221 SystemDataContract::KeywordSearch => Err(Error::ContractNotIncluded("keyword-search")),
222 }
223 }
224}