drt_sc_modules/
default_issue_callbacks.rs

1use drt_sc::{storage::StorageKey, storage_clear, storage_set};
2
3drt_sc::imports!();
4drt_sc::derive_imports!();
5
6// Always keep in sync with the token-related storage mappers. Only modify if really necessary.
7#[drt_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_dcdt().token_identifier;
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 rewa_returned = self.call_value().rewa_value().to_u64().unwrap();
50        if rewa_returned > 0u64 {
51            self.tx().to(&initial_caller).rewa(rewa_returned).transfer();
52        }
53    }
54}