Random Number Generation

bridges/centralized-ethereum/src/actors/dr_sender.rs

@@ -10,6 +10,7 @@ use serde_json::json;
 use std::{fmt, time::Duration};
 use witnet_data_structures::{
     chain::{DataRequestOutput, Hash},
+    mainnet_validations::current_active_wips,
     proto::ProtobufConvert,
     radon_error::RadonErrors,
 };
@@ -263,7 +264,7 @@ fn deserialize_and_validate_dr_bytes(
                 });
             }
 
-            validate_rad_request(&dr_output.data_request, None)
+            validate_rad_request(&dr_output.data_request, &current_active_wips())
                 .map_err(|e| DrSenderError::RadonValidation { msg: e.to_string() })?;
 
             // Check if we want to claim this data request:

bridges/centralized-ethereum/src/actors/dr_sender/tests.rs

@@ -15,29 +15,33 @@ fn deserialize_dr_not_protobuf() {
     assert_eq!(err.encode_cbor(), vec![216, 39, 129, 24, 224]);
 }
 
+fn example_request() -> RADRequest {
+    RADRequest {
+        retrieve: vec![RADRetrieve {
+            url: "http://127.0.0.1:8000".to_string(),
+            script: vec![128],
+            ..Default::default()
+        }],
+        aggregate: RADAggregate {
+            filters: vec![],
+            reducer: 3,
+        },
+        tally: RADTally {
+            filters: vec![],
+            reducer: 3,
+        },
+        time_lock: 0,
+    }
+}
+
 #[test]
 fn deserialize_dr_high_value() {
     // A minimal valid data request
     let dro = DataRequestOutput {
         witness_reward: 1_000_000,
         witnesses: 20,
         min_consensus_percentage: 51,
-        data_request: RADRequest {
-            retrieve: vec![RADRetrieve {
-                url: "http://127.0.0.1:8000".to_string(),
-                script: vec![128],
-                ..Default::default()
-            }],
-            aggregate: RADAggregate {
-                filters: vec![],
-                reducer: 3,
-            },
-            tally: RADTally {
-                filters: vec![],
-                reducer: 3,
-            },
-            time_lock: 0,
-        },
+        data_request: example_request(),
         ..Default::default()
     };
     // The cost of creating this data request is the reward (1_000_000) times the number of
@@ -60,22 +64,7 @@ fn deserialize_dr_value_overflow() {
         witness_reward: u64::MAX,
         witnesses: 20,
         min_consensus_percentage: 51,
-        data_request: RADRequest {
-            retrieve: vec![RADRetrieve {
-                url: "http://127.0.0.1:8000".to_string(),
-                script: vec![128],
-                ..Default::default()
-            }],
-            aggregate: RADAggregate {
-                filters: vec![],
-                reducer: 3,
-            },
-            tally: RADTally {
-                filters: vec![],
-                reducer: 3,
-            },
-            time_lock: 0,
-        },
+        data_request: example_request(),
         ..Default::default()
     };
 

bridges/ethereum/src/actors/claim_and_post.rs

@@ -22,6 +22,7 @@ use web3::{contract, futures::Future, types::U256};
 use witnet_crypto::hash::{calculate_sha256, Sha256};
 use witnet_data_structures::{
     chain::{DataRequestOutput, Hashable, KeyedSignature},
+    mainnet_validations::current_active_wips,
     proto::ProtobufConvert,
 };
 use witnet_util::timestamp::get_local_timestamp;
@@ -97,7 +98,7 @@ fn try_to_claim_local_query(
 
                 let dr_output: DataRequestOutput =
                     match ProtobufConvert::from_pb_bytes(&dr_bytes).and_then(|dr: DataRequestOutput| {
-                        validate_rad_request(&dr.data_request, None)?;
+                        validate_rad_request(&dr.data_request, &current_active_wips())?;
                         Ok(dr)
                     }) {
                         Ok(x) => {

data_structures/src/chain.rs

@@ -1584,14 +1584,21 @@ impl Hashable for Bn256Signature {
 /// Retrieval type
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize, Hash)]
 pub enum RADType {
+    /// Unknown
+    #[serde(rename = "Unknown")]
+    Unknown,
     /// HTTP GET request
     #[serde(rename = "HTTP-GET")]
     HttpGet,
+    /// Random number generation
+    #[serde(rename = "RNG")]
+    Rng,
 }
 
 impl Default for RADType {
     fn default() -> Self {
-        RADType::HttpGet
+        // TODO: Use RadType::HttpGet after WIP-0019 activation
+        RADType::Unknown
     }
 }
 

data_structures/src/data_request.rs

@@ -1,5 +1,7 @@
-use std::collections::{BTreeMap, HashMap, HashSet};
-use std::convert::TryFrom;
+use std::{
+    collections::{BTreeMap, HashMap, HashSet},
+    convert::TryFrom,
+};
 
 use serde::{Deserialize, Serialize};
 
@@ -13,6 +15,7 @@ use crate::{
     radon_report::{RadonReport, Stage, TypeLike},
     transaction::{CommitTransaction, DRTransaction, RevealTransaction, TallyTransaction},
 };
+use witnet_crypto::hash::calculate_sha256;
 
 /// Pool of active data requests
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
@@ -56,10 +59,21 @@ impl DataRequestPool {
     }
 
     /// Get all reveals related to a `DataRequestOuput`
-    pub fn get_reveals(&self, dr_pointer: &Hash) -> Option<Vec<&RevealTransaction>> {
+    pub fn get_reveals(
+        &self,
+        dr_pointer: &Hash,
+        active_wips: &ActiveWips,
+    ) -> Option<Vec<&RevealTransaction>> {
         self.data_request_pool.get(dr_pointer).map(|dr_state| {
             let mut reveals: Vec<&RevealTransaction> = dr_state.info.reveals.values().collect();
-            reveals.sort_unstable_by_key(|reveal| reveal.body.pkh);
+            if active_wips.wip0019() {
+                // As specified in (7) in WIP-0019
+                reveals.sort_unstable_by_key(|reveal| {
+                    concatenate_and_hash(&reveal.body.pkh.hash, dr_pointer.as_ref())
+                });
+            } else {
+                reveals.sort_unstable_by_key(|reveal| reveal.body.pkh);
+            }
 
             reveals
         })
@@ -71,14 +85,25 @@ impl DataRequestPool {
     }
 
     /// Get all the reveals
-    pub fn get_all_reveals(&self) -> HashMap<Hash, Vec<RevealTransaction>> {
+    pub fn get_all_reveals(
+        &self,
+        active_wips: &ActiveWips,
+    ) -> HashMap<Hash, Vec<RevealTransaction>> {
         self.data_request_pool
             .iter()
             .filter_map(|(dr_pointer, dr_state)| {
                 if let DataRequestStage::TALLY = dr_state.stage {
                     let mut reveals: Vec<RevealTransaction> =
                         dr_state.info.reveals.values().cloned().collect();
-                    reveals.sort_unstable_by_key(|reveal| reveal.body.pkh);
+
+                    if active_wips.wip0019() {
+                        // As specified in (7) in WIP-0019
+                        reveals.sort_unstable_by_key(|reveal| {
+                            concatenate_and_hash(&reveal.body.pkh.hash, dr_pointer.as_ref())
+                        });
+                    } else {
+                        reveals.sort_unstable_by_key(|reveal| reveal.body.pkh);
+                    }
 
                     Some((*dr_pointer, reveals))
                 } else {
@@ -393,6 +418,15 @@ impl DataRequestPool {
     }
 }
 
+/// Concatenate 2 bytes sequences and hash
+fn concatenate_and_hash(a: &[u8], b: &[u8]) -> [u8; 32] {
+    let mut bytes_to_hash = vec![];
+    bytes_to_hash.extend(a);
+    bytes_to_hash.extend(b);
+
+    calculate_sha256(bytes_to_hash.as_ref()).0
+}
+
 /// Return the change that should be returned to the creator of the data request if
 /// some witness fails to commit, fails to reveal, or reports a value out of consensus.
 /// If the change is 0, the change `ValueTransferOutput` should not be created

data_structures/src/error.rs

@@ -485,6 +485,8 @@ pub enum DataRequestError {
     UnfinishedDataRequest,
     #[fail(display = "The data request is not valid since it has no retrieval sources")]
     NoRetrievalSources,
+    #[fail(display = "The data request has not a valid RadType")]
+    InvalidRadType,
 }
 
 /// Possible errors when converting between epoch and timestamp

data_structures/src/mainnet_validations.rs

@@ -61,6 +61,26 @@ fn test_wip_info() -> HashMap<String, Epoch> {
     active_wips
 }
 
+/// Auxiliary function that returns the current active wips for using in RADON
+/// It is only used for testing or for external libraries, so we set epoch to MAX
+pub fn current_active_wips() -> ActiveWips {
+    ActiveWips {
+        active_wips: wip_info(),
+        block_epoch: u32::MAX,
+    }
+}
+
+/// Auxiliary function that returns the current active wips and the WIPs in voting process as actived
+/// It is only used for testing
+pub fn all_wips_active() -> ActiveWips {
+    let mut active_wips = current_active_wips();
+    active_wips
+        .active_wips
+        .insert("WIP0017-0018-0019".to_string(), 0);
+
+    active_wips
+}
+
 impl TapiEngine {
     pub fn update_bit_counter(
         &mut self,
@@ -681,7 +701,7 @@ mod tests {
 
         // Test initialize_wip_information with a non-empty TapiEngine
         let (epoch, old_wips) = t.initialize_wip_information(Environment::Mainnet);
-        // WIP0017 is already included and it won't be updated
+        // WIP0017-18-19 is already included and it won't be updated
         let name_wip0017_18_19 = "WIP0017-0018-0019".to_string();
         let mut hs = HashSet::new();
         hs.insert(name_wip0017_18_19);

data_structures/src/proto/mod.rs

@@ -47,13 +47,17 @@ impl ProtobufConvert for chain::RADType {
 
     fn to_pb(&self) -> Self::ProtoStruct {
         match self {
+            chain::RADType::Unknown => witnet::DataRequestOutput_RADRequest_RADType::Unknown,
             chain::RADType::HttpGet => witnet::DataRequestOutput_RADRequest_RADType::HttpGet,
+            chain::RADType::Rng => witnet::DataRequestOutput_RADRequest_RADType::Rng,
         }
     }
 
     fn from_pb(pb: Self::ProtoStruct) -> Result<Self, Error> {
         Ok(match pb {
+            witnet::DataRequestOutput_RADRequest_RADType::Unknown => chain::RADType::Unknown,
             witnet::DataRequestOutput_RADRequest_RADType::HttpGet => chain::RADType::HttpGet,
+            witnet::DataRequestOutput_RADRequest_RADType::Rng => chain::RADType::Rng,
         })
     }
 }

examples/random_bytes.json

@@ -0,0 +1 @@
+{"jsonrpc":"2.0","method":"sendRequest","id":"1","params":{"dro":{"data_request":{"time_lock":0,"retrieve":[{"kind":"RNG","url":"","script":[128]}],"aggregate":{"filters":[],"reducer":2},"tally":{"filters":[],"reducer":11}},"witness_reward":1000,"witnesses":5,"commit_and_reveal_fee":10,"min_consensus_percentage":51,"collateral":1000000000},"fee":0}}

node/src/actors/chain_manager/handlers.rs

@@ -11,7 +11,7 @@ use std::{
 use witnet_data_structures::{
     chain::{
         Block, ChainState, CheckpointBeacon, DataRequestInfo, Epoch, Hash, Hashable, NodeStats,
-        SuperBlockVote, SupplyInfo,
+        RADType, SuperBlockVote, SupplyInfo,
     },
     error::{ChainInfoError, TransactionError::DataRequestNotFound},
     mainnet_validations::ActiveWips,
@@ -1277,13 +1277,26 @@ impl Handler<BuildDrt> for ChainManager {
             block_epoch: self.current_epoch.unwrap(),
         };
 
-        if let Err(e) = validate_rad_request(&msg.dro.data_request, Some(&active_wips)) {
+        let mut dr_output = msg.dro;
+        // TODO: Remove after WIP-0019 activation
+        // Before wip-0019 activation, RadType::HttpGet enum is serialized with a 0.
+        // With the new update, position 0 is RadType::Unknown, so to keep backward compatibility,
+        // we need to convert HttpGet retrievals to Unknown.
+        if !active_wips.wip0019() {
+            for retrieval in &mut dr_output.data_request.retrieve {
+                if retrieval.kind == RADType::HttpGet {
+                    retrieval.kind = RADType::Unknown;
+                }
+            }
+        }
+
+        if let Err(e) = validate_rad_request(&dr_output.data_request, &active_wips) {
             return Box::pin(actix::fut::err(e));
         }
         let timestamp = u64::try_from(get_timestamp()).unwrap();
         let max_dr_weight = self.consensus_constants().max_dr_weight;
         match transaction_factory::build_drt(
-            msg.dro,
+            dr_output,
             msg.fee,
             &mut self.chain_state.own_utxos,
             self.own_pkh.unwrap(),