set Wno-error for simplicity keep warning but dont error on it

fuzz test fixes

set -DPRODUCTION for simplicity in fuzz tests

set UNDEBUG for simplicity in fuzz tests

update wallet fuzz tests

update test script

fix msvc conversion issues

more msvc vector conversion fixes and substitution of boost libs

fix more hexstr calls

fix hexstr calls in init.cpp

default CMAKE_GENERATOR to Unix Makefiles

more span fixes

specify build bin directory

fix executable locations

fix fuzz tests for c11 and functional test fixes

fix fuzz test executable path

specify legacy wallet for elements functional tests

remove assertion for static initialization order issue

use elements fuzz corpus

print debug log on failure

use heap for blind and asset_blind

test: avoid disk space warning for non-regtest

feature_config_args.py incorrectly assumed that its testnet4 node
would not log a disk space warning.

0683b8e increased m_assumed_blockchain_size
on testnet4 from 1 to 11 GiB which triggers this bug on more
systems, e.g. a RAM disk.

Prevent the warning by setting -prune for these nodes.

Fix the same issue in feature_signet.py

Github-Pull: #32057
Rebased-From: 20fe41e

Author: tomt1664

.github/workflows/ci.yml

@@ -222,7 +222,7 @@ jobs:
 
       - name: Generate build system
         run: |
-          cmake -B build --preset vs2022-static -DCMAKE_TOOLCHAIN_FILE="$env:VCPKG_INSTALLATION_ROOT\scripts\buildsystems\vcpkg.cmake" ${{ matrix.generate-options }}
+          cmake -B build --preset vs2022-static -DCMAKE_TOOLCHAIN_FILE="$env:VCPKG_INSTALLATION_ROOT\scripts\buildsystems\vcpkg.cmake" -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE="${{ github.workspace }}/build/bin" ${{ matrix.generate-options }}
 
       - name: Save vcpkg binary cache
         uses: actions/cache/save@v4
@@ -246,18 +246,18 @@ jobs:
         if: matrix.job-type == 'standard'
         working-directory: build
         env:
-          BITCOIND: '${{ github.workspace }}\build\bin\Release\bitcoind.exe'
-          BITCOINCLI: '${{ github.workspace }}\build\bin\Release\bitcoin-cli.exe'
-          BITCOINUTIL: '${{ github.workspace }}\build\bin\Release\bitcoin-util.exe'
-          BITCOINWALLET: '${{ github.workspace }}\build\bin\Release\bitcoin-wallet.exe'
+          BITCOIND: '${{ github.workspace }}\build\bin\elementsd.exe'
+          BITCOINCLI: '${{ github.workspace }}\build\bin\elements-cli.exe'
+          BITCOINUTIL: '${{ github.workspace }}\build\bin\elements-util.exe'
+          BITCOINWALLET: '${{ github.workspace }}\build\bin\elements-wallet.exe'
           TEST_RUNNER_EXTRA: ${{ github.event_name != 'pull_request' && '--extended' || '' }}
         shell: cmd
         run: py -3 test\functional\test_runner.py --jobs %NUMBER_OF_PROCESSORS% --ci --quiet --tmpdirprefix=%RUNNER_TEMP% --combinedlogslen=99999999 --timeout-factor=%TEST_RUNNER_TIMEOUT_FACTOR% %TEST_RUNNER_EXTRA%
 
       - name: Clone corpora
         if: matrix.job-type == 'fuzz'
         run: |
-          git clone --depth=1 https://github.com/bitcoin-core/qa-assets "$env:RUNNER_TEMP\qa-assets"
+          git clone --depth=1 https://github.com/ElementsProject/qa-assets "$env:RUNNER_TEMP\qa-assets"
           Set-Location "$env:RUNNER_TEMP\qa-assets"
           Write-Host "Using qa-assets repo from commit ..."
           git log -1
@@ -266,7 +266,7 @@ jobs:
         if: matrix.job-type == 'fuzz'
         working-directory: build
         env:
-          BITCOINFUZZ: '${{ github.workspace }}\build\bin\Release\fuzz.exe'
+          BITCOINFUZZ: '${{ github.workspace }}\build\bin\fuzz.exe'
         shell: cmd
         run: |
           py -3 test\fuzz\test_runner.py --par %NUMBER_OF_PROCESSORS% --loglevel DEBUG %RUNNER_TEMP%\qa-assets\fuzz_corpora

ci/test/03_test_script.sh

@@ -124,7 +124,7 @@ fi
 # === CMake build (modern path used by the fork) ===
 if [ -n "$NO_DEPENDS" ]; then
   echo "Building with CMake (NO_DEPENDS=1)..."
-  cmake -B build -S . -G "$CMAKE_GENERATOR" $BITCOIN_CONFIG_ALL
+  cmake -B build -S . ${CMAKE_GENERATOR:+-G "$CMAKE_GENERATOR"} $BITCOIN_CONFIG_ALL
 else
   # depends path (still uses configure in some jobs)
   ./autogen.sh
@@ -133,6 +133,21 @@ fi
 
 cmake --build build --config Release --parallel "$MAKEJOBS"
 
+if [ -n "$NO_DEPENDS" ]; then
+  bash -c "${PRINT_CCACHE_STATISTICS}"
+
+  if [ "$RUN_UNIT_TESTS" = "true" ]; then
+    DIR_UNIT_TEST_DATA="${DIR_UNIT_TEST_DATA}" CTEST_OUTPUT_ON_FAILURE=ON ctest --stop-on-failure "${MAKEJOBS}" --timeout $(( TEST_RUNNER_TIMEOUT_FACTOR * 60 ))
+  fi
+
+  if [ "$RUN_FUNCTIONAL_TESTS" = "true" ]; then
+    eval "TEST_RUNNER_EXTRA=($TEST_RUNNER_EXTRA)"
+    test/functional/test_runner.py --ci "${MAKEJOBS}" --tmpdirprefix "${BASE_SCRATCH_DIR}"/test_runner/ --ansi --combinedlogslen=99999999 --timeout-factor="${TEST_RUNNER_TIMEOUT_FACTOR}" "${TEST_RUNNER_EXTRA[@]}" --quiet --failfast
+  fi
+
+  exit 0
+fi
+
 mkdir -p "${BASE_BUILD_DIR}"
 cd "${BASE_BUILD_DIR}"
 

src/CMakeLists.txt

@@ -105,6 +105,9 @@ target_include_directories(elementssimplicity
 target_compile_definitions(elementssimplicity PRIVATE PRODUCTION)
 # Simplicity requires assertions; remove NDEBUG that cmake adds for optimized builds.
 target_compile_options(elementssimplicity PRIVATE -UNDEBUG)
+target_compile_options(elementssimplicity PRIVATE
+  $<$<CXX_COMPILER_ID:MSVC>:/std:c11>
+)
 target_link_libraries(elementssimplicity
   PRIVATE
     core_interface
@@ -113,8 +116,8 @@ target_link_libraries(elementssimplicity
 # macOS Apple Clang is stricter than Linux GCC on this vendored code
 if(APPLE)
   target_compile_options(elementssimplicity PRIVATE
-    -Wno-conditional-uninitialized
-    -Wno-implicit-fallthrough
+    -Wno-error=conditional-uninitialized
+    -Wno-error=implicit-fallthrough
   )
 endif()
 

src/assetsdir.cpp

@@ -8,9 +8,6 @@
 #include <tinyformat.h>
 #include <util/strencodings.h>
 
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/split.hpp>
-
 void CAssetsDir::Set(const CAsset& asset, const AssetMetadata& metadata)
 {
     // No asset or label repetition
@@ -41,7 +38,11 @@ void CAssetsDir::InitFromStrings(const std::vector<std::string>& assetsToInit, c
 {
     for (std::string strToSplit : assetsToInit) {
         std::vector<std::string> vAssets;
-        boost::split(vAssets, strToSplit, boost::is_any_of(":"));
+        const auto pos = strToSplit.find(':');
+        if (pos != std::string::npos) {
+            vAssets.push_back(strToSplit.substr(0, pos));
+            vAssets.push_back(strToSplit.substr(pos + 1));
+        }
         if (vAssets.size() != 2) {
             throw std::runtime_error("-assetdir parameters malformed, expecting asset:label");
         }

src/blind.cpp

@@ -5,6 +5,7 @@
 #include <blind.h>
 #include <chainparams.h>
 
+#include <array>
 #include <hash.h>
 #include <primitives/transaction.h>
 #include <primitives/confidential.h>
@@ -474,8 +475,8 @@ int BlindTransaction(std::vector<uint256 >& input_value_blinding_factors, const
     //Running total of newly blinded outputs
     static const unsigned char diff_zero[32] = {0};
     assert(num_to_blind <= 10000); // More than 10k outputs? Stop spamming.
-    unsigned char blind[10000][32];
-    unsigned char asset_blind[10000][32];
+    std::vector<std::array<unsigned char, 32>> blind(num_to_blind);
+    std::vector<std::array<unsigned char, 32>> asset_blind(num_to_blind);
     secp256k1_pedersen_commitment value_commit;
     secp256k1_generator asset_gen;
     CAsset asset;

src/common/signmessage.cpp

@@ -65,7 +65,7 @@ bool MessageSign(
         return false;
     }
 
-    signature = EncodeBase64(signature_bytes);
+    signature = EncodeBase64(MakeByteSpan(signature_bytes));
 
     return true;
 }

src/core_read.cpp

@@ -143,7 +143,7 @@ static bool DecodeTx(CMutableTransaction& tx, const std::vector<unsigned char>&
     // Try decoding with extended serialization support, and remember if the result successfully
     // consumes the entire input.
     if (try_witness) {
-        DataStream ssData(tx_data);
+        DataStream ssData(MakeByteSpan(tx_data));
         try {
             ssData >> TX_WITH_WITNESS(tx_extended);
             if (ssData.empty()) ok_extended = true;
@@ -161,7 +161,7 @@ static bool DecodeTx(CMutableTransaction& tx, const std::vector<unsigned char>&
 
     // Try decoding with legacy serialization, and remember if the result successfully consumes the entire input.
     if (try_no_witness) {
-        DataStream ssData(tx_data);
+        DataStream ssData(MakeByteSpan(tx_data));
         try {
             ssData >> TX_NO_WITNESS(tx_legacy);
             if (ssData.empty()) ok_legacy = true;
@@ -208,7 +208,7 @@ bool DecodeHexBlockHeader(CBlockHeader& header, const std::string& hex_header)
     if (!IsHex(hex_header)) return false;
 
     const std::vector<unsigned char> header_data{ParseHex(hex_header)};
-    DataStream ser_header(header_data);
+    DataStream ser_header(MakeByteSpan(header_data));
     try {
         ser_header >> TX_WITH_WITNESS(header);
     } catch (const std::exception&) {
@@ -223,7 +223,7 @@ bool DecodeHexBlk(CBlock& block, const std::string& strHexBlk)
         return false;
 
     std::vector<unsigned char> blockData(ParseHex(strHexBlk));
-    DataStream ssBlock(blockData);
+    DataStream ssBlock(MakeByteSpan(blockData));
     try {
         ssBlock >> TX_WITH_WITNESS(block);
     }

src/core_write.cpp

@@ -88,14 +88,14 @@ std::string FormatScript(const CScript& script)
                 }
             }
             if (vch.size() > 0) {
-                ret += strprintf("0x%x 0x%x ", HexStr(std::vector<uint8_t>(it2, it - vch.size())),
-                                               HexStr(std::vector<uint8_t>(it - vch.size(), it)));
+                ret += strprintf("0x%x 0x%x ", HexStr(MakeByteSpan(std::vector<uint8_t>(it2, it - vch.size()))),
+                                               HexStr(MakeByteSpan(std::vector<uint8_t>(it - vch.size(), it))));
             } else {
-                ret += strprintf("0x%x ", HexStr(std::vector<uint8_t>(it2, it)));
+                ret += strprintf("0x%x ", HexStr(MakeByteSpan(std::vector<uint8_t>(it2, it))));
             }
             continue;
         }
-        ret += strprintf("0x%x ", HexStr(std::vector<uint8_t>(it2, script.end())));
+        ret += strprintf("0x%x ", HexStr(MakeByteSpan(std::vector<uint8_t>(it2, script.end()))));
         break;
     }
     return ret.substr(0, ret.empty() ? ret.npos : ret.size() - 1);
@@ -157,9 +157,9 @@ std::string ScriptToAsmStr(const CScript& script, const bool fAttemptSighashDeco
                             vch.pop_back(); // remove the sighash type byte. it will be replaced by the decode.
                         }
                     }
-                    str += HexStr(vch) + strSigHashDecode;
+                    str += HexStr(MakeByteSpan(vch)) + strSigHashDecode;
                 } else {
-                    str += HexStr(vch);
+                    str += HexStr(MakeByteSpan(vch));
                 }
             }
         } else {
@@ -180,7 +180,7 @@ UniValue EncodeHexScriptWitness(const CScriptWitness& witness)
 {
     UniValue witness_hex(UniValue::VARR);
     for (const auto &item : witness.stack) {
-        witness_hex.push_back(HexStr(item));
+        witness_hex.push_back(HexStr(MakeByteSpan(item)));
     }
     return witness_hex;
 }
@@ -292,7 +292,7 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
             if (!scriptWitness.IsNull()) {
                 UniValue txinwitness(UniValue::VARR);
                 for (const auto &item : scriptWitness.stack) {
-                    txinwitness.push_back(HexStr(item));
+                    txinwitness.push_back(HexStr(MakeByteSpan(item)));
                 }
                 in.pushKV("txinwitness", txinwitness);
             }
@@ -301,7 +301,7 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
         if (tx.witness.vtxinwit.size() > i && !tx.witness.vtxinwit[i].m_pegin_witness.IsNull()) {
             UniValue pegin_witness(UniValue::VARR);
             for (const auto& item : tx.witness.vtxinwit[i].m_pegin_witness.stack) {
-                pegin_witness.push_back(HexStr(item));
+                pegin_witness.push_back(HexStr(MakeByteSpan(item)));
             }
             in.pushKV("pegin_witness", pegin_witness);
         }
@@ -330,12 +330,12 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
             if (issuance.nAmount.IsExplicit()) {
                 issue.pushKV("assetamount", ValueFromAmount(issuance.nAmount.GetAmount()));
             } else if (issuance.nAmount.IsCommitment()) {
-                issue.pushKV("assetamountcommitment", HexStr(issuance.nAmount.vchCommitment));
+                issue.pushKV("assetamountcommitment", HexStr(MakeByteSpan(issuance.nAmount.vchCommitment)));
             }
             if (issuance.nInflationKeys.IsExplicit()) {
                 issue.pushKV("tokenamount", ValueFromAmount(issuance.nInflationKeys.GetAmount()));
             } else if (issuance.nInflationKeys.IsCommitment()) {
-                issue.pushKV("tokenamountcommitment", HexStr(issuance.nInflationKeys.vchCommitment));
+                issue.pushKV("tokenamountcommitment", HexStr(MakeByteSpan(issuance.nInflationKeys.vchCommitment)));
             }
             in.pushKV("issuance", issue);
         }
@@ -373,7 +373,7 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
                 }
 
                 if (ptxoutwit->vchSurjectionproof.size()) {
-                    out.pushKV("surjectionproof", HexStr(ptxoutwit->vchSurjectionproof));
+                    out.pushKV("surjectionproof", HexStr(MakeByteSpan(ptxoutwit->vchSurjectionproof)));
                 }
             }
             out.pushKV("valuecommitment", txout.nValue.GetHex());

src/httprpc.cpp

@@ -123,7 +123,7 @@ static bool multiUserAuthorized(std::string strUserPass)
 
         CHMAC_SHA256(reinterpret_cast<const unsigned char*>(strSalt.data()), strSalt.size()).Write(reinterpret_cast<const unsigned char*>(strPass.data()), strPass.size()).Finalize(out);
         std::vector<unsigned char> hexvec(out, out+KEY_SIZE);
-        std::string strHashFromPass = HexStr(hexvec);
+        std::string strHashFromPass = HexStr(MakeByteSpan(hexvec));
 
         if (TimingResistantEqual(strHashFromPass, strHash)) {
             return true;

src/i2p.cpp

@@ -438,7 +438,7 @@ void Session::CreateIfNotCreatedAlready()
             GenerateAndSavePrivateKey(*sock);
         }
 
-        const std::string& private_key_b64 = SwapBase64(EncodeBase64(m_private_key));
+        const std::string& private_key_b64 = SwapBase64(EncodeBase64(MakeByteSpan(m_private_key)));
 
         SendRequestAndGetReply(*sock,
                                strprintf("SESSION CREATE STYLE=STREAM ID=%s DESTINATION=%s "