Feature/vdf#3 kotagit75

Cargo.toml

@@ -17,3 +17,4 @@ sha2 = "0.10.9"
 simple_logger = "5.2.0"
 sysinfo = "0.38.4"
 tokio = { version = "1.50.0", features = ["full"]}
+vdf = "0.1.0"

src/core/stamp.rs

@@ -3,7 +3,10 @@ use sha2::Digest;
 use crate::{
     core::signature::{sign, verify},
     model::{address::Address, signature::Signature, stamp::Stamp},
-    util::key::{PK, SK},
+    util::{
+        key::{PK, SK},
+        vdf::{solve, verify_solution},
+    },
 };
 
 impl Stamp {
@@ -129,8 +132,47 @@ pub fn is_valid_stamp(stamp: &Stamp, difficulty: usize, proof_pk: PK) -> bool {
         stamp.nonce,
         stamp.id,
     );
+    let is_valid_stamp = verify_solution_stamp(stamp.clone());
     let is_valid_sign = stamp.verify_sign();
-    is_valid_pk && is_valid_nonce && is_valid_sign
+    is_valid_pk && is_valid_nonce && is_valid_stamp && is_valid_sign
+}
+
+fn stamp_to_buf_for_vdf(
+    address: &Address,
+    count: u32,
+    pk: &PK,
+    nonce: u32,
+    id: usize,
+) -> Result<Vec<u8>, ()> {
+    stamp_to_buf_for_sign(address, count, pk, nonce, id)
+}
+
+pub fn calc_solution(
+    address: &Address,
+    count: u32,
+    pk: &PK,
+    nonce: u32,
+    id: usize,
+) -> Result<Vec<u8>, ()> {
+    if let Ok(buf) = stamp_to_buf_for_vdf(address, count, pk, nonce, id) {
+        solve(buf.as_slice()).or(Err(()))
+    } else {
+        Err(())
+    }
+}
+
+pub fn verify_solution_stamp(stamp: Stamp) -> bool {
+    if let Ok(buf) = stamp_to_buf_for_vdf(
+        &stamp.address,
+        stamp.count,
+        &stamp.pk,
+        stamp.nonce,
+        stamp.id,
+    ) {
+        verify_solution(buf.as_slice(), stamp.solution.as_slice())
+    } else {
+        false
+    }
 }
 
 pub fn sum_of_count(stamps: Vec<Stamp>) -> u32 {
@@ -173,6 +215,7 @@ mod tests {
             address: address.clone(),
             count: 0,
             pk: pk.clone(),
+            solution: Vec::new(),
             nonce: 0,
             id: 0,
             sign: signature.clone(),

src/effect/run.rs

@@ -1,5 +1,5 @@
 use crate::{
-    core::stamp::{calc_nonce, create_sign_to_stamp},
+    core::stamp::{calc_nonce, calc_solution, create_sign_to_stamp},
     model::{
         effect::Effect,
         p2p::{Client, P2PMessage},
@@ -14,13 +14,17 @@ pub async fn run_effect(state: State, effect: Effect) -> Option<Effect> {
             let address = state.address;
             let count = state.count + 1;
             let nonce = calc_nonce(difficulty, &address, count, &pk, id);
+            let Ok(solution) = calc_solution(&address, count, &pk, nonce, id) else {
+                return None;
+            };
             if let Ok(sign) =
                 create_sign_to_stamp(state.node_sk, &address, count, pk.clone(), nonce, id)
             {
                 let stamp = Stamp {
                     address,
                     count,
                     pk: pk.clone(),
+                    solution,
                     nonce,
                     id,
                     sign,

src/main.rs

@@ -2,6 +2,8 @@
 extern crate log;
 extern crate simple_logger as logger;
 
+extern crate vdf;
+
 use clap::Parser;
 
 use crate::bitclock::start;

src/model/stamp.rs

@@ -11,6 +11,7 @@ pub struct Stamp {
     pub count: u32,
     pub pk: PK,
     pub nonce: u32,
+    pub solution: Vec<u8>,
     pub id: usize,
     pub sign: Signature,
 }

src/update.rs

@@ -132,6 +132,7 @@ mod tests {
             count: 0,
             pk: pk.clone(),
             nonce: 0,
+            solution: Vec::new(),
             id: 0,
             sign: Vec::new(),
         };

src/util.rs

@@ -1,3 +1,4 @@
 pub mod key;
 pub mod math;
 pub mod status;
+pub mod vdf;

src/util/vdf.rs

@@ -0,0 +1,16 @@
+use vdf::{PietrzakVDFParams, VDF, VDFParams};
+
+//
+const VDF_DIFFICULTY: u64 = 68;
+
+pub fn verify_solution(challenge: &[u8], solution: &[u8]) -> bool {
+    let vdf = PietrzakVDFParams(1024).new();
+    let result = vdf.verify(challenge, VDF_DIFFICULTY, solution).is_ok();
+    println!("{:?}", result);
+    result
+}
+
+pub fn solve(challenge: &[u8]) -> Result<Vec<u8>, vdf::InvalidIterations> {
+    let vdf = PietrzakVDFParams(1024).new();
+    vdf.solve(challenge, VDF_DIFFICULTY)
+}