Rebrand hush3 to DragonX and share RandomX dataset across mining threads

Minimal rebrand (see compliant-rebrand branch for full rebrand): - Rename binaries: hushd/hush-cli/hush-tx → dragonxd/dragonx-cli/dragonx-tx - Default to DRAGONX chain params without -ac_* flags (randomx, blocktime=36, private=1) - Update configure.ac: AC_INIT([DragonX],[1.0.0]) - Update client version string and user-agent to /DragonX:1.0.0/ - Add chainparams.cpp with DRAGONX network parameters - Update build.sh, miner.cpp, pow.cpp for DragonX - Add bootstrap-dragonx.sh utility script - Update .gitignore for release directory Share single RandomX dataset across all mining threads: - Add RandomXDatasetManager with readers-writer lock, reducing RAM from ~2GB per thread to ~2GB total plus ~2MB per thread for the VM scratchpad - Add LogProcessMemory() diagnostic helper for Linux and Windows
2026-03-03 17:00:49 -06:00
parent d6ba1aed4e
commit 85c8d7f7dd
27 changed files with 3668 additions and 243 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -167,4 +167,8 @@ REGTEST_7776
 src/cc/librogue.so
 src/cc/games/prices
 src/cc/games/tetris
-release-linux/
+release-linux/
+release/
+src/dragonxd
+src/dragonx-cli
+src/dragonx-tx
--- a/build.sh
+++ b/build.sh
@@ -1,19 +1,152 @@
 #!/usr/bin/env bash
 # Copyright (c) 2016-2024 The Hush developers
+# Copyright (c) 2024-2026 The DragonX developers
 # Distributed under the GPLv3 software license, see the accompanying
 # file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html

 set -eu -o pipefail

-# run correct build script for detected OS
+VERSION="1.0.0"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+RELEASE_DIR="$SCRIPT_DIR/release"
+
+# Parse release flags
+BUILD_LINUX_RELEASE=0
+BUILD_WIN_RELEASE=0
+BUILD_MAC_RELEASE=0
+REMAINING_ARGS=()
+
+for arg in "$@"; do
+    case "$arg" in
+        --linux-release)
+            BUILD_LINUX_RELEASE=1
+            ;;
+        --win-release)
+            BUILD_WIN_RELEASE=1
+            ;;
+        --mac-release)
+            BUILD_MAC_RELEASE=1
+            ;;
+        --all-release)
+            BUILD_LINUX_RELEASE=1
+            BUILD_WIN_RELEASE=1
+            BUILD_MAC_RELEASE=1
+            ;;
+        *)
+            REMAINING_ARGS+=("$arg")
+            ;;
+    esac
+done
+
+# Clean artifacts that may conflict between platform builds
+clean_for_platform() {
+    local platform="$1"
+    echo "Cleaning build artifacts for $platform build..."
+    
+    # Use make clean if Makefile exists (safer than manual deletion)
+    if [ -f src/Makefile ]; then
+        make -C src clean 2>/dev/null || true
+    fi
+    
+    # Remove final binaries
+    if [ -d src ]; then
+        rm -f src/dragonxd src/dragonx-cli src/dragonx-tx 2>/dev/null || true
+        rm -f src/dragonxd.exe src/dragonx-cli.exe src/dragonx-tx.exe 2>/dev/null || true
+        rm -f src/hushd src/hush-cli src/hush-tx 2>/dev/null || true
+        rm -f src/hushd.exe src/hush-cli.exe src/hush-tx.exe 2>/dev/null || true
+    fi
+    
+    # Clean RandomX build for cross-platform compatibility
+    rm -rf src/RandomX/build 2>/dev/null || true
+    
+    # Clean cryptoconditions
+    rm -rf src/cc/*.o src/cc/*.a 2>/dev/null || true
+    
+    # Clean config cache (forces reconfigure for cross-platform)
+    rm -f config.status config.log 2>/dev/null || true
+    
+    echo "Clean complete for $platform"
+}
+
+# Package release for a platform
+package_release() {
+    local platform="$1"
+    local release_subdir="$RELEASE_DIR/dragonx-$VERSION-$platform"
+    
+    echo "Packaging release for $platform..."
+    mkdir -p "$release_subdir"
+    
+    # Copy bootstrap script
+    cp "$SCRIPT_DIR/util/bootstrap-dragonx.sh" "$release_subdir/"
+    
+    # Copy common files
+    cp "$SCRIPT_DIR/contrib/asmap/asmap.dat" "$release_subdir/" 2>/dev/null || true
+    cp "$SCRIPT_DIR/sapling-output.params" "$release_subdir/" 2>/dev/null || true
+    cp "$SCRIPT_DIR/sapling-spend.params" "$release_subdir/" 2>/dev/null || true
+    
+    case "$platform" in
+        linux-amd64)
+            cp "$SCRIPT_DIR/src/dragonxd" "$release_subdir/"
+            cp "$SCRIPT_DIR/src/dragonx-cli" "$release_subdir/"
+            cp "$SCRIPT_DIR/src/dragonx-tx" "$release_subdir/"
+            strip "$release_subdir/dragonxd" "$release_subdir/dragonx-cli" "$release_subdir/dragonx-tx"
+            ;;
+        win64)
+            cp "$SCRIPT_DIR/src/dragonxd.exe" "$release_subdir/"
+            cp "$SCRIPT_DIR/src/dragonx-cli.exe" "$release_subdir/"
+            cp "$SCRIPT_DIR/src/dragonx-tx.exe" "$release_subdir/"
+            x86_64-w64-mingw32-strip "$release_subdir/"*.exe 2>/dev/null || strip "$release_subdir/"*.exe 2>/dev/null || true
+            ;;
+        macos)
+            cp "$SCRIPT_DIR/src/dragonxd" "$release_subdir/"
+            cp "$SCRIPT_DIR/src/dragonx-cli" "$release_subdir/"
+            cp "$SCRIPT_DIR/src/dragonx-tx" "$release_subdir/"
+            strip "$release_subdir/dragonxd" "$release_subdir/dragonx-cli" "$release_subdir/dragonx-tx" 2>/dev/null || true
+            ;;
+    esac
+    
+    echo "Release packaged: $release_subdir"
+    ls -la "$release_subdir"
+}
+
+# Handle release builds
+if [ $BUILD_LINUX_RELEASE -eq 1 ] || [ $BUILD_WIN_RELEASE -eq 1 ] || [ $BUILD_MAC_RELEASE -eq 1 ]; then
+    mkdir -p "$RELEASE_DIR"
+    
+    if [ $BUILD_LINUX_RELEASE -eq 1 ]; then
+        echo "=== Building Linux release ==="
+        clean_for_platform linux
+        ./util/build.sh --disable-tests "${REMAINING_ARGS[@]}"
+        package_release linux-amd64
+    fi
+    
+    if [ $BUILD_WIN_RELEASE -eq 1 ]; then
+        echo "=== Building Windows release ==="
+        clean_for_platform windows
+        ./util/build-win.sh --disable-tests "${REMAINING_ARGS[@]}"
+        package_release win64
+    fi
+    
+    if [ $BUILD_MAC_RELEASE -eq 1 ]; then
+        echo "=== Building macOS release ==="
+        clean_for_platform macos
+        ./util/build-mac.sh --disable-tests "${REMAINING_ARGS[@]}"
+        package_release macos
+    fi
+    
+    echo ""
+    echo "=== Release builds complete ==="
+    ls -la "$RELEASE_DIR"/
+    exit 0
+fi
+
+# Standard build (auto-detect OS)
 if [[ "$OSTYPE" == "linux-gnu"* ]]; then
-    ./util/build.sh --disable-tests $@
+    ./util/build.sh --disable-tests "${REMAINING_ARGS[@]}"
 elif [[ "$OSTYPE" == "darwin"* ]]; then
-    ./util/build-mac.sh --disable-tests $@
+    ./util/build-mac.sh --disable-tests "${REMAINING_ARGS[@]}"
 elif [[ "$OSTYPE" == "msys"* ]]; then
-    ./util/build-win.sh --disable-tests $@
-#elif [[ "$OSTYPE" == "freebsd"* ]]; then
-    # placeholder
+    ./util/build-win.sh --disable-tests "${REMAINING_ARGS[@]}"
 else
    echo "Unable to detect your OS. What are you using?"
 fi
--- a/configure.ac
+++ b/configure.ac
@@ -1,23 +1,23 @@
 dnl require autoconf 2.60 (AS_ECHO/AS_ECHO_N)
 AC_PREREQ([2.60])
-define(_CLIENT_VERSION_MAJOR, 3)
+define(_CLIENT_VERSION_MAJOR, 1)
 dnl Must be kept in sync with src/clientversion.h , ugh!
-define(_CLIENT_VERSION_MINOR, 10)
-define(_CLIENT_VERSION_REVISION, 5)
+define(_CLIENT_VERSION_MINOR, 0)
+define(_CLIENT_VERSION_REVISION, 0)
 define(_CLIENT_VERSION_BUILD, 50)
 define(_ZC_BUILD_VAL, m4_if(m4_eval(_CLIENT_VERSION_BUILD < 25), 1, m4_incr(_CLIENT_VERSION_BUILD), m4_eval(_CLIENT_VERSION_BUILD < 50), 1, m4_eval(_CLIENT_VERSION_BUILD - 24), m4_eval(_CLIENT_VERSION_BUILD == 50), 1, , m4_eval(_CLIENT_VERSION_BUILD - 50)))
 define(_CLIENT_VERSION_SUFFIX, m4_if(m4_eval(_CLIENT_VERSION_BUILD < 25), 1, _CLIENT_VERSION_REVISION-beta$1, m4_eval(_CLIENT_VERSION_BUILD < 50), 1, _CLIENT_VERSION_REVISION-rc$1, m4_eval(_CLIENT_VERSION_BUILD == 50), 1, _CLIENT_VERSION_REVISION, _CLIENT_VERSION_REVISION-$1)))
 define(_CLIENT_VERSION_IS_RELEASE, true)
 define(_COPYRIGHT_YEAR, 2026)
-AC_INIT([Hush],[_CLIENT_VERSION_MAJOR._CLIENT_VERSION_MINOR._CLIENT_VERSION_SUFFIX(_ZC_BUILD_VAL)],[https://git.hush.is/hush/hush3],[hush])
+AC_INIT([DragonX],[_CLIENT_VERSION_MAJOR._CLIENT_VERSION_MINOR._CLIENT_VERSION_SUFFIX(_ZC_BUILD_VAL)],[https://git.dragonx.is/DragonX/dragonx],[dragonx])
 AC_CONFIG_SRCDIR([src/main.cpp])
 AC_CONFIG_HEADERS([src/config/bitcoin-config.h])
 AC_CONFIG_AUX_DIR([build-aux])
 AC_CONFIG_MACRO_DIR([build-aux/m4])

-BITCOIN_DAEMON_NAME=hushd
-BITCOIN_CLI_NAME=hush-cli
-BITCOIN_TX_NAME=hush-tx
+BITCOIN_DAEMON_NAME=dragonxd
+BITCOIN_CLI_NAME=dragonx-cli
+BITCOIN_TX_NAME=dragonx-tx

 dnl Unless the user specified ARFLAGS, force it to be cr
 AC_ARG_VAR(ARFLAGS, [Flags for the archiver, defaults to <cr> if not set])
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -94,11 +94,11 @@ noinst_PROGRAMS =
 TESTS =

 #if BUILD_BITCOIND
-  bin_PROGRAMS += hushd
+  bin_PROGRAMS += dragonxd
 #endif

 if BUILD_BITCOIN_UTILS
-  bin_PROGRAMS += hush-cli hush-tx
+  bin_PROGRAMS += dragonx-cli dragonx-tx
 endif
 if ENABLE_WALLET
  bin_PROGRAMS += wallet-utility
@@ -453,16 +453,16 @@ nodist_libbitcoin_util_a_SOURCES = $(srcdir)/obj/build.h
 #

 # hushd binary #
-hushd_SOURCES = bitcoind.cpp
-hushd_CPPFLAGS = -fPIC $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
-hushd_CXXFLAGS = -fPIC $(AM_CXXFLAGS) $(PIE_FLAGS)
-hushd_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+dragonxd_SOURCES = bitcoind.cpp
+dragonxd_CPPFLAGS = -fPIC $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
+dragonxd_CXXFLAGS = -fPIC $(AM_CXXFLAGS) $(PIE_FLAGS)
+dragonxd_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)

 if TARGET_WINDOWS
-hushd_SOURCES += bitcoind-res.rc
+dragonxd_SOURCES += bitcoind-res.rc
 endif

-hushd_LDADD = \
+dragonxd_LDADD = \
  $(LIBBITCOIN_SERVER) \
  $(LIBBITCOIN_COMMON) \
  $(LIBUNIVALUE) \
@@ -476,10 +476,10 @@ hushd_LDADD = \
  $(LIBRANDOMX)

 if ENABLE_WALLET
-hushd_LDADD += $(LIBBITCOIN_WALLET)
+dragonxd_LDADD += $(LIBBITCOIN_WALLET)
 endif

-hushd_LDADD += \
+dragonxd_LDADD += \
  $(BOOST_LIBS) \
  $(BDB_LIBS) \
  $(SSL_LIBS) \
@@ -490,27 +490,27 @@ hushd_LDADD += \
  $(LIBZCASH_LIBS)

 if TARGET_DARWIN
-hushd_LDADD += libcc.dylib $(LIBSECP256K1)
+dragonxd_LDADD += libcc.dylib $(LIBSECP256K1)
 endif
 if TARGET_WINDOWS
-hushd_LDADD += libcc.dll $(LIBSECP256K1)
+dragonxd_LDADD += libcc.dll $(LIBSECP256K1)
 endif
 if TARGET_LINUX
-hushd_LDADD += libcc.so $(LIBSECP256K1)
+dragonxd_LDADD += libcc.so $(LIBSECP256K1)
 endif

 # [+] Decker: use static linking for libstdc++.6.dylib, libgomp.1.dylib, libgcc_s.1.dylib
 if TARGET_DARWIN
-hushd_LDFLAGS += -static-libgcc
+dragonxd_LDFLAGS += -static-libgcc
 endif

 # hush-cli binary #
-hush_cli_SOURCES = bitcoin-cli.cpp
-hush_cli_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(EVENT_CFLAGS)
-hush_cli_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
-hush_cli_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+dragonx_cli_SOURCES = bitcoin-cli.cpp
+dragonx_cli_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(EVENT_CFLAGS)
+dragonx_cli_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+dragonx_cli_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
 if TARGET_DARWIN
-hush_cli_LDFLAGS += -static-libgcc
+dragonx_cli_LDFLAGS += -static-libgcc
 endif

 # wallet-utility binary #
@@ -522,10 +522,10 @@ wallet_utility_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
 endif

 if TARGET_WINDOWS
-hush_cli_SOURCES += bitcoin-cli-res.rc
+dragonx_cli_SOURCES += bitcoin-cli-res.rc
 endif

-hush_cli_LDADD = \
+dragonx_cli_LDADD = \
 	$(LIBBITCOIN_CLI) \
 	$(LIBUNIVALUE) \
 	$(LIBBITCOIN_UTIL) \
@@ -554,16 +554,16 @@ wallet_utility_LDADD = \
 endif

 # hush-tx binary #
-hush_tx_SOURCES = hush-tx.cpp
-hush_tx_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
-hush_tx_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
-hush_tx_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+dragonx_tx_SOURCES = hush-tx.cpp
+dragonx_tx_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
+dragonx_tx_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+dragonx_tx_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)

 if TARGET_WINDOWS
-hush_tx_SOURCES += bitcoin-tx-res.rc
+dragonx_tx_SOURCES += bitcoin-tx-res.rc
 endif

-hush_tx_LDADD = \
+dragonx_tx_LDADD = \
  $(LIBUNIVALUE) \
  $(LIBBITCOIN_COMMON) \
  $(LIBBITCOIN_UTIL) \
@@ -574,7 +574,7 @@ hush_tx_LDADD = \
  $(LIBZCASH_LIBS) \
  $(LIBRANDOMX)

-hush_tx_LDADD += $(BOOST_LIBS) $(CRYPTO_LIBS)
+dragonx_tx_LDADD += $(BOOST_LIBS) $(CRYPTO_LIBS)

 # Zcash Protocol Primitives
 libzcash_a_SOURCES = \
--- a/src/ac.json
+++ b/src/ac.json
@@ -13,7 +13,7 @@
      "ac_perc": "11111111",
      "ac_eras": "3",
      "ac_script": "76a9145eb10cf64f2bab1b457f1f25e658526155928fac88ac",
-      "clientname": "GoldenSandtrout",
+      "clientname": "DragonX",
      "addnode": [
        "node1.hush.is",
        "node2.hush.is",
--- a/src/bitcoin-cli.cpp
+++ b/src/bitcoin-cli.cpp
@@ -29,8 +29,8 @@
 #include <event2/keyvalq_struct.h>
 #include "support/events.h"

-uint16_t ASSETCHAINS_RPCPORT = 18031;
-uint16_t BITCOIND_RPCPORT = 18031;
+uint16_t ASSETCHAINS_RPCPORT = 21769;
+uint16_t BITCOIND_RPCPORT = 21769;
 char SMART_CHAIN_SYMBOL[65];

 extern uint16_t ASSETCHAINS_RPCPORT;
@@ -47,7 +47,7 @@ std::string HelpMessageCli()
    std::string strUsage;
    strUsage += HelpMessageGroup(_("Options:"));
    strUsage += HelpMessageOpt("-?", _("This help message"));
-    strUsage += HelpMessageOpt("-conf=<file>", strprintf(_("Specify configuration file (default: %s)"), "HUSH3.conf"));
+    strUsage += HelpMessageOpt("-conf=<file>", strprintf(_("Specify configuration file (default: %s)"), "DRAGONX.conf"));
    strUsage += HelpMessageOpt("-datadir=<dir>", _("Specify data directory (this path cannot use '~')"));
    strUsage += HelpMessageOpt("-testnet", _("Use the test network"));
    strUsage += HelpMessageOpt("-regtest", _("Enter regression test mode, which uses a special chain in which blocks can be "
@@ -87,19 +87,19 @@ static int AppInitRPC(int argc, char* argv[])
    ParseParameters(argc, argv);
    std:string name;

-    // default HAC is HUSH3 itself, which to the internals, is also a HAC
-    name = GetArg("-ac_name","HUSH3");
+    // default HAC is DRAGONX itself, which to the internals, is also a HAC
+    name = GetArg("-ac_name","DRAGONX");

    if ( !name.empty() )
        strncpy(SMART_CHAIN_SYMBOL,name.c_str(),sizeof(SMART_CHAIN_SYMBOL)-1);

    if (argc<2 || mapArgs.count("-?") || mapArgs.count("-h") || mapArgs.count("-help") || mapArgs.count("-version")) {
-        std::string strUsage = _("Hush RPC client version") + " " + FormatFullVersion() + "\n" + PrivacyInfo();
+        std::string strUsage = _("DragonX RPC client version") + " " + FormatFullVersion() + "\n" + PrivacyInfo();
        if (!mapArgs.count("-version")) {
            strUsage += "\n" + _("Usage:") + "\n" +
-                  "  hush-cli [options] <command> [params]  " + _("Send command to Hush") + "\n" +
-                  "  hush-cli [options] help                " + _("List commands") + "\n" +
-                  "  hush-cli [options] help <command>      " + _("Get help for a command") + "\n";
+                  "  dragonx-cli [options] <command> [params]  " + _("Send command to DragonX") + "\n" +
+                  "  dragonx-cli [options] help                " + _("List commands") + "\n" +
+                  "  dragonx-cli [options] help <command>      " + _("Get help for a command") + "\n";

            strUsage += "\n" + HelpMessageCli();
        } else {
--- a/src/bitcoind.cpp
+++ b/src/bitcoind.cpp
@@ -117,14 +117,14 @@ bool AppInit(int argc, char* argv[])
    // Process help and version before taking care about datadir
    if (mapArgs.count("-?") || mapArgs.count("-h") ||  mapArgs.count("-help") || mapArgs.count("-version"))
    {
-        std::string strUsage = _("Hush Daemon") + " " + _("version") + " " + FormatFullVersion() + "\n" + PrivacyInfo();
+        std::string strUsage = _("DragonX Daemon") + " " + _("version") + " " + FormatFullVersion() + "\n" + PrivacyInfo();

        if (mapArgs.count("-version"))
        {
            strUsage += LicenseInfo();
        } else {
            strUsage += "\n" + _("Usage:") + "\n" +
-                  "  hushd [options]                     " + _("Start a Hush Daemon") + "\n";
+                  "  dragonxd [options]                  " + _("Start DragonX Daemon") + "\n";

            strUsage += "\n" + HelpMessage(HMM_BITCOIND);
        }
@@ -167,13 +167,13 @@ bool AppInit(int argc, char* argv[])
                   "\n"
                   "You can look at the example configuration file for suggestions of default\n"
                   "options that you may want to change. It should be in one of these locations,\n"
-                   "depending on how you installed Hush\n") +
+                   "depending on how you installed DragonX\n") +
                 _("- Source code:  %s\n"
                   "- .deb package: %s\n")).c_str(),
                GetConfigFile().string().c_str(),
-                "contrib/debian/examples/HUSH3.conf",
-                "/usr/share/doc/hush/examples/HUSH3.conf",
-                "https://git.hush.is/hush/hush3/src/branch/master/contrib/debian/examples/HUSH3.conf");
+                "contrib/debian/examples/DRAGONX.conf",
+                "/usr/share/doc/dragonx/examples/DRAGONX.conf",
+                "https://git.dragonx.is/DragonX/dragonx/src/branch/main/contrib/debian/examples/DRAGONX.conf");
            return false;
        } catch (const std::exception& e) {
            fprintf(stderr,"Error reading configuration file: %s\n", e.what());
@@ -183,15 +183,15 @@ bool AppInit(int argc, char* argv[])
        // Command-line RPC
        bool fCommandLine = false;
        for (int i = 1; i < argc; i++) {
-            // detect accidental use of RPC in hushd
-            if (!IsSwitchChar(argv[i][0]) && !boost::algorithm::istarts_with(argv[i], "hush:")) {
+            // detect accidental use of RPC in dragonxd
+            if (!IsSwitchChar(argv[i][0]) && !boost::algorithm::istarts_with(argv[i], "dragonx:")) {
                fCommandLine = true;
 			}
 		}

        if (fCommandLine)
        {
-            fprintf(stderr, "Error: Ooops! There is no RPC client functionality in hushd. Use the hush-cli utility instead.\n");
+            fprintf(stderr, "Error: Ooops! There is no RPC client functionality in dragonxd. Use the dragonx-cli utility instead.\n");
            exit(EXIT_FAILURE);
        }

@@ -199,7 +199,7 @@ bool AppInit(int argc, char* argv[])
        fDaemon = GetBoolArg("-daemon", false);
        if (fDaemon)
        {
-            fprintf(stdout, "Hush %s server starting\n",SMART_CHAIN_SYMBOL);
+            fprintf(stdout, "DragonX %s server starting\n",SMART_CHAIN_SYMBOL);

            // Daemonize
            pid_t pid = fork();
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
--- a/src/chainparamsbase.cpp
+++ b/src/chainparamsbase.cpp
@@ -30,7 +30,7 @@ class CBaseMainParams : public CBaseChainParams
 public:
    CBaseMainParams()
    {
-        nRPCPort = 18031;
+        nRPCPort = 21769;
    }
 };
 static CBaseMainParams mainParams;
--- a/src/clientversion.cpp
+++ b/src/clientversion.cpp
@@ -32,7 +32,7 @@
 * for both bitcoind and bitcoin-core, to make it harder for attackers to
 * target servers or GUI users specifically.
 */
-const std::string CLIENT_NAME = GetArg("-clientname", "GoldenSandtrout");
+const std::string CLIENT_NAME = GetArg("-clientname", "DragonX");

 /**
 * Client version number
--- a/src/clientversion.h
+++ b/src/clientversion.h
@@ -28,9 +28,9 @@
 // client versioning and copyright year
 //! These need to be macros, as clientversion.cpp's and bitcoin*-res.rc's voodoo requires it
 // Must be kept in sync with configure.ac , ugh!
-#define CLIENT_VERSION_MAJOR 3
-#define CLIENT_VERSION_MINOR 10
-#define CLIENT_VERSION_REVISION 5
+#define CLIENT_VERSION_MAJOR 1
+#define CLIENT_VERSION_MINOR 0
+#define CLIENT_VERSION_REVISION 0
 #define CLIENT_VERSION_BUILD 50

 //! Set to true for release, false for prerelease or test build
@@ -40,7 +40,7 @@
 * Copyright year (2009-this)
 * Todo: update this when changing our copyright comments in the source
 */
-#define COPYRIGHT_YEAR 2024
+#define COPYRIGHT_YEAR 2026

 #endif //HAVE_CONFIG_H

--- a/src/hush_bitcoind.h
+++ b/src/hush_bitcoind.h
@@ -403,7 +403,7 @@ int32_t notarizedtxid_height(char *dest,char *txidstr,int32_t *hushnotarized_hei
    params[0] = 0;
    *hushnotarized_heightp = 0;
    if ( strcmp(dest,"HUSH3") == 0 ) {
-        port     = HUSH3_PORT;
+        port     = DRAGONX_PORT;
        userpass = HUSHUSERPASS;
    } else if ( strcmp(dest,"BTC") == 0 )
    {
@@ -498,7 +498,7 @@ int32_t hush_verifynotarization(char *symbol,char *dest,int32_t height,int32_t N
        {
            if ( SMART_CHAIN_SYMBOL[0] != 0 )
            {
-                jsonstr = hush_issuemethod(HUSHUSERPASS,(char *)"getrawtransaction",params,HUSH3_PORT);
+                jsonstr = hush_issuemethod(HUSHUSERPASS,(char *)"getrawtransaction",params,DRAGONX_PORT);
                //printf("userpass.(%s) got (%s)\n",HUSHUSERPASS,jsonstr);
            }
        }//else jsonstr = _dex_getrawtransaction();
--- a/src/hush_globals.h
+++ b/src/hush_globals.h
@@ -102,7 +102,7 @@ int32_t ASSETCHAINS_OVERWINTER = -1;
 int32_t ASSETCHAINS_STAKED;
 uint64_t ASSETCHAINS_COMMISSION,ASSETCHAINS_SUPPLY = 10,ASSETCHAINS_FOUNDERS_REWARD;
 uint32_t HUSH_INITDONE;
-char HUSHUSERPASS[8192+512+1],BTCUSERPASS[8192]; uint16_t HUSH3_PORT = 18031,BITCOIND_RPCPORT = 18031;
+char HUSHUSERPASS[8192+512+1],BTCUSERPASS[8192]; uint16_t DRAGONX_PORT = 21769,BITCOIND_RPCPORT = 21769;
 uint64_t PENDING_HUSH_TX;
 extern int32_t HUSH_LOADINGBLOCKS;
 unsigned int MAX_BLOCK_SIGOPS = 20000;
--- a/src/hush_utils.h
+++ b/src/hush_utils.h
@@ -1413,20 +1413,20 @@ void hush_configfile(char *symbol,uint16_t rpcport)
 #ifdef _WIN32
    while ( fname[strlen(fname)-1] != '\\' )
        fname[strlen(fname)-1] = 0;
-    strcat(fname,"HUSH3.conf");
+    strcat(fname,"DRAGONX.conf");
 #else
    while ( fname[strlen(fname)-1] != '/' )
        fname[strlen(fname)-1] = 0;
 #ifdef __APPLE__
-    strcat(fname,"HUSH3.conf");
+    strcat(fname,"DRAGONX.conf");
 #else
-    strcat(fname,"HUSH3.conf");
+    strcat(fname,"DRAGONX.conf");
 #endif
 #endif
    if ( (fp= fopen(fname,"rb")) != 0 )
    {
        if ( (hushport= _hush_userpass(username,password,fp)) != 0 )
-            HUSH3_PORT = hushport;
+            DRAGONX_PORT = hushport;
        sprintf(HUSHUSERPASS,"%s:%s",username,password);
        fclose(fp);
        //printf("HUSH.(%s) -> userpass.(%s)\n",fname,HUSHUSERPASS);
@@ -1790,38 +1790,28 @@ void hush_args(char *argv0)
    }


-	name = GetArg("-ac_name","HUSH3");
+	name = GetArg("-ac_name","DRAGONX");
    fprintf(stderr,".oO Starting %s Full Node (Extreme Privacy!) with genproc=%d notary=%d\n",name.c_str(),HUSH_MININGTHREADS, IS_HUSH_NOTARY);

-    vector<string> HUSH_nodes = {};
-    // Only HUSH3 uses these by default, other HACs must opt-in via -connect/-addnode
-    const bool ishush3   = strncmp(name.c_str(), "HUSH3",5) == 0   ? true : false;
+    vector<string> DRAGONX_nodes = {};
+    // Only DRAGONX connects to these by default, other chains must opt-in via -connect/-addnode
+    const bool isdragonx = strncmp(name.c_str(), "DRAGONX",7) == 0 ? true : false;

-    LogPrint("net", "%s: ishush3=%d\n", __func__, ishush3);
-    if (ishush3) {
-        HUSH_nodes = {"node1.hush.is","node2.hush.is","node3.hush.is",
-                      "node4.hush.is","node5.hush.is","node6.hush.is",
-                      "node7.hush.is","node8.hush.is",
-                      "178.250.189.141",
-                      "31.202.19.157",
-                      "45.132.75.69",
-                      "45.63.58.167",
-                      "b2dln7mw7ydnuopls444tuixujhcw5kn5o22cna6gqfmw2fl6drb5nad.onion",
-                      "dslbaa5gut5kapqtd44pbg65tpl5ydsamfy62hjbldhfsvk64qs57pyd.onion",
-                      "vsqdumnh5khjbrzlxoeucbkiuaictdzyc3ezjpxpp2ph3gfwo2ptjmyd.onion",
-                      "plrobkepqjxs2cmig273mxnqh3qhuhdaioyb2n5kafn264ramb7tqxid.onion"
+    LogPrint("net", "%s: isdragonx=%d\n", __func__, isdragonx);
+    if (isdragonx) {
+        DRAGONX_nodes = {"node1.dragonx.is","node2.dragonx.is","node3.dragonx.is",
+                         "node4.dragonx.is","node5.dragonx.is"
        };
-
    }

    vector<string> more_nodes = mapMultiArgs["-addnode"];
    if (more_nodes.size() > 0) {
        fprintf(stderr,"%s: Adding %lu more nodes via custom -addnode arguments\n", __func__, more_nodes.size() );
    }
-    // Add default HUSH nodes after custom addnodes, if applicable
-    if(HUSH_nodes.size() > 0) {
-        LogPrint("net", "%s: adding %d HUSH3 hostname-based nodes\n", __func__, HUSH_nodes.size() );
-        more_nodes.insert( more_nodes.end(), HUSH_nodes.begin(), HUSH_nodes.end() );
+    // Add default DRAGONX nodes after custom addnodes, if applicable
+    if(DRAGONX_nodes.size() > 0) {
+        LogPrint("net", "%s: adding %d DRAGONX hostname-based nodes\n", __func__, DRAGONX_nodes.size() );
+        more_nodes.insert( more_nodes.end(), DRAGONX_nodes.begin(), DRAGONX_nodes.end() );
    }

    mapMultiArgs["-addnode"] = more_nodes;
@@ -1830,10 +1820,15 @@ void hush_args(char *argv0)
    WITNESS_CACHE_SIZE       = MAX_REORG_LENGTH+10;
    ASSETCHAINS_CC           = GetArg("-ac_cc",0);
    HUSH_CCACTIVATE          = GetArg("-ac_ccactivate",0);
-    ASSETCHAINS_BLOCKTIME    = GetArg("-ac_blocktime",60);
-    // We do not support ac_public=1 chains, Hush is a platform for privacy
+
+    // Set defaults based on chain
+    int default_blocktime = isdragonx ? 36 : 60;
+    int default_private   = isdragonx ? 1 : 0;
+
+    ASSETCHAINS_BLOCKTIME    = GetArg("-ac_blocktime", default_blocktime);
+    // We do not support ac_public=1 chains, DragonX is a platform for privacy
    ASSETCHAINS_PUBLIC       = 0;
-    ASSETCHAINS_PRIVATE      = GetArg("-ac_private",0);
+    ASSETCHAINS_PRIVATE      = GetArg("-ac_private", default_private);
    HUSH_SNAPSHOT_INTERVAL   = GetArg("-ac_snapshot",0);
    Split(GetArg("-ac_nk",""), sizeof(ASSETCHAINS_NK)/sizeof(*ASSETCHAINS_NK), ASSETCHAINS_NK, 0);

@@ -1871,7 +1866,9 @@ void hush_args(char *argv0)
    ASSETCHAINS_EARLYTXIDCONTRACT = GetArg("-ac_earlytxidcontract",0);
    if ( name.c_str()[0] != 0 )
    {
-        std::string selectedAlgo = GetArg("-ac_algo", std::string(ASSETCHAINS_ALGORITHMS[0]));
+        // Default algo is randomx for DRAGONX, equihash for others
+        std::string default_algo = isdragonx ? "randomx" : std::string(ASSETCHAINS_ALGORITHMS[0]);
+        std::string selectedAlgo = GetArg("-ac_algo", default_algo);

        for ( int i = 0; i < ASSETCHAINS_NUMALGOS; i++ )
        {
@@ -1900,7 +1897,6 @@ void hush_args(char *argv0)

        // Set our symbol from -ac_name value
        strncpy(SMART_CHAIN_SYMBOL,name.c_str(),sizeof(SMART_CHAIN_SYMBOL)-1);
-        const bool ishush3   = strncmp(SMART_CHAIN_SYMBOL, "HUSH3",5) == 0 ? true : false;

        // Set RandomX validation activation height per chain
        if (ASSETCHAINS_ALGO == ASSETCHAINS_RANDOMX) {
@@ -1915,9 +1911,6 @@ void hush_args(char *argv0)
        }

        ASSETCHAINS_LASTERA = GetArg("-ac_eras", 1);
-        if(ishush3) {
-            ASSETCHAINS_LASTERA = 3;
-        }
        if ( ASSETCHAINS_LASTERA < 1 || ASSETCHAINS_LASTERA > ASSETCHAINS_MAX_ERAS )
        {
            ASSETCHAINS_LASTERA = 1;
@@ -1951,33 +1944,13 @@ void hush_args(char *argv0)
        ASSETCHAINS_SCRIPTPUB       = GetArg("-ac_script","");
        

-        fprintf(stderr,"%s: Setting custom %s reward HUSH3=%d reward,halving,subsidy chain values...\n",__func__, SMART_CHAIN_SYMBOL, ishush3);
-        if(ishush3) {
-            // Migrated from hushd script
-            ASSETCHAINS_CC           = 2;
-            ASSETCHAINS_BLOCKTIME    = 150; // this will change to 75 at the correct block
-            ASSETCHAINS_COMMISSION   = 11111111;
-            // 6250000 - (Sprout pool at block 500,000)
-            ASSETCHAINS_SUPPLY       = 6178674;
-            ASSETCHAINS_FOUNDERS     = 1;
+        fprintf(stderr,"%s: Setting custom %s reward isdragonx=%d reward,halving,subsidy chain values...\n",__func__, SMART_CHAIN_SYMBOL, isdragonx);
+        if(isdragonx) {
+            // DragonX chain parameters (previously set via wrapper script)
+            // -ac_name=DRAGONX -ac_algo=randomx -ac_halving=3500000 -ac_reward=300000000 -ac_blocktime=36 -ac_private=1
            ASSETCHAINS_SAPLING      = 1;
-            // this corresponds to FR address RHushEyeDm7XwtaTWtyCbjGQumYyV8vMjn
-            ASSETCHAINS_SCRIPTPUB       = "76a9145eb10cf64f2bab1b457f1f25e658526155928fac88ac";
-            // we do not want to change the magic of HUSH3 mainnet so we do not call devtax_scriptpub_for_height() here,
-            // instead we call it whenever ASSETCHAINS_SCRIPTPUB is used later on
-
-            // Over-ride HUSH3 values from CLI params. Changing our blocktime to 75s changes things
-            ASSETCHAINS_REWARD[0]     = 0;
-            ASSETCHAINS_REWARD[1]     = 1125000000;
-            ASSETCHAINS_REWARD[2]     = 281250000; // 2.8125  HUSH goes to miners per block after 1st halving at Block 340K
-            ASSETCHAINS_REWARD[3]     = 140625000; // 1.40625 HUSH after 2nd halving at Block 2020000
-            ASSETCHAINS_HALVING[0]    = 129;
-            ASSETCHAINS_HALVING[1]    = GetArg("-z2zheight",340000);
-            ASSETCHAINS_HALVING[2]    = 2020000; // 2020000 = 340000 + 1680000 (1st halving block plus new halving interval)
-            ASSETCHAINS_HALVING[3]    = 3700000; // ASSETCHAINS_HALVING[2] + 1680000;
-            ASSETCHAINS_ENDSUBSIDY[0] = 129;
-            ASSETCHAINS_ENDSUBSIDY[1] = GetArg("-z2zheight",340000);
-            ASSETCHAINS_ENDSUBSIDY[2] = 2*5422111; // TODO: Fix this, twice the previous end of rewards is an estimate
+            ASSETCHAINS_REWARD[0]    = 300000000;  // 3 DRAGONX per block
+            ASSETCHAINS_HALVING[0]   = 3500000;    // halving every 3.5M blocks
        }
        Split(GetArg("-ac_decay",""), sizeof(ASSETCHAINS_DECAY)/sizeof(*ASSETCHAINS_DECAY),  ASSETCHAINS_DECAY, 0);
        Split(GetArg("-ac_notarypay",""), sizeof(ASSETCHAINS_NOTARY_PAY)/sizeof(*ASSETCHAINS_NOTARY_PAY),  ASSETCHAINS_NOTARY_PAY, 0);
@@ -2492,11 +2465,11 @@ void hush_args(char *argv0)
 void hush_nameset(char *symbol,char *dest,char *source)
 {
    if ( source[0] == 0 ) {
-        strcpy(symbol,(char *)"HUSH3");
+        strcpy(symbol,(char *)"DRAGONX");
        strcpy(dest,(char *)"BTC");
    } else {
        strcpy(symbol,source);
-        strcpy(dest,(char *)"HUSH3");
+        strcpy(dest,(char *)"DRAGONX");
    }
 }

--- a/src/init.cpp
+++ b/src/init.cpp
@@ -377,8 +377,8 @@ std::string HelpMessage(HelpMessageMode mode)
    strUsage += HelpMessageOpt("-blocknotify=<cmd>", _("Execute command when the best block changes (%s in cmd is replaced by block hash)"));
    strUsage += HelpMessageOpt("-checkblocks=<n>", strprintf(_("How many blocks to check at startup (default: %u, 0 = all)"), 288));
    strUsage += HelpMessageOpt("-checklevel=<n>", strprintf(_("How thorough the block verification of -checkblocks is (0-4, default: %u)"), 3));
-    strUsage += HelpMessageOpt("-clientname=<SomeName>", _("Full node client name, default 'GoldenSandtrout'"));
-    strUsage += HelpMessageOpt("-conf=<file>", strprintf(_("Specify configuration file (default: %s)"), "HUSH3.conf"));
+    strUsage += HelpMessageOpt("-clientname=<SomeName>", _("Full node client name, default 'DragonX'"));
+    strUsage += HelpMessageOpt("-conf=<file>", strprintf(_("Specify configuration file (default: %s)"), "DRAGONX.conf"));
    if (mode == HMM_BITCOIND)
    {
 #if !defined(WIN32)
@@ -605,7 +605,7 @@ std::string HelpMessage(HelpMessageMode mode)
    strUsage += HelpMessageOpt("-stratumallowip=<ip>", _("Allow Stratum work requests from specified source. Valid for <ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. 1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24). This option can be specified multiple times"));

    // "ac" stands for "affects consensus" or Arrakis Chain
-    strUsage += HelpMessageGroup(_("Hush Arrakis Chain options:"));
+    strUsage += HelpMessageGroup(_("DragonX Chain options:"));
    strUsage += HelpMessageOpt("-ac_algo", _("Choose PoW mining algorithm, either 'equihash' or 'randomx'. default is Equihash (200,9)"));
    strUsage += HelpMessageOpt("-ac_blocktime", _("Block time in seconds, default is 60"));
    strUsage += HelpMessageOpt("-ac_beam", _("BEAM integration"));
@@ -1619,7 +1619,7 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
            return InitError(strprintf("User Agent comment (%s) contains unsafe characters.", cmt));
        uacomments.push_back(SanitizeString(cmt, SAFE_CHARS_UA_COMMENT));
    }
-    strSubVersion = FormatSubVersion(GetArg("-clientname","GoldenSandtrout"), CLIENT_VERSION, uacomments);
+    strSubVersion = FormatSubVersion(GetArg("-clientname","DragonX"), CLIENT_VERSION, uacomments);
    if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
        return InitError(strprintf("Total length of network version string %i exceeds maximum of %i characters. Reduce the number and/or size of uacomments.",
            strSubVersion.size(), MAX_SUBVERSION_LENGTH));
--- a/src/metrics.cpp
+++ b/src/metrics.cpp
@@ -289,7 +289,7 @@ int printMiningStatus(bool mining)
        lines++;
    } else {
        std::cout << _("You are currently not mining.") << std::endl;
-        std::cout << _("To enable mining, add 'gen=1' to your HUSH3.conf and restart.") << std::endl;
+        std::cout << _("To enable mining, add 'gen=1' to your DRAGONX.conf and restart.") << std::endl;
        lines += 2;
    }
    std::cout << std::endl;
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -23,6 +23,7 @@
 #include "pow/tromp/equi_miner.h"
 #endif

+#include <atomic>
 #include "amount.h"
 #include "chainparams.h"
 #include "consensus/consensus.h"
@@ -51,6 +52,7 @@
 #include "transaction_builder.h"
 #include "sodium.h"
 #include <boost/thread.hpp>
+#include <boost/thread/shared_mutex.hpp>
 #include <boost/tuple/tuple.hpp>
 #ifdef ENABLE_MINING
 #include <functional>
@@ -1011,8 +1013,213 @@ enum RandomXSolverCancelCheck
    Reason2
 };

-int GetRandomXInterval() { return GetArg("-ac_randomx_interval",1024); }
-int GetRandomXBlockLag() { return GetArg("-ac_randomx_lag", 64);       }
+int GetRandomXInterval();
+int GetRandomXBlockLag();
+
+#ifdef _WIN32
+#include <windows.h>
+static void LogProcessMemory(const char* label) {
+    // Use K32GetProcessMemoryInfo from kernel32.dll (available on Win7+)
+    // to avoid linking psapi.lib
+    typedef struct {
+        DWORD  cb;
+        DWORD  PageFaultCount;
+        SIZE_T PeakWorkingSetSize;
+        SIZE_T WorkingSetSize;
+        SIZE_T QuotaPeakPagedPoolUsage;
+        SIZE_T QuotaPagedPoolUsage;
+        SIZE_T QuotaPeakNonPagedPoolUsage;
+        SIZE_T QuotaNonPagedPoolUsage;
+        SIZE_T PagefileUsage;
+        SIZE_T PeakPagefileUsage;
+        SIZE_T PrivateUsage;
+    } PMC_EX;
+    typedef BOOL (WINAPI *PFN)(HANDLE, PMC_EX*, DWORD);
+    static PFN pfn = (PFN)GetProcAddress(GetModuleHandleA("kernel32.dll"), "K32GetProcessMemoryInfo");
+    if (pfn) {
+        PMC_EX pmc = {};
+        pmc.cb = sizeof(pmc);
+        if (pfn(GetCurrentProcess(), &pmc, sizeof(pmc))) {
+            LogPrintf("MemDiag [%s]: WorkingSet=%.1fMB, PrivateUsage=%.1fMB, PagefileUsage=%.1fMB\n",
+                      label,
+                      pmc.WorkingSetSize / (1024.0 * 1024.0),
+                      pmc.PrivateUsage / (1024.0 * 1024.0),
+                      pmc.PagefileUsage / (1024.0 * 1024.0));
+        }
+    }
+}
+#else
+static void LogProcessMemory(const char* label) {
+    // Linux: read /proc/self/status
+    FILE *f = fopen("/proc/self/status", "r");
+    if (f) {
+        char line[256];
+        while (fgets(line, sizeof(line), f)) {
+            if (strncmp(line, "VmRSS:", 6) == 0 || strncmp(line, "VmSize:", 7) == 0) {
+                // Remove newline
+                line[strlen(line)-1] = '\0';
+                LogPrintf("MemDiag [%s]: %s\n", label, line);
+            }
+        }
+        fclose(f);
+    }
+}
+#endif
+
+// Shared RandomX dataset manager — all miner threads share a single ~2GB dataset
+// instead of each allocating their own. The dataset is read-only after initialization
+// and RandomX explicitly supports multiple VMs sharing one dataset.
+struct RandomXDatasetManager {
+    randomx_flags flags;
+    randomx_cache *cache;
+    randomx_dataset *dataset;
+    unsigned long datasetItemCount;
+    std::string currentKey;
+    std::mutex mtx;               // protects Init/Shutdown/CreateVM
+    boost::shared_mutex datasetMtx; // readers-writer lock: shared for hashing, exclusive for rebuild
+    bool initialized;
+
+    RandomXDatasetManager() : flags(randomx_get_flags()), cache(nullptr), dataset(nullptr),
+                              datasetItemCount(0), initialized(false) {}
+
+    bool Init() {
+        std::lock_guard<std::mutex> lock(mtx);
+        if (initialized) return true;
+
+        flags |= RANDOMX_FLAG_FULL_MEM;
+        LogPrintf("RandomXDatasetManager: flags=0x%x (JIT=%d, HARD_AES=%d, FULL_MEM=%d, LARGE_PAGES=%d)\n",
+                  (int)flags,
+                  !!(flags & RANDOMX_FLAG_JIT), !!(flags & RANDOMX_FLAG_HARD_AES),
+                  !!(flags & RANDOMX_FLAG_FULL_MEM), !!(flags & RANDOMX_FLAG_LARGE_PAGES));
+
+        LogProcessMemory("before cache alloc");
+
+        cache = randomx_alloc_cache(flags | RANDOMX_FLAG_LARGE_PAGES | RANDOMX_FLAG_SECURE);
+        if (cache == nullptr) {
+            LogPrintf("RandomXDatasetManager: cache alloc failed with large pages, trying without...\n");
+            cache = randomx_alloc_cache(flags | RANDOMX_FLAG_SECURE);
+            if (cache == nullptr) {
+                LogPrintf("RandomXDatasetManager: cache alloc failed with secure, trying basic...\n");
+                cache = randomx_alloc_cache(flags);
+                if (cache == nullptr) {
+                    LogPrintf("RandomXDatasetManager: cannot allocate cache!\n");
+                    return false;
+                }
+            }
+        }
+        LogProcessMemory("after cache alloc");
+
+        // Try to allocate dataset with large pages first for better performance
+        dataset = randomx_alloc_dataset(flags | RANDOMX_FLAG_LARGE_PAGES);
+        if (dataset == nullptr) {
+            LogPrintf("RandomXDatasetManager: dataset alloc failed with large pages, trying without...\n");
+            dataset = randomx_alloc_dataset(flags);
+            if (dataset == nullptr) {
+                LogPrintf("RandomXDatasetManager: cannot allocate dataset!\n");
+                randomx_release_cache(cache);
+                cache = nullptr;
+                return false;
+            }
+        }
+
+        datasetItemCount = randomx_dataset_item_count();
+        initialized = true;
+        LogProcessMemory("after dataset alloc");
+        // Log the actual memory addresses to help diagnose sharing issues  
+        uint8_t *datasetMemory = (uint8_t*)randomx_get_dataset_memory(dataset);
+        size_t datasetSize = datasetItemCount * RANDOMX_DATASET_ITEM_SIZE;
+        LogPrintf("RandomXDatasetManager: allocated shared dataset:\n");
+        LogPrintf("  - Dataset struct at: %p\n", (void*)dataset);
+        LogPrintf("  - Dataset memory at: %p (size: %.2f GB)\n", (void*)datasetMemory, datasetSize / (1024.0 * 1024.0 * 1024.0));
+        LogPrintf("  - Items: %lu, Item size: %d bytes\n", datasetItemCount, RANDOMX_DATASET_ITEM_SIZE);
+        LogPrintf("  - Expected total process memory: ~%.2f GB + ~2MB per mining thread\n", datasetSize / (1024.0 * 1024.0 * 1024.0));
+        return true;
+    }
+
+    // Initialize cache with a key and rebuild the dataset.
+    // Thread-safe: acquires exclusive lock so all hashing threads must finish first.
+    void UpdateKey(const void *key, size_t keySize) {
+        std::string newKey((const char*)key, keySize);
+
+        // Fast check with shared lock — skip if key hasn't changed
+        {
+            boost::shared_lock<boost::shared_mutex> readLock(datasetMtx);
+            if (newKey == currentKey) return; // already up to date
+        }
+
+        // Acquire exclusive lock — blocks until all hashing threads release their shared locks
+        boost::unique_lock<boost::shared_mutex> writeLock(datasetMtx);
+        // Double-check after acquiring exclusive lock (another thread may have rebuilt first)
+        if (newKey == currentKey) return;
+
+        LogPrintf("RandomXDatasetManager: updating key (size=%lu)\n", keySize);
+        randomx_init_cache(cache, key, keySize);
+        currentKey = newKey;
+
+        // Rebuild dataset using all available CPU threads
+        const int initThreadCount = std::thread::hardware_concurrency();
+        if (initThreadCount > 1) {
+            std::vector<std::thread> threads;
+            uint32_t startItem = 0;
+            const auto perThread = datasetItemCount / initThreadCount;
+            const auto remainder = datasetItemCount % initThreadCount;
+            for (int i = 0; i < initThreadCount; ++i) {
+                const auto count = perThread + (i == initThreadCount - 1 ? remainder : 0);
+                threads.push_back(std::thread(&randomx_init_dataset, dataset, cache, startItem, count));
+                startItem += count;
+            }
+            for (unsigned i = 0; i < threads.size(); ++i) {
+                threads[i].join();
+            }
+        } else {
+            randomx_init_dataset(dataset, cache, 0, datasetItemCount);
+        }
+        LogPrintf("RandomXDatasetManager: dataset rebuilt\n");
+        LogProcessMemory("after dataset init");
+    }
+
+    // Creates a per-thread VM using the shared dataset.
+    // Caller must hold a shared lock on datasetMtx.
+    // The VM itself is small (~2MB scratchpad + ~84KB JIT code) — the ~2GB dataset is shared via pointer.
+    // VMs should be created ONCE per thread and reused across blocks to avoid
+    // heap fragmentation on Windows (repeated 2MB alloc/free causes address-space bloat).
+    randomx_vm *CreateVM() {
+        static std::atomic<int> vmCount{0};
+        LogProcessMemory("before CreateVM");
+        randomx_vm *vm = randomx_create_vm(flags, nullptr, dataset);
+        if (vm != nullptr) {
+            int id = ++vmCount;
+            uint8_t *datasetMemory = (uint8_t*)randomx_get_dataset_memory(dataset);
+            LogPrintf("RandomXDatasetManager: VM #%d created — VM at %p, shared dataset at %p\n",
+                      id, (void*)vm, (void*)datasetMemory);
+            LogPrintf("  Per-thread overhead: ~2MB scratchpad + ~84KB JIT (dataset NOT copied)\n");
+            LogProcessMemory("after CreateVM");
+        }
+        return vm;
+    }
+
+    void Shutdown() {
+        std::lock_guard<std::mutex> lock(mtx);
+        if (dataset != nullptr) {
+            randomx_release_dataset(dataset);
+            dataset = nullptr;
+        }
+        if (cache != nullptr) {
+            randomx_release_cache(cache);
+            cache = nullptr;
+        }
+        initialized = false;
+        currentKey.clear();
+        LogPrintf("RandomXDatasetManager: shutdown complete\n");
+    }
+
+    ~RandomXDatasetManager() {
+        Shutdown();
+    }
+};
+
+// Global shared dataset manager, created by GenerateBitcoins before spawning miner threads
+static RandomXDatasetManager *g_rxDatasetManager = nullptr;

 #ifdef ENABLE_WALLET
 void static RandomXMiner(CWallet *pwallet)
@@ -1050,33 +1257,12 @@ void static RandomXMiner()
                                                                       );
    miningTimer.start();

-    randomx_flags flags         = randomx_get_flags();
-    flags |= RANDOMX_FLAG_FULL_MEM;
-    randomx_cache *randomxCache = randomx_alloc_cache(flags | RANDOMX_FLAG_LARGE_PAGES | RANDOMX_FLAG_SECURE );
-    if (randomxCache == NULL) {
-        LogPrintf("RandomX cache is null, trying without large pages...\n");
-        randomxCache = randomx_alloc_cache(flags | RANDOMX_FLAG_SECURE);
-        if (randomxCache == NULL) {
-            LogPrintf("RandomX cache is null, trying without secure...\n");
-        }
-        randomxCache = randomx_alloc_cache(flags);
-        if (randomxCache == NULL) {
-            LogPrintf("RandomX cache is null, cannot mine!\n");
-        }
-    }
-
-    rxdebug("%s: created randomx flags + cache\n");
-    randomx_dataset *randomxDataset = randomx_alloc_dataset(flags);
-    rxdebug("%s: created dataset\n");
-
-    if( randomxDataset == nullptr) {
-        LogPrintf("%s: allocating randomx dataset failed!\n", __func__);
+    // Use the shared dataset manager — no per-thread dataset allocation
+    if (g_rxDatasetManager == nullptr || !g_rxDatasetManager->initialized) {
+        LogPrintf("HushRandomXMiner: shared dataset manager not initialized, aborting!\n");
        return;
    }

-    auto datasetItemCount = randomx_dataset_item_count();
-    rxdebug("%s: dataset items=%lu\n", datasetItemCount);
-
    char randomxHash[RANDOMX_HASH_SIZE];
    rxdebug("%s: created randomxHash of size %d\n", RANDOMX_HASH_SIZE);
    char randomxKey[82]; // randomx spec says keysize of >60 bytes is implementation-specific
@@ -1147,48 +1333,37 @@ void static RandomXMiner()

            // fprintf(stderr,"RandomXMiner: using initial key with interval=%d and lag=%d\n", randomxInterval, randomxBlockLag);
            rxdebug("%s: using initial key, interval=%d, lag=%d, Mining_height=%u\n", randomxInterval, randomxBlockLag, Mining_height);
-            // Use the initial key at the start of the chain, until the first key block
+            // Update the shared dataset key — only one thread will actually rebuild,
+            // others will see the key is already current and skip.
            if( (Mining_height) < randomxInterval + randomxBlockLag) {
-                randomx_init_cache(randomxCache, &randomxKey, sizeof randomxKey);
-                rxdebug("%s: initialized cache with initial key\n");
+                g_rxDatasetManager->UpdateKey(randomxKey, strlen(randomxKey));
+                rxdebug("%s: updated shared dataset with initial key\n");
            } else {
                rxdebug("%s: calculating keyHeight with randomxInterval=%d\n", randomxInterval);
-                // At heights between intervals, we use the same block key and wait randomxBlockLag blocks until changing
                const int keyHeight = ((Mining_height - randomxBlockLag) / randomxInterval) * randomxInterval;
                uint256 randomxBlockKey = chainActive[keyHeight]->GetBlockHash();
-
-                randomx_init_cache(randomxCache, &randomxBlockKey, sizeof randomxBlockKey);
-                rxdebug("%s: initialized cache with keyHeight=%d, randomxBlockKey=%s\n", keyHeight, randomxBlockKey.ToString().c_str());
+                g_rxDatasetManager->UpdateKey(&randomxBlockKey, sizeof randomxBlockKey);
+                rxdebug("%s: updated shared dataset with keyHeight=%d, randomxBlockKey=%s\n", keyHeight, randomxBlockKey.ToString().c_str());
            }

-            const int initThreadCount = std::thread::hardware_concurrency();
-            if(initThreadCount > 1) {
-                rxdebug("%s: initializing dataset with %d threads\n", initThreadCount);
-                std::vector<std::thread> threads;
-                uint32_t startItem = 0;
-                const auto perThread = datasetItemCount / initThreadCount;
-                const auto remainder = datasetItemCount % initThreadCount;
-                for (int i = 0; i < initThreadCount; ++i) {
-                    const auto count = perThread + (i == initThreadCount - 1 ? remainder : 0);
-                    threads.push_back(std::thread(&randomx_init_dataset, randomxDataset, randomxCache, startItem, count));
-                    startItem += count;
+            // Create a per-thread VM once and reuse across blocks.
+            // The VM just stores a pointer to the shared dataset — the pointer
+            // remains valid across key changes since UpdateKey rebuilds the dataset
+            // contents in-place without reallocating.  Reusing the VM avoids
+            // repeated 2MB scratchpad + 84KB JIT alloc/free churn that causes
+            // Windows heap fragmentation and apparent memory growth per thread.
+            if (myVM == nullptr) {
+                // First iteration: acquire shared lock briefly to create VM
+                boost::shared_lock<boost::shared_mutex> initLock(g_rxDatasetManager->datasetMtx);
+                myVM = g_rxDatasetManager->CreateVM();
+                if (myVM == nullptr) {
+                    LogPrintf("RandomXMiner: Cannot create RandomX VM, aborting!\n");
+                    return;
                }
-                for (unsigned i = 0; i < threads.size(); ++i) {
-                    threads[i].join();
-                }
-                threads.clear();
-            } else {
-                rxdebug("%s: initializing dataset with 1 thread\n");
-                randomx_init_dataset(randomxDataset, randomxCache, 0, datasetItemCount);
            }

-            rxdebug("%s: dataset initialized\n");
-
-            myVM = randomx_create_vm(flags, nullptr, randomxDataset);
-            if(myVM == NULL) {
-                LogPrintf("RandomXMiner: Cannot create RandomX VM, aborting!\n");
-                return;
-            }
+            // Acquire shared lock to prevent dataset rebuild while we're hashing
+            boost::shared_lock<boost::shared_mutex> datasetLock(g_rxDatasetManager->datasetMtx);
            //fprintf(stderr,"RandomXMiner: Mining_start=%u\n", Mining_start);
 #ifdef ENABLE_WALLET
            CBlockTemplate *ptr = CreateNewBlockWithKey(reservekey, pindexPrev->GetHeight()+1, gpucount, 0);
@@ -1268,16 +1443,17 @@ void static RandomXMiner()
                arith_uint256 hashTarget;
                hashTarget = HASHTarget;

+                CRandomXInput rxInput(pblocktemplate->block);
                CDataStream randomxInput(SER_NETWORK, PROTOCOL_VERSION);
-                // Use the current block as randomx input
-                randomxInput << pblocktemplate->block;
+                // Serialize block header without nSolution but with nNonce for deterministic RandomX input
+                randomxInput << rxInput;

                // std::cerr << "RandomXMiner: randomxInput=" << HexStr(randomxInput) << "\n";
                // fprintf(stderr,"RandomXMiner: created randomxKey=%s , randomxInput.size=%lu\n", randomxKey, randomxInput.size() ); //randomxInput);
                rxdebug("%s: randomxKey=%s randomxInput=%s\n", randomxKey, HexStr(randomxInput).c_str());

                rxdebug("%s: calculating randomx hash\n");
-                randomx_calculate_hash(myVM, &randomxInput, sizeof randomxInput, randomxHash);
+                randomx_calculate_hash(myVM, &randomxInput[0], randomxInput.size(), randomxHash);
                rxdebug("%s: calculated randomx hash\n");

                rxdebug("%s: randomxHash=");
@@ -1324,14 +1500,28 @@ void static RandomXMiner()

                    CValidationState state;
                    //{ LOCK(cs_main);
-                    if ( !TestBlockValidity(state,B, chainActive.LastTip(), true, false))
+                    // Skip RandomX re-validation during TestBlockValidity — we already
+                    // computed the correct hash, and re-verifying allocates ~256MB which
+                    // can trigger the OOM killer on memory-constrained systems.
+                    SetSkipRandomXValidation(true);
+                    bool fValid = TestBlockValidity(state,B, chainActive.LastTip(), true, false);
+                    SetSkipRandomXValidation(false);
+                    if ( !fValid )
                    {
                        h = UintToArith256(B.GetHash());
-                        fprintf(stderr,"RandomXMiner: Invalid randomx block mined, try again ");
+                        fprintf(stderr,"RandomXMiner: TestBlockValidity FAILED at ht.%d nNonce=%s hash=",
+                                Mining_height, pblock->nNonce.ToString().c_str());
                        for (z=31; z>=0; z--)
                            fprintf(stderr,"%02x",((uint8_t *)&h)[z]);
-                        gotinvalid = 1;
+                        fprintf(stderr," nSolution.size=%lu\n", B.nSolution.size());
+                        // Dump nSolution hex for comparison with validator
+                        fprintf(stderr,"RandomXMiner: nSolution=");
+                        for (unsigned i = 0; i < B.nSolution.size(); i++)
+                            fprintf(stderr,"%02x", B.nSolution[i]);
                        fprintf(stderr,"\n");
+                        LogPrintf("RandomXMiner: TestBlockValidity FAILED at ht.%d, gotinvalid=1, state=%s\n",
+                                  Mining_height, state.GetRejectReason());
+                        gotinvalid = 1;
                        return(false);
                    }
                    //}
@@ -1399,21 +1589,24 @@ void static RandomXMiner()
                    pblock->nBits = savebits;
                }

-                rxdebug("%s: going to destroy rx VM\n");
-                randomx_destroy_vm(myVM);
-                rxdebug("%s: destroyed VM\n");
+                // Release shared lock so UpdateKey can acquire exclusive lock for dataset rebuild
+                // VM is kept alive — its dataset pointer remains valid across rebuilds
+                datasetLock.unlock();
            }

   } catch (const boost::thread_interrupted&) {
       miningTimer.stop();
       c.disconnect();

-       randomx_destroy_vm(myVM);
-       LogPrintf("%s: destroyed vm via thread interrupt\n", __func__);
-       randomx_release_dataset(randomxDataset);
-       rxdebug("%s: released dataset via thread interrupt\n");
-       randomx_release_cache(randomxCache);
-       rxdebug("%s: released cache via thread interrupt\n");
+       if (myVM != nullptr) {
+           randomx_destroy_vm(myVM);
+           myVM = nullptr;
+           LogPrintf("%s: destroyed vm via thread interrupt\n", __func__);
+       } else {
+           LogPrintf("%s: WARNING myVM already null in thread interrupt handler, skipping destroy (would double-free)\n", __func__);
+           fprintf(stderr, "%s: WARNING myVM already null in thread interrupt, would have double-freed!\n", __func__);
+       }
+       // Dataset and cache are owned by g_rxDatasetManager — do NOT release here

       LogPrintf("HushRandomXMiner terminated\n");
       throw;
@@ -1422,20 +1615,21 @@ void static RandomXMiner()
       c.disconnect();
       fprintf(stderr,"RandomXMiner: runtime error: %s\n", e.what());

-       randomx_destroy_vm(myVM);
-       LogPrintf("%s: destroyed vm because of error\n", __func__);
-       randomx_release_dataset(randomxDataset);
-       rxdebug("%s: released dataset because of error\n");
-       randomx_release_cache(randomxCache);
-       rxdebug("%s: released cache because of error\n");
+       if (myVM != nullptr) {
+           randomx_destroy_vm(myVM);
+           myVM = nullptr;
+           LogPrintf("%s: destroyed vm because of error\n", __func__);
+       }
+       // Dataset and cache are owned by g_rxDatasetManager — do NOT release here

       return;
   }

-   randomx_release_dataset(randomxDataset);
-   rxdebug("%s: released dataset in normal exit\n");
-   randomx_release_cache(randomxCache);
-   rxdebug("%s: released cache in normal exit\n");
+   // Only destroy per-thread VM, dataset/cache are shared
+   if (myVM != nullptr) {
+       randomx_destroy_vm(myVM);
+       myVM = nullptr;
+   }
   miningTimer.stop();
   c.disconnect();
 }
@@ -1879,8 +2073,18 @@ void static BitcoinMiner()
        if (minerThreads != NULL)
        {
            minerThreads->interrupt_all();
+            // Wait for all miner threads to fully terminate before destroying shared resources
+            minerThreads->join_all();
            delete minerThreads;
            minerThreads = NULL;
+
+            // Shutdown shared RandomX dataset manager after all threads are done
+            if (g_rxDatasetManager != nullptr) {
+                g_rxDatasetManager->Shutdown();
+                delete g_rxDatasetManager;
+                g_rxDatasetManager = nullptr;
+                LogPrintf("%s: destroyed shared RandomX dataset manager\n", __func__);
+            }
        }

        if(fDebug)
@@ -1895,6 +2099,21 @@ void static BitcoinMiner()

        minerThreads = new boost::thread_group();

+        // Initialize shared RandomX dataset manager before spawning miner threads
+        if (ASSETCHAINS_ALGO == ASSETCHAINS_RANDOMX) {
+            g_rxDatasetManager = new RandomXDatasetManager();
+            if (!g_rxDatasetManager->Init()) {
+                LogPrintf("%s: FATAL - Failed to initialize shared RandomX dataset manager\n", __func__);
+                fprintf(stderr, "%s: FATAL - Failed to initialize shared RandomX dataset manager\n", __func__);
+                delete g_rxDatasetManager;
+                g_rxDatasetManager = nullptr;
+                delete minerThreads;
+                minerThreads = NULL;
+                return;
+            }
+            LogPrintf("%s: shared RandomX dataset manager initialized\n", __func__);
+        }
+
        for (int i = 0; i < nThreads; i++) {
 #ifdef ENABLE_WALLET
            if ( ASSETCHAINS_ALGO == ASSETCHAINS_EQUIHASH ) {
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -339,6 +339,7 @@ unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHead
    memset(zflags,0,sizeof(zflags));
    if ( pindexLast != 0 )
        height = (int32_t)pindexLast->GetHeight() + 1;
+
    if ( ASSETCHAINS_ADAPTIVEPOW > 0 && pindexFirst != 0 && pblock != 0 && height >= (int32_t)(sizeof(ct)/sizeof(*ct)) )
    {
        tipdiff = (pblock->nTime - pindexFirst->nTime);
@@ -685,7 +686,10 @@ bool CheckEquihashSolution(const CBlockHeader *pblock, const CChainParams& param
    return true;
 }

-// Static objects for CheckRandomXSolution
+int GetRandomXInterval() { return GetArg("-ac_randomx_interval", 1024); }
+int GetRandomXBlockLag() { return GetArg("-ac_randomx_lag", 64); }
+
+// Cached RandomX validation state — reused across calls, protected by mutex
 static std::mutex cs_randomx_validator;
 static randomx_cache *s_rxCache = nullptr;
 static randomx_vm *s_rxVM = nullptr;
@@ -862,6 +866,7 @@ bool CheckProofOfWork(const CBlockHeader &blkHeader, uint8_t *pubkey33, int32_t
        if ( HUSH_LOADINGBLOCKS != 0 )
            return true;

+        /*
        if ( SMART_CHAIN_SYMBOL[0] != 0 || height > 792000 )
        {
            if ( Params().NetworkIDString() != "regtest" )
@@ -881,6 +886,7 @@ bool CheckProofOfWork(const CBlockHeader &blkHeader, uint8_t *pubkey33, int32_t
            }
            return false;
        }
+        */
    }
    /*for (i=31; i>=0; i--)
     fprintf(stderr,"%02x",((uint8_t *)&hash)[i]);
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -169,7 +169,7 @@ UniValue getgenerate(const UniValue& params, bool fHelp, const CPubKey& mypk)
        throw runtime_error(
            "getgenerate\n"
            "\nReturn if the server is set to mine coins or not. The default is false.\n"
-            "It is set with the command line argument -gen (or HUSH3.conf setting gen).\n"
+            "It is set with the command line argument -gen (or DRAGONX.conf setting gen).\n"
            "It can also be set with the setgenerate call.\n"
            "\nResult\n"
            "{\n"
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -133,7 +133,7 @@ UniValue getpeerinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
            "    \"pingtime\": n,             (numeric) ping time\n"
            "    \"pingwait\": n,             (numeric) ping wait\n"
            "    \"version\": v,              (numeric) The peer version, such as 170002\n"
-            "    \"subver\": \"/GoldenSandtrout:x.y.z[-v]/\",  (string) The string version\n"
+            "    \"subver\": \"/DragonX:x.y.z[-v]/\",  (string) The string version\n"
            "    \"inbound\": true|false,     (boolean) Inbound (true) or Outbound (false)\n"
            "    \"startingheight\": n,       (numeric) The starting height (block) of the peer\n"
            "    \"banscore\": n,             (numeric) The ban score\n"
@@ -505,7 +505,7 @@ UniValue getnetworkinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
            "\nResult:\n"
            "{\n"
            "  \"version\": xxxxx,                      (numeric) the server version\n"
-            "  \"subversion\": \"/GoldenSandtrout:x.y.z[-v]/\",     (string) the server subversion string\n"
+            "  \"subversion\": \"/DragonX:x.y.z[-v]/\",     (string) the server subversion string\n"
            "  \"protocolversion\": xxxxx,              (numeric) the protocol version\n"
            "  \"localservices\": \"xxxxxxxxxxxxxxxx\", (string) the services we offer to the network\n"
            "  \"timeoffset\": xxxxx,                   (numeric) the time offset (deprecated, always 0)\n"
--- a/src/smartchains.json
+++ b/src/smartchains.json
@@ -14,7 +14,7 @@
   "ac_perc": "11111111",
   "ac_eras": "3",
   "ac_script": "76a9145eb10cf64f2bab1b457f1f25e658526155928fac88ac",
-   "clientname": "GoldenSandtrout",
+   "clientname": "DragonX",
   "addnode": [
       "1.1.1.1"
    ]
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -710,7 +710,7 @@ boost::filesystem::path GetConfigFile()
    if ( SMART_CHAIN_SYMBOL[0] != 0 ) {
        sprintf(confname,"%s.conf",SMART_CHAIN_SYMBOL);
    } else {
-        strcpy(confname,"HUSH3.conf");
+        strcpy(confname,"DRAGONX.conf");
    }
    boost::filesystem::path pathConfigFile(GetArg("-conf",confname));
    if (!pathConfigFile.is_complete())
@@ -731,7 +731,7 @@ void ReadConfigFile(map<string, string>& mapSettingsRet,

    for (boost::program_options::detail::config_file_iterator it(streamConfig, setOptions), end; it != end; ++it)
    {
-        // Don't overwrite existing settings so command line settings override HUSH3.conf
+        // Don't overwrite existing settings so command line settings override DRAGONX.conf
        string strKey = string("-") + it->string_key;
        if (mapSettingsRet.count(strKey) == 0)
        {
@@ -1029,14 +1029,16 @@ void SetThreadPriority(int nPriority)
 std::string PrivacyInfo()
 {
    return "\n" +
-           FormatParagraph(strprintf(_("In order to ensure you are adequately protecting your privacy when using Hush, please see <%s>."),
-                                     "https://hush.is/security/")) + "\n";
+           FormatParagraph(strprintf(_("In order to ensure you are adequately protecting your privacy when using DragonX, please see <%s>."),
+                                     "https://dragonx.is/security/")) + "\n";
 }

 std::string LicenseInfo()
 {
    return "\n" +
-           FormatParagraph(strprintf(_("Copyright (C) 2016-%i Duke Leto and The Hush Developers"), COPYRIGHT_YEAR)) + "\n" +
+           FormatParagraph(strprintf(_("Copyright (C) 2024-%i The DragonX Developers"), COPYRIGHT_YEAR)) + "\n" +
+           "\n" +
+           FormatParagraph(strprintf(_("Copyright (C) 2016-2024 Duke Leto and The Hush Developers"))) + "\n" +
           "\n" +
           FormatParagraph(strprintf(_("Copyright (C) 2016-2020 jl777 and SuperNET developers"))) + "\n" +
           "\n" +
--- a/src/version.h
+++ b/src/version.h
@@ -21,7 +21,8 @@
 #define HUSH_VERSION_H

 // network protocol versioning
-static const int PROTOCOL_VERSION = 1987429;
+// DragonX 1.0.0 - bumped to separate from old HUSH/DragonX nodes with RandomX bug
+static const int PROTOCOL_VERSION = 2000000;
 //! initial proto version, to be increased after version/verack negotiation
 static const int INIT_PROTO_VERSION = 209;
 //! In this version, 'getheaders' was introduced.
@@ -30,8 +31,9 @@ static const int GETHEADERS_VERSION = 31800;
 //! disconnect from peers older than this proto version (HUSH mainnet)
 static const int MIN_HUSH_PEER_PROTO_VERSION = 1987426;

-//! disconnect from peers older than this proto version (HACs)
-static const int MIN_PEER_PROTO_VERSION = 1987420;
+//! disconnect from peers older than this proto version (DragonX/HACs)
+//! Set to 2000000 to reject nodes without RandomX validation fix
+static const int MIN_PEER_PROTO_VERSION = 2000000;

 //! nTime field added to CAddress, starting with this version;
 //! if possible, avoid requesting addresses nodes older than this
--- a/src/wallet-utility.cpp
+++ b/src/wallet-utility.cpp
@@ -13,7 +13,7 @@
 char SMART_CHAIN_SYMBOL[HUSH_SMART_CHAIN_MAXLEN];
 int64_t MAX_MONEY = 200000000 * 100000000LL;
 uint64_t ASSETCHAINS_SUPPLY;
-uint16_t BITCOIND_RPCPORT = 18031;
+uint16_t BITCOIND_RPCPORT = 21769;
 uint16_t ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT;
 uint32_t ASSETCHAIN_INIT,ASSETCHAINS_CC;
 uint32_t ASSETCHAINS_MAGIC = 2387029918;
--- a/util/bootstrap-dragonx.sh
+++ b/util/bootstrap-dragonx.sh
@@ -0,0 +1,227 @@
+#!/usr/bin/env bash
+# Copyright 2024 The Hush Developers
+# Copyright 2024 The DragonX Developers
+# Released under the GPLv3
+#
+# Download and apply a DRAGONX blockchain bootstrap.
+# Safely preserves wallet.dat and configuration files.
+
+set -euo pipefail
+
+BOOTSTRAP_BASE_URL="https://bootstrap.dragonx.is"
+BOOTSTRAP_FILE="DRAGONX.zip"
+CHAIN_NAME="DRAGONX"
+
+# Determine data directory
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    DATADIR="$HOME/Library/Application Support/Hush/$CHAIN_NAME"
+else
+    DATADIR="$HOME/.hush/$CHAIN_NAME"
+fi
+
+CLI="dragonx-cli"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+info()  { echo -e "${GREEN}[INFO]${NC} $*" >&2; }
+warn()  { echo -e "${YELLOW}[WARN]${NC} $*" >&2; }
+error() { echo -e "${RED}[ERROR]${NC} $*" >&2; exit 1; }
+
+# Find dragonx-cli in PATH or relative to this script
+find_cli() {
+    if command -v "$CLI" &>/dev/null; then
+        CLI=$(command -v "$CLI")
+    elif [[ -x "$(dirname "$0")/../../src/$CLI" ]]; then
+        CLI="$(dirname "$0")/../../src/$CLI"
+    else
+        CLI=""
+    fi
+}
+
+# Stop the daemon if running
+stop_daemon() {
+    find_cli
+    if [[ -n "$CLI" ]]; then
+        if "$CLI" getinfo &>/dev/null 2>&1; then
+            info "Stopping DragonX daemon..."
+            "$CLI" stop 2>/dev/null || true
+            # Wait for daemon to exit
+            local tries=0
+            while "$CLI" getinfo &>/dev/null 2>&1; do
+                sleep 2
+                tries=$((tries + 1))
+                if [[ $tries -ge 60 ]]; then
+                    error "Daemon did not stop after 120 seconds. Please stop it manually and retry."
+                fi
+            done
+            info "Daemon stopped."
+        else
+            info "Daemon is not running."
+        fi
+    else
+        warn "dragonx-cli not found. Please make sure the daemon is stopped before continuing."
+        read -rp "Is the DragonX daemon stopped? (y/N): " answer
+        if [[ "${answer,,}" != "y" ]]; then
+            error "Please stop the daemon first and run this script again."
+        fi
+    fi
+}
+
+
+
+# Files/dirs to preserve (never delete these)
+PRESERVE_LIST=(
+    "wallet.dat"
+    "DRAGONX.conf"
+    "peers.dat"
+)
+
+# Remove blockchain data while preserving wallet and config
+clean_chain_data() {
+    if [[ ! -d "$DATADIR" ]]; then
+        info "Data directory does not exist yet, creating it."
+        mkdir -p "$DATADIR"
+        return
+    fi
+
+    info "Cleaning blockchain data from $DATADIR ..."
+
+    # Move preserved files to a temp location
+    local tmpdir
+    tmpdir=$(mktemp -d)
+    for f in "${PRESERVE_LIST[@]}"; do
+        if [[ -e "$DATADIR/$f" ]]; then
+            cp -a "$DATADIR/$f" "$tmpdir/"
+        fi
+    done
+
+    # Remove blockchain directories
+    local dirs_to_remove=("blocks" "chainstate" "notarizations" "komodo" "db.log" "debug.log" "fee_estimates.dat" "banlist.dat")
+    for d in "${dirs_to_remove[@]}"; do
+        if [[ -e "$DATADIR/$d" ]]; then
+            rm -rf "$DATADIR/$d"
+        fi
+    done
+
+    # Restore preserved files
+    for f in "${PRESERVE_LIST[@]}"; do
+        if [[ -e "$tmpdir/$f" ]]; then
+            cp -a "$tmpdir/$f" "$DATADIR/"
+        fi
+    done
+    rm -rf "$tmpdir"
+
+    info "Blockchain data cleaned."
+}
+
+# Download a file via wget or curl
+download_file() {
+    local url="$1"
+    local outfile="$2"
+
+    if command -v wget &>/dev/null; then
+        wget --progress=bar:force -O "$outfile" "$url" || error "Download failed: $url"
+    elif command -v curl &>/dev/null; then
+        curl -L --progress-bar -o "$outfile" "$url" || error "Download failed: $url"
+    else
+        error "Neither wget nor curl found. Please install one and retry."
+    fi
+}
+
+# Download the bootstrap and verify checksums
+download_bootstrap() {
+    local outfile="$DATADIR/$BOOTSTRAP_FILE"
+    local md5file="$DATADIR/${BOOTSTRAP_FILE}.md5"
+    local sha256file="$DATADIR/${BOOTSTRAP_FILE}.sha256"
+
+    info "Downloading bootstrap from $BOOTSTRAP_BASE_URL ..."
+    info "This may take a while depending on your connection speed."
+
+    download_file "$BOOTSTRAP_BASE_URL/$BOOTSTRAP_FILE" "$outfile"
+    info "Bootstrap download complete."
+
+    info "Downloading checksums..."
+    download_file "$BOOTSTRAP_BASE_URL/${BOOTSTRAP_FILE}.md5" "$md5file"
+    download_file "$BOOTSTRAP_BASE_URL/${BOOTSTRAP_FILE}.sha256" "$sha256file"
+
+    # Verify checksums
+    info "Verifying checksums..."
+    cd "$DATADIR"
+
+    if command -v md5sum &>/dev/null; then
+        if md5sum -c "$md5file" >&2; then
+            info "MD5 checksum verified."
+        else
+            error "MD5 checksum verification failed! The download may be corrupted."
+        fi
+    else
+        warn "md5sum not found, skipping MD5 verification."
+    fi
+
+    if command -v sha256sum &>/dev/null; then
+        if sha256sum -c "$sha256file" >&2; then
+            info "SHA256 checksum verified."
+        else
+            error "SHA256 checksum verification failed! The download may be corrupted."
+        fi
+    else
+        warn "sha256sum not found, skipping SHA256 verification."
+    fi
+
+    # Clean up checksum files
+    rm -f "$md5file" "$sha256file"
+
+    echo "$outfile"
+}
+
+# Extract the bootstrap
+extract_bootstrap() {
+    local archive="$1"
+
+    info "Extracting bootstrap..."
+    cd "$DATADIR"
+
+    # Extract zip, but never overwrite wallet.dat or config
+    unzip -o "$archive" -x 'wallet.dat' '*.conf' || error "Extraction failed. Please install unzip and retry."
+
+    info "Bootstrap extracted successfully."
+
+    # Clean up the downloaded archive
+    rm -f "$archive"
+    info "Removed downloaded archive to save disk space."
+}
+
+
+
+main() {
+    echo "============================================"
+    echo "  DragonX Bootstrap Installer"
+    echo "============================================"
+    echo ""
+    info "Data directory: $DATADIR"
+    echo ""
+
+    # Step 1: Stop daemon
+    stop_daemon
+
+    # Step 2: Clean old chain data
+    clean_chain_data
+
+    # Step 3: Download bootstrap
+    local archive
+    archive=$(download_bootstrap)
+
+    # Step 4: Extract bootstrap
+    extract_bootstrap "$archive"
+
+    echo ""
+    info "Bootstrap installation complete!"
+    info "You can now start DragonX with: dragonxd"
+    echo ""
+}
+
+main "$@"
--- a/util/build-win.sh
+++ b/util/build-win.sh
@@ -40,4 +40,4 @@ cd $WD

 sed -i 's/-lboost_system-mt /-lboost_system-mt-s /' configure
 cd src/
-CC="${CC} -g " CXX="${CXX} -g " make V=1  hushd.exe hush-cli.exe hush-tx.exe
+CC="${CC} -g " CXX="${CXX} -g " make V=1  dragonxd.exe dragonx-cli.exe dragonx-tx.exe
--- a/util/gen-linux-binary-release.sh
+++ b/util/gen-linux-binary-release.sh
@@ -1,14 +1,15 @@
 #!/usr/bin/env bash
 # Copyright (c) 2016-2024 The Hush developers
+# Copyright (c) 2024-2026 The DragonX developers
 # Released under the GPLv3

 set -e
 set -x

-#hardcode and uncomment if hushd is not running on this machine
-#VERSION=3.6.3
-VERSION=$(./src/hushd --version|grep version|cut -d' ' -f4|cut -d- -f1|sed 's/v//g')
-DIR="hush-$VERSION-linux-amd64"
+#hardcode and uncomment if dragonxd is not running on this machine
+#VERSION=1.0.0
+VERSION=$(./src/dragonxd --version|grep version|cut -d' ' -f4|cut -d- -f1|sed 's/v//g')
+DIR="dragonx-$VERSION-linux-amd64"
 FILE="$DIR.tar"
 TIME=$(perl -e 'print time')

@@ -23,12 +24,13 @@ mkdir $BUILD
 echo "Created new build dir $BUILD"
 cp contrib/asmap/asmap.dat $BUILD
 cp sapling*.params $BUILD
+cp util/bootstrap-dragonx.sh $BUILD
 cd src
-cp hushd hush-cli hush-tx hush-arrakis-chain ../$BUILD
+cp dragonxd dragonx-cli dragonx-tx ../$BUILD
 cd ../$BUILD
-strip hushd hush-cli hush-tx
+strip dragonxd dragonx-cli dragonx-tx
 cd ..
-tar -f $FILE -c  hush-$VERSION-linux-amd64/*
+tar -f $FILE -c  dragonx-$VERSION-linux-amd64/*
 gzip -9 $FILE
 sha256sum *.gz
 du -sh *.gz