Get block difficulty and chain work of block via CPP FFI

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-evm/src/handler.rs

@@ -34,6 +34,7 @@ impl Handlers {
         &self,
         context: u64,
         update_state: bool,
+        difficulty: u32,
         _miner_address: Option<H160>,
     ) -> Result<(BlockAny, Vec<TransactionV2>), Box<dyn Error>> {
         let mut successful_transactions = Vec::with_capacity(self.evm.tx_queues.len(context));
@@ -71,7 +72,7 @@ impl Handlers {
                 state_root: Default::default(),
                 receipts_root: Default::default(),
                 logs_bloom: Default::default(),
-                difficulty: Default::default(),
+                difficulty: U256::from(difficulty),
                 number,
                 gas_limit: Default::default(),
                 gas_used: Default::default(),

lib/ain-evm/tests/block.rs

@@ -23,7 +23,7 @@ fn test_finalize_block_and_do_not_update_state() {
     handler.evm.tx_queues.add_signed_tx(context, tx1);
 
     let old_state = handler.evm.state.read().unwrap();
-    let _ = handler.finalize_block(context, false, None).unwrap();
+    let _ = handler.finalize_block(context, false, 0, None).unwrap();
 
     let new_state = handler.evm.state.read().unwrap();
     assert_eq!(*new_state, *old_state);
@@ -60,7 +60,7 @@ fn test_finalize_block_and_update_state() {
     assert_eq!(handler.evm.tx_queues.len(context), 3);
     assert_eq!(handler.evm.tx_queues.len(handler.evm.get_context()), 0);
 
-    let (block, failed_txs) = handler.finalize_block(context, true, None).unwrap();
+    let (block, failed_txs) = handler.finalize_block(context, true, 0, None).unwrap();
     assert_eq!(
         block.transactions,
         vec![tx1, tx2, tx3.clone()]
@@ -133,7 +133,7 @@ fn test_deploy_and_call_smart_contract() {
         .tx_queues
         .add_signed_tx(context, create_smart_contract_tx);
 
-    handler.finalize_block(context, true, None).unwrap();
+    handler.finalize_block(context, true, 0, None).unwrap();
 
     // Fund caller address
     handler.evm.add_balance(
@@ -152,7 +152,7 @@ fn test_deploy_and_call_smart_contract() {
         .tx_queues
         .add_signed_tx(context, call_smart_contract_tx);
 
-    handler.finalize_block(context, true, None).unwrap();
+    handler.finalize_block(context, true, 0, None).unwrap();
 
     let smart_contract_storage = handler.evm.get_storage(smart_contract_address);
     assert_eq!(

lib/ain-grpc/src/rpc.rs

@@ -154,11 +154,13 @@ 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);
+
+        Ok(block)
     }
 
     fn chain_id(&self) -> Result<String> {

lib/ain-grpc/src/tests.rs

@@ -50,7 +50,7 @@ fn should_get_balance() {
         .evm
         .add_balance(ctx, H160::from_str(ALICE).unwrap(), U256::from(1337));
 
-    let _ = handler.finalize_block(ctx, true, None);
+    let _ = handler.finalize_block(ctx, true, 0, None);
 
     let res2 = EthService::Eth_GetBalance(handler, input.into());
     assert_eq!(res2.unwrap().balance, "1337");

lib/ain-rs-exports/src/lib.rs

@@ -24,6 +24,7 @@ mod ffi {
         fn evm_finalize(
             context: u64,
             update_state: bool,
+            difficulty: u32,
             miner_address: [u8; 20],
         ) -> Result<Vec<u8>>;
 
@@ -111,12 +112,13 @@ use rlp::Encodable;
 fn evm_finalize(
     context: u64,
     update_state: bool,
+    difficulty: u32,
     miner_address: [u8; 20],
 ) -> Result<Vec<u8>, Box<dyn Error>> {
     let eth_address = H160::from(miner_address);
     let (block, _failed_tx) =
         RUNTIME
             .handlers
-            .finalize_block(context, update_state, Some(eth_address))?;
+            .finalize_block(context, update_state, difficulty, Some(eth_address))?;
     Ok(block.header.rlp_bytes().into())
 }

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

src/miner.cpp

@@ -245,7 +245,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
 
     // TODO Get failed TXs and try to restore to mempool
     std::array<uint8_t, 20> dummyAddress{};
-    const auto rustHeader = evm_finalize(evmContext, false, dummyAddress);
+    const auto rustHeader = evm_finalize(evmContext, false, pos::GetNextWorkRequired(pindexPrev, pblock->nTime, consensus), dummyAddress);
 
     std::vector<uint8_t> evmHeader{};
     evmHeader.resize(rustHeader.size());

src/validation.cpp

@@ -2853,11 +2853,11 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
                 height = idHeight->blockHeight - GetMnResignDelay(std::numeric_limits<int>::max());
                 mnID = node->collateralTx;
             }
-    
+
             const auto blockindex = ::ChainActive()[height];
             assert(blockindex);
 
-            
+
             CTransactionRef tx;
             uint256 hash_block;
             assert(GetTransaction(mnID, tx, Params().GetConsensus(), hash_block, blockindex));
@@ -2873,7 +2873,7 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
             std::copy(minter.begin(), minter.end(), minerAddress.begin());
         }
 
-        evm_finalize(evmContext, true, minerAddress);
+        evm_finalize(evmContext, true, block.nBits, minerAddress);
     }
 
     auto &checkpoints = chainparams.Checkpoints().mapCheckpoints;