1use super::internal_prelude::*;
2use crate::errors::*;
3use crate::internal_prelude::*;
4use radix_engine_interface::api::*;
5use radix_engine_interface::blueprints::access_controller::*;
6use radix_engine_interface::blueprints::package::*;
7use sbor::rust::prelude::*;
8
9pub struct AccessControllerV1NativePackage;
10
11impl AccessControllerV1NativePackage {
12 pub fn definition() -> PackageDefinition {
13 let mut aggregator = TypeAggregator::<ScryptoCustomTypeKind>::new();
14
15 let feature_set = AccessControllerFeatureSet::all_features();
16 let state = AccessControllerStateSchemaInit::create_schema_init(&mut aggregator);
17
18 let mut functions = index_map_new();
19 functions.insert(
20 ACCESS_CONTROLLER_CREATE_IDENT.to_string(),
21 FunctionSchemaInit {
22 receiver: None,
23 input: TypeRef::Static(
24 aggregator.add_child_type_and_descendents::<AccessControllerCreateInput>(),
25 ),
26 output: TypeRef::Static(
27 aggregator.add_child_type_and_descendents::<AccessControllerCreateOutput>(),
28 ),
29 export: ACCESS_CONTROLLER_CREATE_IDENT.to_string(),
30 },
31 );
32 functions.insert(
33 ACCESS_CONTROLLER_CREATE_PROOF_IDENT.to_string(),
34 FunctionSchemaInit {
35 receiver: Some(ReceiverInfo::normal_ref_mut()),
36 input: TypeRef::Static(
37 aggregator.add_child_type_and_descendents::<AccessControllerCreateProofInput>(),
38 ),
39 output: TypeRef::Static(
40 aggregator
41 .add_child_type_and_descendents::<AccessControllerCreateProofOutput>(),
42 ),
43 export: ACCESS_CONTROLLER_CREATE_PROOF_IDENT.to_string(),
44 },
45 );
46 functions.insert(
47 ACCESS_CONTROLLER_INITIATE_RECOVERY_AS_PRIMARY_IDENT.to_string(),
48 FunctionSchemaInit {
49 receiver: Some(ReceiverInfo::normal_ref_mut()),
50 input: TypeRef::Static(aggregator
51 .add_child_type_and_descendents::<AccessControllerInitiateRecoveryAsPrimaryInput>()),
52 output: TypeRef::Static(aggregator
53 .add_child_type_and_descendents::<AccessControllerInitiateRecoveryAsPrimaryOutput>()),
54 export: ACCESS_CONTROLLER_INITIATE_RECOVERY_AS_PRIMARY_IDENT.to_string(),
55 },
56 );
57 functions.insert(
58 ACCESS_CONTROLLER_INITIATE_RECOVERY_AS_RECOVERY_IDENT.to_string(),
59 FunctionSchemaInit {
60 receiver: Some(ReceiverInfo::normal_ref_mut()),
61 input: TypeRef::Static(aggregator
62 .add_child_type_and_descendents::<AccessControllerInitiateRecoveryAsRecoveryInput>()),
63 output: TypeRef::Static(aggregator
64 .add_child_type_and_descendents::<AccessControllerInitiateRecoveryAsRecoveryOutput>()),
65 export: ACCESS_CONTROLLER_INITIATE_RECOVERY_AS_RECOVERY_IDENT.to_string(),
66 },
67 );
68 functions.insert(
69 ACCESS_CONTROLLER_QUICK_CONFIRM_PRIMARY_ROLE_RECOVERY_PROPOSAL_IDENT.to_string(),
70 FunctionSchemaInit {
71 receiver: Some(ReceiverInfo::normal_ref_mut()),
72 input: TypeRef::Static(aggregator
73 .add_child_type_and_descendents::<AccessControllerQuickConfirmPrimaryRoleRecoveryProposalInput>()),
74 output: TypeRef::Static(aggregator
75 .add_child_type_and_descendents::<AccessControllerQuickConfirmPrimaryRoleRecoveryProposalOutput>()),
76 export: ACCESS_CONTROLLER_QUICK_CONFIRM_PRIMARY_ROLE_RECOVERY_PROPOSAL_IDENT.to_string(),
77 },
78 );
79 functions.insert(
80 ACCESS_CONTROLLER_QUICK_CONFIRM_RECOVERY_ROLE_RECOVERY_PROPOSAL_IDENT.to_string(),
81 FunctionSchemaInit {
82 receiver: Some(ReceiverInfo::normal_ref_mut()),
83 input: TypeRef::Static(aggregator
84 .add_child_type_and_descendents::<AccessControllerQuickConfirmRecoveryRoleRecoveryProposalInput>()),
85 output: TypeRef::Static(aggregator
86 .add_child_type_and_descendents::<AccessControllerQuickConfirmRecoveryRoleRecoveryProposalOutput>()),
87 export: ACCESS_CONTROLLER_QUICK_CONFIRM_RECOVERY_ROLE_RECOVERY_PROPOSAL_IDENT.to_string(),
88 },
89 );
90 functions.insert(
91 ACCESS_CONTROLLER_TIMED_CONFIRM_RECOVERY_IDENT.to_string(),
92 FunctionSchemaInit {
93 receiver: Some(ReceiverInfo::normal_ref_mut()),
94 input: TypeRef::Static(aggregator
95 .add_child_type_and_descendents::<AccessControllerTimedConfirmRecoveryInput>()),
96 output: TypeRef::Static(aggregator
97 .add_child_type_and_descendents::<AccessControllerTimedConfirmRecoveryOutput>()),
98 export: ACCESS_CONTROLLER_TIMED_CONFIRM_RECOVERY_IDENT.to_string(),
99 },
100 );
101 functions.insert(
102 ACCESS_CONTROLLER_CANCEL_PRIMARY_ROLE_RECOVERY_PROPOSAL_IDENT.to_string(),
103 FunctionSchemaInit {
104 receiver: Some(ReceiverInfo::normal_ref_mut()),
105 input: TypeRef::Static(aggregator
106 .add_child_type_and_descendents::<AccessControllerCancelPrimaryRoleRecoveryProposalInput>()),
107 output: TypeRef::Static(aggregator
108 .add_child_type_and_descendents::<AccessControllerCancelPrimaryRoleRecoveryProposalOutput>()),
109 export: ACCESS_CONTROLLER_CANCEL_PRIMARY_ROLE_RECOVERY_PROPOSAL_IDENT.to_string(),
110 },
111 );
112 functions.insert(
113 ACCESS_CONTROLLER_CANCEL_RECOVERY_ROLE_RECOVERY_PROPOSAL_IDENT.to_string(),
114 FunctionSchemaInit {
115 receiver: Some(ReceiverInfo::normal_ref_mut()),
116 input: TypeRef::Static(aggregator
117 .add_child_type_and_descendents::<AccessControllerCancelRecoveryRoleRecoveryProposalInput>()),
118 output: TypeRef::Static(aggregator
119 .add_child_type_and_descendents::<AccessControllerCancelRecoveryRoleRecoveryProposalOutput>()),
120 export: ACCESS_CONTROLLER_CANCEL_RECOVERY_ROLE_RECOVERY_PROPOSAL_IDENT.to_string(),
121 },
122 );
123 functions.insert(
124 ACCESS_CONTROLLER_LOCK_PRIMARY_ROLE_IDENT.to_string(),
125 FunctionSchemaInit {
126 receiver: Some(ReceiverInfo::normal_ref_mut()),
127 input: TypeRef::Static(
128 aggregator
129 .add_child_type_and_descendents::<AccessControllerLockPrimaryRoleInput>(),
130 ),
131 output: TypeRef::Static(
132 aggregator
133 .add_child_type_and_descendents::<AccessControllerLockPrimaryRoleOutput>(),
134 ),
135 export: ACCESS_CONTROLLER_LOCK_PRIMARY_ROLE_IDENT.to_string(),
136 },
137 );
138 functions.insert(
139 ACCESS_CONTROLLER_UNLOCK_PRIMARY_ROLE_IDENT.to_string(),
140 FunctionSchemaInit {
141 receiver: Some(ReceiverInfo::normal_ref_mut()),
142 input: TypeRef::Static(
143 aggregator
144 .add_child_type_and_descendents::<AccessControllerUnlockPrimaryRoleInput>(),
145 ),
146 output: TypeRef::Static(
147 aggregator
148 .add_child_type_and_descendents::<AccessControllerUnlockPrimaryRoleOutput>(
149 ),
150 ),
151 export: ACCESS_CONTROLLER_UNLOCK_PRIMARY_ROLE_IDENT.to_string(),
152 },
153 );
154 functions.insert(
155 ACCESS_CONTROLLER_STOP_TIMED_RECOVERY_IDENT.to_string(),
156 FunctionSchemaInit {
157 receiver: Some(ReceiverInfo::normal_ref_mut()),
158 input: TypeRef::Static(
159 aggregator
160 .add_child_type_and_descendents::<AccessControllerStopTimedRecoveryInput>(),
161 ),
162 output: TypeRef::Static(
163 aggregator
164 .add_child_type_and_descendents::<AccessControllerStopTimedRecoveryOutput>(
165 ),
166 ),
167 export: ACCESS_CONTROLLER_STOP_TIMED_RECOVERY_IDENT.to_string(),
168 },
169 );
170 functions.insert(
171 ACCESS_CONTROLLER_INITIATE_BADGE_WITHDRAW_ATTEMPT_AS_PRIMARY_IDENT.to_string(),
172 FunctionSchemaInit {
173 receiver: Some(ReceiverInfo::normal_ref_mut()),
174 input: TypeRef::Static(aggregator
175 .add_child_type_and_descendents::<AccessControllerInitiateBadgeWithdrawAttemptAsPrimaryInput>()),
176 output: TypeRef::Static(aggregator
177 .add_child_type_and_descendents::<AccessControllerInitiateBadgeWithdrawAttemptAsPrimaryOutput>()),
178 export: ACCESS_CONTROLLER_INITIATE_BADGE_WITHDRAW_ATTEMPT_AS_PRIMARY_IDENT.to_string(),
179 },
180 );
181 functions.insert(
182 ACCESS_CONTROLLER_INITIATE_BADGE_WITHDRAW_ATTEMPT_AS_RECOVERY_IDENT.to_string(),
183 FunctionSchemaInit {
184 receiver: Some(ReceiverInfo::normal_ref_mut()),
185 input: TypeRef::Static(aggregator
186 .add_child_type_and_descendents::<AccessControllerInitiateBadgeWithdrawAttemptAsRecoveryInput>()),
187 output: TypeRef::Static(aggregator
188 .add_child_type_and_descendents::<AccessControllerInitiateBadgeWithdrawAttemptAsRecoveryOutput>()),
189 export: ACCESS_CONTROLLER_INITIATE_BADGE_WITHDRAW_ATTEMPT_AS_RECOVERY_IDENT.to_string(),
190 },
191 );
192 functions.insert(
193 ACCESS_CONTROLLER_QUICK_CONFIRM_PRIMARY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT.to_string(),
194 FunctionSchemaInit {
195 receiver: Some(ReceiverInfo::normal_ref_mut()),
196 input: TypeRef::Static(aggregator
197 .add_child_type_and_descendents::<AccessControllerQuickConfirmPrimaryRoleBadgeWithdrawAttemptInput>()),
198 output: TypeRef::Static(aggregator
199 .add_child_type_and_descendents::<AccessControllerQuickConfirmPrimaryRoleBadgeWithdrawAttemptOutput>()),
200 export: ACCESS_CONTROLLER_QUICK_CONFIRM_PRIMARY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT.to_string(),
201 },
202 );
203 functions.insert(
204 ACCESS_CONTROLLER_QUICK_CONFIRM_RECOVERY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT.to_string(),
205 FunctionSchemaInit {
206 receiver: Some(ReceiverInfo::normal_ref_mut()),
207 input: TypeRef::Static(aggregator
208 .add_child_type_and_descendents::<AccessControllerQuickConfirmRecoveryRoleBadgeWithdrawAttemptInput>()),
209 output: TypeRef::Static(aggregator
210 .add_child_type_and_descendents::<AccessControllerQuickConfirmRecoveryRoleBadgeWithdrawAttemptOutput>()),
211 export: ACCESS_CONTROLLER_QUICK_CONFIRM_RECOVERY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT.to_string(),
212 },
213 );
214 functions.insert(
215 ACCESS_CONTROLLER_CANCEL_PRIMARY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT.to_string(),
216 FunctionSchemaInit {
217 receiver: Some(ReceiverInfo::normal_ref_mut()),
218 input: TypeRef::Static(aggregator
219 .add_child_type_and_descendents::<AccessControllerCancelPrimaryRoleBadgeWithdrawAttemptInput>()),
220 output: TypeRef::Static(aggregator
221 .add_child_type_and_descendents::<AccessControllerCancelPrimaryRoleBadgeWithdrawAttemptOutput>()),
222 export: ACCESS_CONTROLLER_CANCEL_PRIMARY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT.to_string(),
223 },
224 );
225 functions.insert(
226 ACCESS_CONTROLLER_CANCEL_RECOVERY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT.to_string(),
227 FunctionSchemaInit {
228 receiver: Some(ReceiverInfo::normal_ref_mut()),
229 input: TypeRef::Static(aggregator
230 .add_child_type_and_descendents::<AccessControllerCancelRecoveryRoleBadgeWithdrawAttemptInput>()),
231 output: TypeRef::Static(aggregator
232 .add_child_type_and_descendents::<AccessControllerCancelRecoveryRoleBadgeWithdrawAttemptOutput>()),
233 export: ACCESS_CONTROLLER_CANCEL_RECOVERY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT.to_string(),
234 },
235 );
236 functions.insert(
237 ACCESS_CONTROLLER_MINT_RECOVERY_BADGES_IDENT.to_string(),
238 FunctionSchemaInit {
239 receiver: Some(ReceiverInfo::normal_ref_mut()),
240 input: TypeRef::Static(
241 aggregator
242 .add_child_type_and_descendents::<AccessControllerMintRecoveryBadgesInput>(
243 ),
244 ),
245 output: TypeRef::Static(
246 aggregator
247 .add_child_type_and_descendents::<AccessControllerMintRecoveryBadgesOutput>(
248 ),
249 ),
250 export: ACCESS_CONTROLLER_MINT_RECOVERY_BADGES_IDENT.to_string(),
251 },
252 );
253
254 let events = event_schema! {
255 aggregator,
256 [
257 InitiateRecoveryEvent,
258 RuleSetUpdateEvent,
259 CancelRecoveryProposalEvent,
260 LockPrimaryRoleEvent,
261 UnlockPrimaryRoleEvent,
262 StopTimedRecoveryEvent,
263 InitiateBadgeWithdrawAttemptEvent,
264 BadgeWithdrawEvent,
265 CancelBadgeWithdrawAttemptEvent
266 ]
267 };
268
269 let schema = generate_full_schema(aggregator);
270 let blueprint_definition = BlueprintDefinitionInit {
271 blueprint_type: BlueprintType::default(),
272 is_transient: false,
273 feature_set,
274 dependencies: indexset!(PACKAGE_OF_DIRECT_CALLER_RESOURCE.into(),),
275
276 schema: BlueprintSchemaInit {
277 generics: vec![],
278 schema,
279 state,
280 events,
281 types: BlueprintTypeSchemaInit::default(),
282 functions: BlueprintFunctionsSchemaInit { functions },
283 hooks: BlueprintHooksInit::default(),
284 },
285
286 royalty_config: PackageRoyaltyConfig::default(),
287 auth_config: AuthConfig {
288 function_auth: FunctionAuth::AllowAll,
289 method_auth: MethodAuthTemplate::StaticRoleDefinition(roles_template!(
290 roles {
291 "primary" => updaters: [SELF_ROLE];
292 "recovery" => updaters: [SELF_ROLE];
293 "confirmation" => updaters: [SELF_ROLE];
294 },
295 methods {
296 ACCESS_CONTROLLER_TIMED_CONFIRM_RECOVERY_IDENT => MethodAccessibility::Public;
297
298 ACCESS_CONTROLLER_CREATE_PROOF_IDENT => ["primary"];
299
300 ACCESS_CONTROLLER_INITIATE_RECOVERY_AS_PRIMARY_IDENT => ["primary"];
301 ACCESS_CONTROLLER_CANCEL_PRIMARY_ROLE_RECOVERY_PROPOSAL_IDENT => ["primary"];
302 ACCESS_CONTROLLER_INITIATE_BADGE_WITHDRAW_ATTEMPT_AS_PRIMARY_IDENT => ["primary"];
303 ACCESS_CONTROLLER_CANCEL_PRIMARY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT => ["primary"];
304
305 ACCESS_CONTROLLER_INITIATE_RECOVERY_AS_RECOVERY_IDENT => ["recovery"];
306 ACCESS_CONTROLLER_CANCEL_RECOVERY_ROLE_RECOVERY_PROPOSAL_IDENT => ["recovery"];
307 ACCESS_CONTROLLER_INITIATE_BADGE_WITHDRAW_ATTEMPT_AS_RECOVERY_IDENT => ["recovery"];
308 ACCESS_CONTROLLER_CANCEL_RECOVERY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT => ["recovery"];
309
310 ACCESS_CONTROLLER_LOCK_PRIMARY_ROLE_IDENT => ["recovery"];
311 ACCESS_CONTROLLER_UNLOCK_PRIMARY_ROLE_IDENT => ["recovery"];
312
313 ACCESS_CONTROLLER_QUICK_CONFIRM_PRIMARY_ROLE_RECOVERY_PROPOSAL_IDENT => ["recovery", "confirmation"];
314 ACCESS_CONTROLLER_QUICK_CONFIRM_PRIMARY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT => ["recovery", "confirmation"];
315
316 ACCESS_CONTROLLER_QUICK_CONFIRM_RECOVERY_ROLE_RECOVERY_PROPOSAL_IDENT => ["primary", "confirmation"];
317 ACCESS_CONTROLLER_QUICK_CONFIRM_RECOVERY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT => ["primary", "confirmation"];
318
319 ACCESS_CONTROLLER_MINT_RECOVERY_BADGES_IDENT => ["primary", "recovery"];
320
321 ACCESS_CONTROLLER_STOP_TIMED_RECOVERY_IDENT => ["primary", "confirmation", "recovery"];
322 }
323 )),
324 },
325 };
326
327 let blueprints = indexmap!(
328 ACCESS_CONTROLLER_BLUEPRINT.to_string() => blueprint_definition
329 );
330
331 PackageDefinition { blueprints }
332 }
333
334 pub fn invoke_export<Y: SystemApi<RuntimeError>>(
335 export_name: &str,
336 input: &IndexedScryptoValue,
337 api: &mut Y,
338 ) -> Result<IndexedScryptoValue, RuntimeError> {
339 AccessControllerV1Blueprint::invoke_export(export_name, input, api)
340 }
341}