version 0.2.1 produces broken PoW as well about pow_sha256 HOT 7 CLOSED

use std::collections::HashMap;
use std::thread;
use std::time::Instant;

use pow_sha256::ConfigBuilder;
use reqwest;
use serde::{Deserialize, Serialize};

static BANNER: &str = "
██ ███    ███      █████      ██████   ██████  ████████ 
██ ████  ████     ██   ██     ██   ██ ██    ██    ██    
██ ██ ████ ██     ███████     ██████  ██    ██    ██    
██ ██  ██  ██     ██   ██     ██   ██ ██    ██    ██    
██ ██      ██     ██   ██     ██████   ██████     ██";
static WEBSITE: &str = "https://demo.mcaptcha.org";
static SITEKEY: &str = "pHy0AktWyOKuxZDzFfoaewncWecCHo23";

#[derive(Deserialize, Debug)]
struct Config {
    difficulty_factor: u32,
    salt: String,
    string: String,
}

#[derive(Serialize)]
struct Verification {
    key: String,
    nonce: u64,
    result: String,
    string: String,
}

#[derive(Deserialize, Debug)]
struct Response {
    token: Option<String>,
    error: Option<String>,
}

fn main() {
    println!("{}\n", BANNER);

    let config_url = format!("{}/api/v1/pow/config", WEBSITE);
    let verify_url = format!("{}/api/v1/pow/verify", WEBSITE);

    println!("fetching PoW configuration from {} ...", config_url);

    let mut map = HashMap::new();
    map.insert("key", SITEKEY);

    let client = reqwest::blocking::Client::new();

    let first_start = Instant::now();

    let config = client
        .post(config_url)
        .json(&map)
        .send()
        .unwrap()
        .json::<Config>()
        .unwrap();

    let duration = first_start.elapsed();

    println!("fetched in {:?}:\n\n{:#?}", duration, config);

    let pow_config = ConfigBuilder::default().salt(config.salt).build().unwrap();

    let start = Instant::now();

    let work = pow_config
        .prove_work(&config.string, config.difficulty_factor)
        .unwrap();

    let duration = start.elapsed();

    assert!(
        pow_config.calculate(&work, &config.string).unwrap() >= config.difficulty_factor.into()
    );
    assert!(pow_config.is_valid_proof(&work, &config.string));
    assert!(pow_config.is_sufficient_difficulty(&work, config.difficulty_factor));

    println!(
        "\nsolved in {:?}:\n\n{:#?}\n\nverifying with {} ...",
        duration, work, verify_url
    );

    let ver = Verification {
        key: SITEKEY.into(),
        nonce: work.nonce,
        result: work.result,
        string: config.string,
    };

    let start = Instant::now();

    let resp = client
        .post(verify_url)
        .json(&ver)
        .send()
        .unwrap()
        .json::<Response>()
        .unwrap();

    let duration = start.elapsed();

    if resp.error.is_some() {
        println!("verification error: {}", resp.error.unwrap());
    } else {
        println!("verified in {:?} token:'{}'", duration, resp.token.unwrap());
    }

    println!("total time: {:?}", first_start.elapsed());
}