1use super::fungible::*;
2use super::non_fungible::*;
3use crate::blueprints::resource::*;
4use crate::errors::ApplicationError;
5use crate::errors::RuntimeError;
6use crate::errors::SystemUpstreamError;
7use crate::internal_prelude::*;
8use crate::kernel::kernel_api::{KernelNodeApi, KernelSubstateApi};
9use crate::system::system_callback::SystemLockData;
10use radix_blueprint_schema_init::*;
11use radix_engine_interface::api::SystemApi;
12use radix_engine_interface::blueprints::hooks::*;
13use radix_engine_interface::blueprints::package::{
14 AuthConfig, BlueprintDefinitionInit, BlueprintType, FunctionAuth, MethodAuthTemplate,
15 PackageDefinition, RoleSpecification, StaticRoleDefinition,
16};
17use radix_engine_interface::blueprints::resource::*;
18
19pub(crate) const FUNGIBLE_RESOURCE_MANAGER_CREATE_EXPORT_NAME: &str =
20 "create_FungibleResourceManager";
21pub(crate) const FUNGIBLE_RESOURCE_MANAGER_CREATE_WITH_INITIAL_SUPPLY_EXPORT_NAME: &str =
22 "create_with_initial_supply_and_address_FungibleResourceManager";
23pub(crate) const FUNGIBLE_RESOURCE_MANAGER_BURN_EXPORT_NAME: &str = "burn_FungibleResourceManager";
24pub(crate) const FUNGIBLE_RESOURCE_MANAGER_PACKAGE_BURN_EXPORT_NAME: &str =
25 "package_burn_FungibleResourceManager";
26pub(crate) const FUNGIBLE_RESOURCE_MANAGER_MINT_EXPORT_NAME: &str = "mint_FungibleResourceManager";
27pub(crate) const FUNGIBLE_RESOURCE_MANAGER_CREATE_EMPTY_VAULT_EXPORT_NAME: &str =
28 "create_empty_vault_FungibleResourceManager";
29pub(crate) const FUNGIBLE_RESOURCE_MANAGER_CREATE_EMPTY_BUCKET_EXPORT_NAME: &str =
30 "create_empty_bucket_FungibleResourceManager";
31pub(crate) const FUNGIBLE_RESOURCE_MANAGER_GET_RESOURCE_TYPE_EXPORT_NAME: &str =
32 "get_resource_type_FungibleResourceManager";
33pub(crate) const FUNGIBLE_RESOURCE_MANAGER_GET_TOTAL_SUPPLY_EXPORT_NAME: &str =
34 "get_total_supply_FungibleResourceManager";
35pub(crate) const FUNGIBLE_RESOURCE_MANAGER_AMOUNT_FOR_WITHDRAWAL_EXPORT_NAME: &str =
36 "amount_for_withdrawal_FungibleResourceManager";
37pub(crate) const FUNGIBLE_RESOURCE_MANAGER_DROP_EMPTY_BUCKET_EXPORT_NAME: &str =
38 "drop_empty_bucket_FungibleResourceManager";
39
40pub(crate) const NON_FUNGIBLE_RESOURCE_MANAGER_CREATE_EXPORT_NAME: &str =
41 "create_NonFungibleResourceManager";
42pub(crate) const NON_FUNGIBLE_RESOURCE_MANAGER_CREATE_WITH_INITIAL_SUPPLY_EXPORT_NAME: &str =
43 "create_with_initial_supply_NonFungibleResourceManager";
44pub(crate) const NON_FUNGIBLE_RESOURCE_MANAGER_BURN_EXPORT_NAME: &str =
45 "burn_NonFungibleResourceManager";
46pub(crate) const NON_FUNGIBLE_RESOURCE_MANAGER_PACKAGE_BURN_EXPORT_NAME: &str =
47 "package_burn_NonFungibleResourceManager";
48pub(crate) const NON_FUNGIBLE_RESOURCE_MANAGER_MINT_EXPORT_NAME: &str =
49 "mint_NonFungibleResourceManager";
50pub(crate) const NON_FUNGIBLE_RESOURCE_MANAGER_MINT_RUID_EXPORT_NAME: &str =
51 "mint_ruid_NonFungibleResourceManager";
52pub(crate) const NON_FUNGIBLE_RESOURCE_MANAGER_CREATE_EMPTY_VAULT_EXPORT_NAME: &str =
53 "create_empty_vault_NonFungibleResourceManager";
54pub(crate) const NON_FUNGIBLE_RESOURCE_MANAGER_CREATE_EMPTY_BUCKET_EXPORT_NAME: &str =
55 "create_empty_bucket_NonFungibleResourceManager";
56pub(crate) const NON_FUNGIBLE_RESOURCE_MANAGER_GET_RESOURCE_TYPE_EXPORT_NAME: &str =
57 "get_resource_type_NonFungibleResourceManager";
58pub(crate) const NON_FUNGIBLE_RESOURCE_MANAGER_GET_TOTAL_SUPPLY_EXPORT_NAME: &str =
59 "get_total_supply_NonFungibleResourceManager";
60pub(crate) const NON_FUNGIBLE_RESOURCE_MANAGER_AMOUNT_FOR_WITHDRAWAL_EXPORT_NAME: &str =
61 "amount_for_withdrawal_NonFungibleResourceManager";
62pub(crate) const NON_FUNGIBLE_RESOURCE_MANAGER_DROP_EMPTY_BUCKET_EXPORT_NAME: &str =
63 "drop_empty_bucket_NonFungibleResourceManager";
64
65pub(crate) const FUNGIBLE_VAULT_TAKE_EXPORT_NAME: &str = "take_FungibleVault";
66pub(crate) const FUNGIBLE_VAULT_TAKE_ADVANCED_EXPORT_NAME: &str = "take_advanced_FungibleVault";
67pub(crate) const FUNGIBLE_VAULT_PUT_EXPORT_NAME: &str = "put_FungibleVault";
68pub(crate) const FUNGIBLE_VAULT_GET_AMOUNT_EXPORT_NAME: &str = "get_amount_FungibleVault";
69pub(crate) const FUNGIBLE_VAULT_RECALL_EXPORT_NAME: &str = "recall_FungibleVault";
70pub(crate) const FUNGIBLE_VAULT_FREEZE_EXPORT_NAME: &str = "freeze_FungibleVault";
71pub(crate) const FUNGIBLE_VAULT_UNFREEZE_EXPORT_NAME: &str = "unfreeze_FungibleVault";
72pub(crate) const FUNGIBLE_VAULT_CREATE_PROOF_OF_AMOUNT_EXPORT_NAME: &str =
73 "create_proof_of_amount_FungibleVault";
74pub(crate) const FUNGIBLE_VAULT_LOCK_AMOUNT_EXPORT_NAME: &str = "lock_amount_FungibleVault";
75pub(crate) const FUNGIBLE_VAULT_UNLOCK_AMOUNT_EXPORT_NAME: &str = "unlock_amount_FungibleVault";
76pub(crate) const FUNGIBLE_VAULT_BURN_EXPORT_NAME: &str = "burn_FungibleVault";
77
78pub(crate) const NON_FUNGIBLE_VAULT_TAKE_EXPORT_NAME: &str = "take_NonFungibleVault";
79pub(crate) const NON_FUNGIBLE_VAULT_TAKE_ADVANCED_EXPORT_NAME: &str =
80 "take_advanced_NonFungibleVault";
81pub(crate) const NON_FUNGIBLE_VAULT_PUT_EXPORT_NAME: &str = "put_NonFungibleVault";
82pub(crate) const NON_FUNGIBLE_VAULT_GET_AMOUNT_EXPORT_NAME: &str = "get_amount_NonFungibleVault";
83pub(crate) const NON_FUNGIBLE_VAULT_RECALL_EXPORT_NAME: &str = "recall_NonFungibleVault";
84pub(crate) const NON_FUNGIBLE_VAULT_FREEZE_EXPORT_NAME: &str = "freeze_NonFungibleVault";
85pub(crate) const NON_FUNGIBLE_VAULT_UNFREEZE_EXPORT_NAME: &str = "unfreeze_NonFungibleVault";
86pub(crate) const NON_FUNGIBLE_VAULT_LOCK_NON_FUNGIBLES_EXPORT_NAME: &str =
87 "unlock_fungibles_NonFungibleVault";
88pub(crate) const NON_FUNGIBLE_VAULT_UNLOCK_NON_FUNGIBLES_EXPORT_NAME: &str =
89 "unlock_non_fungibles_NonFungibleVault";
90pub(crate) const NON_FUNGIBLE_VAULT_BURN_EXPORT_NAME: &str = "burn_NonFungibleVault";
91
92pub(crate) const FUNGIBLE_BUCKET_TAKE_EXPORT_NAME: &str = "take_FungibleBucket";
93pub(crate) const FUNGIBLE_BUCKET_TAKE_ADVANCED_EXPORT_NAME: &str = "take_advanced_FungibleBucket";
94pub(crate) const FUNGIBLE_BUCKET_PUT_EXPORT_NAME: &str = "put_FungibleBucket";
95pub(crate) const FUNGIBLE_BUCKET_GET_AMOUNT_EXPORT_NAME: &str = "get_amount_FungibleBucket";
96pub(crate) const FUNGIBLE_BUCKET_GET_RESOURCE_ADDRESS_EXPORT_NAME: &str =
97 "get_resource_address_FungibleBucket";
98pub(crate) const FUNGIBLE_BUCKET_CREATE_PROOF_OF_AMOUNT_EXPORT_NAME: &str =
99 "create_proof_of_amount_FungibleBucket";
100pub(crate) const FUNGIBLE_BUCKET_CREATE_PROOF_OF_ALL_EXPORT_NAME: &str =
101 "create_proof_of_all_FungibleBucket";
102pub(crate) const FUNGIBLE_BUCKET_LOCK_AMOUNT_EXPORT_NAME: &str = "lock_amount_FungibleBucket";
103pub(crate) const FUNGIBLE_BUCKET_UNLOCK_AMOUNT_EXPORT_NAME: &str = "unlock_amount_FungibleBucket";
104
105pub(crate) const NON_FUNGIBLE_BUCKET_TAKE_EXPORT_NAME: &str = "take_NonFungibleBucket";
106pub(crate) const NON_FUNGIBLE_BUCKET_TAKE_ADVANCED_EXPORT_NAME: &str =
107 "take_advanced_NonFungibleBucket";
108pub(crate) const NON_FUNGIBLE_BUCKET_TAKE_NON_FUNGIBLES_EXPORT_NAME: &str =
109 "take_non_fungibles_NonFungibleBucket";
110pub(crate) const NON_FUNGIBLE_BUCKET_PUT_EXPORT_NAME: &str = "put_NonFungibleBucket";
111pub(crate) const NON_FUNGIBLE_BUCKET_GET_AMOUNT_EXPORT_NAME: &str = "get_amount_NonFungibleBucket";
112pub(crate) const NON_FUNGIBLE_BUCKET_GET_RESOURCE_ADDRESS_EXPORT_NAME: &str =
113 "get_resource_address_NonFungibleBucket";
114pub(crate) const NON_FUNGIBLE_BUCKET_CREATE_PROOF_OF_NON_FUNGIBLES_EXPORT_NAME: &str =
115 "create_proof_of_non_fungibles_NonFungibleBucket";
116pub(crate) const NON_FUNGIBLE_BUCKET_CREATE_PROOF_OF_ALL_EXPORT_NAME: &str =
117 "create_proof_of_all_NonFungibleBucket";
118pub(crate) const NON_FUNGIBLE_BUCKET_LOCK_NON_FUNGIBLES_EXPORT_NAME: &str =
119 "unlock_fungibles_NonFungibleBucket";
120pub(crate) const NON_FUNGIBLE_BUCKET_UNLOCK_NON_FUNGIBLES_EXPORT_NAME: &str =
121 "unlock_non_fungibles_NonFungibleBucket";
122pub(crate) const NON_FUNGIBLE_BUCKET_GET_NON_FUNGIBLE_LOCAL_IDS_EXPORT_NAME: &str =
123 "get_non_fungible_local_ids_NonFungibleBucket";
124pub(crate) const NON_FUNGIBLE_BUCKET_CONTAINS_NON_FUNGIBLE_EXPORT_NAME: &str =
125 "contains_non_fungible_NonFungibleBucket";
126
127pub(crate) const FUNGIBLE_PROOF_CLONE_EXPORT_NAME: &str = "clone_FungibleProof";
128pub(crate) const FUNGIBLE_PROOF_GET_AMOUNT_EXPORT_NAME: &str = "get_amount_FungibleProof";
129pub(crate) const FUNGIBLE_PROOF_GET_RESOURCE_ADDRESS_EXPORT_NAME: &str =
130 "get_resource_address_FungibleProof";
131pub(crate) const FUNGIBLE_PROOF_DROP_EXPORT_NAME: &str = "drop_FungibleProof";
132pub(crate) const FUNGIBLE_PROOF_ON_DROP_EXPORT_NAME: &str = "on_drop_FungibleProof";
133pub(crate) const FUNGIBLE_PROOF_ON_MOVE_EXPORT_NAME: &str = "on_move_FungibleProof";
134
135pub(crate) const NON_FUNGIBLE_PROOF_CLONE_EXPORT_NAME: &str = "clone_NonFungibleProof";
136pub(crate) const NON_FUNGIBLE_PROOF_GET_AMOUNT_EXPORT_NAME: &str = "get_amount_NonFungibleProof";
137pub(crate) const NON_FUNGIBLE_PROOF_GET_RESOURCE_ADDRESS_EXPORT_NAME: &str =
138 "get_resource_address_NonFungibleProof";
139pub(crate) const NON_FUNGIBLE_PROOF_DROP_EXPORT_NAME: &str = "drop_NonFungibleProof";
140pub(crate) const NON_FUNGIBLE_PROOF_ON_DROP_EXPORT_NAME: &str = "on_drop_NonFungibleProof";
141pub(crate) const NON_FUNGIBLE_PROOF_ON_MOVE_EXPORT_NAME: &str = "on_move_NonFungibleProof";
142
143pub(crate) const AUTH_ZONE_POP_EXPORT_NAME: &str = "AuthZone_pop";
144pub(crate) const AUTH_ZONE_PUSH_EXPORT_NAME: &str = "AuthZone_push";
145pub(crate) const AUTH_ZONE_CREATE_PROOF_OF_AMOUNT_EXPORT_NAME: &str =
146 "AuthZone_create_proof_of_amount";
147pub(crate) const AUTH_ZONE_CREATE_PROOF_OF_NON_FUNGIBLES_EXPORT_NAME: &str =
148 "AuthZone_create_proof_of_non_fungibles";
149pub(crate) const AUTH_ZONE_CREATE_PROOF_OF_ALL_EXPORT_NAME: &str = "AuthZone_create_proof_of_all";
150pub(crate) const AUTH_ZONE_DROP_SIGNATURE_PROOFS_EXPORT_NAME: &str =
151 "AuthZone_drop_signature_proofs";
152pub(crate) const AUTH_ZONE_DROP_REGULAR_PROOFS_EXPORT_NAME: &str = "AuthZone_drop_regular_proofs";
153pub(crate) const AUTH_ZONE_DROP_PROOFS_EXPORT_NAME: &str = "AuthZone_drop_proofs";
154pub(crate) const AUTH_ZONE_DRAIN_EXPORT_NAME: &str = "AuthZone_drain";
155pub(crate) const AUTH_ZONE_ASSERT_ACCESS_RULE_EXPORT_NAME: &str = "AuthZone_assert_access_rule";
156
157pub struct ResourceNativePackage;
158
159impl ResourceNativePackage {
160 pub fn definition() -> PackageDefinition {
161 let fungible_resource_manager_blueprint =
162 FungibleResourceManagerBlueprint::get_definition();
163
164 let non_fungible_resource_manager_blueprint =
165 NonFungibleResourceManagerBlueprint::get_definition();
166
167 let fungible_vault_blueprint = FungibleVaultBlueprint::get_definition();
168
169 let non_fungible_vault_blueprint = NonFungibleVaultBlueprint::get_definition();
170
171 let fungible_bucket_blueprint = {
174 let mut aggregator = TypeAggregator::<ScryptoCustomTypeKind>::new();
175
176 let mut fields = Vec::new();
177 fields.push(FieldSchema::static_field(
178 aggregator.add_child_type_and_descendents::<LiquidFungibleResource>(),
179 ));
180 fields.push(FieldSchema::static_field(
181 aggregator.add_child_type_and_descendents::<LockedFungibleResource>(),
182 ));
183
184 let mut functions = index_map_new();
185 functions.insert(
186 BUCKET_PUT_IDENT.to_string(),
187 FunctionSchemaInit {
188 receiver: Some(ReceiverInfo::normal_ref_mut()),
189 input: TypeRef::Static(
190 aggregator.add_child_type_and_descendents::<BucketPutInput>(),
191 ),
192 output: TypeRef::Static(
193 aggregator.add_child_type_and_descendents::<BucketPutOutput>(),
194 ),
195 export: FUNGIBLE_BUCKET_PUT_EXPORT_NAME.to_string(),
196 },
197 );
198 functions.insert(
199 BUCKET_TAKE_IDENT.to_string(),
200 FunctionSchemaInit {
201 receiver: Some(ReceiverInfo::normal_ref_mut()),
202 input: TypeRef::Static(
203 aggregator.add_child_type_and_descendents::<BucketTakeInput>(),
204 ),
205 output: TypeRef::Static(
206 aggregator.add_child_type_and_descendents::<BucketTakeOutput>(),
207 ),
208 export: FUNGIBLE_BUCKET_TAKE_EXPORT_NAME.to_string(),
209 },
210 );
211 functions.insert(
212 BUCKET_TAKE_ADVANCED_IDENT.to_string(),
213 FunctionSchemaInit {
214 receiver: Some(ReceiverInfo::normal_ref_mut()),
215 input: TypeRef::Static(
216 aggregator.add_child_type_and_descendents::<BucketTakeAdvancedInput>(),
217 ),
218 output: TypeRef::Static(
219 aggregator.add_child_type_and_descendents::<BucketTakeAdvancedOutput>(),
220 ),
221 export: FUNGIBLE_BUCKET_TAKE_ADVANCED_EXPORT_NAME.to_string(),
222 },
223 );
224 functions.insert(
225 BUCKET_GET_AMOUNT_IDENT.to_string(),
226 FunctionSchemaInit {
227 receiver: Some(ReceiverInfo::normal_ref()),
228 input: TypeRef::Static(
229 aggregator.add_child_type_and_descendents::<BucketGetAmountInput>(),
230 ),
231 output: TypeRef::Static(
232 aggregator.add_child_type_and_descendents::<BucketGetAmountOutput>(),
233 ),
234 export: FUNGIBLE_BUCKET_GET_AMOUNT_EXPORT_NAME.to_string(),
235 },
236 );
237 functions.insert(
238 BUCKET_GET_RESOURCE_ADDRESS_IDENT.to_string(),
239 FunctionSchemaInit {
240 receiver: Some(ReceiverInfo::normal_ref()),
241 input: TypeRef::Static(
242 aggregator
243 .add_child_type_and_descendents::<BucketGetResourceAddressInput>(),
244 ),
245 output: TypeRef::Static(
246 aggregator
247 .add_child_type_and_descendents::<BucketGetResourceAddressOutput>(),
248 ),
249 export: FUNGIBLE_BUCKET_GET_RESOURCE_ADDRESS_EXPORT_NAME.to_string(),
250 },
251 );
252 functions.insert(
253 FUNGIBLE_BUCKET_CREATE_PROOF_OF_AMOUNT_IDENT.to_string(),
254 FunctionSchemaInit {
255 receiver: Some(ReceiverInfo::normal_ref_mut()),
256 input: TypeRef::Static(
257 aggregator
258 .add_child_type_and_descendents::<FungibleBucketCreateProofOfAmountInput>(),
259 ),
260 output: TypeRef::Static(
261 aggregator
262 .add_child_type_and_descendents::<FungibleBucketCreateProofOfAmountOutput>(),
263 ),
264 export: FUNGIBLE_BUCKET_CREATE_PROOF_OF_AMOUNT_EXPORT_NAME.to_string(),
265 },
266 );
267 functions.insert(
268 BUCKET_CREATE_PROOF_OF_ALL_IDENT.to_string(),
269 FunctionSchemaInit {
270 receiver: Some(ReceiverInfo::normal_ref_mut()),
271 input: TypeRef::Static(
272 aggregator.add_child_type_and_descendents::<BucketCreateProofOfAllInput>(),
273 ),
274 output: TypeRef::Static(
275 aggregator.add_child_type_and_descendents::<BucketCreateProofOfAllOutput>(),
276 ),
277 export: FUNGIBLE_BUCKET_CREATE_PROOF_OF_ALL_EXPORT_NAME.to_string(),
278 },
279 );
280 functions.insert(
281 FUNGIBLE_BUCKET_LOCK_AMOUNT_IDENT.to_string(),
282 FunctionSchemaInit {
283 receiver: Some(ReceiverInfo::normal_ref_mut()),
284 input: TypeRef::Static(
285 aggregator
286 .add_child_type_and_descendents::<FungibleBucketLockAmountInput>(),
287 ),
288 output: TypeRef::Static(
289 aggregator
290 .add_child_type_and_descendents::<FungibleBucketLockAmountOutput>(),
291 ),
292 export: FUNGIBLE_BUCKET_LOCK_AMOUNT_EXPORT_NAME.to_string(),
293 },
294 );
295 functions.insert(
296 FUNGIBLE_BUCKET_UNLOCK_AMOUNT_IDENT.to_string(),
297 FunctionSchemaInit {
298 receiver: Some(ReceiverInfo::normal_ref_mut()),
299 input: TypeRef::Static(
300 aggregator
301 .add_child_type_and_descendents::<FungibleBucketUnlockAmountInput>(),
302 ),
303 output: TypeRef::Static(
304 aggregator
305 .add_child_type_and_descendents::<FungibleBucketUnlockAmountOutput>(),
306 ),
307 export: FUNGIBLE_BUCKET_UNLOCK_AMOUNT_EXPORT_NAME.to_string(),
308 },
309 );
310
311 let schema = generate_full_schema(aggregator);
312
313 BlueprintDefinitionInit {
314 blueprint_type: BlueprintType::Inner {
315 outer_blueprint: FUNGIBLE_RESOURCE_MANAGER_BLUEPRINT.to_string(),
316 },
317 is_transient: true,
318 dependencies: indexset!(),
319 feature_set: indexset!(),
320
321 schema: BlueprintSchemaInit {
322 generics: vec![],
323 schema,
324 state: BlueprintStateSchemaInit {
325 fields,
326 collections: vec![],
327 },
328 events: BlueprintEventSchemaInit::default(),
329 types: BlueprintTypeSchemaInit::default(),
330 functions: BlueprintFunctionsSchemaInit { functions },
331 hooks: BlueprintHooksInit::default(),
332 },
333
334 royalty_config: PackageRoyaltyConfig::default(),
335 auth_config: AuthConfig {
336 function_auth: FunctionAuth::AllowAll,
337 method_auth: MethodAuthTemplate::StaticRoleDefinition(StaticRoleDefinition {
338 methods: method_auth_template! {
339 BUCKET_GET_AMOUNT_IDENT => MethodAccessibility::Public;
340 BUCKET_GET_RESOURCE_ADDRESS_IDENT => MethodAccessibility::Public;
341 BUCKET_CREATE_PROOF_OF_ALL_IDENT => MethodAccessibility::Public;
342 FUNGIBLE_BUCKET_CREATE_PROOF_OF_AMOUNT_IDENT => MethodAccessibility::Public;
343 BUCKET_PUT_IDENT => MethodAccessibility::Public;
344 BUCKET_TAKE_IDENT => MethodAccessibility::Public;
345 BUCKET_TAKE_ADVANCED_IDENT => MethodAccessibility::Public;
346
347 FUNGIBLE_BUCKET_LOCK_AMOUNT_IDENT => MethodAccessibility::OwnPackageOnly;
348 FUNGIBLE_BUCKET_UNLOCK_AMOUNT_IDENT => MethodAccessibility::OwnPackageOnly;
349 },
350 roles: RoleSpecification::UseOuter,
351 }),
352 },
353 }
354 };
355
356 let non_fungible_bucket_blueprint = {
359 let mut aggregator = TypeAggregator::<ScryptoCustomTypeKind>::new();
360
361 let mut fields = Vec::new();
362 fields.push(FieldSchema::static_field(
363 aggregator.add_child_type_and_descendents::<LiquidNonFungibleResource>(),
364 ));
365 fields.push(FieldSchema::static_field(
366 aggregator.add_child_type_and_descendents::<LockedNonFungibleResource>(),
367 ));
368
369 let mut functions = index_map_new();
370 functions.insert(
371 BUCKET_PUT_IDENT.to_string(),
372 FunctionSchemaInit {
373 receiver: Some(ReceiverInfo::normal_ref_mut()),
374 input: TypeRef::Static(
375 aggregator.add_child_type_and_descendents::<BucketPutInput>(),
376 ),
377 output: TypeRef::Static(
378 aggregator.add_child_type_and_descendents::<BucketPutOutput>(),
379 ),
380 export: NON_FUNGIBLE_BUCKET_PUT_EXPORT_NAME.to_string(),
381 },
382 );
383 functions.insert(
384 BUCKET_TAKE_IDENT.to_string(),
385 FunctionSchemaInit {
386 receiver: Some(ReceiverInfo::normal_ref_mut()),
387 input: TypeRef::Static(
388 aggregator.add_child_type_and_descendents::<BucketTakeInput>(),
389 ),
390 output: TypeRef::Static(
391 aggregator.add_child_type_and_descendents::<BucketTakeOutput>(),
392 ),
393 export: NON_FUNGIBLE_BUCKET_TAKE_EXPORT_NAME.to_string(),
394 },
395 );
396 functions.insert(
397 BUCKET_TAKE_ADVANCED_IDENT.to_string(),
398 FunctionSchemaInit {
399 receiver: Some(ReceiverInfo::normal_ref_mut()),
400 input: TypeRef::Static(
401 aggregator.add_child_type_and_descendents::<BucketTakeAdvancedInput>(),
402 ),
403 output: TypeRef::Static(
404 aggregator.add_child_type_and_descendents::<BucketTakeAdvancedOutput>(),
405 ),
406 export: NON_FUNGIBLE_BUCKET_TAKE_ADVANCED_EXPORT_NAME.to_string(),
407 },
408 );
409 functions.insert(
410 NON_FUNGIBLE_BUCKET_TAKE_NON_FUNGIBLES_IDENT.to_string(),
411 FunctionSchemaInit {
412 receiver: Some(ReceiverInfo::normal_ref_mut()),
413 input: TypeRef::Static(
414 aggregator.add_child_type_and_descendents::<BucketTakeNonFungiblesInput>(),
415 ),
416 output: TypeRef::Static(
417 aggregator.add_child_type_and_descendents::<BucketTakeNonFungiblesOutput>(),
418 ),
419 export: NON_FUNGIBLE_BUCKET_TAKE_NON_FUNGIBLES_EXPORT_NAME.to_string(),
420 },
421 );
422 functions.insert(
423 BUCKET_GET_AMOUNT_IDENT.to_string(),
424 FunctionSchemaInit {
425 receiver: Some(ReceiverInfo::normal_ref()),
426 input: TypeRef::Static(
427 aggregator.add_child_type_and_descendents::<BucketGetAmountInput>(),
428 ),
429 output: TypeRef::Static(
430 aggregator.add_child_type_and_descendents::<BucketGetAmountOutput>(),
431 ),
432 export: NON_FUNGIBLE_BUCKET_GET_AMOUNT_EXPORT_NAME.to_string(),
433 },
434 );
435 functions.insert(
436 BUCKET_GET_RESOURCE_ADDRESS_IDENT.to_string(),
437 FunctionSchemaInit {
438 receiver: Some(ReceiverInfo::normal_ref()),
439 input: TypeRef::Static(
440 aggregator
441 .add_child_type_and_descendents::<BucketGetResourceAddressInput>(),
442 ),
443 output: TypeRef::Static(
444 aggregator
445 .add_child_type_and_descendents::<BucketGetResourceAddressOutput>(),
446 ),
447 export: NON_FUNGIBLE_BUCKET_GET_RESOURCE_ADDRESS_EXPORT_NAME.to_string(),
448 },
449 );
450 functions.insert(
451 NON_FUNGIBLE_BUCKET_CREATE_PROOF_OF_NON_FUNGIBLES_IDENT.to_string(),
452 FunctionSchemaInit {
453 receiver: Some(ReceiverInfo::normal_ref_mut()),
454 input: TypeRef::Static(aggregator.add_child_type_and_descendents::<NonFungibleBucketCreateProofOfNonFungiblesInput>()),
455 output: TypeRef::Static(aggregator.add_child_type_and_descendents::<NonFungibleBucketCreateProofOfNonFungiblesOutput>()),
456 export: NON_FUNGIBLE_BUCKET_CREATE_PROOF_OF_NON_FUNGIBLES_EXPORT_NAME.to_string(),
457 },
458 );
459 functions.insert(
460 BUCKET_CREATE_PROOF_OF_ALL_IDENT.to_string(),
461 FunctionSchemaInit {
462 receiver: Some(ReceiverInfo::normal_ref_mut()),
463 input: TypeRef::Static(
464 aggregator.add_child_type_and_descendents::<BucketCreateProofOfAllInput>(),
465 ),
466 output: TypeRef::Static(
467 aggregator.add_child_type_and_descendents::<BucketCreateProofOfAllOutput>(),
468 ),
469 export: NON_FUNGIBLE_BUCKET_CREATE_PROOF_OF_ALL_EXPORT_NAME.to_string(),
470 },
471 );
472 functions.insert(
473 NON_FUNGIBLE_BUCKET_GET_NON_FUNGIBLE_LOCAL_IDS_IDENT.to_string(),
474 FunctionSchemaInit {
475 receiver: Some(ReceiverInfo::normal_ref()),
476 input: TypeRef::Static(
477 aggregator
478 .add_child_type_and_descendents::<BucketGetNonFungibleLocalIdsInput>(),
479 ),
480 output: TypeRef::Static(
481 aggregator
482 .add_child_type_and_descendents::<BucketGetNonFungibleLocalIdsOutput>(),
483 ),
484 export: NON_FUNGIBLE_BUCKET_GET_NON_FUNGIBLE_LOCAL_IDS_EXPORT_NAME.to_string(),
485 },
486 );
487 functions.insert(
488 NON_FUNGIBLE_BUCKET_CONTAINS_NON_FUNGIBLE_IDENT.to_string(),
489 FunctionSchemaInit {
490 receiver: Some(ReceiverInfo::normal_ref()),
491 input: TypeRef::Static(
492 aggregator
493 .add_child_type_and_descendents::<NonFungibleBucketContainsNonFungibleInput>(),
494 ),
495 output: TypeRef::Static(
496 aggregator
497 .add_child_type_and_descendents::<NonFungibleBucketContainsNonFungibleOutput>(),
498 ),
499 export: NON_FUNGIBLE_BUCKET_CONTAINS_NON_FUNGIBLE_EXPORT_NAME.to_string(),
500 },
501 );
502 functions.insert(
503 NON_FUNGIBLE_BUCKET_LOCK_NON_FUNGIBLES_IDENT.to_string(),
504 FunctionSchemaInit {
505 receiver: Some(ReceiverInfo::normal_ref_mut()),
506 input: TypeRef::Static(aggregator
507 .add_child_type_and_descendents::<NonFungibleBucketLockNonFungiblesInput>()),
508 output: TypeRef::Static(aggregator
509 .add_child_type_and_descendents::<NonFungibleBucketLockNonFungiblesOutput>(
510 )),
511 export: NON_FUNGIBLE_BUCKET_LOCK_NON_FUNGIBLES_EXPORT_NAME.to_string(),
512 },
513 );
514 functions.insert(
515 NON_FUNGIBLE_BUCKET_UNLOCK_NON_FUNGIBLES_IDENT.to_string(),
516 FunctionSchemaInit {
517 receiver: Some(ReceiverInfo::normal_ref_mut()),
518 input: TypeRef::Static(aggregator
519 .add_child_type_and_descendents::<NonFungibleBucketUnlockNonFungiblesInput>()),
520 output: TypeRef::Static(aggregator
521 .add_child_type_and_descendents::<NonFungibleBucketUnlockNonFungiblesOutput>()),
522 export: NON_FUNGIBLE_BUCKET_UNLOCK_NON_FUNGIBLES_EXPORT_NAME.to_string(),
523 },
524 );
525
526 let schema = generate_full_schema(aggregator);
527
528 BlueprintDefinitionInit {
529 blueprint_type: BlueprintType::Inner {
530 outer_blueprint: NON_FUNGIBLE_RESOURCE_MANAGER_BLUEPRINT.to_string(),
531 },
532 is_transient: true,
533 dependencies: indexset!(),
534 feature_set: indexset!(),
535
536 schema: BlueprintSchemaInit {
537 generics: vec![],
538 schema,
539 state: BlueprintStateSchemaInit {
540 fields,
541 collections: vec![],
542 },
543 events: BlueprintEventSchemaInit::default(),
544 types: BlueprintTypeSchemaInit::default(),
545 functions: BlueprintFunctionsSchemaInit { functions },
546 hooks: BlueprintHooksInit::default(),
547 },
548
549 royalty_config: PackageRoyaltyConfig::default(),
550 auth_config: AuthConfig {
551 function_auth: FunctionAuth::AllowAll,
552 method_auth: MethodAuthTemplate::StaticRoleDefinition(StaticRoleDefinition {
553 methods: method_auth_template! {
554 BUCKET_GET_AMOUNT_IDENT => MethodAccessibility::Public;
555 BUCKET_GET_RESOURCE_ADDRESS_IDENT => MethodAccessibility::Public;
556 BUCKET_CREATE_PROOF_OF_ALL_IDENT => MethodAccessibility::Public;
557 BUCKET_PUT_IDENT => MethodAccessibility::Public;
558 BUCKET_TAKE_IDENT => MethodAccessibility::Public;
559 BUCKET_TAKE_ADVANCED_IDENT => MethodAccessibility::Public;
560 NON_FUNGIBLE_BUCKET_TAKE_NON_FUNGIBLES_IDENT => MethodAccessibility::Public;
561 NON_FUNGIBLE_BUCKET_GET_NON_FUNGIBLE_LOCAL_IDS_IDENT => MethodAccessibility::Public;
562 NON_FUNGIBLE_BUCKET_CONTAINS_NON_FUNGIBLE_IDENT => MethodAccessibility::Public;
563 NON_FUNGIBLE_BUCKET_CREATE_PROOF_OF_NON_FUNGIBLES_IDENT => MethodAccessibility::Public;
564
565 NON_FUNGIBLE_BUCKET_LOCK_NON_FUNGIBLES_IDENT => MethodAccessibility::OwnPackageOnly;
566 NON_FUNGIBLE_BUCKET_UNLOCK_NON_FUNGIBLES_IDENT => MethodAccessibility::OwnPackageOnly;
567 },
568 roles: RoleSpecification::UseOuter,
569 }),
570 },
571 }
572 };
573
574 let fungible_proof_blueprint = {
575 let mut aggregator = TypeAggregator::<ScryptoCustomTypeKind>::new();
576
577 let mut fields = Vec::new();
578 fields.push(FieldSchema::static_field(
579 aggregator.add_child_type_and_descendents::<ProofMoveableSubstate>(),
580 ));
581 fields.push(FieldSchema::static_field(
582 aggregator.add_child_type_and_descendents::<FungibleProofSubstate>(),
583 ));
584
585 let mut functions = index_map_new();
586 functions.insert(
587 PROOF_DROP_IDENT.to_string(),
588 FunctionSchemaInit {
589 receiver: None,
590 input: TypeRef::Static(
591 aggregator.add_child_type_and_descendents::<ProofDropInput>(),
592 ),
593 output: TypeRef::Static(
594 aggregator.add_child_type_and_descendents::<ProofDropOutput>(),
595 ),
596 export: FUNGIBLE_PROOF_DROP_EXPORT_NAME.to_string(),
597 },
598 );
599 functions.insert(
600 PROOF_CLONE_IDENT.to_string(),
601 FunctionSchemaInit {
602 receiver: Some(ReceiverInfo::normal_ref_mut()),
603 input: TypeRef::Static(
604 aggregator.add_child_type_and_descendents::<ProofCloneInput>(),
605 ),
606 output: TypeRef::Static(
607 aggregator.add_child_type_and_descendents::<ProofCloneOutput>(),
608 ),
609 export: FUNGIBLE_PROOF_CLONE_EXPORT_NAME.to_string(),
610 },
611 );
612 functions.insert(
613 PROOF_GET_AMOUNT_IDENT.to_string(),
614 FunctionSchemaInit {
615 receiver: Some(ReceiverInfo::normal_ref()),
616 input: TypeRef::Static(
617 aggregator.add_child_type_and_descendents::<ProofGetAmountInput>(),
618 ),
619 output: TypeRef::Static(
620 aggregator.add_child_type_and_descendents::<ProofGetAmountOutput>(),
621 ),
622 export: FUNGIBLE_PROOF_GET_AMOUNT_EXPORT_NAME.to_string(),
623 },
624 );
625 functions.insert(
626 PROOF_GET_RESOURCE_ADDRESS_IDENT.to_string(),
627 FunctionSchemaInit {
628 receiver: Some(ReceiverInfo::normal_ref()),
629 input: TypeRef::Static(
630 aggregator.add_child_type_and_descendents::<ProofGetResourceAddressInput>(),
631 ),
632 output: TypeRef::Static(
633 aggregator
634 .add_child_type_and_descendents::<ProofGetResourceAddressOutput>(),
635 ),
636 export: FUNGIBLE_PROOF_GET_RESOURCE_ADDRESS_EXPORT_NAME.to_string(),
637 },
638 );
639
640 let schema = generate_full_schema(aggregator);
641
642 BlueprintDefinitionInit {
643 blueprint_type: BlueprintType::Inner {
644 outer_blueprint: FUNGIBLE_RESOURCE_MANAGER_BLUEPRINT.to_string(),
645 },
646 is_transient: true,
647 dependencies: indexset!(),
648 feature_set: indexset!(),
649
650 schema: BlueprintSchemaInit {
651 generics: vec![],
652 schema,
653 state: BlueprintStateSchemaInit {
654 fields,
655 collections: vec![],
656 },
657 events: BlueprintEventSchemaInit::default(),
658 types: BlueprintTypeSchemaInit::default(),
659 functions: BlueprintFunctionsSchemaInit { functions },
660 hooks: BlueprintHooksInit {
661 hooks: indexmap!(
662 BlueprintHook::OnDrop => FUNGIBLE_PROOF_ON_DROP_EXPORT_NAME.to_string(),
663 BlueprintHook::OnMove => FUNGIBLE_PROOF_ON_MOVE_EXPORT_NAME.to_string(),
664 ),
665 },
666 },
667
668 royalty_config: PackageRoyaltyConfig::default(),
669 auth_config: AuthConfig {
670 function_auth: FunctionAuth::AllowAll,
671 method_auth: MethodAuthTemplate::AllowAll,
672 },
673 }
674 };
675
676 let non_fungible_proof_blueprint = {
677 let mut aggregator = TypeAggregator::<ScryptoCustomTypeKind>::new();
678
679 let mut fields = Vec::new();
680 fields.push(FieldSchema::static_field(
681 aggregator.add_child_type_and_descendents::<ProofMoveableSubstate>(),
682 ));
683 fields.push(FieldSchema::static_field(
684 aggregator.add_child_type_and_descendents::<NonFungibleProofSubstate>(),
685 ));
686
687 let mut functions = index_map_new();
688 functions.insert(
689 PROOF_DROP_IDENT.to_string(),
690 FunctionSchemaInit {
691 receiver: None,
692 input: TypeRef::Static(
693 aggregator.add_child_type_and_descendents::<ProofDropInput>(),
694 ),
695 output: TypeRef::Static(
696 aggregator.add_child_type_and_descendents::<ProofDropOutput>(),
697 ),
698 export: NON_FUNGIBLE_PROOF_DROP_EXPORT_NAME.to_string(),
699 },
700 );
701 functions.insert(
702 PROOF_CLONE_IDENT.to_string(),
703 FunctionSchemaInit {
704 receiver: Some(ReceiverInfo::normal_ref()),
705 input: TypeRef::Static(
706 aggregator.add_child_type_and_descendents::<ProofCloneInput>(),
707 ),
708 output: TypeRef::Static(
709 aggregator.add_child_type_and_descendents::<ProofCloneOutput>(),
710 ),
711 export: NON_FUNGIBLE_PROOF_CLONE_EXPORT_NAME.to_string(),
712 },
713 );
714 functions.insert(
715 PROOF_GET_AMOUNT_IDENT.to_string(),
716 FunctionSchemaInit {
717 receiver: Some(ReceiverInfo::normal_ref()),
718 input: TypeRef::Static(
719 aggregator.add_child_type_and_descendents::<ProofGetAmountInput>(),
720 ),
721 output: TypeRef::Static(
722 aggregator.add_child_type_and_descendents::<ProofGetAmountOutput>(),
723 ),
724 export: NON_FUNGIBLE_PROOF_GET_AMOUNT_EXPORT_NAME.to_string(),
725 },
726 );
727 functions.insert(
728 PROOF_GET_RESOURCE_ADDRESS_IDENT.to_string(),
729 FunctionSchemaInit {
730 receiver: Some(ReceiverInfo::normal_ref()),
731 input: TypeRef::Static(
732 aggregator.add_child_type_and_descendents::<ProofGetResourceAddressInput>(),
733 ),
734 output: TypeRef::Static(
735 aggregator
736 .add_child_type_and_descendents::<ProofGetResourceAddressOutput>(),
737 ),
738 export: NON_FUNGIBLE_PROOF_GET_RESOURCE_ADDRESS_EXPORT_NAME.to_string(),
739 },
740 );
741
742 functions.insert(
743 NON_FUNGIBLE_PROOF_GET_LOCAL_IDS_IDENT.to_string(),
744 FunctionSchemaInit {
745 receiver: Some(ReceiverInfo::normal_ref()),
746 input: TypeRef::Static(
747 aggregator
748 .add_child_type_and_descendents::<NonFungibleProofGetLocalIdsInput>(),
749 ),
750 output: TypeRef::Static(
751 aggregator
752 .add_child_type_and_descendents::<NonFungibleProofGetLocalIdsOutput>(),
753 ),
754 export: NON_FUNGIBLE_PROOF_GET_LOCAL_IDS_IDENT.to_string(),
755 },
756 );
757
758 let schema = generate_full_schema(aggregator);
759
760 BlueprintDefinitionInit {
761 blueprint_type: BlueprintType::Inner {
762 outer_blueprint: NON_FUNGIBLE_RESOURCE_MANAGER_BLUEPRINT.to_string(),
763 },
764 is_transient: true,
765 dependencies: indexset!(),
766 feature_set: indexset!(),
767
768 schema: BlueprintSchemaInit {
769 generics: vec![],
770 schema,
771 state: BlueprintStateSchemaInit {
772 fields,
773 collections: vec![],
774 },
775 events: BlueprintEventSchemaInit::default(),
776 types: BlueprintTypeSchemaInit::default(),
777 functions: BlueprintFunctionsSchemaInit { functions },
778 hooks: BlueprintHooksInit {
779 hooks: indexmap!(
780 BlueprintHook::OnDrop => NON_FUNGIBLE_PROOF_ON_DROP_EXPORT_NAME.to_string(),
781 BlueprintHook::OnMove => NON_FUNGIBLE_PROOF_ON_MOVE_EXPORT_NAME.to_string()
782 ),
783 },
784 },
785
786 royalty_config: PackageRoyaltyConfig::default(),
787 auth_config: AuthConfig {
788 function_auth: FunctionAuth::AllowAll,
789 method_auth: MethodAuthTemplate::AllowAll,
790 },
791 }
792 };
793
794 let worktop_blueprint = WorktopBlueprint::get_definition();
795
796 let auth_zone_blueprint = {
797 let mut aggregator = TypeAggregator::<ScryptoCustomTypeKind>::new();
798
799 let mut fields = Vec::new();
800 fields.push(FieldSchema::static_field(
801 aggregator.add_child_type_and_descendents::<GenesisSchemaAuthZone>(),
802 ));
803
804 let mut functions = index_map_new();
805 functions.insert(
806 AUTH_ZONE_POP_IDENT.to_string(),
807 FunctionSchemaInit {
808 receiver: Some(ReceiverInfo::normal_ref_mut()),
809 input: TypeRef::Static(
810 aggregator.add_child_type_and_descendents::<AuthZonePopInput>(),
811 ),
812 output: TypeRef::Static(
813 aggregator.add_child_type_and_descendents::<AuthZonePopOutput>(),
814 ),
815 export: AUTH_ZONE_POP_EXPORT_NAME.to_string(),
816 },
817 );
818 functions.insert(
819 AUTH_ZONE_PUSH_IDENT.to_string(),
820 FunctionSchemaInit {
821 receiver: Some(ReceiverInfo::normal_ref_mut()),
822 input: TypeRef::Static(
823 aggregator.add_child_type_and_descendents::<AuthZonePushInput>(),
824 ),
825 output: TypeRef::Static(
826 aggregator.add_child_type_and_descendents::<AuthZonePushOutput>(),
827 ),
828 export: AUTH_ZONE_PUSH_EXPORT_NAME.to_string(),
829 },
830 );
831 functions.insert(
832 AUTH_ZONE_CREATE_PROOF_OF_AMOUNT_IDENT.to_string(),
833 FunctionSchemaInit {
834 receiver: Some(ReceiverInfo::normal_ref_mut()),
835 input: TypeRef::Static(
836 aggregator
837 .add_child_type_and_descendents::<AuthZoneCreateProofOfAmountInput>(),
838 ),
839 output: TypeRef::Static(
840 aggregator
841 .add_child_type_and_descendents::<AuthZoneCreateProofOfAmountOutput>(),
842 ),
843 export: AUTH_ZONE_CREATE_PROOF_OF_AMOUNT_EXPORT_NAME.to_string(),
844 },
845 );
846 functions.insert(
847 AUTH_ZONE_CREATE_PROOF_OF_NON_FUNGIBLES_IDENT.to_string(),
848 FunctionSchemaInit {
849 receiver: Some(ReceiverInfo::normal_ref_mut()),
850 input: TypeRef::Static(aggregator
851 .add_child_type_and_descendents::<AuthZoneCreateProofOfNonFungiblesInput>()),
852 output: TypeRef::Static(aggregator
853 .add_child_type_and_descendents::<AuthZoneCreateProofOfNonFungiblesOutput>(
854 )),
855 export: AUTH_ZONE_CREATE_PROOF_OF_NON_FUNGIBLES_EXPORT_NAME.to_string(),
856 },
857 );
858 functions.insert(
859 AUTH_ZONE_CREATE_PROOF_OF_ALL_IDENT.to_string(),
860 FunctionSchemaInit {
861 receiver: Some(ReceiverInfo::normal_ref_mut()),
862 input: TypeRef::Static(
863 aggregator
864 .add_child_type_and_descendents::<AuthZoneCreateProofOfAllInput>(),
865 ),
866 output: TypeRef::Static(
867 aggregator
868 .add_child_type_and_descendents::<AuthZoneCreateProofOfAllOutput>(),
869 ),
870 export: AUTH_ZONE_CREATE_PROOF_OF_ALL_EXPORT_NAME.to_string(),
871 },
872 );
873 functions.insert(
874 AUTH_ZONE_DROP_PROOFS_IDENT.to_string(),
875 FunctionSchemaInit {
876 receiver: Some(ReceiverInfo::normal_ref_mut()),
877 input: TypeRef::Static(
878 aggregator.add_child_type_and_descendents::<AuthZoneDropProofsInput>(),
879 ),
880 output: TypeRef::Static(
881 aggregator.add_child_type_and_descendents::<AuthZoneDropProofsOutput>(),
882 ),
883 export: AUTH_ZONE_DROP_PROOFS_EXPORT_NAME.to_string(),
884 },
885 );
886 functions.insert(
887 AUTH_ZONE_DROP_SIGNATURE_PROOFS_IDENT.to_string(),
888 FunctionSchemaInit {
889 receiver: Some(ReceiverInfo::normal_ref_mut()),
890 input: TypeRef::Static(
891 aggregator
892 .add_child_type_and_descendents::<AuthZoneDropSignatureProofsInput>(),
893 ),
894 output: TypeRef::Static(
895 aggregator
896 .add_child_type_and_descendents::<AuthZoneDropSignatureProofsOutput>(),
897 ),
898 export: AUTH_ZONE_DROP_SIGNATURE_PROOFS_EXPORT_NAME.to_string(),
899 },
900 );
901 functions.insert(
902 AUTH_ZONE_DROP_REGULAR_PROOFS_IDENT.to_string(),
903 FunctionSchemaInit {
904 receiver: Some(ReceiverInfo::normal_ref_mut()),
905 input: TypeRef::Static(
906 aggregator
907 .add_child_type_and_descendents::<AuthZoneDropSignatureProofsInput>(),
908 ),
909 output: TypeRef::Static(
910 aggregator
911 .add_child_type_and_descendents::<AuthZoneDropSignatureProofsOutput>(),
912 ),
913 export: AUTH_ZONE_DROP_REGULAR_PROOFS_EXPORT_NAME.to_string(),
914 },
915 );
916 functions.insert(
917 AUTH_ZONE_DRAIN_IDENT.to_string(),
918 FunctionSchemaInit {
919 receiver: Some(ReceiverInfo::normal_ref_mut()),
920 input: TypeRef::Static(
921 aggregator.add_child_type_and_descendents::<AuthZoneDrainInput>(),
922 ),
923 output: TypeRef::Static(
924 aggregator.add_child_type_and_descendents::<AuthZoneDrainOutput>(),
925 ),
926 export: AUTH_ZONE_DRAIN_EXPORT_NAME.to_string(),
927 },
928 );
929 functions.insert(
930 AUTH_ZONE_ASSERT_ACCESS_RULE_IDENT.to_string(),
931 FunctionSchemaInit {
932 receiver: Some(ReceiverInfo::normal_ref()),
933 input: TypeRef::Static(
934 aggregator
935 .add_child_type_and_descendents::<AuthZoneAssertAccessRuleInput>(),
936 ),
937 output: TypeRef::Static(
938 aggregator
939 .add_child_type_and_descendents::<AuthZoneAssertAccessRuleOutput>(),
940 ),
941 export: AUTH_ZONE_ASSERT_ACCESS_RULE_EXPORT_NAME.to_string(),
942 },
943 );
944
945 let schema = generate_full_schema(aggregator);
946 let auth_zone_blueprint = BlueprintStateSchemaInit {
947 fields,
948 collections: vec![],
949 };
950
951 BlueprintDefinitionInit {
952 blueprint_type: BlueprintType::default(),
953 is_transient: true,
954 dependencies: indexset!(),
955 feature_set: indexset!(),
956
957 schema: BlueprintSchemaInit {
958 generics: vec![],
959 schema,
960 state: auth_zone_blueprint,
961 events: BlueprintEventSchemaInit::default(),
962 types: BlueprintTypeSchemaInit::default(),
963 functions: BlueprintFunctionsSchemaInit { functions },
964 hooks: BlueprintHooksInit::default(),
965 },
966
967 royalty_config: PackageRoyaltyConfig::default(),
968 auth_config: AuthConfig {
969 function_auth: FunctionAuth::AllowAll,
970 method_auth: MethodAuthTemplate::AllowAll,
971 },
972 }
973 };
974
975 let blueprints = indexmap!(
976 FUNGIBLE_RESOURCE_MANAGER_BLUEPRINT.to_string() => fungible_resource_manager_blueprint,
977 NON_FUNGIBLE_RESOURCE_MANAGER_BLUEPRINT.to_string() => non_fungible_resource_manager_blueprint,
978 FUNGIBLE_VAULT_BLUEPRINT.to_string() => fungible_vault_blueprint,
979 NON_FUNGIBLE_VAULT_BLUEPRINT.to_string() => non_fungible_vault_blueprint,
980 FUNGIBLE_BUCKET_BLUEPRINT.to_string() => fungible_bucket_blueprint,
981 NON_FUNGIBLE_BUCKET_BLUEPRINT.to_string() => non_fungible_bucket_blueprint,
982 FUNGIBLE_PROOF_BLUEPRINT.to_string() => fungible_proof_blueprint,
983 NON_FUNGIBLE_PROOF_BLUEPRINT.to_string() => non_fungible_proof_blueprint,
984 WORKTOP_BLUEPRINT.to_string() => worktop_blueprint,
985 AUTH_ZONE_BLUEPRINT.to_string() => auth_zone_blueprint,
986 );
987
988 PackageDefinition { blueprints }
989 }
990
991 pub fn invoke_export<
992 Y: SystemApi<RuntimeError> + KernelNodeApi + KernelSubstateApi<SystemLockData>,
993 >(
994 export_name: &str,
995 input: &IndexedScryptoValue,
996 api: &mut Y,
997 ) -> Result<IndexedScryptoValue, RuntimeError> {
998 match export_name {
999 FUNGIBLE_RESOURCE_MANAGER_CREATE_EXPORT_NAME => {
1000 let input: FungibleResourceManagerCreateInput = input.as_typed().map_err(|e| {
1001 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1002 })?;
1003 let rtn = FungibleResourceManagerBlueprint::create(
1004 input.owner_role,
1005 input.track_total_supply,
1006 input.divisibility,
1007 input.resource_roles,
1008 input.metadata,
1009 input.address_reservation,
1010 api,
1011 )?;
1012 Ok(IndexedScryptoValue::from_typed(&rtn))
1013 }
1014 FUNGIBLE_RESOURCE_MANAGER_CREATE_WITH_INITIAL_SUPPLY_EXPORT_NAME => {
1015 let input: FungibleResourceManagerCreateWithInitialSupplyInput =
1016 input.as_typed().map_err(|e| {
1017 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1018 })?;
1019 let rtn = FungibleResourceManagerBlueprint::create_with_initial_supply(
1020 input.owner_role,
1021 input.track_total_supply,
1022 input.divisibility,
1023 input.initial_supply,
1024 input.resource_roles,
1025 input.metadata,
1026 input.address_reservation,
1027 api,
1028 )?;
1029 Ok(IndexedScryptoValue::from_typed(&rtn))
1030 }
1031 FUNGIBLE_RESOURCE_MANAGER_MINT_EXPORT_NAME => {
1032 let input: FungibleResourceManagerMintInput = input.as_typed().map_err(|e| {
1033 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1034 })?;
1035 let rtn = FungibleResourceManagerBlueprint::mint(input.amount, api)?;
1036 Ok(IndexedScryptoValue::from_typed(&rtn))
1037 }
1038 FUNGIBLE_RESOURCE_MANAGER_BURN_EXPORT_NAME => {
1039 let input: ResourceManagerBurnInput = input.as_typed().map_err(|e| {
1040 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1041 })?;
1042 let rtn = FungibleResourceManagerBlueprint::burn(input.bucket, api)?;
1043 Ok(IndexedScryptoValue::from_typed(&rtn))
1044 }
1045 FUNGIBLE_RESOURCE_MANAGER_PACKAGE_BURN_EXPORT_NAME => {
1046 let input: ResourceManagerPackageBurnInput = input.as_typed().map_err(|e| {
1047 RuntimeError::SystemUpstreamError(SystemUpstreamError::InputDecodeError(e))
1048 })?;
1049 let rtn = FungibleResourceManagerBlueprint::package_burn(input.bucket, api)?;
1050 Ok(IndexedScryptoValue::from_typed(&rtn))
1051 }
1052 FUNGIBLE_RESOURCE_MANAGER_DROP_EMPTY_BUCKET_EXPORT_NAME => {
1053 let input: ResourceManagerDropEmptyBucketInput = input.as_typed().map_err(|e| {
1054 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1055 })?;
1056 let rtn = FungibleResourceManagerBlueprint::drop_empty_bucket(input.bucket, api)?;
1057 Ok(IndexedScryptoValue::from_typed(&rtn))
1058 }
1059 FUNGIBLE_RESOURCE_MANAGER_CREATE_EMPTY_VAULT_EXPORT_NAME => {
1060 let _input: ResourceManagerCreateEmptyVaultInput =
1061 input.as_typed().map_err(|e| {
1062 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1063 })?;
1064 let rtn = FungibleResourceManagerBlueprint::create_empty_vault(api)?;
1065 Ok(IndexedScryptoValue::from_typed(&rtn))
1066 }
1067 FUNGIBLE_RESOURCE_MANAGER_CREATE_EMPTY_BUCKET_EXPORT_NAME => {
1068 let _input: ResourceManagerCreateEmptyBucketInput =
1069 input.as_typed().map_err(|e| {
1070 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1071 })?;
1072
1073 let rtn = FungibleResourceManagerBlueprint::create_empty_bucket(api)?;
1074 Ok(IndexedScryptoValue::from_typed(&rtn))
1075 }
1076 FUNGIBLE_RESOURCE_MANAGER_GET_RESOURCE_TYPE_EXPORT_NAME => {
1077 let _input: ResourceManagerGetResourceTypeInput =
1078 input.as_typed().map_err(|e| {
1079 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1080 })?;
1081 let rtn = FungibleResourceManagerBlueprint::get_resource_type(api)?;
1082 Ok(IndexedScryptoValue::from_typed(&rtn))
1083 }
1084 FUNGIBLE_RESOURCE_MANAGER_GET_TOTAL_SUPPLY_EXPORT_NAME => {
1085 let _input: ResourceManagerGetTotalSupplyInput = input.as_typed().map_err(|e| {
1086 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1087 })?;
1088 let rtn = FungibleResourceManagerBlueprint::get_total_supply(api)?;
1089 Ok(IndexedScryptoValue::from_typed(&rtn))
1090 }
1091 FUNGIBLE_RESOURCE_MANAGER_AMOUNT_FOR_WITHDRAWAL_EXPORT_NAME => {
1092 let input: ResourceManagerGetAmountForWithdrawalInput =
1093 input.as_typed().map_err(|e| {
1094 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1095 })?;
1096 let rtn = FungibleResourceManagerBlueprint::amount_for_withdrawal(
1097 api,
1098 input.request_amount,
1099 input.withdraw_strategy,
1100 )?;
1101 Ok(IndexedScryptoValue::from_typed(&rtn))
1102 }
1103 NON_FUNGIBLE_RESOURCE_MANAGER_CREATE_EXPORT_NAME => {
1104 let input: NonFungibleResourceManagerCreateInput =
1105 input.as_typed().map_err(|e| {
1106 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1107 })?;
1108 let rtn = NonFungibleResourceManagerBlueprint::create(
1109 input.owner_role,
1110 input.id_type,
1111 input.track_total_supply,
1112 input.non_fungible_schema,
1113 input.resource_roles,
1114 input.metadata,
1115 input.address_reservation,
1116 api,
1117 )?;
1118 Ok(IndexedScryptoValue::from_typed(&rtn))
1119 }
1120 NON_FUNGIBLE_RESOURCE_MANAGER_CREATE_WITH_INITIAL_SUPPLY_EXPORT_NAME => {
1121 let input: NonFungibleResourceManagerCreateWithInitialSupplyInput =
1122 input.as_typed().map_err(|e| {
1123 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1124 })?;
1125 let rtn = NonFungibleResourceManagerBlueprint::create_with_initial_supply(
1126 input.owner_role,
1127 input.id_type,
1128 input.track_total_supply,
1129 input.non_fungible_schema,
1130 input.entries,
1131 input.resource_roles,
1132 input.metadata,
1133 input.address_reservation,
1134 api,
1135 )?;
1136 Ok(IndexedScryptoValue::from_typed(&rtn))
1137 }
1138 NON_FUNGIBLE_RESOURCE_MANAGER_CREATE_RUID_WITH_INITIAL_SUPPLY_IDENT => {
1139 let input: NonFungibleResourceManagerCreateRuidWithInitialSupplyInput =
1140 input.as_typed().map_err(|e| {
1141 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1142 })?;
1143
1144 let rtn = NonFungibleResourceManagerBlueprint::create_ruid_with_initial_supply(
1145 input.owner_role,
1146 input.track_total_supply,
1147 input.non_fungible_schema,
1148 input.entries,
1149 input.resource_roles,
1150 input.metadata,
1151 input.address_reservation,
1152 api,
1153 )?;
1154
1155 Ok(IndexedScryptoValue::from_typed(&rtn))
1156 }
1157 NON_FUNGIBLE_RESOURCE_MANAGER_MINT_EXPORT_NAME => {
1158 let input: NonFungibleResourceManagerMintInput = input.as_typed().map_err(|e| {
1159 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1160 })?;
1161 let rtn =
1162 NonFungibleResourceManagerBlueprint::mint_non_fungible(input.entries, api)?;
1163 Ok(IndexedScryptoValue::from_typed(&rtn))
1164 }
1165 NON_FUNGIBLE_RESOURCE_MANAGER_MINT_RUID_EXPORT_NAME => {
1166 let input: NonFungibleResourceManagerMintRuidInput =
1167 input.as_typed().map_err(|e| {
1168 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1169 })?;
1170 let rtn = NonFungibleResourceManagerBlueprint::mint_ruid_non_fungible(
1171 input.entries,
1172 api,
1173 )?;
1174 Ok(IndexedScryptoValue::from_typed(&rtn))
1175 }
1176 NON_FUNGIBLE_RESOURCE_MANAGER_MINT_SINGLE_RUID_IDENT => {
1177 let input: NonFungibleResourceManagerMintSingleRuidInput =
1178 input.as_typed().map_err(|e| {
1179 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1180 })?;
1181 let rtn = NonFungibleResourceManagerBlueprint::mint_single_ruid_non_fungible(
1182 input.entry,
1183 api,
1184 )?;
1185 Ok(IndexedScryptoValue::from_typed(&rtn))
1186 }
1187 NON_FUNGIBLE_RESOURCE_MANAGER_BURN_EXPORT_NAME => {
1188 let input: ResourceManagerBurnInput = input.as_typed().map_err(|e| {
1189 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1190 })?;
1191 let rtn = NonFungibleResourceManagerBlueprint::burn(input.bucket, api)?;
1192 Ok(IndexedScryptoValue::from_typed(&rtn))
1193 }
1194 NON_FUNGIBLE_RESOURCE_MANAGER_PACKAGE_BURN_EXPORT_NAME => {
1195 let input: ResourceManagerPackageBurnInput = input.as_typed().map_err(|e| {
1196 RuntimeError::SystemUpstreamError(SystemUpstreamError::InputDecodeError(e))
1197 })?;
1198 let rtn = NonFungibleResourceManagerBlueprint::package_burn(input.bucket, api)?;
1199 Ok(IndexedScryptoValue::from_typed(&rtn))
1200 }
1201 NON_FUNGIBLE_RESOURCE_MANAGER_DROP_EMPTY_BUCKET_EXPORT_NAME => {
1202 let input: ResourceManagerDropEmptyBucketInput = input.as_typed().map_err(|e| {
1203 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1204 })?;
1205 let rtn =
1206 NonFungibleResourceManagerBlueprint::drop_empty_bucket(input.bucket, api)?;
1207 Ok(IndexedScryptoValue::from_typed(&rtn))
1208 }
1209 NON_FUNGIBLE_RESOURCE_MANAGER_CREATE_EMPTY_BUCKET_EXPORT_NAME => {
1210 let _input: ResourceManagerCreateEmptyBucketInput =
1211 input.as_typed().map_err(|e| {
1212 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1213 })?;
1214
1215 let rtn = NonFungibleResourceManagerBlueprint::create_empty_bucket(api)?;
1216 Ok(IndexedScryptoValue::from_typed(&rtn))
1217 }
1218 NON_FUNGIBLE_RESOURCE_MANAGER_CREATE_EMPTY_VAULT_EXPORT_NAME => {
1219 let _input: ResourceManagerCreateEmptyVaultInput =
1220 input.as_typed().map_err(|e| {
1221 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1222 })?;
1223 let rtn = NonFungibleResourceManagerBlueprint::create_empty_vault(api)?;
1224
1225 Ok(IndexedScryptoValue::from_typed(&rtn))
1226 }
1227 NON_FUNGIBLE_RESOURCE_MANAGER_UPDATE_DATA_IDENT => {
1228 let input: NonFungibleResourceManagerUpdateDataInput =
1229 input.as_typed().map_err(|e| {
1230 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1231 })?;
1232 let rtn = NonFungibleResourceManagerBlueprint::update_non_fungible_data(
1233 input.id,
1234 input.field_name,
1235 input.data,
1236 api,
1237 )?;
1238 Ok(IndexedScryptoValue::from_typed(&rtn))
1239 }
1240 NON_FUNGIBLE_RESOURCE_MANAGER_EXISTS_IDENT => {
1241 let input: NonFungibleResourceManagerExistsInput =
1242 input.as_typed().map_err(|e| {
1243 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1244 })?;
1245 let rtn = NonFungibleResourceManagerBlueprint::non_fungible_exists(input.id, api)?;
1246 Ok(IndexedScryptoValue::from_typed(&rtn))
1247 }
1248 NON_FUNGIBLE_RESOURCE_MANAGER_GET_RESOURCE_TYPE_EXPORT_NAME => {
1249 let _input: ResourceManagerGetResourceTypeInput =
1250 input.as_typed().map_err(|e| {
1251 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1252 })?;
1253 let rtn = NonFungibleResourceManagerBlueprint::get_resource_type(api)?;
1254 Ok(IndexedScryptoValue::from_typed(&rtn))
1255 }
1256 NON_FUNGIBLE_RESOURCE_MANAGER_GET_TOTAL_SUPPLY_EXPORT_NAME => {
1257 let _input: ResourceManagerGetTotalSupplyInput = input.as_typed().map_err(|e| {
1258 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1259 })?;
1260 let rtn = NonFungibleResourceManagerBlueprint::get_total_supply(api)?;
1261 Ok(IndexedScryptoValue::from_typed(&rtn))
1262 }
1263 NON_FUNGIBLE_RESOURCE_MANAGER_AMOUNT_FOR_WITHDRAWAL_EXPORT_NAME => {
1264 let input: ResourceManagerGetAmountForWithdrawalInput =
1265 input.as_typed().map_err(|e| {
1266 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1267 })?;
1268 let rtn = NonFungibleResourceManagerBlueprint::amount_for_withdrawal(
1269 api,
1270 input.request_amount,
1271 input.withdraw_strategy,
1272 )?;
1273 Ok(IndexedScryptoValue::from_typed(&rtn))
1274 }
1275 NON_FUNGIBLE_RESOURCE_MANAGER_GET_NON_FUNGIBLE_IDENT => {
1276 let input: NonFungibleResourceManagerGetNonFungibleInput =
1277 input.as_typed().map_err(|e| {
1278 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1279 })?;
1280 let rtn = NonFungibleResourceManagerBlueprint::get_non_fungible(input.id, api)?;
1281 Ok(IndexedScryptoValue::from_typed(&rtn))
1282 }
1283
1284 FUNGIBLE_VAULT_LOCK_FEE_IDENT => {
1285 let input: FungibleVaultLockFeeInput = input.as_typed().map_err(|e| {
1286 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1287 })?;
1288 let rtn = FungibleVaultBlueprint::lock_fee(input.amount, input.contingent, api)?;
1289 Ok(IndexedScryptoValue::from_typed(&rtn))
1290 }
1291 FUNGIBLE_VAULT_TAKE_EXPORT_NAME => {
1292 let input: VaultTakeInput = input.as_typed().map_err(|e| {
1293 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1294 })?;
1295 let rtn = FungibleVaultBlueprint::take(&input.amount, api)?;
1296 Ok(IndexedScryptoValue::from_typed(&rtn))
1297 }
1298 FUNGIBLE_VAULT_TAKE_ADVANCED_EXPORT_NAME => {
1299 let input: VaultTakeAdvancedInput = input.as_typed().map_err(|e| {
1300 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1301 })?;
1302 let rtn = FungibleVaultBlueprint::take_advanced(
1303 &input.amount,
1304 input.withdraw_strategy,
1305 api,
1306 )?;
1307 Ok(IndexedScryptoValue::from_typed(&rtn))
1308 }
1309 FUNGIBLE_VAULT_RECALL_EXPORT_NAME => {
1310 let input: VaultRecallInput = input.as_typed().map_err(|e| {
1311 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1312 })?;
1313 let rtn = FungibleVaultBlueprint::recall(input.amount, api)?;
1314 Ok(IndexedScryptoValue::from_typed(&rtn))
1315 }
1316 FUNGIBLE_VAULT_FREEZE_EXPORT_NAME => {
1317 let input: VaultFreezeInput = input.as_typed().map_err(|e| {
1318 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1319 })?;
1320 let rtn = FungibleVaultBlueprint::freeze(input.to_freeze, api)?;
1321 Ok(IndexedScryptoValue::from_typed(&rtn))
1322 }
1323 FUNGIBLE_VAULT_UNFREEZE_EXPORT_NAME => {
1324 let input: VaultUnfreezeInput = input.as_typed().map_err(|e| {
1325 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1326 })?;
1327 let rtn = FungibleVaultBlueprint::unfreeze(input.to_unfreeze, api)?;
1328 Ok(IndexedScryptoValue::from_typed(&rtn))
1329 }
1330 FUNGIBLE_VAULT_PUT_EXPORT_NAME => {
1331 let input: VaultPutInput = input.as_typed().map_err(|e| {
1332 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1333 })?;
1334 let rtn = FungibleVaultBlueprint::put(input.bucket, api)?;
1335 Ok(IndexedScryptoValue::from_typed(&rtn))
1336 }
1337 FUNGIBLE_VAULT_GET_AMOUNT_EXPORT_NAME => {
1338 let _input: VaultGetAmountInput = input.as_typed().map_err(|e| {
1339 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1340 })?;
1341 let rtn = FungibleVaultBlueprint::get_amount(api)?;
1342 Ok(IndexedScryptoValue::from_typed(&rtn))
1343 }
1344 FUNGIBLE_VAULT_CREATE_PROOF_OF_AMOUNT_EXPORT_NAME => {
1345 let input: FungibleVaultCreateProofOfAmountInput =
1346 input.as_typed().map_err(|e| {
1347 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1348 })?;
1349 let rtn = FungibleVaultBlueprint::create_proof_of_amount(input.amount, api)?;
1350 Ok(IndexedScryptoValue::from_typed(&rtn))
1351 }
1352 FUNGIBLE_VAULT_LOCK_AMOUNT_EXPORT_NAME => {
1353 let input: FungibleVaultLockFungibleAmountInput =
1354 input.as_typed().map_err(|e| {
1355 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1356 })?;
1357 let rtn = FungibleVaultBlueprint::lock_amount(input.amount, api)?;
1358 Ok(IndexedScryptoValue::from_typed(&rtn))
1359 }
1360 FUNGIBLE_VAULT_UNLOCK_AMOUNT_EXPORT_NAME => {
1361 let input: FungibleVaultUnlockFungibleAmountInput =
1362 input.as_typed().map_err(|e| {
1363 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1364 })?;
1365 let rtn = FungibleVaultBlueprint::unlock_amount(input.amount, api)?;
1366 Ok(IndexedScryptoValue::from_typed(&rtn))
1367 }
1368 FUNGIBLE_VAULT_BURN_EXPORT_NAME => {
1369 let input: VaultBurnInput = input.as_typed().map_err(|e| {
1370 RuntimeError::SystemUpstreamError(SystemUpstreamError::InputDecodeError(e))
1371 })?;
1372 let rtn = FungibleVaultBlueprint::burn(input.amount, api)?;
1373 Ok(IndexedScryptoValue::from_typed(&rtn))
1374 }
1375
1376 NON_FUNGIBLE_VAULT_TAKE_ADVANCED_EXPORT_NAME => {
1377 let input: VaultTakeAdvancedInput = input.as_typed().map_err(|e| {
1378 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1379 })?;
1380 let rtn = NonFungibleVaultBlueprint::take_advanced(
1381 &input.amount,
1382 input.withdraw_strategy,
1383 api,
1384 )?;
1385 Ok(IndexedScryptoValue::from_typed(&rtn))
1386 }
1387 NON_FUNGIBLE_VAULT_TAKE_EXPORT_NAME => {
1388 let input: VaultTakeInput = input.as_typed().map_err(|e| {
1389 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1390 })?;
1391 let rtn = NonFungibleVaultBlueprint::take(&input.amount, api)?;
1392 Ok(IndexedScryptoValue::from_typed(&rtn))
1393 }
1394 NON_FUNGIBLE_VAULT_TAKE_NON_FUNGIBLES_IDENT => {
1395 let input: NonFungibleVaultTakeNonFungiblesInput =
1396 input.as_typed().map_err(|e| {
1397 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1398 })?;
1399 let rtn = NonFungibleVaultBlueprint::take_non_fungibles(
1400 &input.non_fungible_local_ids,
1401 api,
1402 )?;
1403 Ok(IndexedScryptoValue::from_typed(&rtn))
1404 }
1405 NON_FUNGIBLE_VAULT_RECALL_EXPORT_NAME => {
1406 let input: VaultRecallInput = input.as_typed().map_err(|e| {
1407 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1408 })?;
1409 let rtn = NonFungibleVaultBlueprint::recall(input.amount, api)?;
1410 Ok(IndexedScryptoValue::from_typed(&rtn))
1411 }
1412 NON_FUNGIBLE_VAULT_FREEZE_EXPORT_NAME => {
1413 let input: VaultFreezeInput = input.as_typed().map_err(|e| {
1414 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1415 })?;
1416 let rtn = NonFungibleVaultBlueprint::freeze(input.to_freeze, api)?;
1417 Ok(IndexedScryptoValue::from_typed(&rtn))
1418 }
1419 NON_FUNGIBLE_VAULT_UNFREEZE_EXPORT_NAME => {
1420 let input: VaultUnfreezeInput = input.as_typed().map_err(|e| {
1421 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1422 })?;
1423 let rtn = NonFungibleVaultBlueprint::unfreeze(input.to_unfreeze, api)?;
1424 Ok(IndexedScryptoValue::from_typed(&rtn))
1425 }
1426 NON_FUNGIBLE_VAULT_RECALL_NON_FUNGIBLES_IDENT => {
1427 let input: NonFungibleVaultRecallNonFungiblesInput =
1428 input.as_typed().map_err(|e| {
1429 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1430 })?;
1431 let rtn = NonFungibleVaultBlueprint::recall_non_fungibles(
1432 input.non_fungible_local_ids,
1433 api,
1434 )?;
1435 Ok(IndexedScryptoValue::from_typed(&rtn))
1436 }
1437 NON_FUNGIBLE_VAULT_PUT_EXPORT_NAME => {
1438 let input: VaultPutInput = input.as_typed().map_err(|e| {
1439 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1440 })?;
1441 let rtn = NonFungibleVaultBlueprint::put(input.bucket, api)?;
1442 Ok(IndexedScryptoValue::from_typed(&rtn))
1443 }
1444 NON_FUNGIBLE_VAULT_GET_AMOUNT_EXPORT_NAME => {
1445 let _input: VaultGetAmountInput = input.as_typed().map_err(|e| {
1446 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1447 })?;
1448 let rtn = NonFungibleVaultBlueprint::get_amount(api)?;
1449 Ok(IndexedScryptoValue::from_typed(&rtn))
1450 }
1451 NON_FUNGIBLE_VAULT_GET_NON_FUNGIBLE_LOCAL_IDS_IDENT => {
1452 let input: NonFungibleVaultGetNonFungibleLocalIdsInput =
1453 input.as_typed().map_err(|e| {
1454 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1455 })?;
1456 let rtn = NonFungibleVaultBlueprint::get_non_fungible_local_ids(input.limit, api)?;
1457 Ok(IndexedScryptoValue::from_typed(&rtn))
1458 }
1459 NON_FUNGIBLE_VAULT_CONTAINS_NON_FUNGIBLE_IDENT => {
1460 let input: NonFungibleVaultContainsNonFungibleInput =
1461 input.as_typed().map_err(|e| {
1462 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1463 })?;
1464 let rtn = NonFungibleVaultBlueprint::contains_non_fungible(input.id, api)?;
1465 Ok(IndexedScryptoValue::from_typed(&rtn))
1466 }
1467 NON_FUNGIBLE_VAULT_CREATE_PROOF_OF_NON_FUNGIBLES_IDENT => {
1468 let input: NonFungibleVaultCreateProofOfNonFungiblesInput =
1469 input.as_typed().map_err(|e| {
1470 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1471 })?;
1472 let rtn = NonFungibleVaultBlueprint::create_proof_of_non_fungibles(input.ids, api)?;
1473 Ok(IndexedScryptoValue::from_typed(&rtn))
1474 }
1475 NON_FUNGIBLE_VAULT_LOCK_NON_FUNGIBLES_EXPORT_NAME => {
1476 let input: NonFungibleVaultLockNonFungiblesInput =
1477 input.as_typed().map_err(|e| {
1478 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1479 })?;
1480 let rtn = NonFungibleVaultBlueprint::lock_non_fungibles(&input.local_ids, api)?;
1481 Ok(IndexedScryptoValue::from_typed(&rtn))
1482 }
1483 NON_FUNGIBLE_VAULT_UNLOCK_NON_FUNGIBLES_EXPORT_NAME => {
1484 let input: NonFungibleVaultUnlockNonFungiblesInput =
1485 input.as_typed().map_err(|e| {
1486 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1487 })?;
1488 let rtn = NonFungibleVaultBlueprint::unlock_non_fungibles(input.local_ids, api)?;
1489 Ok(IndexedScryptoValue::from_typed(&rtn))
1490 }
1491 NON_FUNGIBLE_VAULT_BURN_EXPORT_NAME => {
1492 let input: VaultBurnInput = input.as_typed().map_err(|e| {
1493 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1494 })?;
1495 let rtn = NonFungibleVaultBlueprint::burn(input.amount, api)?;
1496 Ok(IndexedScryptoValue::from_typed(&rtn))
1497 }
1498 NON_FUNGIBLE_VAULT_BURN_NON_FUNGIBLES_IDENT => {
1499 let input: NonFungibleVaultBurnNonFungiblesInput =
1500 input.as_typed().map_err(|e| {
1501 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1502 })?;
1503 let rtn = NonFungibleVaultBlueprint::burn_non_fungibles(
1504 &input.non_fungible_local_ids,
1505 api,
1506 )?;
1507 Ok(IndexedScryptoValue::from_typed(&rtn))
1508 }
1509
1510 FUNGIBLE_PROOF_CLONE_EXPORT_NAME => {
1511 let _input: ProofCloneInput = input.as_typed().map_err(|e| {
1512 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1513 })?;
1514 let rtn = FungibleProofBlueprint::clone(api)?;
1515 Ok(IndexedScryptoValue::from_typed(&rtn))
1516 }
1517 FUNGIBLE_PROOF_GET_AMOUNT_EXPORT_NAME => {
1518 let _input: ProofGetAmountInput = input.as_typed().map_err(|e| {
1519 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1520 })?;
1521 let rtn = FungibleProofBlueprint::get_amount(api)?;
1522 Ok(IndexedScryptoValue::from_typed(&rtn))
1523 }
1524 FUNGIBLE_PROOF_GET_RESOURCE_ADDRESS_EXPORT_NAME => {
1525 let _input: ProofGetResourceAddressInput = input.as_typed().map_err(|e| {
1526 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1527 })?;
1528
1529 let rtn = FungibleProofBlueprint::get_resource_address(api)?;
1530 Ok(IndexedScryptoValue::from_typed(&rtn))
1531 }
1532 FUNGIBLE_PROOF_DROP_EXPORT_NAME => {
1533 let input: ProofDropInput = input.as_typed().map_err(|e| {
1534 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1535 })?;
1536 let rtn = FungibleProofBlueprint::drop(input.proof, api)?;
1537 Ok(IndexedScryptoValue::from_typed(&rtn))
1538 }
1539 FUNGIBLE_PROOF_ON_DROP_EXPORT_NAME => {
1540 let _input: OnDropInput = input.as_typed().map_err(|e| {
1541 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1542 })?;
1543 let rtn = FungibleProofBlueprint::on_drop(api)?;
1544 Ok(IndexedScryptoValue::from_typed(&rtn))
1545 }
1546 FUNGIBLE_PROOF_ON_MOVE_EXPORT_NAME => {
1547 let input: OnMoveInput = input.as_typed().map_err(|e| {
1548 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1549 })?;
1550 let rtn = FungibleProofBlueprint::on_move(
1551 input.is_moving_down,
1552 input.is_to_barrier,
1553 input.destination_blueprint_id,
1554 api,
1555 )?;
1556 Ok(IndexedScryptoValue::from_typed(&rtn))
1557 }
1558 NON_FUNGIBLE_PROOF_CLONE_EXPORT_NAME => {
1559 let _input: ProofCloneInput = input.as_typed().map_err(|e| {
1560 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1561 })?;
1562 let rtn = NonFungibleProofBlueprint::clone(api)?;
1563 Ok(IndexedScryptoValue::from_typed(&rtn))
1564 }
1565 NON_FUNGIBLE_PROOF_GET_AMOUNT_EXPORT_NAME => {
1566 let _input: ProofGetAmountInput = input.as_typed().map_err(|e| {
1567 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1568 })?;
1569 let rtn = NonFungibleProofBlueprint::get_amount(api)?;
1570 Ok(IndexedScryptoValue::from_typed(&rtn))
1571 }
1572 NON_FUNGIBLE_PROOF_GET_LOCAL_IDS_IDENT => {
1573 let _input: NonFungibleProofGetLocalIdsInput = input.as_typed().map_err(|e| {
1574 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1575 })?;
1576 let rtn = NonFungibleProofBlueprint::get_local_ids(api)?;
1577 Ok(IndexedScryptoValue::from_typed(&rtn))
1578 }
1579
1580 NON_FUNGIBLE_PROOF_GET_RESOURCE_ADDRESS_EXPORT_NAME => {
1581 let _input: ProofGetResourceAddressInput = input.as_typed().map_err(|e| {
1582 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1583 })?;
1584
1585 let rtn = NonFungibleProofBlueprint::get_resource_address(api)?;
1586 Ok(IndexedScryptoValue::from_typed(&rtn))
1587 }
1588 NON_FUNGIBLE_PROOF_DROP_EXPORT_NAME => {
1589 let input: ProofDropInput = input.as_typed().map_err(|e| {
1590 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1591 })?;
1592 let rtn = NonFungibleProofBlueprint::drop(input.proof, api)?;
1593 Ok(IndexedScryptoValue::from_typed(&rtn))
1594 }
1595 NON_FUNGIBLE_PROOF_ON_DROP_EXPORT_NAME => {
1596 let _input: OnDropInput = input.as_typed().map_err(|e| {
1597 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1598 })?;
1599 let rtn = NonFungibleProofBlueprint::on_drop(api)?;
1600 Ok(IndexedScryptoValue::from_typed(&rtn))
1601 }
1602 NON_FUNGIBLE_PROOF_ON_MOVE_EXPORT_NAME => {
1603 let input: OnMoveInput = input.as_typed().map_err(|e| {
1604 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1605 })?;
1606 let rtn = NonFungibleProofBlueprint::on_move(
1607 input.is_moving_down,
1608 input.is_to_barrier,
1609 input.destination_blueprint_id,
1610 api,
1611 )?;
1612 Ok(IndexedScryptoValue::from_typed(&rtn))
1613 }
1614
1615 FUNGIBLE_BUCKET_PUT_EXPORT_NAME => {
1616 let input: BucketPutInput = input.as_typed().map_err(|e| {
1617 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1618 })?;
1619 let rtn = FungibleBucketBlueprint::put(input.bucket, api)?;
1620 Ok(IndexedScryptoValue::from_typed(&rtn))
1621 }
1622 FUNGIBLE_BUCKET_TAKE_EXPORT_NAME => {
1623 let input: BucketTakeInput = input.as_typed().map_err(|e| {
1624 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1625 })?;
1626 let rtn = FungibleBucketBlueprint::take(input.amount, api)?;
1627 Ok(IndexedScryptoValue::from_typed(&rtn))
1628 }
1629 FUNGIBLE_BUCKET_TAKE_ADVANCED_EXPORT_NAME => {
1630 let input: BucketTakeAdvancedInput = input.as_typed().map_err(|e| {
1631 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1632 })?;
1633 let rtn = FungibleBucketBlueprint::take_advanced(
1634 input.amount,
1635 input.withdraw_strategy,
1636 api,
1637 )?;
1638 Ok(IndexedScryptoValue::from_typed(&rtn))
1639 }
1640 FUNGIBLE_BUCKET_GET_AMOUNT_EXPORT_NAME => {
1641 let _input: BucketGetAmountInput = input.as_typed().map_err(|e| {
1642 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1643 })?;
1644
1645 let amount = FungibleBucketBlueprint::get_amount(api)?;
1646
1647 Ok(IndexedScryptoValue::from_typed(&amount))
1648 }
1649 FUNGIBLE_BUCKET_GET_RESOURCE_ADDRESS_EXPORT_NAME => {
1650 let _input: BucketGetResourceAddressInput = input.as_typed().map_err(|e| {
1651 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1652 })?;
1653 let rtn = FungibleBucketBlueprint::get_resource_address(api)?;
1654 Ok(IndexedScryptoValue::from_typed(&rtn))
1655 }
1656 FUNGIBLE_BUCKET_CREATE_PROOF_OF_AMOUNT_EXPORT_NAME => {
1657 let input: FungibleBucketCreateProofOfAmountInput =
1658 input.as_typed().map_err(|e| {
1659 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1660 })?;
1661 let rtn = FungibleBucketBlueprint::create_proof_of_amount(input.amount, api)?;
1662 Ok(IndexedScryptoValue::from_typed(&rtn))
1663 }
1664 FUNGIBLE_BUCKET_CREATE_PROOF_OF_ALL_EXPORT_NAME => {
1665 let _input: BucketCreateProofOfAllInput = input.as_typed().map_err(|e| {
1666 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1667 })?;
1668 let rtn = FungibleBucketBlueprint::create_proof_of_all(api)?;
1669 Ok(IndexedScryptoValue::from_typed(&rtn))
1670 }
1671 FUNGIBLE_BUCKET_LOCK_AMOUNT_EXPORT_NAME => {
1672 let input: FungibleBucketLockAmountInput = input.as_typed().map_err(|e| {
1673 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1674 })?;
1675 let rtn = FungibleBucketBlueprint::lock_amount(input.amount, api)?;
1676 Ok(IndexedScryptoValue::from_typed(&rtn))
1677 }
1678 FUNGIBLE_BUCKET_UNLOCK_AMOUNT_EXPORT_NAME => {
1679 let input: FungibleBucketLockAmountInput = input.as_typed().map_err(|e| {
1680 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1681 })?;
1682 let rtn = FungibleBucketBlueprint::unlock_amount(input.amount, api)?;
1683 Ok(IndexedScryptoValue::from_typed(&rtn))
1684 }
1685 NON_FUNGIBLE_BUCKET_PUT_EXPORT_NAME => {
1686 let input: BucketPutInput = input.as_typed().map_err(|e| {
1687 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1688 })?;
1689 let rtn = NonFungibleBucketBlueprint::put(input.bucket, api)?;
1690 Ok(IndexedScryptoValue::from_typed(&rtn))
1691 }
1692 NON_FUNGIBLE_BUCKET_TAKE_EXPORT_NAME => {
1693 let input: BucketTakeInput = input.as_typed().map_err(|e| {
1694 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1695 })?;
1696 let rtn = NonFungibleBucketBlueprint::take(&input.amount, api)?;
1697 Ok(IndexedScryptoValue::from_typed(&rtn))
1698 }
1699 NON_FUNGIBLE_BUCKET_TAKE_ADVANCED_EXPORT_NAME => {
1700 let input: BucketTakeAdvancedInput = input.as_typed().map_err(|e| {
1701 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1702 })?;
1703 let rtn = NonFungibleBucketBlueprint::take_advanced(
1704 &input.amount,
1705 input.withdraw_strategy,
1706 api,
1707 )?;
1708 Ok(IndexedScryptoValue::from_typed(&rtn))
1709 }
1710 NON_FUNGIBLE_BUCKET_TAKE_NON_FUNGIBLES_EXPORT_NAME => {
1711 let input: BucketTakeNonFungiblesInput = input.as_typed().map_err(|e| {
1712 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1713 })?;
1714 let rtn = NonFungibleBucketBlueprint::take_non_fungibles(&input.ids, api)?;
1715 Ok(IndexedScryptoValue::from_typed(&rtn))
1716 }
1717 NON_FUNGIBLE_BUCKET_GET_AMOUNT_EXPORT_NAME => {
1718 let _input: BucketGetAmountInput = input.as_typed().map_err(|e| {
1719 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1720 })?;
1721
1722 let amount = NonFungibleBucketBlueprint::get_amount(api)?;
1723
1724 Ok(IndexedScryptoValue::from_typed(&amount))
1725 }
1726 NON_FUNGIBLE_BUCKET_GET_RESOURCE_ADDRESS_EXPORT_NAME => {
1727 let _input: BucketGetResourceAddressInput = input.as_typed().map_err(|e| {
1728 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1729 })?;
1730 let address = NonFungibleBucketBlueprint::get_resource_address(api)?;
1731 Ok(IndexedScryptoValue::from_typed(&address))
1732 }
1733 NON_FUNGIBLE_BUCKET_CREATE_PROOF_OF_NON_FUNGIBLES_EXPORT_NAME => {
1734 let input: NonFungibleBucketCreateProofOfNonFungiblesInput =
1735 input.as_typed().map_err(|e| {
1736 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1737 })?;
1738 let rtn =
1739 NonFungibleBucketBlueprint::create_proof_of_non_fungibles(input.ids, api)?;
1740 Ok(IndexedScryptoValue::from_typed(&rtn))
1741 }
1742 NON_FUNGIBLE_BUCKET_CREATE_PROOF_OF_ALL_EXPORT_NAME => {
1743 let _input: BucketCreateProofOfAllInput = input.as_typed().map_err(|e| {
1744 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1745 })?;
1746 let rtn = NonFungibleBucketBlueprint::create_proof_of_all(api)?;
1747 Ok(IndexedScryptoValue::from_typed(&rtn))
1748 }
1749
1750 NON_FUNGIBLE_BUCKET_GET_NON_FUNGIBLE_LOCAL_IDS_EXPORT_NAME => {
1751 let _input: BucketGetNonFungibleLocalIdsInput = input.as_typed().map_err(|e| {
1752 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1753 })?;
1754 let rtn = NonFungibleBucketBlueprint::get_non_fungible_local_ids(api)?;
1755 Ok(IndexedScryptoValue::from_typed(&rtn))
1756 }
1757 NON_FUNGIBLE_BUCKET_CONTAINS_NON_FUNGIBLE_EXPORT_NAME => {
1758 let input: NonFungibleVaultContainsNonFungibleInput =
1759 input.as_typed().map_err(|e| {
1760 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1761 })?;
1762 let rtn = NonFungibleBucketBlueprint::contains_non_fungible(input.id, api)?;
1763 Ok(IndexedScryptoValue::from_typed(&rtn))
1764 }
1765 NON_FUNGIBLE_BUCKET_LOCK_NON_FUNGIBLES_EXPORT_NAME => {
1766 let input: NonFungibleBucketLockNonFungiblesInput =
1767 input.as_typed().map_err(|e| {
1768 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1769 })?;
1770 let rtn = NonFungibleBucketBlueprint::lock_non_fungibles(&input.local_ids, api)?;
1771 Ok(IndexedScryptoValue::from_typed(&rtn))
1772 }
1773 NON_FUNGIBLE_BUCKET_UNLOCK_NON_FUNGIBLES_EXPORT_NAME => {
1774 let input: NonFungibleBucketUnlockNonFungiblesInput =
1775 input.as_typed().map_err(|e| {
1776 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1777 })?;
1778 let rtn = NonFungibleBucketBlueprint::unlock_non_fungibles(input.local_ids, api)?;
1779 Ok(IndexedScryptoValue::from_typed(&rtn))
1780 }
1781
1782 WORKTOP_DROP_IDENT => WorktopBlueprint::drop(input, api),
1783 WORKTOP_PUT_IDENT => WorktopBlueprint::put(input, api),
1784 WORKTOP_TAKE_IDENT => WorktopBlueprint::take(input, api),
1785 WORKTOP_TAKE_NON_FUNGIBLES_IDENT => WorktopBlueprint::take_non_fungibles(input, api),
1786 WORKTOP_TAKE_ALL_IDENT => WorktopBlueprint::take_all(input, api),
1787 WORKTOP_ASSERT_CONTAINS_IDENT => WorktopBlueprint::assert_contains(input, api),
1788 WORKTOP_ASSERT_CONTAINS_AMOUNT_IDENT => {
1789 WorktopBlueprint::assert_contains_amount(input, api)
1790 }
1791 WORKTOP_ASSERT_CONTAINS_NON_FUNGIBLES_IDENT => {
1792 WorktopBlueprint::assert_contains_non_fungibles(input, api)
1793 }
1794
1795 WORKTOP_DRAIN_IDENT => WorktopBlueprint::drain(input, api),
1796 AUTH_ZONE_POP_EXPORT_NAME => {
1797 let _input: AuthZonePopInput = input.as_typed().map_err(|e| {
1798 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1799 })?;
1800
1801 let proof = AuthZoneBlueprint::pop(api)?;
1802
1803 Ok(IndexedScryptoValue::from_typed(&proof))
1804 }
1805 AUTH_ZONE_PUSH_EXPORT_NAME => {
1806 let input: AuthZonePushInput = input.as_typed().map_err(|e| {
1807 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1808 })?;
1809
1810 AuthZoneBlueprint::push(input.proof, api)?;
1811
1812 Ok(IndexedScryptoValue::from_typed(&()))
1813 }
1814 AUTH_ZONE_CREATE_PROOF_OF_AMOUNT_EXPORT_NAME => {
1815 let input: AuthZoneCreateProofOfAmountInput = input.as_typed().map_err(|e| {
1816 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1817 })?;
1818
1819 let proof = AuthZoneBlueprint::create_proof_of_amount(
1820 input.resource_address,
1821 input.amount,
1822 api,
1823 )?;
1824
1825 Ok(IndexedScryptoValue::from_typed(&proof))
1826 }
1827 AUTH_ZONE_CREATE_PROOF_OF_NON_FUNGIBLES_EXPORT_NAME => {
1828 let input: AuthZoneCreateProofOfNonFungiblesInput =
1829 input.as_typed().map_err(|e| {
1830 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1831 })?;
1832
1833 let proof = AuthZoneBlueprint::create_proof_of_non_fungibles(
1834 input.resource_address,
1835 input.ids,
1836 api,
1837 )?;
1838
1839 Ok(IndexedScryptoValue::from_typed(&proof))
1840 }
1841 AUTH_ZONE_CREATE_PROOF_OF_ALL_EXPORT_NAME => {
1842 let input: AuthZoneCreateProofOfAllInput = input.as_typed().map_err(|e| {
1843 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1844 })?;
1845
1846 let proof = AuthZoneBlueprint::create_proof_of_all(input.resource_address, api)?;
1847
1848 Ok(IndexedScryptoValue::from_typed(&proof))
1849 }
1850 AUTH_ZONE_DROP_PROOFS_EXPORT_NAME => {
1851 let _input: AuthZoneDropProofsInput = input.as_typed().map_err(|e| {
1852 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1853 })?;
1854
1855 AuthZoneBlueprint::drop_proofs(api)?;
1856
1857 Ok(IndexedScryptoValue::from_typed(&()))
1858 }
1859 AUTH_ZONE_DROP_SIGNATURE_PROOFS_EXPORT_NAME => {
1860 let _input: AuthZoneDropProofsInput = input.as_typed().map_err(|e| {
1861 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1862 })?;
1863
1864 AuthZoneBlueprint::drop_signature_proofs(api)?;
1865
1866 Ok(IndexedScryptoValue::from_typed(&()))
1867 }
1868 AUTH_ZONE_DROP_REGULAR_PROOFS_EXPORT_NAME => {
1869 let _input: AuthZoneDropProofsInput = input.as_typed().map_err(|e| {
1870 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1871 })?;
1872
1873 AuthZoneBlueprint::drop_regular_proofs(api)?;
1874
1875 Ok(IndexedScryptoValue::from_typed(&()))
1876 }
1877 AUTH_ZONE_DRAIN_EXPORT_NAME => {
1878 let _input: AuthZoneDrainInput = input.as_typed().map_err(|e| {
1879 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1880 })?;
1881
1882 let proofs = AuthZoneBlueprint::drain(api)?;
1883
1884 Ok(IndexedScryptoValue::from_typed(&proofs))
1885 }
1886 AUTH_ZONE_ASSERT_ACCESS_RULE_EXPORT_NAME => {
1887 let input: AuthZoneAssertAccessRuleInput = input.as_typed().map_err(|e| {
1888 RuntimeError::ApplicationError(ApplicationError::InputDecodeError(e))
1889 })?;
1890
1891 let rtn = AuthZoneBlueprint::assert_access_rule(input.rule, api)?;
1892
1893 Ok(IndexedScryptoValue::from_typed(&rtn))
1894 }
1895 _ => Err(RuntimeError::ApplicationError(
1896 ApplicationError::ExportDoesNotExist(export_name.to_string()),
1897 )),
1898 }
1899 }
1900}