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