nexus-sdk 2.0.0

Rust SDK for Nexus protocol types, RPC access, and transaction construction.
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
98
99
100
101
102
103
104
105
106

//! Map helpers for generated port data values.
//!
//! Move stores ports as [`crate::move_bindings::sui_framework::vec_map::VecMap`] entries keyed by
//! generated [`crate::move_bindings::interface::graph::InputPort`] and
//! [`crate::move_bindings::interface::graph::OutputPort`] values. SDK callers usually operate on
//! [`std::collections::HashMap`] names, so this module projects both stored
//! [`crate::move_bindings::primitives::data::NexusData`] values.

use {
    crate::move_bindings::{
        interface::graph::{InputPort, OutputPort},
        move_std::ascii::String as MoveString,
        primitives::data::NexusData,
        sui_framework::vec_map::{Entry as VecMapEntry, VecMap},
    },
    std::collections::HashMap,
};

impl VecMap<InputPort, NexusData> {
    pub fn into_map(self) -> HashMap<String, NexusData> {
        self.contents
            .into_iter()
            .map(|entry| (String::from(entry.key.name), entry.value))
            .collect()
    }

    pub fn from_map(values: HashMap<String, NexusData>) -> Self {
        Self {
            contents: values
                .into_iter()
                .map(|(key, value)| VecMapEntry {
                    key: InputPort {
                        name: MoveString::from(key),
                    },
                    value,
                })
                .collect(),
        }
    }
}

impl VecMap<OutputPort, NexusData> {
    pub fn into_map(self) -> HashMap<String, NexusData> {
        self.contents
            .into_iter()
            .map(|entry| (String::from(entry.key.name), entry.value))
            .collect()
    }

    pub fn from_map(values: HashMap<String, NexusData>) -> Self {
        Self {
            contents: values
                .into_iter()
                .map(|(key, value)| VecMapEntry {
                    key: OutputPort {
                        name: MoveString::from(key),
                    },
                    value,
                })
                .collect(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn inline_bytes(value: &'static [u8]) -> NexusData {
        NexusData::inline_data(value).expect("fixture is bounded")
    }

    fn sample_ports_data() -> VecMap<InputPort, NexusData> {
        let mut values = HashMap::new();
        values.insert("port1".to_string(), inline_bytes(b"port-value"));
        VecMap::<InputPort, NexusData>::from_map(values)
    }

    #[test]
    fn test_bcs_roundtrip_ports_data() {
        let ports_data = sample_ports_data();
        let bytes = bcs::to_bytes(&ports_data).unwrap();
        let decoded: VecMap<InputPort, NexusData> = bcs::from_bytes(&bytes).unwrap();
        assert_eq!(decoded, ports_data);
        assert_eq!(
            decoded.contents[0].value.inline_data_bytes(),
            Some(b"port-value".to_vec())
        );
    }

    #[test]
    fn test_into_map_returns_inner_hashmap() {
        let ports_data = sample_ports_data();
        let map = ports_data.clone().into_map();

        assert_eq!(map.len(), 1);
        assert_eq!(map.get("port1").unwrap(), &inline_bytes(b"port-value"));
    }

    #[test]
    fn test_into_map_empty_ports_data() {
        let ports_data = VecMap::<InputPort, NexusData>::from_map(HashMap::new());
        let map = ports_data.into_map();
        assert!(map.is_empty());
    }
}