radix-engine 1.3.1

Reference implementation of Radix Engine, from the Radix DLT project.
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

use radix_common::ScryptoSbor;

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
#[repr(u8)]
pub enum ScryptoVmVersion {
    V1_0,
    V1_1,
    V1_2,
}

impl ScryptoVmVersion {
    pub const fn latest() -> ScryptoVmVersion {
        Self::cuttlefish()
    }

    pub const fn babylon_genesis() -> ScryptoVmVersion {
        Self::V1_0
    }

    pub const fn anemone() -> ScryptoVmVersion {
        Self::V1_1
    }

    pub const fn cuttlefish() -> ScryptoVmVersion {
        Self::V1_2
    }

    pub const fn crypto_utils_v1() -> ScryptoVmVersion {
        Self::V1_1
    }

    pub const fn crypto_utils_v2() -> ScryptoVmVersion {
        Self::V1_2
    }
}

impl From<ScryptoVmVersion> for u64 {
    fn from(version: ScryptoVmVersion) -> Self {
        version as u64
    }
}

impl TryFrom<u64> for ScryptoVmVersion {
    type Error = ScryptoVmVersionError;

    fn try_from(version: u64) -> Result<Self, Self::Error> {
        match version {
            0 => Ok(Self::V1_0),
            1 => Ok(Self::V1_1),
            2 => Ok(Self::V1_2),
            v => Err(Self::Error::FromIntError(v)),
        }
    }
}

#[derive(Debug, Clone, Eq, PartialEq, ScryptoSbor)]
pub enum ScryptoVmVersionError {
    FromIntError(u64),
}

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

    #[test]
    fn test_scrypto_vm_version() {
        let v = ScryptoVmVersion::latest();
        assert_eq!(v, ScryptoVmVersion::V1_2);
        assert_eq!(ScryptoVmVersion::crypto_utils_v1(), ScryptoVmVersion::V1_1);
    }

    #[test]
    fn test_scrypto_vm_version_conversions() {
        let v: u64 = ScryptoVmVersion::V1_1.into();
        assert_eq!(v, 1);

        let v: ScryptoVmVersion = 1u64.try_into().unwrap();
        assert_eq!(v, ScryptoVmVersion::V1_1);

        let e = ScryptoVmVersion::try_from(3u64).unwrap_err();

        assert_eq!(e, ScryptoVmVersionError::FromIntError(3u64));
    }

    #[test]
    fn test_scrypto_vm_version_ordering() {
        assert!(ScryptoVmVersion::crypto_utils_v1() == ScryptoVmVersion::V1_1);
        assert!(ScryptoVmVersion::crypto_utils_v1() > ScryptoVmVersion::V1_0);
        assert!(ScryptoVmVersion::crypto_utils_v1() < ScryptoVmVersion::crypto_utils_v2());
    }
}