difficulty 추가

Author: leejaeseung

jaeseung-blockchain/src/block/block.rs

@@ -4,6 +4,10 @@ use sha256::digest;
 
 use rs_merkle::{algorithms::Sha256, Hasher, MerkleTree};
 
+use crate::constants::{
+    BLOCK_GENERATION_INTERVAL_MINUTE, BLOCK_GENERATION_MILLIS, DIFFICULTY_ADJUSTMENT_INTERVAL_COUNT,
+};
+
 #[derive(Debug, PartialEq, Clone)] // TODO : Copy 와 Clone 의 차이점?
 pub struct Block {
     header: BlockHeader,
@@ -17,19 +21,82 @@ impl Block {
         let data = vec![Self::GENESIS_DATA.to_string()];
 
         Ok(Block {
-            header: BlockHeader::make(0, &["0"; 64].join(""), 0, &data)?,
+            header: BlockHeader::make(
+                0,
+                Self::unsafe_get_timestamp(),
+                &["0"; 64].join(""),
+                0,
+                0,
+                &data,
+            )?,
             data: data,
         })
     }
 
-    pub fn new(previous_block: &Block, nonce: i32, data: &Vec<String>) -> Result<Block, String> {
+    pub fn new(
+        previous_block: &Block,
+        nonce: i32,
+        data: &Vec<String>,
+        adjustment_block: &Block,
+    ) -> Result<Block, String> {
         let p_header = &previous_block.header;
 
+        let new_height = p_header.height + 1;
+        let new_timestamp = Self::unsafe_get_timestamp();
+
+        let difficulty =
+            Self::get_difficulty(new_height, new_timestamp, previous_block, adjustment_block);
+
         Ok(Block {
-            header: BlockHeader::make(p_header.height + 1, &p_header.hash, nonce, data)?,
-            data: data.clone(),
+            header: BlockHeader::make(
+                p_header.height + 1,
+                new_timestamp,
+                &p_header.hash,
+                nonce,
+                difficulty,
+                data,
+            )?,
+            data: data.clone(), // TODO : clone 이 맞을까?
         })
     }
+
+    fn get_difficulty(
+        new_height: i32,
+        new_timestamp: u64,
+        previous_block: &Block,
+        adjustment_block: &Block,
+    ) -> i32 {
+        match new_height {
+            0..=9 => 0,
+            10..=19 => 1,
+            h if h % 10 != i32::from(DIFFICULTY_ADJUSTMENT_INTERVAL_COUNT) => {
+                previous_block.header.difficulty
+            }
+            _ => {
+                let time_taken = new_timestamp - adjustment_block.header.timestamp;
+                let time_expected = u64::from(
+                    DIFFICULTY_ADJUSTMENT_INTERVAL_COUNT
+                        * BLOCK_GENERATION_INTERVAL_MINUTE
+                        * BLOCK_GENERATION_MILLIS,
+                );
+
+                if time_taken < time_expected / 2 {
+                    adjustment_block.header.difficulty + 1
+                } else if time_taken > time_expected * 2 {
+                    adjustment_block.header.difficulty - 1
+                } else {
+                    adjustment_block.header.difficulty
+                }
+            }
+        }
+    }
+
+    fn unsafe_get_timestamp() -> u64 {
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs()
+    }
 }
 
 #[derive(Debug, PartialEq, Clone)]
@@ -46,27 +113,30 @@ struct BlockHeader {
 
 impl BlockHeader {
     const VERSION: &str = "1.0.0";
-    const DIFFICULTY: i32 = 0;
 
     fn make(
         height: i32,
+        timestamp: u64,
         previous_hash: &String,
         nonce: i32,
+        difficulty: i32,
         data: &Vec<String>,
     ) -> Result<BlockHeader, String> {
-        let version = Self::VERSION.to_string();
-        let timestamp = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap()
-            .as_secs();
-        let difficulty = Self::DIFFICULTY;
         let merkle_root = Self::make_merkle_root(data).ok_or("Merkle Tree Parsing Failed")?;
 
         Ok(BlockHeader {
-            version,
+            version: Self::VERSION.to_string(),
             height,
             timestamp,
-            hash: Self::make_hash(timestamp, &merkle_root, previous_hash, nonce),
+            hash: Self::make_block_hash(
+                // TODO : 여기서 바로 마이닝을 하자.
+                height,
+                timestamp,
+                &merkle_root,
+                previous_hash,
+                nonce,
+                difficulty,
+            ),
             previous_hash: Some(previous_hash.clone()),
             merkle_root,
             nonce,
@@ -83,18 +153,23 @@ impl BlockHeader {
         merkle_tree.root_hex()
     }
 
-    fn make_hash(
+    fn make_block_hash(
+        height: i32,
         timestamp: u64,
         merkle_root: &String,
         previous_hash: &String,
         nonce: i32,
+        difficulty: i32,
     ) -> String {
         let target = format!(
-            "{}{}{}{}",
+            "{}{}{}{}{}{}{}",
+            Self::VERSION.to_string(),
+            height.to_string(),
             timestamp.to_string(),
             merkle_root,
             previous_hash,
-            nonce.to_string()
+            nonce.to_string(),
+            difficulty.to_string()
         );
         digest(target)
     }

jaeseung-blockchain/src/constants.rs

@@ -0,0 +1,8 @@
+// 블록 1 묶음의 블록 개수
+pub const DIFFICULTY_ADJUSTMENT_INTERVAL_COUNT: u16 = 10;
+
+// 블록 1 묶음이 생성 되기까지의 예상 시간(분)
+pub const BLOCK_GENERATION_INTERVAL_MINUTE: u16 = 10;
+
+// 블록 1 개가 생성 되기까지의 예상 시간(밀리초)
+pub const BLOCK_GENERATION_MILLIS: u16 = 60000;

jaeseung-blockchain/src/main.rs

@@ -1,5 +1,6 @@
 mod block;
 mod chain;
+mod constants;
 
 use block::Block;