multiversx_sc/api/
blockchain_api.rs

1use super::{HandleTypeInfo, ManagedTypeApi, ManagedTypeApiImpl, RawHandle};
2use crate::types::{
3    heap::{Address, Box, H256},
4    EsdtLocalRoleFlags,
5};
6
7pub trait BlockchainApi: ManagedTypeApi {
8    type BlockchainApiImpl: BlockchainApiImpl
9        + HandleTypeInfo<
10            ManagedBufferHandle = Self::ManagedBufferHandle,
11            BigIntHandle = Self::BigIntHandle,
12            BigFloatHandle = Self::BigFloatHandle,
13            EllipticCurveHandle = Self::EllipticCurveHandle,
14        >;
15
16    fn blockchain_api_impl() -> Self::BlockchainApiImpl;
17}
18
19/// Interface to be used by the actual smart contract code.
20///
21/// Note: contracts and the api are not mutable.
22/// They simply pass on/retrieve data to/from the protocol.
23/// When mocking the blockchain state, we use the Rc/RefCell pattern
24/// to isolate mock state mutability from the contract interface.
25pub trait BlockchainApiImpl: ManagedTypeApiImpl {
26    fn get_caller_legacy(&self) -> Address;
27
28    fn load_caller_managed(&self, dest: Self::ManagedBufferHandle) {
29        self.mb_overwrite(dest, self.get_caller_legacy().as_bytes());
30    }
31
32    fn get_sc_address_legacy(&self) -> Address;
33
34    fn load_sc_address_managed(&self, dest: Self::ManagedBufferHandle) {
35        self.mb_overwrite(dest, self.get_sc_address_legacy().as_bytes())
36    }
37
38    fn load_owner_address_managed(&self, dest: Self::ManagedBufferHandle);
39
40    fn get_shard_of_address_legacy(&self, address: &Address) -> u32;
41
42    fn get_shard_of_address(&self, address_handle: Self::ManagedBufferHandle) -> u32 {
43        let mut address = Address::zero();
44        let _ = self.mb_load_slice(address_handle, 0, address.as_mut());
45        self.get_shard_of_address_legacy(&address)
46    }
47
48    fn is_smart_contract_legacy(&self, address: &Address) -> bool;
49
50    fn is_smart_contract(&self, address_handle: Self::ManagedBufferHandle) -> bool {
51        let mut address = Address::zero();
52        let _ = self.mb_load_slice(address_handle, 0, address.as_mut());
53        self.is_smart_contract_legacy(&address)
54    }
55
56    fn load_balance_legacy(&self, dest: Self::BigIntHandle, address: &Address);
57
58    fn load_balance(&self, dest: Self::BigIntHandle, address_handle: Self::ManagedBufferHandle) {
59        let mut address = Address::zero();
60        let _ = self.mb_load_slice(address_handle, 0, address.as_mut());
61        self.load_balance_legacy(dest, &address);
62    }
63
64    fn load_state_root_hash_managed(&self, dest: Self::ManagedBufferHandle);
65
66    fn get_tx_hash_legacy(&self) -> H256;
67
68    fn load_tx_hash_managed(&self, dest: Self::ManagedBufferHandle) {
69        self.mb_overwrite(dest, self.get_tx_hash_legacy().as_bytes());
70    }
71
72    fn get_gas_left(&self) -> u64;
73
74    fn get_block_timestamp(&self) -> u64;
75
76    fn get_block_nonce(&self) -> u64;
77
78    fn get_block_round(&self) -> u64;
79
80    fn get_block_epoch(&self) -> u64;
81
82    fn load_block_random_seed_managed(&self, dest: Self::ManagedBufferHandle);
83
84    fn get_prev_block_timestamp(&self) -> u64;
85
86    fn get_prev_block_nonce(&self) -> u64;
87
88    fn get_prev_block_round(&self) -> u64;
89
90    fn get_prev_block_epoch(&self) -> u64;
91
92    fn get_prev_block_random_seed_legacy(&self) -> Box<[u8; 48]>;
93
94    fn load_prev_block_random_seed_managed(&self, dest: Self::ManagedBufferHandle) {
95        self.mb_overwrite(dest, self.get_prev_block_random_seed_legacy().as_slice());
96    }
97
98    fn get_current_esdt_nft_nonce(
99        &self,
100        address_handle: Self::ManagedBufferHandle,
101        token_id_handle: Self::ManagedBufferHandle,
102    ) -> u64;
103
104    fn load_esdt_balance(
105        &self,
106        address_handle: Self::ManagedBufferHandle,
107        token_id_handle: Self::ManagedBufferHandle,
108        nonce: u64,
109        dest: Self::BigIntHandle,
110    );
111
112    #[allow(clippy::too_many_arguments)]
113    fn managed_get_esdt_token_data(
114        &self,
115        address_handle: RawHandle,
116        token_id_handle: RawHandle,
117        nonce: u64,
118        value_handle: RawHandle,
119        properties_handle: RawHandle,
120        hash_handle: RawHandle,
121        name_handle: RawHandle,
122        attributes_handle: RawHandle,
123        creator_handle: RawHandle,
124        royalties_handle: RawHandle,
125        uris_handle: RawHandle,
126    );
127
128    fn managed_get_back_transfers(
129        &self,
130        esdt_transfer_value_handle: RawHandle,
131        call_value_handle: RawHandle,
132    );
133
134    fn check_esdt_frozen(
135        &self,
136        address_handle: Self::ManagedBufferHandle,
137        token_id_handle: Self::ManagedBufferHandle,
138        nonce: u64,
139    ) -> bool;
140
141    fn check_esdt_paused(&self, token_id_handle: Self::ManagedBufferHandle) -> bool;
142
143    fn check_esdt_limited_transfer(&self, token_id_handle: Self::ManagedBufferHandle) -> bool;
144
145    fn load_esdt_local_roles(
146        &self,
147        token_id_handle: Self::ManagedBufferHandle,
148    ) -> EsdtLocalRoleFlags;
149
150    fn managed_get_code_metadata(
151        &self,
152        address_handle: Self::ManagedBufferHandle,
153        response_handle: Self::ManagedBufferHandle,
154    );
155
156    fn managed_is_builtin_function(&self, function_name_handle: Self::ManagedBufferHandle) -> bool;
157}