Chia-Network
diff --git a/‎.github/workflows/vdf-client-hw.yml‎
Lines changed: 38 additions & 22 deletions b/‎.github/workflows/vdf-client-hw.yml‎
Lines changed: 38 additions & 22 deletions
diff --git a/‎src/CMakeLists.txt‎
Lines changed: 35 additions & 11 deletions b/‎src/CMakeLists.txt‎
Lines changed: 35 additions & 11 deletions
diff --git a/‎src/hw/emu_runner.cpp‎
Lines changed: 26 additions & 25 deletions b/‎src/hw/emu_runner.cpp‎
Lines changed: 26 additions & 25 deletions
diff --git a/‎src/proof_deserialization_regression_test.cpp‎
Lines changed: 56 additions & 0 deletions b/‎src/proof_deserialization_regression_test.cpp‎
Lines changed: 56 additions & 0 deletions
@@ -61,6 +61,7 @@ jobs:
       - name: Install macOS deps (build + runtime)
         if: startsWith(matrix.os, 'macos')
         run: |
+          brew ls --versions cmake >/dev/null 2>&1 || brew install cmake
           brew ls --versions gmp >/dev/null 2>&1 || brew install gmp
           brew ls --versions boost >/dev/null 2>&1 || brew install boost
           echo "DYLD_FALLBACK_LIBRARY_PATH=$(brew --prefix gmp)/lib:${DYLD_FALLBACK_LIBRARY_PATH:-}" >> "$GITHUB_ENV"
@@ -219,16 +220,20 @@ jobs:
           if (-not $gnuAsmEnabled) {
             throw "ENABLE_GNU_ASM is not ON on Windows CI build"
           }
-          cmake --build build --target vdf_client vdf_bench 1weso_test 2weso_test prover_test vdf_client_session_test emu_hw_test hw_test emu_hw_vdf_client hw_vdf_client
-          $asmFiles = @(
-            "build/asm_compiled.s",
-            "build/avx2_asm_compiled.s",
-            "build/avx512_asm_compiled.s"
-          )
+          cmake --build build --target vdf_client vdf_bench 1weso_test 2weso_test prover_test regression_unit_tests regression_io_tests emu_hw_test hw_test emu_hw_vdf_client hw_vdf_client
+          if ($LASTEXITCODE -ne 0) {
+            throw "Windows build failed with exit code $LASTEXITCODE"
+          }
+          $asmFiles = @("asm_compiled.s", "avx2_asm_compiled.s", "avx512_asm_compiled.s")
           foreach ($asmFile in $asmFiles) {
-            if (-not (Test-Path $asmFile)) {
-              throw "Expected generated asm output not found: $asmFile"
+            # Depending on generator/layout, CMAKE_CURRENT_BINARY_DIR for src may resolve
+            # to build/ or build/src/. Accept either location to avoid false negatives.
+            $candidatePaths = @("build/$asmFile", "build/src/$asmFile")
+            $foundPath = $candidatePaths | Where-Object { Test-Path $_ } | Select-Object -First 1
+            if (-not $foundPath) {
+              throw "Expected generated asm output not found in build/ or build/src/: $asmFile"
             }
+            Write-Host "Verified generated asm output: $foundPath"
           }
 
       - name: Run HW smoke test (Ubuntu/macOS)
@@ -243,14 +248,24 @@ jobs:
           echo "Running emu_hw_vdf_client --list"
           ./emu_hw_vdf_client --list
 
-      - name: Run vdf tests (optimized)
-        if: matrix.config == 'optimized=1' && matrix.os != 'windows-latest'
+      - name: Run vdf tests (optimized smoke)
+        if: matrix.config == 'optimized=1' && matrix.os != 'windows-latest' && matrix.os != 'ubuntu-latest'
         run: |
           cd src
-          echo "Running 1weso_test"
-          ./1weso_test
-          echo "Running 2weso_test"
-          ./2weso_test
+          echo "Running 1weso_test (fast smoke)"
+          ./1weso_test 1000
+          echo "Running 2weso_test (fast smoke)"
+          ./2weso_test 1000
+
+      - name: Run vdf tests (optimized protected threshold path)
+        if: matrix.config == 'optimized=1' && matrix.os == 'ubuntu-latest'
+        run: |
+          cd src
+          echo "Running 1weso_test (fast smoke)"
+          ./1weso_test 1000
+          # 100 * 910000 = 91,000,000; this intentionally crosses the 2-weso switch threshold.
+          echo "Running 2weso_test (protected threshold path)"
+          ./2weso_test 910000
 
       - name: Run vdf tests (short)
         if: matrix.config != 'optimized=1' && matrix.os != 'windows-latest'
@@ -293,17 +308,17 @@ jobs:
           .\emu_hw_vdf_client.exe --list
           if ($LASTEXITCODE -ne 0) { throw "emu_hw_vdf_client --list failed with exit code $LASTEXITCODE" }
 
-      - name: Run vdf tests (Windows)
+      - name: Run vdf tests (Windows, optimized smoke)
         if: matrix.os == 'windows-latest' && matrix.config == 'optimized=1'
         shell: pwsh
         run: |
           cd build
           $env:PATH = "$PWD;$PWD\..\src\hw\libft4222;$PWD\..\mpir_gc_x64;$env:PATH"
-          Write-Host "Running 1weso_test"
-          .\1weso_test.exe
+          Write-Host "Running 1weso_test (fast smoke)"
+          .\1weso_test.exe 1000
           if ($LASTEXITCODE -ne 0) { throw "1weso_test failed with exit code $LASTEXITCODE" }
-          Write-Host "Running 2weso_test"
-          .\2weso_test.exe
+          Write-Host "Running 2weso_test (fast smoke)"
+          .\2weso_test.exe 1000
           if ($LASTEXITCODE -ne 0) { throw "2weso_test failed with exit code $LASTEXITCODE" }
 
       - name: Run prover test (Windows)
@@ -317,18 +332,19 @@ jobs:
           .\prover_test.exe
           if ($LASTEXITCODE -ne 0) { throw "prover_test failed with exit code $LASTEXITCODE" }
 
-      - name: Run vdf_client_session regression (GoogleTest, Unix)
+      - name: Run GoogleTest regressions (Unix)
         if: matrix.config == 'optimized=1' && matrix.os != 'windows-latest'
         run: |
           cmake -S src -B build-regression -DBUILD_PYTHON=OFF -DBUILD_CHIAVDFC=OFF -DBUILD_VDF_CLIENT=OFF -DBUILD_VDF_BENCH=OFF -DBUILD_VDF_TESTS=ON -DBUILD_HW_TOOLS=OFF -DENABLE_GNU_ASM=ON
-          cmake --build build-regression --target vdf_client_session_test
+          cmake --build build-regression --target regression_unit_tests regression_io_tests
           ctest --test-dir build-regression --output-on-failure -R '^regression\.'
 
-      - name: Run vdf_client_session regression (GoogleTest, Windows)
+      - name: Run GoogleTest regressions (Windows)
         if: matrix.os == 'windows-latest' && matrix.config == 'optimized=1'
         shell: pwsh
         run: |
           cd build
+          $env:PATH = "$PWD;$PWD\..\src\hw\libft4222;$PWD\..\mpir_gc_x64;$env:PATH"
           ctest -C Release --output-on-failure -R '^regression\.'
 
       - name: Benchmark vdf_bench square (Ubuntu/Mac)
 
@@ -382,20 +382,44 @@ if(BUILD_VDF_TESTS)
   target_link_libraries(prover_test PRIVATE ${GMP_LIBRARIES} ${GMPXX_LIBRARIES} Threads::Threads)
   vdf_add_windows_clang_opts(prover_test)
 
-  add_executable(vdf_client_session_test
-    ${CMAKE_CURRENT_SOURCE_DIR}/vdf_client_session_test.cpp
+  # Keep regression coverage in a small, fixed number of binaries to limit CI build churn.
+  # Use a single translation unit to avoid duplicate symbol collisions from header-defined functions.
+  add_executable(regression_unit_tests
+    ${CMAKE_CURRENT_SOURCE_DIR}/regression_unit_tests.cpp
+  )
+  target_sources(regression_unit_tests PRIVATE ${VDF_COMMON_SOURCES} ${VDF_ASM_SOURCES})
+  target_compile_definitions(regression_unit_tests PRIVATE ${VDF_COMMON_DEFINITIONS})
+  vdf_add_boost_includes(regression_unit_tests)
+  target_link_libraries(
+    regression_unit_tests
+    PRIVATE
+    GTest::gtest_main
+    Threads::Threads
+    ${GMP_LIBRARIES}
+    ${GMPXX_LIBRARIES}
+  )
+  if(UNIX AND NOT APPLE)
+    # Generated asm objects use absolute relocations; disable PIE for this target.
+    target_link_options(regression_unit_tests PRIVATE -no-pie)
+  endif()
+  vdf_add_windows_clang_opts(regression_unit_tests)
+  gtest_discover_tests(
+    regression_unit_tests
+    TEST_PREFIX "regression.unit."
+    DISCOVERY_MODE PRE_TEST
   )
-  vdf_add_boost_includes(vdf_client_session_test)
-  target_link_libraries(vdf_client_session_test PRIVATE GTest::gtest_main Threads::Threads)
-  vdf_add_windows_clang_opts(vdf_client_session_test)
-  gtest_discover_tests(vdf_client_session_test TEST_PREFIX "regression.")
 
-  add_executable(checked_cast_test
-    ${CMAKE_CURRENT_SOURCE_DIR}/checked_cast_test.cpp
+  add_executable(regression_io_tests
+    ${CMAKE_CURRENT_SOURCE_DIR}/vdf_client_session_test.cpp
+  )
+  vdf_add_boost_includes(regression_io_tests)
+  target_link_libraries(regression_io_tests PRIVATE GTest::gtest_main Threads::Threads)
+  vdf_add_windows_clang_opts(regression_io_tests)
+  gtest_discover_tests(
+    regression_io_tests
+    TEST_PREFIX "regression.io."
+    DISCOVERY_MODE PRE_TEST
   )
-  target_link_libraries(checked_cast_test PRIVATE GTest::gtest_main Threads::Threads)
-  vdf_add_windows_clang_opts(checked_cast_test)
-  gtest_discover_tests(checked_cast_test TEST_PREFIX "regression.")
 
 endif()
 
 
@@ -8,6 +8,7 @@
 #include <cstring>
 #include <thread>
 #include <mutex>
+#include <atomic>
 
 #ifndef _WIN32
 #include <arpa/inet.h>
@@ -57,10 +58,10 @@ struct job_state {
     uint64_t target_iter;
     integer d, l;
     form qf;
-    bool init_done;
-    bool stopping;
-    bool running;
-    bool error;
+    std::atomic<bool> init_done{false};
+    std::atomic<bool> stopping{true};
+    std::atomic<bool> running{false};
+    std::atomic<bool> error{false};
     ChiaDriver *drv;
     std::mutex mtx;
 };
@@ -81,15 +82,15 @@ void init_state(struct job_state *st, struct job_reg_set *r)
     st->drv->read_bytes(sizeof(r->l), 0, (uint8_t *)r->l, st->l.impl, st->drv->NUM_1X_COEFFS);
 
     st->qf = form::from_abd(a, f, st->d);
-    st->init_done = true;
-    st->stopping = false;
+    st->init_done.store(true, std::memory_order_release);
+    st->stopping.store(false, std::memory_order_release);
 }
 
 void clear_state(struct job_state *st)
 {
-    if (st->init_done) {
+    if (st->init_done.load(std::memory_order_acquire)) {
         delete st->drv;
-        st->init_done = false;
+        st->init_done.store(false, std::memory_order_release);
     }
 }
 
@@ -101,9 +102,9 @@ void run_job(int i)
 
     LOG_INFO("Emu %d: Starting run for %lu iters", i, st->target_iter);
 
-    st->error = false;
-    st->running = true;
-    while (!st->stopping && st->cur_iter < st->target_iter) {
+    st->error.store(false, std::memory_order_release);
+    st->running.store(true, std::memory_order_release);
+    while (!st->stopping.load(std::memory_order_acquire) && st->cur_iter < st->target_iter) {
         nudupl_form(qf2, st->qf, st->d, st->l);
         reducer.reduce(qf2);
 
@@ -116,7 +117,7 @@ void run_job(int i)
         st->qf = qf2;
         st->mtx.unlock();
     }
-    st->running = false;
+    st->running.store(false, std::memory_order_release);
     LOG_INFO("Emu %d: job ended", i);
 }
 
@@ -127,8 +128,8 @@ void job_thread(int i)
 
 static void start_job(int i)
 {
-    while (states[i]->running) {
-        states[i]->stopping = true;
+    while (states[i]->running.load(std::memory_order_acquire)) {
+        states[i]->stopping.store(true, std::memory_order_release);
         LOG_INFO("Emu %d: Waiting for the old thread to finish", i);
         vdf_usleep(1000);
     }
@@ -142,27 +143,26 @@ static void start_job(int i)
 
 static void disable_engine(int i)
 {
-    if (states[i] && states[i]->init_done && !states[i]->stopping) {
+    if (states[i] &&
+        states[i]->init_done.load(std::memory_order_acquire) &&
+        !states[i]->stopping.load(std::memory_order_acquire)) {
         LOG_INFO("Emu %d: Disabling engine", i);
-        states[i]->stopping = true;
+        states[i]->stopping.store(true, std::memory_order_release);
     }
 }
 
 static void enable_engine(int i)
 {
     if (!states[i]) {
         states[i] = new job_state;
-        states[i]->init_done = false;
-        states[i]->stopping = true;
-        states[i]->running = false;
         #ifdef _WIN32
         srand(1);
         #else
         srand48(1);
         #endif
     }
-    if (states[i]->stopping) {
-        states[i]->stopping = false;
+    if (states[i]->stopping.load(std::memory_order_acquire)) {
+        states[i]->stopping.store(false, std::memory_order_release);
         LOG_INFO("Emu %d: Enabling engine", i);
     }
 }
@@ -191,16 +191,17 @@ void inject_error(struct job_status *stat, struct job_state *st)
     #else
     const uint32_t rand_val = static_cast<uint32_t>(mrand48());
     #endif
-    if (p != 0 && (st->error || (rand_val % static_cast<uint32_t>(p) == 0))) {
+    if (p != 0 && (st->error.load(std::memory_order_acquire) ||
+            (rand_val % static_cast<uint32_t>(p) == 0))) {
         // Inject error by messing up 'a' register
         stat->a[10] = ~stat->a[10];
-        st->error = true;
+        st->error.store(true, std::memory_order_release);
     }
 }
 
 void update_status(struct job_status *stat, struct job_state *st)
 {
-    if (!st->stopping) {
+    if (!st->stopping.load(std::memory_order_acquire)) {
         st->mtx.lock();
         st->drv->write_bytes(sizeof(stat->iters), 0, (uint8_t *)stat->iters, st->cur_iter);
         st->drv->write_bytes(sizeof(stat->a), 0, (uint8_t *)stat->a, st->qf.a.impl, st->drv->NUM_2X_COEFFS);
@@ -248,7 +249,7 @@ void read_regs(uint32_t addr, uint8_t *buf, uint32_t size)
         uint32_t job_id_addr2 = job_status_base +
             CHIA_VDF_JOB_CSR_MULT * i;
 
-        if (!states[i] || !states[i]->init_done) {
+        if (!states[i] || !states[i]->init_done.load(std::memory_order_acquire)) {
             continue;
         }
 
 
@@ -0,0 +1,56 @@
+#include "verifier.h"
+
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace {
+
+std::vector<uint8_t> hex_to_bytes(const std::string& hex) {
+    EXPECT_EQ(hex.size() % 2, 0U);
+    std::vector<uint8_t> out;
+    out.reserve(hex.size() / 2);
+    for (size_t i = 0; i < hex.size(); i += 2) {
+        out.push_back(static_cast<uint8_t>(std::stoul(hex.substr(i, 2), nullptr, 16)));
+    }
+    return out;
+}
+
+integer get_fixture_discriminant() {
+    auto challenge = hex_to_bytes("9104c5b5e45d48f374efa0488fe6a617790e9aecb3c9cddec06809b09f45ce9b");
+    return CreateDiscriminant(challenge, 1024);
+}
+
+std::vector<uint8_t> get_fixture_form_bytes() {
+    auto proof_blob = hex_to_bytes(
+        "0200553bf0f382fc65a94f20afad5dbce2c1ee8ba3bf93053559ac9960c8fd80ac2222e9b649701a4141a4d8999f0dbfe0c39ea744096598a7528328e5199f0aa30aec8aae8ab5018bf1245329a8272ddff1afbd87ad2eaba1b7fd57bd25edc62e0b010000003f0ffcd0dc307a2aa4678bafba661c77d176ef23afc86e7ea9f4f9eac52b8e1850748019245ecc96547da9b731dc72cded5582a9b0c63e13fd42446c7b28b41d3ded1d0b666d5ddb5b29719e4ebe70969e67e42ddd8591eae60d83dbe619f1250400");
+    EXPECT_GE(proof_blob.size(), static_cast<size_t>(BQFC_FORM_SIZE));
+    return std::vector<uint8_t>(proof_blob.begin(), proof_blob.begin() + BQFC_FORM_SIZE);
+}
+
+}  // namespace
+
+TEST(ProofDeserializationRegressionTest, RejectsWrongSerializedSize) {
+    integer d = get_fixture_discriminant();
+    std::vector<uint8_t> too_short(BQFC_FORM_SIZE - 1, 0);
+    EXPECT_THROW((void)DeserializeForm(d, too_short.data(), too_short.size()), std::runtime_error);
+}
+
+TEST(ProofDeserializationRegressionTest, RejectsInvalidCompressedBytesWithoutCrash) {
+    integer d = get_fixture_discriminant();
+    std::vector<uint8_t> malformed(BQFC_FORM_SIZE, 0);
+    malformed[0] = 0x00;
+    malformed[1] = 0xFF;  // Impossible g_size for d_bits=1024.
+    EXPECT_THROW((void)DeserializeForm(d, malformed.data(), malformed.size()), std::runtime_error);
+}
+
+TEST(ProofDeserializationRegressionTest, RejectsNonCanonicalEncoding) {
+    integer d = get_fixture_discriminant();
+    std::vector<uint8_t> canonical = get_fixture_form_bytes();
+    EXPECT_NO_THROW((void)DeserializeForm(d, canonical.data(), canonical.size()));
+
+    canonical[BQFC_FORM_SIZE - 1] ^= 0x01;
+    EXPECT_THROW((void)DeserializeForm(d, canonical.data(), canonical.size()), std::runtime_error);
+}