canic-cdk 0.25.3

Canic — a canister orchestration and management toolkit for the Internet Computer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! Internal macro to expose static `Principal` handles for known canisters.
//! Data lives in `.inc.rs` files and is shared with build.rs via include!().

macro_rules! static_canisters {
    ($($name:ident = $id:expr;)+) => {
        $(
            pub static $name: ::std::sync::LazyLock<::candid::Principal> =
                ::std::sync::LazyLock::new(|| {
                    ::candid::Principal::from_text($id)
                        .expect("principal literal validated by build.rs")
                });
        )+
    }
}

macro_rules! sns_table {
    (
        $(
            $name:ident {
                root: $root:expr,
                governance: $gov:expr,
                index: $idx:expr,
                ledger: $led:expr $(,)?
            }
        ),+ $(,)?
    ) => {
        ///
        /// SnsType
        ///
        #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
        pub enum SnsType {
            $($name,)+
        }

        impl SnsType {
            fn canisters(self) -> &'static SnsCanisters {
                SNS_CANISTERS
                    .get_or_init(init_sns_canisters)
                    .get(&self)
                    .expect("SNS canister table missing entry")
            }

            #[must_use]
            pub fn principal(self, role: SnsRole) -> Principal {
                let set = self.canisters();
                match role {
                    SnsRole::Root => set.root,
                    SnsRole::Governance => set.governance,
                    SnsRole::Index => set.index,
                    SnsRole::Ledger => set.ledger,
                }
            }

            #[must_use]
            pub fn root(self) -> Principal {
                self.canisters().root
            }

            #[must_use]
            pub fn governance(self) -> Principal {
                self.canisters().governance
            }

            #[must_use]
            pub fn index(self) -> Principal {
                self.canisters().index
            }

            #[must_use]
            pub fn ledger(self) -> Principal {
                self.canisters().ledger
            }
        }

        /// Alias to enable access like `SNS::OpenChat.ledger()`.
        pub type SNS = SnsType;

        static SNS_CANISTERS: OnceLock<HashMap<SnsType, SnsCanisters>> = OnceLock::new();

        fn init_sns_canisters() -> HashMap<SnsType, SnsCanisters> {
            let mut map = HashMap::new();
            $(
                map.insert(
                    SnsType::$name,
                    SnsCanisters {
                        root: parse_principal(SnsType::$name, "root", $root),
                        governance: parse_principal(SnsType::$name, "governance", $gov),
                        index: parse_principal(SnsType::$name, "index", $idx),
                        ledger: parse_principal(SnsType::$name, "ledger", $led),
                    },
                );
            )+
            map
        }

    };
}