Chain 함수 완성. difficulty 증가하지 않는 버그 있음.

Author: leejaeseung

jaeseung-blockchain/Cargo.lock

@@ -5,4 +5,5 @@ edition = "2021"
 
 [dependencies]
 rs_merkle = "1.4"
-sha256 = "1.5.0"
+sha256 = "1.5.0"
+to-binary = "0.4.0"

jaeseung-blockchain/Cargo.toml

@@ -4,6 +4,8 @@ use sha256::digest;
 
 use rs_merkle::{algorithms::Sha256, Hasher, MerkleTree};
 
+use to_binary::BinaryString;
+
 use crate::constants::{
     BLOCK_GENERATION_INTERVAL_MINUTE, BLOCK_GENERATION_MILLIS, DIFFICULTY_ADJUSTMENT_INTERVAL_COUNT,
 };
@@ -26,7 +28,6 @@ impl Block {
                 Self::unsafe_get_timestamp(),
                 &["0"; 64].join(""),
                 0,
-                0,
                 &data,
             )?,
             data: data,
@@ -35,7 +36,6 @@ impl Block {
 
     pub fn new(
         previous_block: &Block,
-        nonce: i32,
         data: &Vec<String>,
         adjustment_block: &Block,
     ) -> Result<Block, String> {
@@ -52,7 +52,6 @@ impl Block {
                 p_header.height + 1,
                 new_timestamp,
                 &p_header.hash,
-                nonce,
                 difficulty,
                 data,
             )?,
@@ -69,7 +68,7 @@ impl Block {
         match new_height {
             0..=9 => 0,
             10..=19 => 1,
-            h if h % 10 != i32::from(DIFFICULTY_ADJUSTMENT_INTERVAL_COUNT) => {
+            h if h % 10 != DIFFICULTY_ADJUSTMENT_INTERVAL_COUNT as i32 => {
                 previous_block.header.difficulty
             }
             _ => {
@@ -118,25 +117,42 @@ impl BlockHeader {
         height: i32,
         timestamp: u64,
         previous_hash: &String,
-        nonce: i32,
         difficulty: i32,
         data: &Vec<String>,
     ) -> Result<BlockHeader, String> {
+        let prefix_zero = "0".repeat(difficulty as usize);
+
         let merkle_root = Self::make_merkle_root(data).ok_or("Merkle Tree Parsing Failed")?;
 
-        Ok(BlockHeader {
-            version: Self::VERSION.to_string(),
-            height,
-            timestamp,
-            hash: Self::make_block_hash(
-                // TODO : 여기서 바로 마이닝을 하자.
+        let mut nonce = 0;
+
+        // TODO : closure 와 꼬리 재귀를 써서 할 순 없을까?
+        let (nonce, hash) = loop {
+            nonce += 1;
+
+            let hash = Self::make_block_hash(
                 height,
                 timestamp,
                 &merkle_root,
                 previous_hash,
                 nonce,
                 difficulty,
-            ),
+            );
+
+            let binary = BinaryString::from_hex(&hash)
+                .map_err(|_| "hex to binary failed".to_string())?
+                .to_string();
+
+            if binary.as_str().starts_with(prefix_zero.as_str()) {
+                break (nonce, hash);
+            }
+        };
+
+        Ok(BlockHeader {
+            version: Self::VERSION.to_string(),
+            height,
+            timestamp,
+            hash,
             previous_hash: Some(previous_hash.clone()),
             merkle_root,
             nonce,
@@ -174,20 +190,3 @@ impl BlockHeader {
         digest(target)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_new_genesis() {
-        let actual = Block::new_genesis().unwrap();
-
-        let data = vec![Block::GENESIS_DATA.to_string()];
-        let expected = Block {
-            header: BlockHeader::make(0, &["0"; 64].join(""), 0, &data).unwrap(),
-            data,
-        };
-        assert_eq!(actual, expected);
-    }
-}

jaeseung-blockchain/src/block/block.rs

@@ -1,4 +1,4 @@
-use crate::block::Block;
+use crate::{block::Block, constants::DIFFICULTY_ADJUSTMENT_INTERVAL_COUNT};
 
 #[derive(Debug)]
 pub struct Chain {
@@ -12,8 +12,8 @@ impl Chain {
         })
     }
 
-    pub fn get_length(&self) -> usize {
-        self.block_chain.len()
+    pub fn get_length(&self) -> u32 {
+        self.block_chain.len() as u32
     }
 
     pub fn get_lastest_block(&self) -> Option<&Block> {
@@ -24,11 +24,24 @@ impl Chain {
         let previous_block = self
             .get_lastest_block()
             .ok_or("previous_block not exist.")?;
-        let new_block = Block::new(previous_block, 0, data)?;
+        let adjustment_block = self.get_adjustment_block()?;
+
+        let new_block = Block::new(previous_block, data, &adjustment_block)?;
 
         self.block_chain.push(new_block); // TODO : 안전할까?
         Ok(self)
     }
+
+    fn get_adjustment_block(&self) -> Result<Block, String> {
+        let current_length = self.get_length();
+
+        match current_length {
+            ..DIFFICULTY_ADJUSTMENT_INTERVAL_COUNT => Block::new_genesis(),
+            _ => Ok(self.block_chain
+                [(current_length - DIFFICULTY_ADJUSTMENT_INTERVAL_COUNT) as usize]
+                .clone()),
+        }
+    }
 }
 
 #[cfg(test)]

jaeseung-blockchain/src/chain/chain.rs

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

jaeseung-blockchain/src/constants.rs

@@ -3,9 +3,14 @@ mod chain;
 mod constants;
 
 use block::Block;
+use chain::Chain;
 
 fn main() {
-    let block = Block::new_genesis();
+    let mut chain = Chain::new().unwrap();
 
-    print!("{:?}", block);
+    for x in 1..30000 {
+        chain.add_block(&vec![format!("data-{x}").to_string()]);
+    }
+
+    print!("{:#?}", chain);
 }