[core,model] Add ext_random_seed runtime call bindings

core/src/env/api.rs

@@ -31,6 +31,9 @@ pub type Address = <ContractEnv as EnvTypes>::Address;
 /// The environmental balance type.
 pub type Balance = <ContractEnv as EnvTypes>::Balance;
 
+/// The environmental hash type.
+pub type Hash = <ContractEnv as EnvTypes>::Hash;
+
 /// Returns the address of the caller of the current smart contract execution.
 pub fn caller() -> Address {
     ContractEnv::caller()
@@ -41,6 +44,11 @@ pub fn input() -> Vec<u8> {
     ContractEnv::input()
 }
 
+/// Returns the latest block RNG seed
+pub fn random_seed() -> Hash {
+    ContractEnv::random_seed()
+}
+
 /// Returns the current smart contract exection back to the caller
 /// and return the given encoded value.
 ///

core/src/env/srml/mod.rs

@@ -22,6 +22,7 @@ mod types;
 pub use self::types::{
     Address,
     Balance,
+    Hash,
     DefaultSrmlTypes,
 };
 

core/src/env/srml/srml_only/impls.rs

@@ -46,6 +46,7 @@ where
 {
     type Address = <T as EnvTypes>::Address;
     type Balance = <T as EnvTypes>::Balance;
+    type Hash = <T as EnvTypes>::Hash;
 }
 
 impl<T> EnvStorage for SrmlEnv<T>
@@ -88,6 +89,7 @@ impl<T> Env for SrmlEnv<T>
 where
     T: EnvTypes,
     <T as EnvTypes>::Address: for<'a> From<&'a [u8]>,
+    <T as EnvTypes>::Hash: for<'a> From<&'a [u8]>,
 {
     fn caller() -> <Self as EnvTypes>::Address {
         unsafe { sys::ext_caller() };
@@ -116,13 +118,24 @@ where
         }
     }
 
+    fn random_seed() -> <Self as EnvTypes>::Hash {
+        unsafe { sys::ext_random_seed() };
+        let size = unsafe { sys::ext_scratch_size() };
+        let mut value = Vec::new();
+        if size > 0 {
+            value.resize(size as usize, 0);
+            unsafe {
+                sys::ext_scratch_copy(value.as_mut_ptr() as u32, 0, size);
+            }
+        }
+        value
+    }
+
     unsafe fn r#return(data: &[u8]) -> ! {
         sys::ext_return(data.as_ptr() as u32, data.len() as u32);
     }
 
     fn println(content: &str) {
-        unsafe {
-            sys::ext_println(content.as_ptr() as u32, content.len() as u32)
-        }
+        unsafe { sys::ext_println(content.as_ptr() as u32, content.len() as u32) }
     }
 }

core/src/env/srml/types.rs

@@ -26,6 +26,7 @@ pub struct DefaultSrmlTypes;
 impl EnvTypes for DefaultSrmlTypes {
     type Address = self::Address;
     type Balance = self::Balance;
+    type Hash = self::Hash;
 }
 
 /// The default SRML address type.
@@ -44,3 +45,17 @@ impl<'a> From<&'a [u8]> for Address {
 
 /// The default SRML balance type.
 pub type Balance = u64;
+
+/// The default SRML hash type.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Encode, Decode)]
+pub struct Hash([u8; 32]);
+
+impl<'a> From<&'a [u8]> for Hash {
+    fn from(bytes: &'a [u8]) -> Self {
+        assert_eq!(bytes.len(), 32);
+        let mut array = [0; 32];
+        let bytes = &bytes[..array.len()]; // panics if not enough data
+        array.copy_from_slice(bytes);
+        Hash(array)
+    }
+}

core/src/env/test_env.rs

@@ -110,6 +110,12 @@ pub struct TestEnvData {
     ///
     /// The current input can be adjusted by `TestEnvData::set_input`.
     input: Vec<u8>,
+    /// The random seed for the next contract invocation.
+    ///
+    ///  # Note
+    ///
+    /// The current random seed can be adjusted by `TestEnvData::set_random_seed`.
+    random_seed: Vec<u8>,
     /// The expected return data of the next contract invocation.
     ///
     /// # Note
@@ -128,6 +134,7 @@ impl Default for TestEnvData {
             storage: HashMap::new(),
             caller: vec![0x0; 32],
             input: Vec::new(),
+            random_seed: vec![0x0, 32],
             expected_return: Vec::new(),
             total_reads: Cell::new(0),
             total_writes: 0,
@@ -141,6 +148,7 @@ impl TestEnvData {
         self.storage.clear();
         self.caller.clear();
         self.input.clear();
+        self.random_seed.clear();
         self.expected_return.clear();
         self.total_reads.set(0);
         self.total_writes = 0;
@@ -190,6 +198,11 @@ impl TestEnvData {
     pub fn set_input(&mut self, input_bytes: &[u8]) {
         self.input = input_bytes.to_vec();
     }
+
+    /// Sets the random seed for the next contract invocation.
+    pub fn set_random_seed(&mut self, random_seed_bytes: &[u8]) {
+        self.random_seed = random_seed_bytes.to_vec();
+    }
 }
 
 impl TestEnvData {
@@ -242,6 +255,11 @@ impl TestEnvData {
         self.input.clone()
     }
 
+    /// Returns the random seed for the contract invocation.
+    pub fn random_seed(&self) -> srml::Hash {
+        srml::Hash::from(self.random_seed.as_slice())
+    }
+
     /// Returns the data to the internal caller.
     ///
     /// # Note
@@ -319,13 +337,20 @@ impl TestEnv {
     pub fn set_input(input_bytes: &[u8]) {
         TEST_ENV_DATA.with(|test_env| test_env.borrow_mut().set_input(input_bytes))
     }
+
+    /// Sets the random seed for the next contract invocation.
+    pub fn set_random_seed(random_seed_bytes: &[u8]) {
+        TEST_ENV_DATA
+            .with(|test_env| test_env.borrow_mut().set_random_seed(random_seed_bytes))
+    }
 }
 
 const TEST_ENV_LOG_TARGET: &str = "test-env";
 
 impl EnvTypes for TestEnv {
     type Address = srml::Address;
     type Balance = srml::Balance;
+    type Hash = srml::Hash;
 }
 
 impl EnvStorage for TestEnv {
@@ -361,6 +386,8 @@ impl EnvStorage for TestEnv {
 impl Env for TestEnv
 where
     <Self as EnvTypes>::Address: for<'a> From<&'a [u8]>,
+    <Self as EnvTypes>::Hash: for<'a> From<&'a [u8]>,
+
 {
     fn caller() -> <Self as EnvTypes>::Address {
         log::debug!(target: TEST_ENV_LOG_TARGET, "TestEnv::caller()");
@@ -372,6 +399,11 @@ where
         TEST_ENV_DATA.with(|test_env| test_env.borrow().input())
     }
 
+    fn random_seed() -> <Self as EnvTypes>::Hash {
+        log::debug!(target: TEST_ENV_LOG_TARGET, "TestEnv::random_seed()",);
+        TEST_ENV_DATA.with(|test_env| test_env.borrow().random_seed())
+    }
+
     unsafe fn r#return(data: &[u8]) -> ! {
         log::debug!(
             target: TEST_ENV_LOG_TARGET,

core/src/env/traits.rs

@@ -26,6 +26,8 @@ pub trait EnvTypes {
     type Address: Codec + PartialEq + Eq;
     /// The type of balances.
     type Balance: Codec;
+    /// The type of hash.
+    type Hash: Codec;
 }
 
 /// Types implementing this can act as contract storage.
@@ -63,6 +65,9 @@ pub trait Env: EnvTypes + EnvStorage {
     /// Loads input data for contract execution.
     fn input() -> Vec<u8>;
 
+    /// Get the latest block RNG seed
+    fn random_seed() -> <Self as EnvTypes>::Hash;
+
     /// Returns from the contract execution with the given value.
     ///
     /// # Safety