feat(lib): impl calculate minter fees methode in Block

Author: ryzen-xp

lib/src/lib.rs

@@ -7,9 +7,21 @@ construct_uint! {
   pub struct U256(4);
 }
 
-pub const INITIAL_REWARD: i32 = 1;
-
-pub const HALVING_INTERVAL: i32 = 23;
+// initial reward in bitcoin - multiply by 10^8 to get satoshis
+pub const INITIAL_REWARD: u64 = 50;
+// halving interval in blocks
+pub const HALVING_INTERVAL: u64 = 210;
+// ideal block time in seconds
+pub const IDEAL_BLOCK_TIME: u64 = 10;
+// minimum target
+pub const MIN_TARGET: U256 = U256([
+    0xFFFF_FFFF_FFFF_FFFF,
+    0xFFFF_FFFF_FFFF_FFFF,
+    0xFFFF_FFFF_FFFF_FFFF,
+    0x0000_FFFF_FFFF_FFFF,
+]);
+// difficulty update interval in blocks
+pub const DIFFICULTY_UPDATE_INTERVAL: u64 = 50;
 
 pub mod crypto;
 pub mod error;

lib/src/types.rs

@@ -213,9 +213,43 @@ impl Block {
 
     pub fn calculate_miner_reward(
         &self,
-        _utxo: HashMap<Hash, TransactionOutput>,
+        utxo: HashMap<Hash, TransactionOutput>,
     ) -> Result<u64, CoinError> {
-        Ok(1)
+        let mut inputs: HashMap<Hash, TransactionOutput> = HashMap::new();
+
+        let mut outputs: HashMap<Hash, TransactionOutput> = HashMap::new();
+
+        for tx in self.transactions.iter().skip(1) {
+            for input in &tx.inputs {
+                if inputs.contains_key(&input.prev_transaction_output_hash) {
+                    return Err(CoinError::InvalidTransaction);
+                }
+
+                let option_prv_output = utxo.get(&input.prev_transaction_output_hash);
+
+                if option_prv_output.is_none() {
+                    return Err(CoinError::InvalidTransaction);
+                }
+
+                let prev_output = option_prv_output.unwrap();
+
+                inputs.insert(input.prev_transaction_output_hash, prev_output.clone());
+            }
+
+            for output in &tx.outputs {
+                if outputs.contains_key(&output.hash()) {
+                    return Err(CoinError::InvalidTransaction);
+                }
+
+                outputs.insert(output.hash(), output.clone());
+            }
+        }
+
+        let input_value: u64 = inputs.values().map(|x| x.value).sum();
+
+        let output_value: u64 = outputs.values().map(|x| x.value).sum();
+
+        Ok(input_value - output_value)
     }
 
     pub fn hash(&self) -> Hash {