Merge upstream/main into the fork

Brings the nine commits that are actually the latest on our lineage:
isolated testnet parameters and genesis, optional 2 MB large pages for
RandomX, and five README changes. This is what "up to date" means here --
not the 1.2.2x tags, which carry higher version numbers but were cut
2026-07-30, three weeks before the line we ship, and which upstream/main
does not contain.

Three conflicts, all resolved toward upstream's structure while keeping
what this fork knows:

main.cpp -- upstream moved genesis construction into BuildGenesisBlock() so
mainnet and the new testnet can share it. Verified byte-for-byte before
taking it: MAINNET_GENESIS_TIMESTAMP, _TIME (1753315200), _NONCE (3141),
_HASH, _MERKLE, the scriptPubKey, nBits and nVersion all equal what this
tree built inline. The mainnet genesis hash is unchanged and the asserts
still guard it. Kept our warning about never editing those inputs, and kept
our note that 1753315200 is 2025-07-24, not 2026 -- upstream's comment on
that constant states the wrong year.

net.h -- DEFAULT_PORT = htons(8433) becomes MAINNET_PORT/TESTNET_PORT in
host order. Nothing is lost: net.cpp's GetDefaultPort() applies htons()
itself and is what every caller uses, so the value reaching a sockaddr is
unchanged and mainnet stays on 8433.

selftest.cpp -- the known-tests string had diverged in both directions.
Took the union: upstream's network-params alongside our payout-ledger,
rather than dropping either.

Gates: 15/15 selftests (our 14 plus upstream's network-params), consensus
constants unchanged against e4f898c except the pre-existing
MAX_BLOCK_SIZE_GEN, mainnet genesis intact, compactblock's 17 checks still
pass, money-log check ok, GNU_STACK RW.

12 files changed, 424 insertions, 78 deletions

diff --git a/README.md b/README.md
index 77a0ad8..4453529 100644
--- a/README.md
+++ b/README.md
@@ -8,9 +8,11 @@ CPU-only cryptocurrency. A revival of Bitcoin 0.1.0 with RandomX proof of work a
 
 ![PoW](https://img.shields.io/badge/PoW-RandomX%20(CPU)-2ea44f?style=for-the-badge)
 ![Privacy](https://img.shields.io/badge/addresses-.btf%20anonymous-2ea44f?style=for-the-badge)
+![Tor](https://img.shields.io/badge/tor-onion%20service-7d4698?style=for-the-badge)
 ![Fair Launch](https://img.shields.io/badge/premine-none-2ea44f?style=for-the-badge)
+[![Discord](https://img.shields.io/badge/discord-join-5865F2?style=for-the-badge)](https://discord.gg/n7B2Eamn3)
 
-**[Download](../../releases/latest)**
+**[Download](https://releases.bitflash.network/)** · **[Discord](https://discord.gg/n7B2Eamn3)**
 
 </div>
 
@@ -46,14 +48,14 @@ For a plain SOCKS5 proxy without Tor-specific defaults, use
 
 ## Quick start
 
-Download the [latest release](../../releases/latest) and run. No install, no
-configuration — it connects automatically and starts syncing.
+Download the [latest release](https://releases.bitflash.network/) and run. No
+install, no configuration — it connects automatically and starts syncing.
 
 **Linux:** make the `.AppImage` executable and run it.
 
-**Windows:** extract the `-windows.zip` and run `Bitflash.exe`.
-If you want managed Tor without a separate Tor install, use the
-`-windows-with-tor.zip` package and start Bitflash with `-managedtor`.
+**Windows:** extract the `-windows-with-tor.zip` and run `Bitflash.exe`. Tor is
+bundled and a managed Tor instance starts automatically, so onion transport
+works with no separate install. Pass `-nomanagedtor` to turn it off.
 
 Every release ships a `SHA256SUMS` covering the assets. Verifying takes a second
 and is worth doing:
@@ -83,7 +85,7 @@ Public mirrors should make the latest checksum files available both under the
 versioned release directory and at the release root:
 
 ```text
-https://releases.bitflash.network/v1.2.19/SHA256SUMS
+https://releases.bitflash.network/v1.2.20/SHA256SUMS
 https://releases.bitflash.network/SHA256SUMS        # alias to latest
 ```
 
@@ -166,6 +168,14 @@ words also cover the address the window shows you. **Both still matter** — the
 phrase and the file back up different things, and the difference is where people
 lose money.
 
+Since 1.2.20 the file is a single self-contained `wallet.sqlite` by default. A
+fresh data directory starts on it; an existing Berkeley DB `wallet.dat` keeps
+working and the desktop app converts it in one click on first run, never
+touching the original, which stays as a fallback. Choose a backend explicitly
+with `-walletbackend=sqlite` or `-walletbackend=bdb`, recorded in a
+`wallet-backend` marker in the data directory. See
+[wallet storage](docs/storage.md).
+
 The derivation is written down in [docs/derivation.md](docs/derivation.md), with
 test vectors and a script that reproduces them from scratch. It is there so the
 twelve words keep working even if this software does not: paths, address format
@@ -179,8 +189,11 @@ bitflash -newphrase                          # create it, show it once, exit
 bitflash -restorephrase="twelve words here"  # rebuild a wallet from it
 ```
 
-`-newphrase` installs a BIP32 seed, derives the wallet's key pool and default
-receiving address from it, and prints the words once. It refuses if a phrase
+`-newphrase` installs a BIP39/BIP32 seed and derives the wallet as a BIP44 tree
+along `m/44'/4346950'/0'/…` — coin type **4346950** is `0x425446`, the ASCII
+bytes `BTF`, registered in [SLIP-0044](https://github.com/satoshilabs/slips/blob/master/slip-0044.md).
+It builds the key pool and default receiving address from the seed, and prints
+the words once. It refuses if a phrase
 already exists: replacing one silently would strand every coin on addresses the
 written-down words no longer describe.
 
@@ -207,6 +220,10 @@ matter.
 
 ### The file
 
+Under the SQLite default the wallet is one self-contained `wallet.sqlite`, and
+`-backupwallet` writes a matching `.sqlite` copy that opens on its own — no
+sidecar directory. The Berkeley DB notes below apply to a legacy `wallet.dat`.
+
 **Copying `wallet.dat` on its own is not a backup.** Berkeley DB ties the file
 to the environment in the `database/` subdirectory beside it, so a lone
 `wallet.dat` will not open elsewhere — the keys are all still in there, and the
@@ -244,7 +261,7 @@ as a verdict to somebody who has just lost a wallet.
 
 ### When wallet.dat itself will not open
 
-Everything above still runs through Berkeley DB. If the database is the thing
+A legacy `wallet.dat` runs on Berkeley DB. If that database is the thing
 that is broken — a build that will not read it, a file truncated by a bad copy,
 an environment beyond recovery — the keys are usually still fine, and you can
 take them out as text:
@@ -348,10 +365,12 @@ Other options worth knowing:
 
 ```bash
 -datadir=PATH    # wallet and chain data elsewhere
--port=N          # P2P listen port, default 8433
+-testnet         # isolated test network genesis, datadir, port 18433, and magic
+-port=N          # P2P listen port, default 8433; testnet default 18433
 -socks=HOST:PORT # SOCKS5 for outbound Nostr, .btf relay, and onion peer dials
 -tor[=HOST:PORT] # Tor mode; default local Tor SOCKS5 proxy is 127.0.0.1:9050
 -managedtor[=PATH] # start Tor, create a hidden service, advertise its onion
+-nomanagedtor    # disable the automatic bundled-Tor startup
 -onionservice=HOST.onion:PORT # advertise this node's Tor hidden service
 -debug           # verbose log; without it debug.log is nearly silent
 -help            # full list
@@ -372,6 +391,10 @@ proxy. IPv6 proxy endpoints use brackets, for example `-socks=[::1]:9050`.
 and signed direct `.onion` peer dials through Tor, and keeps external-IP probes
 disabled. Use `-tor=HOST:PORT` when Tor listens somewhere else.
 
+The desktop app starts a managed Tor automatically when no other Tor option is
+set, so onion transport works out of the box; `-nomanagedtor` turns that off.
+For a headless node, ask for it explicitly:
+
 `-managedtor[=PATH]` starts a Tor process for this node, writes a local `torrc`,
 creates a v3 hidden service for port `8433`, routes outbound discovery through
 that Tor instance, and signs the generated `.onion:8433` endpoint into the
@@ -496,7 +519,8 @@ windows-tor` to require the extra signature check.
 | Addressing | `.btf` rendezvous — see the caveats above |
 | Premine | None |
 | Pool server | Built-in — `.btf` rendezvous only |
-| Wallet recovery | Twelve-word phrase (BIP39 + BIP32), plus file backup |
+| Wallet recovery | Twelve-word phrase (BIP39 + BIP32 + BIP44, coin type 4346950), plus file backup |
+| Wallet storage | SQLite `wallet.sqlite` by default, or Berkeley DB `wallet.dat` |
 
 The halving interval is the number most people get wrong coming from Bitcoin.
 Same 210,000 blocks, but at two minutes instead of ten, so it arrives in about
@@ -504,6 +528,6 @@ ten months rather than four years.
 
 ---
 
-Experimental software. Young network. Don't put in more than you are willing to lose.
+Young network. Keep your node current and don't put in more than you are willing to lose.
 
 MIT. Built on Bitcoin 0.1.0 (Satoshi Nakamoto, 2009).
diff --git a/src/Makefile b/src/Makefile
index 888110f..c997ae3 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -225,6 +225,7 @@ tests: test_bip32 test_compactblock bitflash-node
         ./bitflash-node -selftest=wallet-crypto
         ./bitflash-node -selftest=wallet-encrypt
         ./bitflash-node -selftest=net-message
+        ./bitflash-node -selftest=network-params
         ./bitflash-node -selftest=consensus-limits
         ./bitflash-node -selftest=pool-stratum
         ./bitflash-node -selftest=payout-ledger
diff --git a/src/main.cpp b/src/main.cpp
index 7398064..0fa6b89 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -42,12 +42,30 @@ unsigned int nTransactionsUpdated = 0;
 map<COutPoint, CInPoint> mapNextTx;
 
 map<uint256, CBlockIndex*> mapBlockIndex;
-// Bitflash genesis -- mined under RandomX PoW on 2026-07-22
-// (nTime 1753142400, nBits 0x1f0fffff, RandomX key "Bitflash/RandomX/v1/...")
-// Bitflash 2026 stable relaunch genesis (2-min blocks, RandomX). Mined values.
-unsigned int GENESIS_NONCE = 3141;
-uint256 hashGenesisBlock("0x5bd7cb255d814e48cebcdfb72da4dc87b34bd774227f8ceb546c5640f4bdc169");
-uint256 hashGenesisMerkleRoot("0x1a45b4482532abb29b10e234d3f13132230525a339ecea91658ffa675a5b1325");
+// Bitflash mainnet genesis -- mined under RandomX PoW for the 2026 stable
+// relaunch. Testnet gets its own resettable genesis below so block indexes,
+// headers, and wallet scans cannot be accidentally mixed across networks.
+static const unsigned int MAINNET_GENESIS_TIME  = 1753315200; // 2026-07-24 00:00:00 UTC
+static const unsigned int MAINNET_GENESIS_NONCE = 3141;
+static const char* MAINNET_GENESIS_TIMESTAMP =
+    "Bitflash 24/Jul/2026 Fair launch: one CPU one vote, no premine";
+static const char* MAINNET_GENESIS_HASH =
+    "0x5bd7cb255d814e48cebcdfb72da4dc87b34bd774227f8ceb546c5640f4bdc169";
+static const char* MAINNET_GENESIS_MERKLE =
+    "0x1a45b4482532abb29b10e234d3f13132230525a339ecea91658ffa675a5b1325";
+
+static const unsigned int TESTNET_GENESIS_TIME  = 1787184000; // 2026-08-20 00:00:00 UTC
+static const unsigned int TESTNET_GENESIS_NONCE = 3199;
+static const char* TESTNET_GENESIS_TIMESTAMP =
+    "Bitflash testnet 20/Aug/2026: resettable public test chain";
+static const char* TESTNET_GENESIS_HASH =
+    "0xa9d11c6d697bcb7aea0653bc088b12dcf9f44e732df205162cf085fd9d9963eb";
+static const char* TESTNET_GENESIS_MERKLE =
+    "0x510b293105e3ff85b8d4c3920e357f85d1a86bf199eb4e7d11f04f380030ec5c";
+
+unsigned int GENESIS_NONCE = MAINNET_GENESIS_NONCE;
+uint256 hashGenesisBlock(MAINNET_GENESIS_HASH);
+uint256 hashGenesisMerkleRoot(MAINNET_GENESIS_MERKLE);
 CBlockIndex* pindexGenesisBlock = NULL;
 int nBestHeight = -1;
 uint256 hashBestChain = 0;
@@ -254,6 +272,63 @@ static std::atomic<uint64> gParticipantHashRateX1000{0};
 static std::mutex gParticipantStatusMutex;
 static std::string gParticipantStatus;
 
+void SelectGenesisParams(bool fTestNetIn)
+{
+    static bool fGenesisParamsSelected = false;
+    static bool fGenesisParamsTestNet = false;
+    if (fGenesisParamsSelected && fGenesisParamsTestNet == fTestNetIn)
+        return;
+
+    fGenesisParamsSelected = true;
+    fGenesisParamsTestNet = fTestNetIn;
+
+    if (fTestNetIn)
+    {
+        GENESIS_NONCE = TESTNET_GENESIS_NONCE;
+        hashGenesisBlock = uint256(TESTNET_GENESIS_HASH);
+        hashGenesisMerkleRoot = uint256(TESTNET_GENESIS_MERKLE);
+    }
+    else
+    {
+        GENESIS_NONCE = MAINNET_GENESIS_NONCE;
+        hashGenesisBlock = uint256(MAINNET_GENESIS_HASH);
+        hashGenesisMerkleRoot = uint256(MAINNET_GENESIS_MERKLE);
+    }
+}
+
+void SelectChainParams(bool fTestNetIn)
+{
+    SelectNetworkParams(fTestNetIn);
+    SelectGenesisParams(fTestNetIn);
+}
+
+static CBlock BuildGenesisBlock()
+{
+    const char* pszTimestamp = IsTestNet() ?
+        TESTNET_GENESIS_TIMESTAMP : MAINNET_GENESIS_TIMESTAMP;
+
+    CTransaction txNew;
+    txNew.vin.resize(1);
+    txNew.vout.resize(1);
+    txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(4) <<
+        vector<unsigned char>((unsigned char*)pszTimestamp,
+                              (unsigned char*)pszTimestamp + strlen(pszTimestamp));
+    txNew.vout[0].nValue = 50 * COIN;
+    txNew.vout[0].scriptPubKey = CScript() <<
+        CBigNum("0x5F1DF16B2B704C8A578D0BBAF74D385CDE12C11EE50455F3C438EF4C3FBCF649B6DE611FEAE06279A60939E028A8D65C10B73071A6F16719274855FEB0FD8A6704") <<
+        OP_CHECKSIG;
+
+    CBlock block;
+    block.vtx.push_back(txNew);
+    block.hashPrevBlock = 0;
+    block.hashMerkleRoot = block.BuildMerkleTree();
+    block.nVersion = 1;
+    block.nTime = IsTestNet() ? TESTNET_GENESIS_TIME : MAINNET_GENESIS_TIME;
+    block.nBits = 0x1f0fffff; // = bnProofOfWorkLimit (Bitflash RandomX floor)
+    block.nNonce = GENESIS_NONCE;
+    return block;
+}
+
 void SetParticipantMiningStatus(const std::string& status)
 {
     // Updates the GUI status string only. Logging is done at each call site
@@ -2654,11 +2729,21 @@ string GetAppDir()
     {
         return ".";
     }
-    static bool fMkdirDone;
-    if (!fMkdirDone)
+    static string strCreatedBaseDir;
+    if (strCreatedBaseDir != strDir)
     {
-        fMkdirDone = true;
         _mkdir(strDir.c_str());
+        strCreatedBaseDir = strDir;
+    }
+    if (IsTestNet())
+    {
+        strDir += "/testnet";
+        static string strCreatedTestnetDir;
+        if (strCreatedTestnetDir != strDir)
+        {
+            _mkdir(strDir.c_str());
+            strCreatedTestnetDir = strDir;
+        }
     }
     return strDir;
 }
@@ -2812,38 +2897,34 @@ bool LoadBlockIndex(bool fAllowNew)
 
         // Bitflash genesis block -- own header (fair launch)
         //
-        // Do not change pszTimestamp, the scriptPubKey, nTime or nNonce. They
-        // are the inputs to the genesis hash, and the genesis hash is
-        // consensus. Changing one on its own trips the assert below, which is
-        // loud and reverts cleanly; changing one and regenerating
-        // GENESIS_NONCE and hashGenesisBlock to match -- which is exactly what
-        // the re-mining branch below prints out and invites -- gives a node
-        // that starts without complaint, builds its own chain from height 0,
-        // and rejects every real peer as being on a different chain. That one
-        // fails silently, and the damage scales with how many people run the
-        // "fixed" build.
-        char* pszTimestamp = "Bitflash 24/Jul/2026 Fair launch: one CPU one vote, no premine";
-        CTransaction txNew;
-        txNew.vin.resize(1);
-        txNew.vout.resize(1);
-        txNew.vin[0].scriptSig     = CScript() << 486604799 << CBigNum(4) << vector<unsigned char>((unsigned char*)pszTimestamp, (unsigned char*)pszTimestamp + strlen(pszTimestamp));
-        txNew.vout[0].nValue       = 50 * COIN;
-        txNew.vout[0].scriptPubKey = CScript() << CBigNum("0x5F1DF16B2B704C8A578D0BBAF74D385CDE12C11EE50455F3C438EF4C3FBCF649B6DE611FEAE06279A60939E028A8D65C10B73071A6F16719274855FEB0FD8A6704") << OP_CHECKSIG;
-        CBlock block;
-        block.vtx.push_back(txNew);
-        block.hashPrevBlock = 0;
-        block.hashMerkleRoot = block.BuildMerkleTree();
-        block.nVersion = 1;
-        // 1753315200 is 2025-07-24T00:00:00Z. The headline in pszTimestamp
-        // above reads 2026 and does not match it. This is a known discrepancy
-        // and not a typo in the constant: the value is only consensus-critical
-        // as an input to the genesis hash, the block hashes to
-        // hashGenesisBlock with it, and every node on the network agrees. The
-        // mismatch is in the launched chain and cannot be corrected -- see the
-        // warning above before deciding otherwise.
-        block.nTime    = 1753315200;
-        block.nBits    = 0x1f0fffff; // = bnProofOfWorkLimit (Bitflash RandomX floor)
-        block.nNonce   = GENESIS_NONCE;
+        // Upstream moved the construction into BuildGenesisBlock() so mainnet
+        // and the isolated testnet can share it. The mainnet inputs it uses are
+        // byte-identical to what this block built inline before the merge --
+        // timestamp string, nTime, nNonce, scriptPubKey, nBits and nVersion all
+        // verified equal against MAINNET_GENESIS_* -- so the mainnet genesis
+        // hash is unchanged. The warning below is why that was checked rather
+        // than assumed, and it still applies to those constants:
+        //
+        // Do not change MAINNET_GENESIS_TIMESTAMP, the scriptPubKey,
+        // MAINNET_GENESIS_TIME or MAINNET_GENESIS_NONCE. They are the inputs to
+        // the genesis hash, and the genesis hash is consensus. Changing one on
+        // its own trips the assert below, which is loud and reverts cleanly;
+        // changing one and regenerating GENESIS_NONCE and hashGenesisBlock to
+        // match -- which is exactly what the re-mining branch below prints out
+        // and invites -- gives a node that starts without complaint, builds its
+        // own chain from height 0, and rejects every real peer as being on a
+        // different chain. That one fails silently, and the damage scales with
+        // how many people run the "fixed" build.
+        //
+        // MAINNET_GENESIS_TIME is 1753315200, which is 2025-07-24T00:00:00Z,
+        // while the headline in MAINNET_GENESIS_TIMESTAMP reads 2026 -- as does
+        // the comment upstream put on that constant, which is wrong about the
+        // year. This is a known discrepancy and not a typo in the value: it is
+        // only consensus-critical as an input to the genesis hash, the block
+        // hashes to hashGenesisBlock with it, and every node on the network
+        // agrees. The mismatch is in the launched chain and cannot be corrected
+        // -- see the warning above before deciding otherwise.
+        CBlock block = BuildGenesisBlock();
 
         // If the nonce has not been found yet, mine the genesis once (RandomX)
         // and print the values to be hardcoded in the constants above.
diff --git a/src/main.h b/src/main.h
index e05b467..26b3b69 100644
--- a/src/main.h
+++ b/src/main.h
@@ -94,6 +94,8 @@ extern map<uint256, CBlockIndex*> mapBlockIndex;
 extern uint256 hashGenesisBlock;
 extern uint256 hashGenesisMerkleRoot;
 extern unsigned int GENESIS_NONCE;
+void SelectGenesisParams(bool fTestNetIn);
+void SelectChainParams(bool fTestNetIn);
 extern CBlockIndex* pindexGenesisBlock;
 extern int nBestHeight;
 extern uint256 hashBestChain;
diff --git a/src/main_gui.cpp b/src/main_gui.cpp
index dd001c8..2e4eb91 100644
--- a/src/main_gui.cpp
+++ b/src/main_gui.cpp
@@ -120,7 +120,7 @@ static void PrintUsage()
     printf("            wallet-crypto, wallet-encrypt, wallet-portability,\n");
     printf("            net-message,\n");
     printf("            consensus-limits, pool-stratum,\n");
-    printf("            parse-money, socks5-proxy, or managed-tor\n");
+    printf("            parse-money, network-params, socks5-proxy, or managed-tor\n");
     printf("\n");
     printf("Mining mode:\n");
     printf("  /operator\n");
@@ -132,6 +132,8 @@ static void PrintUsage()
     printf("  /stratumbridgeport=N       (default 3333; listen on 127.0.0.1)\n");
     printf("  /solomine\n");
     printf("  /genproclimit=N            (mining threads; 0 or absent = every core but one)\n");
+    printf("  /nolargepages              (do not ask for 2 MB pages for the RandomX\n");
+    printf("                              cache, dataset and scratchpads)\n");
     printf("  /checkblocks=N             (blocks re-verified at startup, default 288, 0 = all)\n");
     printf("\n");
     printf("Pool operator announcement:\n");
@@ -148,7 +150,8 @@ static void PrintUsage()
     printf("  /onionservice=HOST.onion:PORT  (advertise this node's Tor hidden service)\n");
     printf("\n");
     printf("Network:\n");
-    printf("  /port=N                    (P2P listen port, default 8433)\n");
+    printf("  /testnet                   (isolated test network genesis, datadir, port, and magic)\n");
+    printf("  /port=N                    (P2P listen port, default 8433; testnet 18433)\n");
     printf("  /socks=HOST:PORT           (SOCKS5 proxy for Nostr, .btf relay, and onion dials)\n");
     printf("  /tor[=HOST:PORT]           (Tor mode; default SOCKS5 proxy is 127.0.0.1:9050)\n");
     printf("  /managedtor[=PATH]         (start Tor, create a hidden service, advertise its onion)\n");
@@ -214,6 +217,9 @@ static void ParseStartupArguments(int argc, char* argv[])
     if (arg(argc,argv,"/datadir") || arg(argc,argv,"-datadir"))
         strSetDataDir = argval2(argc, argv, "/datadir", "-datadir");
 
+    bool fUseTestNet = arg(argc, argv, "/testnet") || arg(argc, argv, "-testnet");
+    SelectChainParams(fUseTestNet);
+
     if (arg(argc,argv,"/debug") || arg(argc,argv,"-debug"))
         fDebug = true;
 
@@ -284,6 +290,11 @@ static void ParseStartupArguments(int argc, char* argv[])
     if (!strCheckBlocks.empty())
         nCheckBlocksOnLoad = atoi(strCheckBlocks.c_str());
 
+    // Must be read before LoadBlockIndex(), which is what first calls
+    // RandomXInit() and fixes how the cache is allocated.
+    if (arg(argc,argv,"/nolargepages") || arg(argc,argv,"-nolargepages"))
+        fRandomXLargePages = false;
+
     // /genproclimit=N -- threads to hash with. 0 or absent means automatic,
     // which is every core but one. Named after Bitcoin's own option so it reads
     // familiarly to anyone who has run one of these before.
diff --git a/src/makefile.mingw b/src/makefile.mingw
index 740bba6..362794a 100644
--- a/src/makefile.mingw
+++ b/src/makefile.mingw
@@ -116,6 +116,7 @@ tests: test_bip32.exe bitflash.exe
         ./bitflash.exe -selftest=wallet-backend-default
         ./bitflash.exe -selftest=wallet-convert
         ./bitflash.exe -selftest=net-message
+        ./bitflash.exe -selftest=network-params
         ./bitflash.exe -selftest=consensus-limits
         ./bitflash.exe -selftest=pool-stratum
         ./bitflash.exe -selftest=socks5-proxy
diff --git a/src/net.cpp b/src/net.cpp
index bb05259..0576402 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -50,10 +50,14 @@ static int BtfPoll(BtfPollFd* pfd, unsigned int nfd, int nTimeoutMs)
 //
 // Global state variables
 //
+static const char pchMainnetMessageStart[4] = { 0xbf, 0x20, 0x5c, 0xfd };
+static const char pchTestnetMessageStart[4] = { (char)0xce, (char)0xe2, (char)0xc0, (char)0xff };
+static bool fTestNet = false;
+char pchMessageStart[4] = { 0xbf, 0x20, 0x5c, 0xfd };
 bool fClient = false;
 uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
-CAddress addrLocalHost(0, DEFAULT_PORT, nLocalServices);
-unsigned short nListenPort = DEFAULT_PORT; // local P2P port (tunable via /port)
+CAddress addrLocalHost(0, GetDefaultPort(), nLocalServices);
+unsigned short nListenPort = GetDefaultPort(); // local P2P port (tunable via /port)
 CNode nodeLocalHost(INVALID_SOCKET, CAddress("127.0.0.1", nLocalServices));
 CNode* pnodeLocalHost = &nodeLocalHost;
 bool fShutdown = false;
@@ -90,6 +94,29 @@ static int64 nBtfHandshakeSilent = 0;
 static string strBtfLastDialFail;
 static string strBtfLastHandshakeTimeout;
 
+bool IsTestNet()
+{
+    return fTestNet;
+}
+
+unsigned short GetDefaultPort()
+{
+    return htons(fTestNet ? TESTNET_PORT : MAINNET_PORT);
+}
+
+void SelectNetworkParams(bool fTestNetIn)
+{
+    if (fTestNet == fTestNetIn)
+        return;
+
+    fTestNet = fTestNetIn;
+    memcpy(pchMessageStart,
+           fTestNet ? pchTestnetMessageStart : pchMainnetMessageStart,
+           sizeof(pchMessageStart));
+    nListenPort = GetDefaultPort();
+    addrLocalHost.port = nListenPort;
+}
+
 void BtfChurnNoteResolveAttempt()
 {
     CRITICAL_BLOCK(cs_btfChurn)
@@ -288,6 +315,7 @@ string GetDiagnosticsText()
     int nMedian = GetPeerMedianHeight();
 
     str += "Bitflash node diagnostics\n";
+    str += strprintf("  network           %s\n", IsTestNet() ? "testnet" : "mainnet");
     str += strprintf("  uptime            %s\n",
                      FormatAge(nNodeStartTime ? nNow - nNodeStartTime : -1).c_str());
     if (nMedian < 0)
@@ -338,6 +366,7 @@ string GetDiagnosticsText()
                                      nMining,
                                      (RandomXFastReady() ? 2080 : 256) + 2 * nMining).c_str()
                          : ", not mining");
+    str += strprintf("  large pages       %s\n", RandomXLargePagesStatus());
 
     str += SockAccountingText();
 
diff --git a/src/net.h b/src/net.h
index 752b1fe..0988542 100644
--- a/src/net.h
+++ b/src/net.h
@@ -12,7 +12,13 @@ class CBlockIndex;
 
 
 
-static const unsigned short DEFAULT_PORT = htons(8433);
+// Held in host byte order, unlike the DEFAULT_PORT constant these replace,
+// which was htons(8433). Nothing is lost: net.cpp's GetDefaultPort() applies
+// htons() itself and is what every caller now uses, so the value that reaches
+// a sockaddr is byte-for-byte what it was. Mainnet stays on 8433.
+static const unsigned short MAINNET_PORT = 8433;
+static const unsigned short TESTNET_PORT = 18433;
+static const unsigned int PUBLISH_HOPS = 5;
 enum
 {
     NODE_NETWORK = (1 << 0),
@@ -30,6 +36,9 @@ enum
 bool IsBlockFetchNearTip();
 
 bool GetMyExternalIP(unsigned int& ipRet);
+bool IsTestNet();
+unsigned short GetDefaultPort();
+void SelectNetworkParams(bool fTestNetIn);
 CNode* ConnectNodeBtf(const string& strBtfAddr);
 CNode* ConnectNodeBtfResolved(const string& strBtfAddr, const string& strMeeting,
                               const string& strOnion, const unsigned char enc_pub[32],
@@ -266,15 +275,17 @@ void CheckForShutdown(int n);
 // The message start string is designed to be unlikely to occur in normal data.
 // The characters are rarely used upper ascii, not valid as UTF-8, and produce
 // a large 4-byte int at any alignment.
-// Magic bytes unique to the Bitflash network (0xbf = "BF"). Second byte bumped
-// to 0x20 for the 2026 stable relaunch so the old test chain can't interfere.
-static const char pchMessageStart[4] = { 0xbf, 0x20, 0x5c, 0xfd };
+// Magic bytes unique to the selected Bitflash network. Mainnet uses 0xbf =
+// "BF"; testnet swaps the whole sequence so a test node cannot handshake with
+// mainnet before consensus-level testnet activation exists.
+extern char pchMessageStart[4];
 
 class CMessageHeader
 {
 public:
     enum { COMMAND_SIZE=12 };
-    char pchMessageStart[sizeof(::pchMessageStart)];
+    enum { MESSAGE_START_SIZE=4 };
+    char pchMessageStart[MESSAGE_START_SIZE];
     char pchCommand[COMMAND_SIZE];
     unsigned int nMessageSize;
 
@@ -365,7 +376,7 @@ public:
         nServices = 0;
         memcpy(pchReserved, pchIPv4, sizeof(pchReserved));
         ip = 0;
-        port = DEFAULT_PORT;
+        port = GetDefaultPort();
         nTime = GetAdjustedTime();
         nLastFailed = 0;
     }
@@ -395,7 +406,7 @@ public:
         nServices = nServicesIn;
         memcpy(pchReserved, pchIPv4, sizeof(pchReserved));
         ip = 0;
-        port = DEFAULT_PORT;
+        port = GetDefaultPort();
         nTime = GetAdjustedTime();
         nLastFailed = 0;
 
diff --git a/src/randomx_pow.cpp b/src/randomx_pow.cpp
index 9c59364..a509543 100644
--- a/src/randomx_pow.cpp
+++ b/src/randomx_pow.cpp
@@ -24,6 +24,50 @@ static std::mutex      g_csInit;
 static bool            g_fInit    = false;
 static bool            g_fFast    = false;
 
+// RandomX reads a 256 MB cache, a 2 GB dataset and a 2 MB scratchpad per VM
+// at random, so most reads miss the TLB on 4 KB pages. 2 MB pages recover
+// roughly a tenth of the hash rate.
+//
+// The pool must be reserved first (vm.nr_hugepages), and RandomX returns NULL
+// instead of falling back, so each allocation below retries without the flag.
+bool fRandomXLargePages = true;   // cleared by -nolargepages
+static bool g_fLargeCache   = false;
+static bool g_fLargeDataset = false;
+static bool g_fLargeAny     = false;
+
+// How to reserve the large-page pool, for the hint printed when a large-page
+// allocation falls back to normal pages. The mechanism is OS-specific.
+static const char* LargePagesHint()
+{
+#ifdef _WIN32
+    return "enable the \"Lock pages in memory\" privilege and run elevated";
+#else
+    return "reserve them with: sysctl vm.nr_hugepages=1280";
+#endif
+}
+
+static randomx_flags WithLargePages(randomx_flags f)
+{
+    return (randomx_flags)(f | RANDOMX_FLAG_LARGE_PAGES);
+}
+
+// Ask for a cache in large pages, then plain pages. Sets fLargeOut to say
+// which one answered.
+static randomx_cache* AllocCache(randomx_flags flags, bool& fLargeOut)
+{
+    fLargeOut = false;
+    if (fRandomXLargePages)
+    {
+        randomx_cache* c = randomx_alloc_cache(WithLargePages(flags));
+        if (c)
+        {
+            fLargeOut = true;
+            return c;
+        }
+    }
+    return randomx_alloc_cache(flags);
+}
+
 
 bool RandomXInit()
 {
@@ -37,28 +81,56 @@ bool RandomXInit()
     // Detect the best flags for this CPU (JIT, hardware AES, Argon2).
     g_flags = randomx_get_flags();
 
-    g_cache = randomx_alloc_cache(g_flags);
+    g_cache = AllocCache(g_flags, g_fLargeCache);
     if (!g_cache)
     {
         // Try without JIT as a fallback
         g_flags = RANDOMX_FLAG_DEFAULT;
-        g_cache = randomx_alloc_cache(g_flags);
+        g_cache = AllocCache(g_flags, g_fLargeCache);
         if (!g_cache)
             return error("RandomX: failed to allocate cache (256 MB)");
     }
     randomx_init_cache(g_cache, RANDOMX_KEY, strlen(RANDOMX_KEY));
 
-    // Verification VM in light mode (cache only)
-    g_vmVerify = randomx_create_vm(g_flags, g_cache, NULL);
+    // Verification VM in light mode (cache only). The scratchpad is only 2 MB
+    // and this VM is created once, but it hashes every block the node ever
+    // validates, so it gets the same treatment.
+    bool fLargeVerify = false;
+    if (fRandomXLargePages)
+    {
+        g_vmVerify = randomx_create_vm(WithLargePages(g_flags), g_cache, NULL);
+        fLargeVerify = (g_vmVerify != NULL);
+    }
+    if (!g_vmVerify)
+        g_vmVerify = randomx_create_vm(g_flags, g_cache, NULL);
     if (!g_vmVerify)
         return error("RandomX: failed to create verification VM");
 
+    g_fLargeAny = g_fLargeCache || fLargeVerify;
     g_fInit = true;
-    printf("RandomX: initialized (cache 256 MB, flags=%d)\n", (int)g_flags);
+    printf("RandomX: initialized (cache 256 MB, flags=%d, large pages: %s)\n",
+           (int)g_flags, RandomXLargePagesStatus());
+    if (fRandomXLargePages && !g_fLargeCache)
+        printf("RandomX: large pages unavailable for the cache; %s "
+               "for about 10%% more hash rate\n", LargePagesHint());
     return true;
 }
 
 
+const char* RandomXLargePagesStatus()
+{
+    if (!fRandomXLargePages)
+        return "off (-nolargepages)";
+    if (g_fLargeCache && g_fLargeDataset)
+        return "cache + dataset";
+    if (g_fLargeCache)
+        return "cache only";
+    if (g_fLargeDataset)
+        return "dataset only";
+    return g_fLargeAny ? "scratchpad only" : "unavailable";
+}
+
+
 // One dataset, once, no matter how many miners ask for it.
 //
 // Every miner thread calls this at startup. The g_fFast guard below is only
@@ -88,8 +160,18 @@ bool RandomXInitDataset(int nThreads)
     if (g_fFast)
         return true;
 
-    randomx_flags fastFlags = (randomx_flags)(g_flags | RANDOMX_FLAG_FULL_MEM);
-    g_dataset = randomx_alloc_dataset(fastFlags);
+    // Only RANDOMX_FLAG_LARGE_PAGES means anything to randomx_alloc_dataset;
+    // the rest of g_flags belongs to the VMs that read it.
+    if (fRandomXLargePages)
+    {
+        g_dataset = randomx_alloc_dataset(WithLargePages(RANDOMX_FLAG_DEFAULT));
+        g_fLargeDataset = (g_dataset != NULL);
+        if (!g_dataset)
+            printf("RandomX: large pages unavailable for the 2 GB dataset; %s "
+                   "for about 10%% more hash rate\n", LargePagesHint());
+    }
+    if (!g_dataset)
+        g_dataset = randomx_alloc_dataset(RANDOMX_FLAG_DEFAULT);
     if (!g_dataset)
     {
         printf("RandomX: not enough memory for the 2 GB dataset, staying in light mode\n");
@@ -158,13 +240,26 @@ void* RandomXCreateMinerVM()
 {
     if (!g_fInit && !RandomXInit())
         return NULL;
+
+    randomx_flags   flags   = g_flags;
+    randomx_cache*  cache   = g_cache;
+    randomx_dataset* dataset = NULL;
     if (g_fFast && g_dataset)
     {
-        randomx_flags fastFlags = (randomx_flags)(g_flags | RANDOMX_FLAG_FULL_MEM);
-        return randomx_create_vm(fastFlags, NULL, g_dataset);
+        flags   = (randomx_flags)(g_flags | RANDOMX_FLAG_FULL_MEM);
+        cache   = NULL;
+        dataset = g_dataset;
+    }
+
+    // Each thread gets its own 2 MB scratchpad, so the large-page pool can run
+    // dry partway through a fleet of miners. Threads that miss out still run.
+    if (fRandomXLargePages)
+    {
+        randomx_vm* vm = randomx_create_vm(WithLargePages(flags), cache, dataset);
+        if (vm)
+            return vm;
     }
-    // Light mode: own VM sharing the cache
-    return randomx_create_vm(g_flags, g_cache, NULL);
+    return randomx_create_vm(flags, cache, dataset);
 }
 
 
diff --git a/src/randomx_pow.h b/src/randomx_pow.h
index 0027571..355b708 100644
--- a/src/randomx_pow.h
+++ b/src/randomx_pow.h
@@ -41,4 +41,11 @@ uint256 RandomXHashWithVM(void* vm, const void* pHeader, size_t nSize);
 // True when the 2 GB dataset is ready (fast mode active).
 bool RandomXFastReady();
 
+// Ask for large (2 MB) pages for the cache, dataset and scratchpads. Set false
+// by -nolargepages. Must be set before the first RandomXInit().
+extern bool fRandomXLargePages;
+
+// Which allocations actually got large pages, for the status display.
+const char* RandomXLargePagesStatus();
+
 #endif
diff --git a/src/readme.txt b/src/readme.txt
index 7490a9a..455884c 100644
--- a/src/readme.txt
+++ b/src/readme.txt
@@ -41,7 +41,8 @@ The resulting executable is src/bitflash.exe.
 
 Command-line options (in addition to the original ones)
 -------------------------------------------------------
-  /port=N        listen on P2P port N (default 8433)
+  /testnet       use isolated test network genesis, datadir, port 18433, and message magic
+  /port=N        listen on P2P port N (default 8433; testnet default 18433)
   /socks=HOST:PORT
                  route outbound Nostr, .btf rendezvous, and direct onion peer
                  dials through a SOCKS5 proxy, e.g. /socks=127.0.0.1:9050 for local Tor
diff --git a/src/selftest.cpp b/src/selftest.cpp
index 65f215b..357d532 100644
--- a/src/selftest.cpp
+++ b/src/selftest.cpp
@@ -3118,6 +3118,87 @@ static int RunNetMessageSelfTest()
     return nFail == 0 ? 0 : 1;
 }
 
+static int RunNetworkParamsSelfTest()
+{
+    fflush(stdout);
+    printf("network-params self-test\n");
+
+    int nFail = 0;
+    std::string strOldDataDir = strSetDataDir;
+    try
+    {
+        SelectChainParams(false);
+        nFail += Check(!IsTestNet(), "starts on mainnet after explicit selection") ? 0 : 1;
+        nFail += Check(ntohs(GetDefaultPort()) == MAINNET_PORT,
+                       "mainnet default P2P port is 8433") ? 0 : 1;
+        CAddress mainAddr("127.0.0.1");
+        nFail += Check(mainAddr.port == htons(MAINNET_PORT),
+                       "mainnet address parsing uses the mainnet default port") ? 0 : 1;
+        CMessageHeader mainHeader("ping", 0);
+        char mainMagic[4];
+        memcpy(mainMagic, mainHeader.pchMessageStart, sizeof(mainMagic));
+        uint256 mainGenesis = hashGenesisBlock;
+        uint256 mainMerkle = hashGenesisMerkleRoot;
+        unsigned int mainNonce = GENESIS_NONCE;
+
+        SelectChainParams(true);
+        nFail += Check(IsTestNet(), "testnet selection is sticky") ? 0 : 1;
+        nFail += Check(ntohs(GetDefaultPort()) == TESTNET_PORT,
+                       "testnet default P2P port is 18433") ? 0 : 1;
+        CAddress testAddr("127.0.0.1");
+        nFail += Check(testAddr.port == htons(TESTNET_PORT),
+                       "testnet address parsing uses the testnet default port") ? 0 : 1;
+        CMessageHeader testHeader("ping", 0);
+        nFail += Check(memcmp(mainMagic, testHeader.pchMessageStart, sizeof(mainMagic)) != 0,
+                       "testnet message magic differs from mainnet") ? 0 : 1;
+        nFail += Check(hashGenesisBlock != mainGenesis &&
+                       hashGenesisMerkleRoot != mainMerkle &&
+                       GENESIS_NONCE != mainNonce,
+                       "testnet genesis constants differ from mainnet") ? 0 : 1;
+        nFail += Check(hashGenesisBlock == uint256("0xa9d11c6d697bcb7aea0653bc088b12dcf9f44e732df205162cf085fd9d9963eb") &&
+                       hashGenesisMerkleRoot == uint256("0x510b293105e3ff85b8d4c3920e357f85d1a86bf199eb4e7d11f04f380030ec5c") &&
+                       GENESIS_NONCE == 3199,
+                       "testnet genesis constants are pinned") ? 0 : 1;
+
+        std::string tmp;
+        if (!MakeTempDir(tmp))
+        {
+            nFail += Check(false, "creates a temporary data directory") ? 0 : 1;
+        }
+        else
+        {
+            strSetDataDir = tmp;
+            SelectChainParams(false);
+            std::string mainDir = GetAppDir();
+            SelectChainParams(true);
+            std::string testDir = GetAppDir();
+            nFail += Check(mainDir == tmp,
+                           "mainnet uses the selected data directory") ? 0 : 1;
+            nFail += Check(testDir == tmp + "/testnet",
+                           "testnet stores data below a testnet subdirectory") ? 0 : 1;
+            RemoveTree(tmp);
+        }
+    }
+    catch (const std::exception& e)
+    {
+        printf("  FAIL exception: %s\n", e.what());
+        nFail++;
+    }
+    catch (...)
+    {
+        printf("  FAIL unknown exception\n");
+        nFail++;
+    }
+
+    strSetDataDir = strOldDataDir;
+    SelectChainParams(false);
+
+    printf("%s (%d failure%s)\n", nFail == 0 ? "ALL TESTS PASSED" : "TESTS FAILED",
+           nFail, nFail == 1 ? "" : "s");
+    fflush(stdout);
+    return nFail == 0 ? 0 : 1;
+}
+
 static CBlock MakeSizedConsensusBlock(size_t nScriptBytes)
 {
     CTransaction tx;
@@ -3716,6 +3797,8 @@ int RunSelfTest(const std::string& name)
         return RunWalletPortabilitySelfTest();
     if (name == "net-message")
         return RunNetMessageSelfTest();
+    if (name == "network-params")
+        return RunNetworkParamsSelfTest();
     if (name == "consensus-limits")
         return RunConsensusLimitsSelfTest();
     if (name == "pool-stratum")
@@ -3730,6 +3813,6 @@ int RunSelfTest(const std::string& name)
         return RunManagedTorSelfTest();
 
     printf("Unknown self-test '%s'\n", name.c_str());
-    printf("Known self-tests: wallet-keypool, wallet-hd, wallet-format, wallet-storage-sanity, db-env-reopen, wallet-sqlite, wallet-sqlite-migration, wallet-crypto, wallet-encrypt, wallet-sqlite-encrypt, wallet-backend-default, wallet-convert, wallet-portability, net-message, consensus-limits, pool-stratum, payout-ledger, parse-money, socks5-proxy, managed-tor\n");
+    printf("Known self-tests: wallet-keypool, wallet-hd, wallet-format, wallet-storage-sanity, db-env-reopen, wallet-sqlite, wallet-sqlite-migration, wallet-crypto, wallet-encrypt, wallet-sqlite-encrypt, wallet-backend-default, wallet-convert, wallet-portability, net-message, network-params, consensus-limits, pool-stratum, payout-ledger, parse-money, socks5-proxy, managed-tor\n");
     return 1;
 }