Impelment vrf hash generator to EngineSigner

Author: HoOngEe

core/src/account_provider.rs

@@ -25,6 +25,7 @@ use ckey::{public_to_address, Address, Error as KeyError, Generator, KeyPair, Pa
 use ckeystore::accounts_dir::MemoryDirectory;
 use ckeystore::{DecryptedAccount, Error as KeystoreError, KeyStore, SecretStore, SimpleSecretStore};
 use parking_lot::RwLock;
+use vrf::openssl::Error as VRFError;
 
 /// Type of unlock.
 #[derive(Clone, PartialEq)]
@@ -56,6 +57,8 @@ pub enum Error {
     KeyError(KeyError),
     /// Keystore error.
     KeystoreError(KeystoreError),
+    /// VRF error,
+    VRFError(VRFError),
 }
 
 impl From<KeyError> for Error {
@@ -70,13 +73,20 @@ impl From<KeystoreError> for Error {
     }
 }
 
+impl From<VRFError> for Error {
+    fn from(e: VRFError) -> Self {
+        Error::VRFError(e)
+    }
+}
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         match self {
             Error::NotUnlocked => write!(f, "Account is locked"),
             Error::NotFound => write!(f, "Account does not exist"),
             Error::KeyError(e) => write!(f, "{}", e),
             Error::KeystoreError(e) => write!(f, "{}", e),
+            Error::VRFError(e) => write!(f, "{}", e),
         }
     }
 }

core/src/consensus/signer.rs

@@ -19,6 +19,7 @@ use std::sync::Arc;
 use ckey::{Address, Public, SchnorrSignature, Signature};
 use ckeystore::DecryptedAccount;
 use primitives::H256;
+use vrf::openssl::ECVRF;
 
 use crate::account_provider::{AccountProvider, Error as AccountProviderError};
 
@@ -77,6 +78,19 @@ impl EngineSigner {
         Ok(result)
     }
 
+    /// Generate a vrf random hash.
+    pub fn vrf_hash(&self, hash: H256, vrf_inst: &mut ECVRF) -> Result<Vec<u8>, AccountProviderError> {
+        Ok(match &self.decrypted_account {
+            Some(account) => account.vrf_hash(&hash, vrf_inst)?,
+            None => {
+                let address = self.signer.map(|(address, _)| address).unwrap_or_default();
+                self.account_provider
+                    .get_unlocked_account(&address)
+                    .and_then(|account| account.vrf_hash(&hash, vrf_inst).map_err(From::from))?
+            }
+        })
+    }
+
     /// Sign a message hash with ECDSA.
     pub fn sign_ecdsa(&self, hash: H256) -> Result<Signature, AccountProviderError> {
         let address = self.signer.map(|(address, _public)| address).unwrap_or_else(Default::default);