randomoracle 4.0.3

A Rust package for implementing a random oracle by DiaData.
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#![cfg_attr(not(feature = "std"), no_std)]

use ink::prelude::vec::Vec;

pub use crate::randomoracle::{
    RandomOracle,
    RandomOracleRef,
};

#[ink::trait_definition]
pub trait IRandomOracle {

    #[ink(message)]
    fn get_random_value_for_round(&self, round: Vec<u8>) -> Vec<u8>;
 
    #[ink(message)]
     fn get_last_round(&self) -> Vec<u8>;
}

#[derive(PartialEq, Debug, Clone, scale::Encode, scale::Decode)]
#[cfg_attr(
    feature = "std",
    derive(scale_info::TypeInfo, ::ink::storage::traits::StorageLayout)
)]

pub struct RandomData {
    randomness: Vec<u8>,
    signature: Vec<u8>,
    previous_signature: Vec<u8>,
}

#[ink::contract]
pub mod randomoracle {
    use super::*;
    pub use crate::RandomData;

    use ink::storage::Mapping;

    #[ink(storage)]

    pub struct RandomOracle {
        value: Mapping<Vec<u8>, RandomData>,
        owner: AccountId,
        last_round: Vec<u8>,

    }

    impl RandomOracle {
        #[ink(constructor)]
        pub fn new() -> Self {
            Self {
                value: Mapping::default(),
                owner: Self::env().caller(),
                last_round: Vec::default(),
            }
        }

        #[ink(message)]
        pub fn set_random_value(
            &mut self,
            round: Vec<u8>,
            randomness: Vec<u8>,
            signature: Vec<u8>,
            previous_signature: Vec<u8>,
        ) {
            let caller = Self::env().caller();
            assert_eq!(caller, self.owner);
            self.last_round = round.clone();
            self.value.insert(
                round,
                &RandomData {
                    randomness: randomness,
                    signature: signature,
                    previous_signature: previous_signature,
                },
            );
        }

        #[ink(message)]
        pub fn get_round(&self, round: Vec<u8>) -> Option<RandomData> {
            if let Some(random_data) = self.value.get(round) {
                Some(random_data.clone())
            } else {
                None
            }
        }
    }

    impl IRandomOracle for RandomOracle {

        #[ink(message)]
          fn get_random_value_for_round(&self, round: Vec<u8>) -> Vec<u8> {
            return self.value.get(round).unwrap().randomness.clone();
        }


        #[ink(message)]
          fn get_last_round(&self) -> Vec<u8> {
            return self.last_round.clone();
        }
    }
    #[cfg(test)]
    mod tests {
        use super::*;

        #[ink::test]
        fn test_all() {
            let mut contract = RandomOracle::new();
            let round_invalid = vec![1u8, 1, 3];

            let round = vec![1u8, 2, 3];
            let randomness = vec![4u8, 5, 6];
            let signature = vec![7u8, 8, 9];
            let previous_signature = vec![10u8, 11, 12];
            contract.set_random_value(round.clone(), randomness.clone(), signature.clone(), previous_signature.clone());

            assert_eq!(contract.get_random_value_for_round(round.clone()), randomness);
            contract.get_round(round_invalid.clone());
            assert_eq!(contract.get_last_round(), round);
        }
    }
}