radix_native_sdk/runtime/
runtime.rs

1use radix_common::constants::CONSENSUS_MANAGER;
2use radix_common::data::scrypto::*;
3use radix_common::time::*;
4use radix_common::traits::ScryptoEvent;
5use radix_common::types::{NodeId, PackageAddress};
6use radix_engine_interface::api::actor_api::EventFlags;
7use radix_engine_interface::api::*;
8use radix_engine_interface::blueprints::consensus_manager::*;
9use radix_engine_interface::blueprints::resource::{
10    AccessRule, AuthZoneAssertAccessRuleInput, AUTH_ZONE_ASSERT_ACCESS_RULE_IDENT,
11};
12use radix_engine_interface::types::Epoch;
13use sbor::rust::prelude::*;
14
15#[derive(Debug)]
16pub struct Runtime {}
17
18impl Runtime {
19    pub fn emit_event<
20        Y: SystemApi<E>,
21        E: SystemApiError,
22        T: ScryptoEncode + ScryptoDescribe + ScryptoEvent,
23    >(
24        api: &mut Y,
25        event: T,
26    ) -> Result<(), E> {
27        api.actor_emit_event(
28            T::EVENT_NAME.to_string(),
29            scrypto_encode(&event).unwrap(),
30            EventFlags::empty(),
31        )
32    }
33
34    pub fn emit_event_no_revert<
35        Y: SystemApi<E>,
36        E: SystemApiError,
37        T: ScryptoEncode + ScryptoDescribe + ScryptoEvent,
38    >(
39        api: &mut Y,
40        event: T,
41    ) -> Result<(), E> {
42        api.actor_emit_event(
43            T::EVENT_NAME.to_string(),
44            scrypto_encode(&event).unwrap(),
45            EventFlags::FORCE_WRITE,
46        )
47    }
48
49    pub fn current_epoch<Y: SystemObjectApi<E>, E: SystemApiError>(
50        api: &mut Y,
51    ) -> Result<Epoch, E> {
52        let rtn = api.call_method(
53            CONSENSUS_MANAGER.as_node_id(),
54            CONSENSUS_MANAGER_GET_CURRENT_EPOCH_IDENT,
55            scrypto_encode(&ConsensusManagerGetCurrentEpochInput).unwrap(),
56        )?;
57
58        Ok(scrypto_decode(&rtn).unwrap())
59    }
60
61    pub fn current_time<Y: SystemObjectApi<E>, E: SystemApiError>(
62        precision: TimePrecision,
63        api: &mut Y,
64    ) -> Result<Instant, E> {
65        let rtn = api.call_method(
66            CONSENSUS_MANAGER.as_node_id(),
67            CONSENSUS_MANAGER_GET_CURRENT_TIME_IDENT,
68            scrypto_encode(&ConsensusManagerGetCurrentTimeInputV2 { precision }).unwrap(),
69        )?;
70
71        Ok(scrypto_decode(&rtn).unwrap())
72    }
73
74    pub fn compare_against_current_time<Y: SystemObjectApi<E>, E: SystemApiError>(
75        instant: Instant,
76        precision: TimePrecision,
77        operator: TimeComparisonOperator,
78        api: &mut Y,
79    ) -> Result<bool, E> {
80        let rtn = api.call_method(
81            CONSENSUS_MANAGER.as_node_id(),
82            CONSENSUS_MANAGER_COMPARE_CURRENT_TIME_IDENT,
83            scrypto_encode(&ConsensusManagerCompareCurrentTimeInputV2 {
84                precision,
85                instant,
86                operator,
87            })
88            .unwrap(),
89        )?;
90
91        Ok(scrypto_decode(&rtn).unwrap())
92    }
93
94    pub fn generate_ruid<Y: SystemApi<E>, E: SystemApiError>(api: &mut Y) -> Result<[u8; 32], E> {
95        api.generate_ruid()
96    }
97
98    pub fn assert_access_rule<Y: SystemApi<E>, E: SystemApiError>(
99        rule: AccessRule,
100        api: &mut Y,
101    ) -> Result<(), E> {
102        let auth_zone = api.actor_get_node_id(ACTOR_REF_AUTH_ZONE)?;
103        let _rtn = api.call_method(
104            &auth_zone,
105            AUTH_ZONE_ASSERT_ACCESS_RULE_IDENT,
106            scrypto_encode(&AuthZoneAssertAccessRuleInput { rule }).unwrap(),
107        )?;
108
109        Ok(())
110    }
111
112    pub fn get_node_id<Y: SystemApi<E>, E: SystemApiError>(api: &mut Y) -> Result<NodeId, E> {
113        api.actor_get_node_id(ACTOR_REF_SELF)
114    }
115
116    pub fn package_address<Y: SystemApi<E>, E: SystemApiError>(
117        api: &mut Y,
118    ) -> Result<PackageAddress, E> {
119        api.actor_get_blueprint_id().map(|x| x.package_address)
120    }
121}
radix_native_sdk/runtime/runtime.rs

radix_native_sdk/runtime/
runtime.rs
