multiversx_sc_modules/
default_issue_callbacks.rs

1use multiversx_sc::{storage::StorageKey, storage_clear, storage_set};
2
3multiversx_sc::imports!();
4multiversx_sc::derive_imports!();
5
6// Always keep in sync with the token-related storage mappers. Only modify if really necessary.
7#[multiversx_sc::module]
8pub trait DefaultIssueCallbacksModule {
9    #[callback]
10    fn default_issue_cb(
11        &self,
12        initial_caller: ManagedAddress,
13        storage_key: ManagedBuffer,
14        #[call_result] result: ManagedAsyncCallResult<TokenIdentifier>,
15    ) {
16        let key = StorageKey::from(storage_key);
17        match result {
18            ManagedAsyncCallResult::Ok(token_id) => {
19                storage_set(key.as_ref(), &TokenMapperState::Token(token_id));
20            },
21            ManagedAsyncCallResult::Err(_) => {
22                self.return_failed_issue_funds(initial_caller);
23                storage_clear(key.as_ref());
24            },
25        }
26    }
27
28    #[callback]
29    fn default_issue_init_supply_cb(
30        &self,
31        initial_caller: ManagedAddress,
32        storage_key: ManagedBuffer,
33        #[call_result] result: ManagedAsyncCallResult<()>,
34    ) {
35        let key = StorageKey::from(storage_key);
36        match result {
37            ManagedAsyncCallResult::Ok(()) => {
38                let token_id = self.call_value().single_esdt().token_identifier.clone();
39                storage_set(key.as_ref(), &TokenMapperState::Token(token_id));
40            },
41            ManagedAsyncCallResult::Err(_) => {
42                self.return_failed_issue_funds(initial_caller);
43                storage_clear(key.as_ref());
44            },
45        }
46    }
47
48    fn return_failed_issue_funds(&self, initial_caller: ManagedAddress) {
49        let egld_returned = self.call_value().egld_direct_non_strict();
50        if *egld_returned > 0u64 {
51            self.tx().to(&initial_caller).egld(egld_returned).transfer();
52        }
53    }
54}