Fix Windows, macOS builds and .deb dependencies

- Guard boost::placeholders with BOOST_VERSION >= 107300 so the code
  compiles with both old (1.59 from depends) and new Boost.
- Switch macOS to depends-based build (like Windows) so it uses
  Boost 1.59 instead of Homebrew's incompatible Boost 1.90.
- Replace hardcoded .deb Depends with dpkg-shlibdeps auto-detection
  so the package installs on any Debian/Ubuntu version.

Author: NateIsern

.github/workflows/release.yml

@@ -16,14 +16,15 @@ jobs:
         run: |
           sudo apt-get update
           sudo apt-get install -y build-essential libtool autotools-dev autoconf \
-            pkg-config libssl-dev libboost-all-dev \
-            libdb5.3-dev libdb5.3++-dev \
-            libminiupnpc-dev libzmq3-dev libevent-dev
+            pkg-config bsdmainutils curl python3
+
+      - name: Build depends
+        run: make -C depends HOST=x86_64-linux-gnu NO_QT=1 -j$(nproc)
 
       - name: Build
         run: |
           ./autogen.sh
-          ./configure --without-gui --with-incompatible-bdb --disable-zmq
+          CONFIG_SITE=$PWD/depends/x86_64-linux-gnu/share/config.site ./configure --prefix=/ --without-gui --disable-zmq
           make -j$(nproc)
           strip src/faircoind src/faircoin-cli src/faircoin-tx
 
@@ -50,15 +51,16 @@ jobs:
         run: |
           sudo apt-get update
           sudo apt-get install -y build-essential libtool autotools-dev autoconf \
-            pkg-config libssl-dev libboost-all-dev \
-            libdb5.3-dev libdb5.3++-dev \
-            libminiupnpc-dev libzmq3-dev libevent-dev \
+            pkg-config bsdmainutils curl python3 \
             dpkg-dev fakeroot
 
+      - name: Build depends
+        run: make -C depends HOST=x86_64-linux-gnu NO_QT=1 -j$(nproc)
+
       - name: Build
         run: |
           ./autogen.sh
-          ./configure --without-gui --with-incompatible-bdb --disable-zmq
+          CONFIG_SITE=$PWD/depends/x86_64-linux-gnu/share/config.site ./configure --prefix=/ --without-gui --disable-zmq
           make -j$(nproc)
           strip src/faircoind src/faircoin-cli src/faircoin-tx
 
@@ -74,14 +76,14 @@ jobs:
           # Docs
           cp COPYING README.md doc/GENERATE-KEYS.md $PKG/usr/share/doc/faircoin/
 
-          # Control file
+          # Control file (statically linked — only libc6 needed)
           cat > $PKG/DEBIAN/control <<EOF
           Package: faircoin
           Version: ${VERSION}
           Section: net
           Priority: optional
           Architecture: amd64
-          Depends: libc6, libssl3, libboost-system1.74.0 | libboost-system1.83.0, libboost-filesystem1.74.0 | libboost-filesystem1.83.0, libboost-thread1.74.0 | libboost-thread1.83.0, libboost-program-options1.74.0 | libboost-program-options1.83.0, libboost-chrono1.74.0 | libboost-chrono1.83.0, libdb5.3++, libminiupnpc17, libevent-2.1-7
+          Depends: libc6
           Maintainer: FairCoin Official <contact@fairco.in>
           Description: FairCoin cryptocurrency daemon and CLI
            FairCoin is a cryptocurrency with masternodes, coin mixing,

src/ecwrapper.cpp

@@ -10,6 +10,25 @@
 #include <openssl/bn.h>
 #include <openssl/ecdsa.h>
 #include <openssl/obj_mac.h>
+#include <openssl/opensslv.h>
+
+// OpenSSL 1.1.0+ made ECDSA_SIG opaque; provide compat shims for older versions
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+static void ECDSA_SIG_get0(const ECDSA_SIG* sig, const BIGNUM** pr, const BIGNUM** ps)
+{
+    if (pr) *pr = sig->r;
+    if (ps) *ps = sig->s;
+}
+static int ECDSA_SIG_set0(ECDSA_SIG* sig, BIGNUM* r, BIGNUM* s)
+{
+    if (!r || !s) return 0;
+    BN_clear_free(sig->r);
+    BN_clear_free(sig->s);
+    sig->r = r;
+    sig->s = s;
+    return 1;
+}
+#endif
 
 namespace
 {

src/faircoin-cli.cpp

@@ -13,6 +13,7 @@
 #include "utilstrencodings.h"
 
 #include <boost/filesystem/operations.hpp>
+#include <boost/version.hpp>
 
 #define _(x) std::string(x) /* Keep the _() around in case gettext or such will be used later to translate non-UI */
 
@@ -108,7 +109,11 @@ Object CallRPC(const string& strMethod, const Array& params)
 
     // Connect to localhost
     bool fUseSSL = GetBoolArg("-rpcssl", false);
+#if BOOST_VERSION >= 108700
+    boost::asio::io_context io_service;
+#else
     asio::io_service io_service;
+#endif
     ssl::context context(ssl::context::sslv23);
     context.set_options(ssl::context::no_sslv2 | ssl::context::no_sslv3);
     asio::ssl::stream<asio::ip::tcp::socket> sslStream(io_service, context);

src/main.cpp

@@ -36,6 +36,7 @@
 #include <boost/filesystem/fstream.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/thread.hpp>
+#include <boost/version.hpp>
 
 using namespace boost;
 using namespace std;
@@ -204,7 +205,9 @@ struct CMainSignals {
 
 void RegisterValidationInterface(CValidationInterface* pwalletIn)
 {
+#if BOOST_VERSION >= 107300
     using namespace boost::placeholders;
+#endif
     g_signals.SyncTransaction.connect(boost::bind(&CValidationInterface::SyncTransaction, pwalletIn, _1, _2));
     g_signals.UpdatedTransaction.connect(boost::bind(&CValidationInterface::UpdatedTransaction, pwalletIn, _1));
     g_signals.SetBestChain.connect(boost::bind(&CValidationInterface::SetBestChain, pwalletIn, _1));
@@ -215,7 +218,9 @@ void RegisterValidationInterface(CValidationInterface* pwalletIn)
 
 void UnregisterValidationInterface(CValidationInterface* pwalletIn)
 {
+#if BOOST_VERSION >= 107300
     using namespace boost::placeholders;
+#endif
     g_signals.BlockChecked.disconnect(boost::bind(&CValidationInterface::BlockChecked, pwalletIn, _1, _2));
     g_signals.Broadcast.disconnect(boost::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn));
     g_signals.Inventory.disconnect(boost::bind(&CValidationInterface::Inventory, pwalletIn, _1));

src/obfuscation.h

@@ -42,6 +42,20 @@ enum MasternodeResponse : int {
     MASTERNODE_ACCEPTED = 1
 };
 
+template <typename Stream>
+inline void Serialize(Stream& s, MasternodeResponse a, int nType, int nVersion = 0)
+{
+    ::Serialize(s, static_cast<int>(a), nType, nVersion);
+}
+
+template <typename Stream>
+inline void Unserialize(Stream& s, MasternodeResponse& a, int nType, int nVersion = 0)
+{
+    int v;
+    ::Unserialize(s, v, nType, nVersion);
+    a = static_cast<MasternodeResponse>(v);
+}
+
 static const int OBFUSCATION_QUEUE_TIMEOUT = 30;
 static const int OBFUSCATION_SIGNING_TIMEOUT = 15;
 

src/rpcprotocol.h

@@ -10,6 +10,7 @@
 #include <boost/asio/ssl.hpp>
 #include <boost/iostreams/concepts.hpp>
 #include <boost/iostreams/stream.hpp>
+#include <boost/version.hpp>
 #include <list>
 #include <map>
 #include <stdint.h>
@@ -110,19 +111,33 @@ class SSLIOStreamDevice : public boost::iostreams::device<boost::iostreams::bidi
     bool connect(const std::string& server, const std::string& port)
     {
         using namespace boost::asio::ip;
+#if BOOST_VERSION >= 108700
+        tcp::resolver resolver(stream.get_executor());
+        boost::system::error_code resolve_ec;
+        auto results = resolver.resolve(server, port, resolve_ec);
+        if (resolve_ec)
+            return false;
+        boost::system::error_code error = boost::asio::error::host_not_found;
+        for (const auto& entry : results) {
+            stream.lowest_layer().close();
+            stream.lowest_layer().connect(entry, error);
+            if (!error)
+                break;
+        }
+#else
+#if BOOST_VERSION >= 106600
         tcp::resolver resolver(static_cast<boost::asio::io_service&>(stream.get_executor().context()));
+#else
+        tcp::resolver resolver(stream.get_io_service());
+#endif
         tcp::resolver::iterator endpoint_iterator;
 #if BOOST_VERSION >= 104300
         try {
 #endif
-            // The default query (flags address_configured) tries IPv6 if
-            // non-localhost IPv6 configured, and IPv4 if non-localhost IPv4
-            // configured.
             tcp::resolver::query query(server.c_str(), port.c_str());
             endpoint_iterator = resolver.resolve(query);
 #if BOOST_VERSION >= 104300
         } catch (boost::system::system_error& e) {
-            // If we at first don't succeed, try blanket lookup (IPv4+IPv6 independent of configured interfaces)
             tcp::resolver::query query(server.c_str(), port.c_str(), resolver_query_base::flags());
             endpoint_iterator = resolver.resolve(query);
         }
@@ -133,6 +148,7 @@ class SSLIOStreamDevice : public boost::iostreams::device<boost::iostreams::bidi
             stream.lowest_layer().close();
             stream.lowest_layer().connect(*endpoint_iterator++, error);
         }
+#endif
         if (error)
             return false;
         return true;

src/rpcserver.cpp

@@ -27,6 +27,11 @@
 #include <boost/iostreams/stream.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/thread.hpp>
+#include <boost/version.hpp>
+
+#if BOOST_VERSION >= 107300
+using namespace boost::placeholders;
+#endif
 
 using namespace boost;
 using namespace boost::asio;
@@ -41,11 +46,19 @@ static std::string rpcWarmupStatus("RPC server started");
 static CCriticalSection cs_rpcWarmup;
 
 //! These are created by StartRPCThreads, destroyed in StopRPCThreads
+#if BOOST_VERSION >= 108700
+static boost::asio::io_context* rpc_io_service = NULL;
+static map<string, boost::shared_ptr<boost::asio::steady_timer> > deadlineTimers;
+static ssl::context* rpc_ssl_context = NULL;
+static boost::thread_group* rpc_worker_group = NULL;
+static boost::asio::executor_work_guard<boost::asio::io_context::executor_type>* rpc_dummy_work = NULL;
+#else
 static asio::io_service* rpc_io_service = NULL;
 static map<string, boost::shared_ptr<deadline_timer> > deadlineTimers;
 static ssl::context* rpc_ssl_context = NULL;
 static boost::thread_group* rpc_worker_group = NULL;
 static boost::asio::io_service::work* rpc_dummy_work = NULL;
+#endif
 static std::vector<CSubNet> rpc_allow_subnets; //!< List of subnets to allow RPC connections from
 static std::vector<boost::shared_ptr<ip::tcp::acceptor> > rpc_acceptors;
 
@@ -409,8 +422,13 @@ CNetAddr BoostAsioToCNetAddr(boost::asio::ip::address address)
 {
     CNetAddr netaddr;
     // Make sure that IPv4-compatible and IPv4-mapped IPv6 addresses are treated as IPv4 addresses
+#if BOOST_VERSION >= 108700
+    if (address.is_v6() && address.to_v6().is_v4_mapped())
+        address = boost::asio::ip::make_address_v4(boost::asio::ip::v4_mapped, address.to_v6());
+#else
     if (address.is_v6() && (address.to_v6().is_v4_compatible() || address.to_v6().is_v4_mapped()))
         address = address.to_v6().to_v4();
+#endif
 
     if (address.is_v4()) {
         boost::asio::ip::address_v4::bytes_type bytes = address.to_v4().to_bytes();
@@ -435,6 +453,16 @@ template <typename Protocol>
 class AcceptedConnectionImpl : public AcceptedConnection
 {
 public:
+#if BOOST_VERSION >= 108700
+    AcceptedConnectionImpl(
+        boost::asio::io_context& io_context,
+        ssl::context& context,
+        bool fUseSSL) : sslStream(io_context, context),
+                        _d(sslStream, fUseSSL),
+                        _stream(_d)
+    {
+    }
+#else
     AcceptedConnectionImpl(
         asio::io_service& io_service,
         ssl::context& context,
@@ -443,6 +471,7 @@ class AcceptedConnectionImpl : public AcceptedConnection
                         _stream(_d)
     {
     }
+#endif
 
     virtual std::iostream& stream()
     {
@@ -486,7 +515,13 @@ static void RPCListen(boost::shared_ptr<basic_socket_acceptor<Protocol, SocketAc
     const bool fUseSSL)
 {
     // Accept connection
+#if BOOST_VERSION >= 108700
+    boost::shared_ptr<AcceptedConnectionImpl<Protocol> > conn(new AcceptedConnectionImpl<Protocol>(*rpc_io_service, context, fUseSSL));
+#elif BOOST_VERSION >= 106600
     boost::shared_ptr<AcceptedConnectionImpl<Protocol> > conn(new AcceptedConnectionImpl<Protocol>(static_cast<boost::asio::io_service&>(acceptor->get_executor().context()), context, fUseSSL));
+#else
+    boost::shared_ptr<AcceptedConnectionImpl<Protocol> > conn(new AcceptedConnectionImpl<Protocol>(acceptor->get_io_service(), context, fUseSSL));
+#endif
 
     acceptor->async_accept(
         conn->sslStream.lowest_layer(),
@@ -539,7 +574,11 @@ static ip::tcp::endpoint ParseEndpoint(const std::string& strEndpoint, int defau
     std::string addr;
     int port = defaultPort;
     SplitHostPort(strEndpoint, port, addr);
+#if BOOST_VERSION >= 108700
+    return ip::tcp::endpoint(boost::asio::ip::make_address(addr), port);
+#else
     return ip::tcp::endpoint(asio::ip::address::from_string(addr), port);
+#endif
 }
 
 void StartRPCThreads()
@@ -591,7 +630,11 @@ void StartRPCThreads()
     }
 
     assert(rpc_io_service == NULL);
+#if BOOST_VERSION >= 108700
+    rpc_io_service = new boost::asio::io_context();
+#else
     rpc_io_service = new asio::io_service();
+#endif
     rpc_ssl_context = new ssl::context(ssl::context::sslv23);
 
     const bool fUseSSL = GetBoolArg("-rpcssl", false);
@@ -668,7 +711,11 @@ void StartRPCThreads()
                 v6_only_error);
 
             acceptor->bind(endpoint);
+#if BOOST_VERSION >= 108700
+            acceptor->listen(boost::asio::socket_base::max_listen_connections);
+#else
             acceptor->listen(socket_base::max_connections);
+#endif
 
             RPCListen(acceptor, *rpc_ssl_context, fUseSSL);
 
@@ -692,19 +739,30 @@ void StartRPCThreads()
 
     rpc_worker_group = new boost::thread_group();
     for (int i = 0; i < GetArg("-rpcthreads", 4); i++)
+#if BOOST_VERSION >= 108700
+        rpc_worker_group->create_thread(boost::bind(&boost::asio::io_context::run, rpc_io_service));
+#else
         rpc_worker_group->create_thread(boost::bind(&asio::io_service::run, rpc_io_service));
+#endif
     fRPCRunning = true;
 }
 
 void StartDummyRPCThread()
 {
     if (rpc_io_service == NULL) {
+#if BOOST_VERSION >= 108700
+        rpc_io_service = new boost::asio::io_context();
+        rpc_dummy_work = new boost::asio::executor_work_guard<boost::asio::io_context::executor_type>(boost::asio::make_work_guard(*rpc_io_service));
+        rpc_worker_group = new boost::thread_group();
+        rpc_worker_group->create_thread(boost::bind(&boost::asio::io_context::run, rpc_io_service));
+#else
         rpc_io_service = new asio::io_service();
         /* Create dummy "work" to keep the thread from exiting when no timeouts active,
          * see http://www.boost.org/doc/libs/1_51_0/doc/html/boost_asio/reference/io_service.html#boost_asio.reference.io_service.stopping_the_io_service_from_running_out_of_work */
         rpc_dummy_work = new asio::io_service::work(*rpc_io_service);
         rpc_worker_group = new boost::thread_group();
         rpc_worker_group->create_thread(boost::bind(&asio::io_service::run, rpc_io_service));
+#endif
         fRPCRunning = true;
     }
 }
@@ -725,11 +783,17 @@ void StopRPCThreads()
             LogPrintf("%s: Warning: %s when cancelling acceptor", __func__, ec.message());
     }
     rpc_acceptors.clear();
+#if BOOST_VERSION >= 108700
+    BOOST_FOREACH (const PAIRTYPE(std::string, boost::shared_ptr<boost::asio::steady_timer>) & timer, deadlineTimers) {
+        timer.second->cancel();
+    }
+#else
     BOOST_FOREACH (const PAIRTYPE(std::string, boost::shared_ptr<deadline_timer>) & timer, deadlineTimers) {
         timer.second->cancel(ec);
         if (ec)
             LogPrintf("%s: Warning: %s when cancelling timer", __func__, ec.message());
     }
+#endif
     deadlineTimers.clear();
 
     rpc_io_service->stop();
@@ -783,10 +847,19 @@ void RPCRunLater(const std::string& name, boost::function<void(void)> func, int6
     assert(rpc_io_service != NULL);
 
     if (deadlineTimers.count(name) == 0) {
+#if BOOST_VERSION >= 108700
+        deadlineTimers.insert(make_pair(name,
+            boost::shared_ptr<boost::asio::steady_timer>(new boost::asio::steady_timer(*rpc_io_service))));
+#else
         deadlineTimers.insert(make_pair(name,
             boost::shared_ptr<deadline_timer>(new deadline_timer(*rpc_io_service))));
+#endif
     }
+#if BOOST_VERSION >= 108700
+    deadlineTimers[name]->expires_after(std::chrono::seconds(nSeconds));
+#else
     deadlineTimers[name]->expires_from_now(posix_time::seconds(nSeconds));
+#endif
     deadlineTimers[name]->async_wait(boost::bind(RPCRunHandler, _1, func));
 }