FFI: Get block difficulty and chain work of block

lib/ain-cpp-imports/src/bridge.rs

@@ -8,5 +8,7 @@ pub mod ffi {
         fn publishEthTransaction(data: Vec<u8>) -> bool;
         fn getAccounts() -> Vec<String>;
         fn getDatadir() -> String;
+        fn getDifficulty(_block_hash: [u8; 32]) -> u32;
+        fn getChainWork(_block_hash: [u8; 32]) -> [u8; 32];
     }
 }

lib/ain-cpp-imports/src/lib.rs

@@ -25,6 +25,12 @@ mod ffi {
     pub fn getDatadir() -> String {
         unimplemented!("{}", UNIMPL_MSG)
     }
+    pub fn getDifficulty(_block_hash: [u8; 32]) -> u32 {
+        unimplemented!("{}", UNIMPL_MSG)
+    }
+    pub fn getChainWork(_block_hash: [u8; 32]) -> [u8; 32] {
+        unimplemented!("{}", UNIMPL_MSG)
+    }
 }
 
 pub fn get_chain_id() -> Result<u64, Box<dyn Error>> {
@@ -52,5 +58,15 @@ pub fn get_datadir() -> Result<String, Box<dyn Error>> {
     Ok(datadir)
 }
 
+pub fn get_difficulty(block_hash: [u8; 32]) -> Result<u32, Box<dyn Error>> {
+    let bits = ffi::getDifficulty(block_hash);
+    Ok(bits)
+}
+
+pub fn get_chainwork(block_hash: [u8; 32]) -> Result<[u8; 32], Box<dyn Error>> {
+    let chainwork = ffi::getChainWork(block_hash);
+    Ok(chainwork)
+}
+
 #[cfg(test)]
 mod tests {}

lib/ain-grpc/src/rpc.rs

@@ -154,11 +154,30 @@ impl MetachainRPCServer for MetachainRPCModule {
 
         let hash: H256 = hash.parse().expect("Invalid hash");
 
-        Ok(self
+        let block: Option<RpcBlock> = self
             .handler
             .storage
             .get_block_by_hash(&hash)
-            .map(Into::into))
+            .map(Into::into);
+
+        match block {
+            None => Ok(None),
+            Some(mut block) => {
+                let hash_array = hash.to_fixed_bytes();
+                let difficulty = ain_cpp_imports::get_difficulty(hash_array);
+                let chainwork = ain_cpp_imports::get_chainwork(hash_array);
+
+                if let Ok(difficulty) = difficulty {
+                    block.difficulty = U256::from(difficulty);
+                }
+
+                if let Ok(chainwork) = chainwork {
+                    block.total_difficulty = Some(U256::from(chainwork));
+                }
+
+                Ok(Some(block))
+            }
+        }
     }
 
     fn chain_id(&self) -> Result<String> {

src/ffi/ffiexports.cpp

@@ -66,3 +66,44 @@ rust::vec<rust::string> getAccounts() {
 rust::string getDatadir() {
     return GetDataDir().c_str();
 }
+
+uint32_t getDifficulty(std::array<uint8_t, 32> blockHash) {
+    uint256 hash{};
+    std::copy(blockHash.begin(), blockHash.end(), hash.begin());
+
+    const CBlockIndex* pblockindex;
+    uint32_t difficulty{};
+    {
+        LOCK(cs_main);
+        pblockindex = LookupBlockIndex(hash);
+
+        if (!pblockindex) {
+            return difficulty;
+        }
+
+        difficulty = pblockindex->nBits;
+    }
+
+    return difficulty;
+}
+
+std::array<uint8_t, 32> getChainWork(std::array<uint8_t, 32> blockHash) {
+    uint256 hash{};
+    std::copy(blockHash.begin(), blockHash.end(), hash.begin());
+
+    const CBlockIndex* pblockindex;
+    std::array<uint8_t, 32> chainWork{};
+    {
+        LOCK(cs_main);
+        pblockindex = LookupBlockIndex(hash);
+
+        if (!pblockindex) {
+            return chainWork;
+        }
+
+        const auto sourceWork = ArithToUint256(pblockindex->nChainWork);
+        std::copy(sourceWork.begin(), sourceWork.end(), chainWork.begin());
+    }
+
+    return chainWork;
+}

src/ffi/ffiexports.h

@@ -9,5 +9,7 @@ bool isMining();
 bool publishEthTransaction(rust::Vec<uint8_t> rawTransaction);
 rust::vec<rust::string> getAccounts();
 rust::string getDatadir();
+uint32_t getDifficulty(std::array<uint8_t, 32> blockHash);
+std::array<uint8_t, 32> getChainWork(std::array<uint8_t, 32> blockHash);
 
 #endif // DEFI_EVM_FFI_H