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 AccessControllerV2NativePackage;
10
11impl AccessControllerV2NativePackage {
12 pub fn definition() -> PackageDefinition {
13 let mut aggregator = TypeAggregator::<ScryptoCustomTypeKind>::new();
14
15 let feature_set = AccessControllerV2FeatureSet::all_features();
16 let state = AccessControllerV2StateSchemaInit::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 functions.insert(
254 ACCESS_CONTROLLER_LOCK_RECOVERY_FEE_IDENT.to_string(),
255 FunctionSchemaInit {
256 receiver: Some(ReceiverInfo::normal_ref_mut()),
257 input: TypeRef::Static(
258 aggregator
259 .add_child_type_and_descendents::<AccessControllerLockRecoveryFeeInput>(),
260 ),
261 output: TypeRef::Static(
262 aggregator
263 .add_child_type_and_descendents::<AccessControllerLockRecoveryFeeOutput>(),
264 ),
265 export: ACCESS_CONTROLLER_LOCK_RECOVERY_FEE_IDENT.to_string(),
266 },
267 );
268 functions.insert(
269 ACCESS_CONTROLLER_WITHDRAW_RECOVERY_FEE_IDENT.to_string(),
270 FunctionSchemaInit {
271 receiver: Some(ReceiverInfo::normal_ref_mut()),
272 input: TypeRef::Static(
273 aggregator
274 .add_child_type_and_descendents::<AccessControllerWithdrawRecoveryFeeInput>(
275 ),
276 ),
277 output: TypeRef::Static(
278 aggregator
279 .add_child_type_and_descendents::<AccessControllerWithdrawRecoveryFeeOutput>(
280 ),
281 ),
282 export: ACCESS_CONTROLLER_WITHDRAW_RECOVERY_FEE_IDENT.to_string(),
283 },
284 );
285 functions.insert(
286 ACCESS_CONTROLLER_CONTRIBUTE_RECOVERY_FEE_IDENT.to_string(),
287 FunctionSchemaInit {
288 receiver: Some(ReceiverInfo::normal_ref_mut()),
289 input: TypeRef::Static(
290 aggregator
291 .add_child_type_and_descendents::<AccessControllerContributeRecoveryFeeInput>(
292 ),
293 ),
294 output: TypeRef::Static(
295 aggregator
296 .add_child_type_and_descendents::<AccessControllerContributeRecoveryFeeOutput>(
297 ),
298 ),
299 export: ACCESS_CONTROLLER_CONTRIBUTE_RECOVERY_FEE_IDENT.to_string(),
300 },
301 );
302
303 let events = event_schema! {
304 aggregator,
305 [
306 InitiateRecoveryEvent,
308 RuleSetUpdateEvent,
309 CancelRecoveryProposalEvent,
310 LockPrimaryRoleEvent,
311 UnlockPrimaryRoleEvent,
312 StopTimedRecoveryEvent,
313 InitiateBadgeWithdrawAttemptEvent,
314 BadgeWithdrawEvent,
315 CancelBadgeWithdrawAttemptEvent,
316 DepositRecoveryXrdEvent,
318 WithdrawRecoveryXrdEvent
319 ]
320 };
321
322 let schema = generate_full_schema(aggregator);
323 let blueprint_definition = BlueprintDefinitionInit {
324 blueprint_type: BlueprintType::default(),
325 is_transient: false,
326 feature_set,
327 dependencies: indexset!(PACKAGE_OF_DIRECT_CALLER_RESOURCE.into(),),
328
329 schema: BlueprintSchemaInit {
330 generics: vec![],
331 schema,
332 state,
333 events,
334 types: BlueprintTypeSchemaInit::default(),
335 functions: BlueprintFunctionsSchemaInit { functions },
336 hooks: BlueprintHooksInit::default(),
337 },
338
339 royalty_config: PackageRoyaltyConfig::default(),
340 auth_config: AuthConfig {
341 function_auth: FunctionAuth::AllowAll,
342 method_auth: MethodAuthTemplate::StaticRoleDefinition(roles_template!(
343 roles {
344 "primary" => updaters: [SELF_ROLE];
345 "recovery" => updaters: [SELF_ROLE];
346 "confirmation" => updaters: [SELF_ROLE];
347 },
348 methods {
349 ACCESS_CONTROLLER_TIMED_CONFIRM_RECOVERY_IDENT => MethodAccessibility::Public;
350
351 ACCESS_CONTROLLER_CREATE_PROOF_IDENT => ["primary"];
352
353 ACCESS_CONTROLLER_INITIATE_RECOVERY_AS_PRIMARY_IDENT => ["primary"];
354 ACCESS_CONTROLLER_CANCEL_PRIMARY_ROLE_RECOVERY_PROPOSAL_IDENT => ["primary"];
355 ACCESS_CONTROLLER_INITIATE_BADGE_WITHDRAW_ATTEMPT_AS_PRIMARY_IDENT => ["primary"];
356 ACCESS_CONTROLLER_CANCEL_PRIMARY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT => ["primary"];
357
358 ACCESS_CONTROLLER_INITIATE_RECOVERY_AS_RECOVERY_IDENT => ["recovery"];
359 ACCESS_CONTROLLER_CANCEL_RECOVERY_ROLE_RECOVERY_PROPOSAL_IDENT => ["recovery"];
360 ACCESS_CONTROLLER_INITIATE_BADGE_WITHDRAW_ATTEMPT_AS_RECOVERY_IDENT => ["recovery"];
361 ACCESS_CONTROLLER_CANCEL_RECOVERY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT => ["recovery"];
362
363 ACCESS_CONTROLLER_LOCK_PRIMARY_ROLE_IDENT => ["recovery"];
364 ACCESS_CONTROLLER_UNLOCK_PRIMARY_ROLE_IDENT => ["recovery"];
365
366 ACCESS_CONTROLLER_QUICK_CONFIRM_PRIMARY_ROLE_RECOVERY_PROPOSAL_IDENT => ["recovery", "confirmation"];
367 ACCESS_CONTROLLER_QUICK_CONFIRM_PRIMARY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT => ["recovery", "confirmation"];
368
369 ACCESS_CONTROLLER_QUICK_CONFIRM_RECOVERY_ROLE_RECOVERY_PROPOSAL_IDENT => ["primary", "confirmation"];
370 ACCESS_CONTROLLER_QUICK_CONFIRM_RECOVERY_ROLE_BADGE_WITHDRAW_ATTEMPT_IDENT => ["primary", "confirmation"];
371
372 ACCESS_CONTROLLER_MINT_RECOVERY_BADGES_IDENT => ["primary", "recovery"];
373
374 ACCESS_CONTROLLER_STOP_TIMED_RECOVERY_IDENT => ["primary", "confirmation", "recovery"];
375
376 ACCESS_CONTROLLER_LOCK_RECOVERY_FEE_IDENT => ["primary", "confirmation", "recovery"];
377 ACCESS_CONTROLLER_WITHDRAW_RECOVERY_FEE_IDENT => ["primary"];
378 ACCESS_CONTROLLER_CONTRIBUTE_RECOVERY_FEE_IDENT => MethodAccessibility::Public;
379 }
380 )),
381 },
382 };
383
384 let blueprints = indexmap!(
385 ACCESS_CONTROLLER_BLUEPRINT.to_string() => blueprint_definition
386 );
387
388 PackageDefinition { blueprints }
389 }
390
391 pub fn invoke_export<Y: SystemApi<RuntimeError>>(
392 export_name: &str,
393 input: &IndexedScryptoValue,
394 api: &mut Y,
395 ) -> Result<IndexedScryptoValue, RuntimeError> {
396 AccessControllerV2Blueprint::invoke_export(export_name, input, api)
397 }
398}