Establish Monzero Phase 0 and inactive assets baselinemonzero-phase0-assets-prototype-20260815

19 files changed, 1188 insertions, 110 deletions

diff --git a/tests/core_tests/double_spend.h b/tests/core_tests/double_spend.h
index 6dccd6a0c..f47c69661 100644
--- a/tests/core_tests/double_spend.h
+++ b/tests/core_tests/double_spend.h
@@ -32,7 +32,11 @@
 #include "chaingen.h"
 
 const size_t invalid_index_value = std::numeric_limits<size_t>::max();
-const uint64_t FIRST_BLOCK_REWARD = 17592186044415;
+// Monzero's verified height-zero subsidy (190.73486328125 XMZ). Keeping the
+// inherited Monero value creates a miner change output in tx_0, so the
+// in-transaction double-spend fixture selects that change as though it
+// belonged to Bob and fails before consensus validation is exercised.
+const uint64_t FIRST_BLOCK_REWARD = 19073486328125;
 
 
 template<class concrete_test>
diff --git a/tests/phase0/README.md b/tests/phase0/README.md
new file mode 100644
index 000000000..3b619f1ee
--- /dev/null
+++ b/tests/phase0/README.md
@@ -0,0 +1,70 @@
+# Monzero Phase 0 integration tests
+
+These tests use temporary regtest directories and must not connect to or modify
+the live Monzero network.
+
+Run the three-node smoke test from the repository root:
+
+```bash
+python3 tests/phase0/monzero_multinode.py --build-dir build
+```
+
+The test starts three `monzerod` processes and one `monzero-wallet-rpc`
+process on localhost. It generates a temporary wallet, creates blocks, checks
+that every node reaches the same tip, restarts one node, and verifies that the
+restarted node catches up. It then matures a coinbase output, sends one XMZ to
+a second temporary wallet, verifies transaction-pool relay through all three
+nodes, mines the transaction on a different node, and verifies the receiver's
+confirmed balance. Before the transfer, it isolates the two edge nodes, creates
+competing three- and five-block forks, reconnects them, and verifies all nodes
+adopt the longer fork and identical tip. Finally, it restores the receiving
+wallet from its temporary mnemonic seed, rescans from height zero, and checks
+the recovered address and balance.
+
+Ports 26174-26205 must be available. All child processes are terminated on
+normal completion and on test failure. Pass `--keep-data` to retain temporary
+databases and logs for diagnosis.
+
+This is a smoke test, not the complete consensus qualification suite.
+Double-spend, deeper/adversarial reorg, and adversarial asset tests remain
+required before activating a new protocol version.
+
+## Fast unit gate
+
+Run the ordinary unit tests with a validating resolver and keep the expensive
+pruning-boundary concurrency scenario in the separate stress-test gate:
+
+```bash
+tests/phase0/run-fast-unit-tests.sh build
+```
+
+Override `DNS_PUBLIC` with another validating TCP resolver when required. The
+excluded `cryptonote_protocol_handler.race_condition` test must still pass in
+the scheduled stress gate; exclusion here is not a waiver.
+
+## Stress gate
+
+Run the pruning-boundary concurrency scenario separately:
+
+```bash
+tests/phase0/run-stress-tests.sh build
+```
+
+The default timeout is 1,800 seconds. Override it with
+`MONZERO_STRESS_TIMEOUT=<seconds>` when running on slower hardware. A timeout
+is a failed gate and must not be treated as a skipped test.
+
+## Adversarial core gate
+
+Build the native core-test executable and run the focused double-spend and
+key-image suite:
+
+```bash
+cmake --build build --target core_tests -j2
+tests/phase0/run-adversarial-core-tests.sh build
+```
+
+This covers conflicting key images in the transaction pool; double spends in
+one transaction, one block, separate blocks, competing chains, and alternate
+chains; and both kept-by-block modes. The default timeout is 1,800 seconds and
+can be overridden with `MONZERO_ADVERSARIAL_TIMEOUT`.
diff --git a/tests/phase0/monzero_multinode.py b/tests/phase0/monzero_multinode.py
new file mode 100755
index 000000000..106fcd9cb
--- /dev/null
+++ b/tests/phase0/monzero_multinode.py
@@ -0,0 +1,367 @@
+#!/usr/bin/env python3
+
+"""Isolated Monzero three-node propagation and restart smoke test.
+
+This script uses temporary regtest data and wallet directories. It never reads
+or writes the user's normal Monzero data directory or wallet files.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+import urllib.error
+import urllib.request
+
+
+HOST = "127.0.0.1"
+P2P_PORTS = (26174, 26184, 26194)
+RPC_PORTS = (26175, 26185, 26195)
+ZMQ_PORTS = (26176, 26186, 26196)
+WALLET_RPC_PORT = 26205
+
+
+class TestFailure(RuntimeError):
+    pass
+
+
+def request(port: int, path: str, body: dict, timeout: float = 5.0) -> dict:
+    payload = json.dumps(body).encode("utf-8")
+    req = urllib.request.Request(
+        f"http://{HOST}:{port}{path}",
+        data=payload,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    with urllib.request.urlopen(req, timeout=timeout) as response:
+        result = json.loads(response.read().decode("utf-8"))
+    if "error" in result:
+        raise TestFailure(f"RPC error from port {port}: {result['error']}")
+    return result
+
+
+def json_rpc(port: int, method: str, params: dict | None = None) -> dict:
+    response = request(
+        port,
+        "/json_rpc",
+        {"jsonrpc": "2.0", "id": "0", "method": method, "params": params or {}},
+    )
+    return response.get("result", {})
+
+
+def get_info(port: int) -> dict:
+    return request(port, "/get_info", {})
+
+
+def transaction_pool_hashes(port: int) -> set[str]:
+    response = request(port, "/get_transaction_pool", {})
+    return {
+        transaction.get("id_hash", "")
+        for transaction in response.get("transactions", [])
+        if transaction.get("id_hash")
+    }
+
+
+def wait_until(description: str, predicate, timeout: float = 45.0) -> None:
+    deadline = time.monotonic() + timeout
+    last_error = None
+    while time.monotonic() < deadline:
+        try:
+            if predicate():
+                return
+        except (OSError, TestFailure, urllib.error.URLError, ValueError) as error:
+            last_error = error
+        time.sleep(0.25)
+    suffix = f"; last error: {last_error}" if last_error else ""
+    raise TestFailure(f"Timed out waiting for {description}{suffix}")
+
+
+def stop_process(process: subprocess.Popen | None) -> None:
+    if process is None or process.poll() is not None:
+        return
+    process.send_signal(signal.SIGTERM)
+    try:
+        process.wait(timeout=10)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        process.wait(timeout=5)
+
+
+def daemon_command(binary: pathlib.Path, root: pathlib.Path, index: int) -> list[str]:
+    peers = []
+    if index > 0:
+        peers.extend(["--add-exclusive-node", f"{HOST}:{P2P_PORTS[index - 1]}"])
+    if index + 1 < len(P2P_PORTS):
+        peers.extend(["--add-exclusive-node", f"{HOST}:{P2P_PORTS[index + 1]}"])
+    return [
+        str(binary),
+        "--regtest",
+        "--fixed-difficulty", "1",
+        "--data-dir", str(root / f"node-{index}"),
+        "--p2p-bind-ip", HOST,
+        "--p2p-bind-port", str(P2P_PORTS[index]),
+        "--rpc-bind-ip", HOST,
+        "--rpc-bind-port", str(RPC_PORTS[index]),
+        "--zmq-rpc-bind-ip", HOST,
+        "--zmq-rpc-bind-port", str(ZMQ_PORTS[index]),
+        "--rpc-ssl", "disabled",
+        "--disable-dns-checkpoints",
+        "--check-updates", "disabled",
+        "--no-igd",
+        "--non-interactive",
+        "--log-level", "0",
+        *peers,
+    ]
+
+
+def start_daemon(binary: pathlib.Path, root: pathlib.Path, index: int, logs) -> subprocess.Popen:
+    log = open(root / f"node-{index}.log", "ab", buffering=0)
+    logs.append(log)
+    return subprocess.Popen(
+        daemon_command(binary, root, index),
+        stdout=log,
+        stderr=subprocess.STDOUT,
+        start_new_session=True,
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--build-dir", default="build", help="CMake build directory")
+    parser.add_argument("--keep-data", action="store_true", help="keep temporary logs and databases")
+    args = parser.parse_args()
+
+    build_dir = pathlib.Path(args.build_dir).resolve()
+    daemon = build_dir / "bin" / "monzerod"
+    wallet_rpc = build_dir / "bin" / "monzero-wallet-rpc"
+    for binary in (daemon, wallet_rpc):
+        if not binary.is_file():
+            raise TestFailure(f"Required binary not found: {binary}")
+
+    root = pathlib.Path(tempfile.mkdtemp(prefix="monzero-phase0-"))
+    processes: list[subprocess.Popen | None] = [None, None, None]
+    wallet_process = None
+    logs = []
+
+    try:
+        print(f"Temporary test network: {root}")
+        for index in range(3):
+            processes[index] = start_daemon(daemon, root, index, logs)
+
+        for index, port in enumerate(RPC_PORTS):
+            wait_until(f"node {index} RPC", lambda port=port: get_info(port).get("status") == "OK")
+
+        wait_until(
+            "the three-node P2P topology",
+            lambda: all(
+                get_info(port).get("incoming_connections_count", 0)
+                + get_info(port).get("outgoing_connections_count", 0) >= 1
+                for port in RPC_PORTS
+            ),
+            timeout=60,
+        )
+
+        wallet_log = open(root / "wallet-rpc.log", "ab", buffering=0)
+        logs.append(wallet_log)
+        (root / "wallets").mkdir()
+        wallet_process = subprocess.Popen(
+            [
+                str(wallet_rpc),
+                "--wallet-dir", str(root / "wallets"),
+                "--rpc-bind-ip", HOST,
+                "--rpc-bind-port", str(WALLET_RPC_PORT),
+                "--disable-rpc-login",
+                "--rpc-ssl", "disabled",
+                "--daemon-address", f"{HOST}:{RPC_PORTS[0]}",
+                "--daemon-ssl", "disabled",
+                # Regtest intentionally activates the latest hard fork at
+                # height 1, which cannot match the public-network schedule.
+                "--allow-mismatched-daemon-version",
+                "--log-level", "0",
+            ],
+            stdout=wallet_log,
+            stderr=subprocess.STDOUT,
+            start_new_session=True,
+        )
+        wait_until("wallet RPC", lambda: json_rpc(WALLET_RPC_PORT, "get_version").get("version", 0) > 0)
+        json_rpc(WALLET_RPC_PORT, "create_wallet", {"filename": "miner", "password": "", "language": "English"})
+        address = json_rpc(WALLET_RPC_PORT, "get_address").get("address")
+        if not address:
+            raise TestFailure("Temporary wallet did not return an address")
+
+        initial_height = get_info(RPC_PORTS[0])["height"]
+        json_rpc(RPC_PORTS[0], "generateblocks", {"wallet_address": address, "amount_of_blocks": 12})
+        target_height = initial_height + 12
+        wait_until(
+            f"all nodes to reach height {target_height}",
+            lambda: all(get_info(port)["height"] >= target_height for port in RPC_PORTS),
+            timeout=90,
+        )
+        hashes = [get_info(port)["top_block_hash"] for port in RPC_PORTS]
+        if len(set(hashes)) != 1:
+            raise TestFailure(f"Nodes disagree on the propagated tip: {hashes}")
+
+        print("Stopping node 2 and extending the chain by five blocks...")
+        stop_process(processes[2])
+        processes[2] = None
+        json_rpc(RPC_PORTS[0], "generateblocks", {"wallet_address": address, "amount_of_blocks": 5})
+        restart_target = target_height + 5
+        wait_until("connected nodes to accept the extension", lambda: get_info(RPC_PORTS[1])["height"] >= restart_target)
+
+        processes[2] = start_daemon(daemon, root, 2, logs)
+        wait_until("restarted node 2 RPC", lambda: get_info(RPC_PORTS[2]).get("status") == "OK")
+        wait_until(
+            f"restarted node 2 to catch up to height {restart_target}",
+            lambda: get_info(RPC_PORTS[2])["height"] >= restart_target,
+            timeout=90,
+        )
+        final_info = [get_info(port) for port in RPC_PORTS]
+        final_hashes = [info["top_block_hash"] for info in final_info]
+        if len(set(final_hashes)) != 1:
+            raise TestFailure(f"Nodes disagree after restart: {final_hashes}")
+
+        print("Testing competing forks and longest-chain convergence...")
+        stop_process(processes[1])
+        processes[1] = None
+        wait_until(
+            "edge nodes to become isolated",
+            lambda: all(
+                get_info(port).get("incoming_connections_count", 0)
+                + get_info(port).get("outgoing_connections_count", 0) == 0
+                for port in (RPC_PORTS[0], RPC_PORTS[2])
+            ),
+            timeout=30,
+        )
+        json_rpc(RPC_PORTS[0], "generateblocks", {"wallet_address": address, "amount_of_blocks": 3})
+        json_rpc(RPC_PORTS[2], "generateblocks", {"wallet_address": address, "amount_of_blocks": 5})
+        longer_fork_height = restart_target + 5
+        longer_fork_tip = get_info(RPC_PORTS[2])["top_block_hash"]
+
+        processes[1] = start_daemon(daemon, root, 1, logs)
+        wait_until("restarted node 1 RPC", lambda: get_info(RPC_PORTS[1]).get("status") == "OK")
+        wait_until(
+            "all nodes to adopt the longer competing fork",
+            lambda: all(
+                get_info(port)["height"] >= longer_fork_height
+                and get_info(port)["top_block_hash"] == longer_fork_tip
+                for port in RPC_PORTS
+            ),
+            timeout=120,
+        )
+
+        print("Testing wallet-to-wallet transaction relay and confirmation...")
+        json_rpc(RPC_PORTS[0], "generateblocks", {"wallet_address": address, "amount_of_blocks": 60})
+        spendable_height = longer_fork_height + 60
+        wait_until(
+            f"all nodes to reach spendable height {spendable_height}",
+            lambda: all(get_info(port)["height"] >= spendable_height for port in RPC_PORTS),
+            timeout=120,
+        )
+        json_rpc(WALLET_RPC_PORT, "refresh")
+
+        json_rpc(WALLET_RPC_PORT, "close_wallet")
+        json_rpc(WALLET_RPC_PORT, "create_wallet", {"filename": "receiver", "password": "", "language": "English"})
+        receiver_address = json_rpc(WALLET_RPC_PORT, "get_address").get("address")
+        if not receiver_address:
+            raise TestFailure("Receiver wallet did not return an address")
+        json_rpc(WALLET_RPC_PORT, "close_wallet")
+        json_rpc(WALLET_RPC_PORT, "open_wallet", {"filename": "miner", "password": ""})
+        json_rpc(WALLET_RPC_PORT, "refresh")
+
+        transfer = json_rpc(
+            WALLET_RPC_PORT,
+            "transfer",
+            {
+                "destinations": [{"amount": 100_000_000_000, "address": receiver_address}],
+                "get_tx_key": True,
+            },
+        )
+        transaction_hash = transfer.get("tx_hash")
+        if not transaction_hash:
+            raise TestFailure(f"Transfer did not return a transaction hash: {transfer}")
+        wait_until(
+            "transaction relay to every node",
+            lambda: all(transaction_hash in transaction_pool_hashes(port) for port in RPC_PORTS),
+            timeout=60,
+        )
+
+        json_rpc(RPC_PORTS[1], "generateblocks", {"wallet_address": address, "amount_of_blocks": 1})
+        confirmed_height = spendable_height + 1
+        wait_until(
+            f"transaction confirmation at height {confirmed_height}",
+            lambda: all(
+                get_info(port)["height"] >= confirmed_height
+                and transaction_hash not in transaction_pool_hashes(port)
+                for port in RPC_PORTS
+            ),
+            timeout=90,
+        )
+        json_rpc(WALLET_RPC_PORT, "close_wallet")
+        json_rpc(WALLET_RPC_PORT, "open_wallet", {"filename": "receiver", "password": ""})
+        json_rpc(WALLET_RPC_PORT, "refresh")
+        receiver_balance = json_rpc(WALLET_RPC_PORT, "get_balance").get("balance", 0)
+        if receiver_balance != 100_000_000_000:
+            raise TestFailure(f"Receiver balance is {receiver_balance}, expected 100000000000")
+
+        receiver_seed = json_rpc(WALLET_RPC_PORT, "query_key", {"key_type": "mnemonic"}).get("key")
+        if not receiver_seed:
+            raise TestFailure("Receiver wallet did not return its temporary recovery seed")
+        json_rpc(WALLET_RPC_PORT, "close_wallet")
+        restored = json_rpc(
+            WALLET_RPC_PORT,
+            "restore_deterministic_wallet",
+            {
+                "filename": "receiver-restored",
+                "password": "",
+                "seed": receiver_seed,
+                "restore_height": 0,
+            },
+        )
+        if restored.get("address") != receiver_address:
+            raise TestFailure(
+                f"Restored address {restored.get('address')} does not match {receiver_address}"
+            )
+        json_rpc(WALLET_RPC_PORT, "refresh")
+        restored_balance = json_rpc(WALLET_RPC_PORT, "get_balance").get("balance", 0)
+        if restored_balance != receiver_balance:
+            raise TestFailure(
+                f"Restored balance is {restored_balance}, expected {receiver_balance}"
+            )
+
+        final_info = [get_info(port) for port in RPC_PORTS]
+        final_hashes = [info["top_block_hash"] for info in final_info]
+        if len(set(final_hashes)) != 1:
+            raise TestFailure(f"Nodes disagree after transaction confirmation: {final_hashes}")
+
+        print("PASS: connectivity, propagation, catch-up, reorg, transfer, and wallet restoration")
+        print("Final height:", final_info[0]["height"])
+        print("Final tip:", final_hashes[0])
+        print("Confirmed transaction:", transaction_hash)
+        return 0
+    finally:
+        stop_process(wallet_process)
+        for process in reversed(processes):
+            stop_process(process)
+        for log in logs:
+            log.close()
+        if args.keep_data:
+            kept = pathlib.Path.cwd() / f"monzero-phase0-{int(time.time())}"
+            shutil.move(str(root), str(kept))
+            print(f"Kept test data at {kept}")
+        else:
+            shutil.rmtree(root, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except (TestFailure, OSError, urllib.error.URLError) as error:
+        print(f"FAIL: {error}", file=sys.stderr)
+        sys.exit(1)
diff --git a/tests/phase0/run-adversarial-core-tests.sh b/tests/phase0/run-adversarial-core-tests.sh
new file mode 100755
index 000000000..05fd95a96
--- /dev/null
+++ b/tests/phase0/run-adversarial-core-tests.sh
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+project_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+build_dir="${1:-${project_root}/build}"
+core_tests="${build_dir}/tests/core_tests/core_tests"
+timeout_seconds="${MONZERO_ADVERSARIAL_TIMEOUT:-1800}"
+filter='^(txpool_spend_key_(public|all)|txpool_double_spend_(norelay|local|keyimage)|gen_double_spend_.*)$'
+
+if [[ ! -x "${core_tests}" ]]; then
+  echo "Core-test binary not found: ${core_tests}" >&2
+  echo "Build it with: cmake --build ${build_dir} --target core_tests -j2" >&2
+  exit 1
+fi
+
+echo "Running Monzero double-spend and key-image adversarial gate (timeout: ${timeout_seconds}s)"
+exec timeout --signal=INT --kill-after=30 "${timeout_seconds}" \
+  "${core_tests}" \
+  --generate_and_play_test_data \
+  --filter "${filter}"
diff --git a/tests/phase0/run-fast-unit-tests.sh b/tests/phase0/run-fast-unit-tests.sh
new file mode 100755
index 000000000..08e3152e4
--- /dev/null
+++ b/tests/phase0/run-fast-unit-tests.sh
@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+project_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+build_dir="${1:-${project_root}/build}"
+unit_tests="${build_dir}/tests/unit_tests/unit_tests"
+
+if [[ ! -x "${unit_tests}" ]]; then
+  echo "Unit-test binary not found: ${unit_tests}" >&2
+  echo "Build it with: cmake --build ${build_dir} --target unit_tests -j2" >&2
+  exit 1
+fi
+
+# Keep external DNS behavior reproducible across developer and CI resolvers.
+export DNS_PUBLIC="${DNS_PUBLIC:-tcp://1.1.1.1}"
+
+# This pruning-boundary concurrency scenario creates about 9,600 blocks and is
+# kept in the separate stress gate. It is not a fast unit test.
+exec "${unit_tests}" \
+  --gtest_color=no \
+  --gtest_filter=-cryptonote_protocol_handler.race_condition
diff --git a/tests/phase0/run-stress-tests.sh b/tests/phase0/run-stress-tests.sh
new file mode 100755
index 000000000..20e8e7bc5
--- /dev/null
+++ b/tests/phase0/run-stress-tests.sh
@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+project_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+build_dir="${1:-${project_root}/build}"
+unit_tests="${build_dir}/tests/unit_tests/unit_tests"
+timeout_seconds="${MONZERO_STRESS_TIMEOUT:-1800}"
+
+if [[ ! -x "${unit_tests}" ]]; then
+  echo "Unit-test binary not found: ${unit_tests}" >&2
+  echo "Build it with: cmake --build ${build_dir} --target unit_tests -j2" >&2
+  exit 1
+fi
+
+export DNS_PUBLIC="${DNS_PUBLIC:-tcp://1.1.1.1}"
+
+echo "Running the pruning-boundary concurrency stress test (timeout: ${timeout_seconds}s)"
+exec timeout --signal=INT --kill-after=30 "${timeout_seconds}" \
+  "${unit_tests}" \
+  --gtest_color=no \
+  --gtest_filter=cryptonote_protocol_handler.race_condition
diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt
index 2415dfea8..16e498ae9 100644
--- a/tests/unit_tests/CMakeLists.txt
+++ b/tests/unit_tests/CMakeLists.txt
@@ -30,6 +30,7 @@ set(unit_tests_sources
   account.cpp
   apply_permutation.cpp
   address_from_url.cpp
+  asset_types.cpp
   base58.cpp
   blockchain_db.cpp
   block_queue.cpp
@@ -67,6 +68,7 @@ set(unit_tests_sources
   memwipe.cpp
   mlocker.cpp
   mnemonics.cpp
+  monzero_consensus.cpp
   mul_div.cpp
   multiexp.cpp
   multisig.cpp
@@ -154,3 +156,4 @@ add_test(
 monero_add_minimal_executable(test_notifier test_notifier.cpp)
 target_link_libraries(test_notifier ${EXTRA_LIBRARIES})
 set_property(TARGET test_notifier PROPERTY FOLDER "tests")
+add_dependencies(unit_tests test_notifier)
diff --git a/tests/unit_tests/asset_types.cpp b/tests/unit_tests/asset_types.cpp
new file mode 100644
index 000000000..b2f250fc5
--- /dev/null
+++ b/tests/unit_tests/asset_types.cpp
@@ -0,0 +1,442 @@
+#include "gtest/gtest.h"
+
+#include <cstring>
+#include <limits>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "cryptonote_basic/asset_types.h"
+#include "string_tools.h"
+
+namespace
+{
+  cryptonote::assets::issuance_descriptor make_descriptor(cryptonote::network_type network)
+  {
+    cryptonote::assets::issuance_descriptor descriptor;
+    descriptor.network = network;
+    if (!epee::string_tools::hex_to_pod(
+          "9b2e4c0281c0b02e7c53291a94d1d0cbff8883f8024f5142ee494ffbbd088071",
+          descriptor.issuer_key))
+      throw std::runtime_error("invalid fixed issuer key test vector");
+    std::memset(descriptor.issuance_nonce.data, 0x42, sizeof(descriptor.issuance_nonce.data));
+    descriptor.atomic_supply = UINT64_C(2100000000000000);
+    descriptor.display_decimals = 8;
+    std::memset(descriptor.metadata_hash.data, 0x24, sizeof(descriptor.metadata_hash.data));
+    descriptor.metadata_reference = "ipfs://bafy-monzero-test-vector";
+    return descriptor;
+  }
+
+  crypto::signature authorize(const cryptonote::assets::issuance_descriptor& descriptor,
+    const crypto::public_key& public_key, const crypto::secret_key& secret_key)
+  {
+    crypto::hash message{};
+    if (!cryptonote::assets::derive_issuance_authorization_hash(descriptor, message))
+      throw std::runtime_error("could not derive issuance authorization test message");
+    crypto::signature signature{};
+    crypto::generate_signature(message, public_key, secret_key, signature);
+    return signature;
+  }
+}
+
+TEST(asset_types, deterministic_canonical_identity)
+{
+  const auto descriptor = make_descriptor(cryptonote::MAINNET);
+  crypto::hash first{};
+  crypto::hash second{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(descriptor, first));
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(descriptor, second));
+  EXPECT_EQ(first, second);
+  EXPECT_EQ("1a83e64b6ec56327a06ae1d25387b6f1762120e0ec0b532351395d770a9896ce",
+    epee::string_tools::pod_to_hex(first));
+
+  std::vector<uint8_t> encoded;
+  ASSERT_TRUE(cryptonote::assets::encode_issuance_descriptor(descriptor, encoded));
+  ASSERT_GT(encoded.size(), descriptor.metadata_reference.size());
+}
+
+TEST(asset_types, network_domain_separation)
+{
+  auto mainnet = make_descriptor(cryptonote::MAINNET);
+  auto testnet = mainnet;
+  testnet.network = cryptonote::TESTNET;
+  crypto::hash mainnet_id{};
+  crypto::hash testnet_id{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(mainnet, mainnet_id));
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(testnet, testnet_id));
+  EXPECT_NE(mainnet_id, testnet_id);
+}
+
+TEST(asset_types, every_identity_field_is_committed)
+{
+  const auto original = make_descriptor(cryptonote::MAINNET);
+  crypto::hash original_id{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(original, original_id));
+
+  auto changed = original;
+  changed.atomic_supply++;
+  crypto::hash changed_id{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(changed, changed_id));
+  EXPECT_NE(original_id, changed_id);
+
+  changed = original;
+  changed.metadata_reference.push_back('2');
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(changed, changed_id));
+  EXPECT_NE(original_id, changed_id);
+
+  changed = original;
+  changed.issuance_nonce.data[0] ^= 1;
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(changed, changed_id));
+  EXPECT_NE(original_id, changed_id);
+
+  changed = original;
+  changed.type = cryptonote::assets::asset_class::edition;
+  changed.display_decimals = 0;
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(changed, changed_id));
+  EXPECT_NE(original_id, changed_id);
+
+  changed = original;
+  changed.type = cryptonote::assets::asset_class::non_fungible;
+  changed.atomic_supply = 1;
+  changed.display_decimals = 0;
+  std::memset(changed.collection_id.data, 0x11, sizeof(changed.collection_id.data));
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(changed, changed_id));
+  EXPECT_NE(original_id, changed_id);
+}
+
+TEST(asset_types, rejects_invalid_descriptors)
+{
+  std::string error;
+  auto descriptor = make_descriptor(cryptonote::MAINNET);
+
+  descriptor.version++;
+  EXPECT_FALSE(cryptonote::assets::validate_issuance_descriptor(descriptor, &error));
+  descriptor = make_descriptor(cryptonote::MAINNET);
+  descriptor.network = cryptonote::FAKECHAIN;
+  EXPECT_FALSE(cryptonote::assets::validate_issuance_descriptor(descriptor, &error));
+  descriptor = make_descriptor(cryptonote::MAINNET);
+  descriptor.atomic_supply = 0;
+  EXPECT_FALSE(cryptonote::assets::validate_issuance_descriptor(descriptor, &error));
+  descriptor = make_descriptor(cryptonote::MAINNET);
+  descriptor.display_decimals = cryptonote::assets::MAX_DISPLAY_DECIMALS + 1;
+  EXPECT_FALSE(cryptonote::assets::validate_issuance_descriptor(descriptor, &error));
+  descriptor = make_descriptor(cryptonote::MAINNET);
+  descriptor.metadata_reference.assign(cryptonote::assets::MAX_METADATA_REFERENCE_BYTES + 1, 'x');
+  EXPECT_FALSE(cryptonote::assets::validate_issuance_descriptor(descriptor, &error));
+  descriptor = make_descriptor(cryptonote::MAINNET);
+  descriptor.metadata_reference = std::string("bad\0reference", 13);
+  EXPECT_FALSE(cryptonote::assets::validate_issuance_descriptor(descriptor, &error));
+}
+
+TEST(asset_types, enforces_nft_collection_and_edition_rules)
+{
+  std::string error;
+  auto nft = make_descriptor(cryptonote::TESTNET);
+  nft.type = cryptonote::assets::asset_class::non_fungible;
+  nft.atomic_supply = 1;
+  nft.display_decimals = 0;
+  EXPECT_TRUE(cryptonote::assets::validate_issuance_descriptor(nft, &error));
+
+  nft.atomic_supply = 2;
+  EXPECT_FALSE(cryptonote::assets::validate_issuance_descriptor(nft, &error));
+  nft.atomic_supply = 1;
+  nft.display_decimals = 1;
+  EXPECT_FALSE(cryptonote::assets::validate_issuance_descriptor(nft, &error));
+
+  auto collection = make_descriptor(cryptonote::TESTNET);
+  collection.type = cryptonote::assets::asset_class::collection;
+  collection.atomic_supply = 1;
+  collection.display_decimals = 0;
+  EXPECT_TRUE(cryptonote::assets::validate_issuance_descriptor(collection, &error));
+  collection.collection_id.data[0] = 1;
+  EXPECT_FALSE(cryptonote::assets::validate_issuance_descriptor(collection, &error));
+
+  auto edition = make_descriptor(cryptonote::TESTNET);
+  edition.type = cryptonote::assets::asset_class::edition;
+  edition.display_decimals = 0;
+  std::memset(edition.collection_id.data, 0x33, sizeof(edition.collection_id.data));
+  EXPECT_TRUE(cryptonote::assets::validate_issuance_descriptor(edition, &error));
+  edition.display_decimals = 1;
+  EXPECT_FALSE(cryptonote::assets::validate_issuance_descriptor(edition, &error));
+
+  auto fungible = make_descriptor(cryptonote::TESTNET);
+  fungible.collection_id.data[0] = 1;
+  EXPECT_FALSE(cryptonote::assets::validate_issuance_descriptor(fungible, &error));
+}
+
+TEST(asset_types, verifies_issuer_and_collection_authorizations)
+{
+  crypto::public_key issuer_public{};
+  crypto::secret_key issuer_secret{};
+  crypto::generate_keys(issuer_public, issuer_secret);
+
+  auto collection = make_descriptor(cryptonote::TESTNET);
+  collection.type = cryptonote::assets::asset_class::collection;
+  collection.atomic_supply = 1;
+  collection.display_decimals = 0;
+  collection.issuer_key = issuer_public;
+  crypto::hash collection_id{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(collection, collection_id));
+
+  crypto::hash issuance_message{};
+  ASSERT_TRUE(cryptonote::assets::derive_issuance_authorization_hash(collection, issuance_message));
+  crypto::signature issuance_signature{};
+  crypto::generate_signature(issuance_message, issuer_public, issuer_secret, issuance_signature);
+  EXPECT_TRUE(cryptonote::assets::verify_issuance_authorization(collection, issuance_signature));
+  collection.issuance_nonce.data[0] ^= 1;
+  EXPECT_FALSE(cryptonote::assets::verify_issuance_authorization(collection, issuance_signature));
+  collection.issuance_nonce.data[0] ^= 1;
+
+  auto nft = make_descriptor(cryptonote::TESTNET);
+  nft.type = cryptonote::assets::asset_class::non_fungible;
+  nft.atomic_supply = 1;
+  nft.display_decimals = 0;
+  nft.collection_id = collection_id;
+  crypto::hash nft_id{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(nft, nft_id));
+
+  crypto::hash membership_message{};
+  ASSERT_TRUE(cryptonote::assets::derive_collection_membership_hash(collection_id, nft_id, membership_message));
+  crypto::signature membership_signature{};
+  crypto::generate_signature(membership_message, issuer_public, issuer_secret, membership_signature);
+  EXPECT_TRUE(cryptonote::assets::verify_collection_membership(
+    collection_id, nft_id, issuer_public, membership_signature));
+
+  nft_id.data[0] ^= 1;
+  EXPECT_FALSE(cryptonote::assets::verify_collection_membership(
+    collection_id, nft_id, issuer_public, membership_signature));
+  EXPECT_FALSE(cryptonote::assets::derive_collection_membership_hash(
+    crypto::null_hash, nft_id, membership_message));
+}
+
+TEST(asset_types, registry_authenticates_collection_membership_and_reorgs)
+{
+  crypto::public_key collection_public{};
+  crypto::secret_key collection_secret{};
+  crypto::generate_keys(collection_public, collection_secret);
+  crypto::public_key member_public{};
+  crypto::secret_key member_secret{};
+  crypto::generate_keys(member_public, member_secret);
+
+  cryptonote::assets::asset_registry registry;
+  auto collection = make_descriptor(cryptonote::TESTNET);
+  collection.type = cryptonote::assets::asset_class::collection;
+  collection.atomic_supply = 1;
+  collection.display_decimals = 0;
+  collection.issuer_key = collection_public;
+  const auto collection_auth = authorize(collection, collection_public, collection_secret);
+  crypto::hash collection_id{};
+  ASSERT_TRUE(registry.apply_issuance(collection, collection_auth, boost::none, 10, collection_id));
+  EXPECT_TRUE(registry.contains(collection_id));
+
+  auto nft = make_descriptor(cryptonote::TESTNET);
+  nft.type = cryptonote::assets::asset_class::non_fungible;
+  nft.atomic_supply = 1;
+  nft.display_decimals = 0;
+  nft.collection_id = collection_id;
+  nft.issuer_key = member_public;
+  crypto::hash nft_id{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(nft, nft_id));
+  const auto nft_auth = authorize(nft, member_public, member_secret);
+  crypto::hash membership_message{};
+  ASSERT_TRUE(cryptonote::assets::derive_collection_membership_hash(collection_id, nft_id, membership_message));
+  crypto::signature membership_signature{};
+  crypto::generate_signature(membership_message, collection_public, collection_secret, membership_signature);
+
+  crypto::hash registered_nft{};
+  EXPECT_FALSE(registry.apply_issuance(nft, nft_auth, membership_signature, 9, registered_nft));
+  ASSERT_TRUE(registry.apply_issuance(nft, nft_auth, membership_signature, 12, registered_nft));
+  EXPECT_EQ(nft_id, registered_nft);
+  EXPECT_EQ(2u, registry.size());
+  EXPECT_EQ(2u, registry.known_assets().size());
+  ASSERT_NE(nullptr, registry.find(nft_id));
+  EXPECT_EQ(12u, registry.find(nft_id)->issuance_height);
+
+  crypto::hash duplicate{};
+  EXPECT_FALSE(registry.apply_issuance(nft, nft_auth, membership_signature, 13, duplicate));
+
+  registry.detach(12);
+  EXPECT_TRUE(registry.contains(collection_id));
+  EXPECT_FALSE(registry.contains(nft_id));
+  EXPECT_EQ(1u, registry.size());
+  EXPECT_TRUE(registry.apply_issuance(nft, nft_auth, membership_signature, 14, registered_nft));
+  registry.detach(10);
+  EXPECT_EQ(0u, registry.size());
+}
+
+TEST(asset_types, registry_rejects_fake_or_missing_collection_authority)
+{
+  crypto::public_key issuer_public{};
+  crypto::secret_key issuer_secret{};
+  crypto::generate_keys(issuer_public, issuer_secret);
+  crypto::public_key attacker_public{};
+  crypto::secret_key attacker_secret{};
+  crypto::generate_keys(attacker_public, attacker_secret);
+
+  cryptonote::assets::asset_registry registry;
+  auto collection = make_descriptor(cryptonote::STAGENET);
+  collection.type = cryptonote::assets::asset_class::collection;
+  collection.atomic_supply = 1;
+  collection.display_decimals = 0;
+  collection.issuer_key = issuer_public;
+  crypto::hash collection_id{};
+  ASSERT_TRUE(registry.apply_issuance(
+    collection, authorize(collection, issuer_public, issuer_secret), boost::none, 1, collection_id));
+
+  auto nft = make_descriptor(cryptonote::STAGENET);
+  nft.type = cryptonote::assets::asset_class::non_fungible;
+  nft.atomic_supply = 1;
+  nft.display_decimals = 0;
+  nft.collection_id = collection_id;
+  nft.issuer_key = attacker_public;
+  const auto nft_auth = authorize(nft, attacker_public, attacker_secret);
+  crypto::hash nft_id{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(nft, nft_id));
+  crypto::hash ignored{};
+  EXPECT_FALSE(registry.apply_issuance(nft, nft_auth, boost::none, 2, ignored));
+
+  crypto::hash membership_message{};
+  ASSERT_TRUE(cryptonote::assets::derive_collection_membership_hash(collection_id, nft_id, membership_message));
+  crypto::signature fake_membership{};
+  crypto::generate_signature(membership_message, attacker_public, attacker_secret, fake_membership);
+  EXPECT_FALSE(registry.apply_issuance(nft, nft_auth, fake_membership, 2, ignored));
+
+  nft.collection_id.data[0] ^= 1;
+  EXPECT_FALSE(registry.apply_issuance(
+    nft, authorize(nft, attacker_public, attacker_secret), boost::none, 2, ignored));
+}
+
+TEST(asset_types, validates_fixed_supply_issuance_and_xmz_fee)
+{
+  const auto descriptor = make_descriptor(cryptonote::TESTNET);
+  crypto::hash asset_id{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(descriptor, asset_id));
+
+  cryptonote::assets::transparent_balance_statement statement;
+  statement.xmz_inputs = 5000;
+  statement.xmz_outputs = 4500;
+  statement.xmz_fee = 500;
+  statement.issuance = descriptor;
+  statement.asset_outputs.push_back({asset_id, descriptor.atomic_supply});
+  EXPECT_TRUE(cryptonote::assets::validate_transparent_balance_statement(statement, {}));
+
+  statement.asset_outputs[0].amount++;
+  EXPECT_FALSE(cryptonote::assets::validate_transparent_balance_statement(statement, {}));
+}
+
+TEST(asset_types, validates_transfer_and_explicit_burn)
+{
+  const auto descriptor = make_descriptor(cryptonote::TESTNET);
+  crypto::hash asset_id{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(descriptor, asset_id));
+  const std::set<crypto::hash> known{asset_id};
+
+  cryptonote::assets::transparent_balance_statement statement;
+  statement.xmz_inputs = 1000;
+  statement.xmz_outputs = 900;
+  statement.xmz_fee = 100;
+  statement.asset_inputs.push_back({asset_id, 100});
+  statement.asset_outputs.push_back({asset_id, 60});
+  statement.asset_burns.push_back({asset_id, 40});
+  EXPECT_TRUE(cryptonote::assets::validate_transparent_balance_statement(statement, known));
+
+  statement.asset_burns[0].amount = 39;
+  EXPECT_FALSE(cryptonote::assets::validate_transparent_balance_statement(statement, known));
+}
+
+TEST(asset_types, rejects_cross_asset_conversion_and_unknown_assets)
+{
+  auto first_descriptor = make_descriptor(cryptonote::TESTNET);
+  auto second_descriptor = first_descriptor;
+  second_descriptor.issuance_nonce.data[0] ^= 1;
+  crypto::hash first{};
+  crypto::hash second{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(first_descriptor, first));
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(second_descriptor, second));
+
+  cryptonote::assets::transparent_balance_statement statement;
+  statement.asset_inputs.push_back({first, 100});
+  statement.asset_outputs.push_back({second, 100});
+  EXPECT_FALSE(cryptonote::assets::validate_transparent_balance_statement(statement, {first, second}));
+
+  statement.asset_outputs[0].asset_id = first;
+  EXPECT_FALSE(cryptonote::assets::validate_transparent_balance_statement(statement, {}));
+}
+
+TEST(asset_types, rejects_duplicate_issuance_and_native_inflation)
+{
+  const auto descriptor = make_descriptor(cryptonote::STAGENET);
+  crypto::hash asset_id{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(descriptor, asset_id));
+
+  cryptonote::assets::transparent_balance_statement statement;
+  statement.xmz_inputs = 100;
+  statement.xmz_outputs = 100;
+  statement.issuance = descriptor;
+  statement.asset_outputs.push_back({asset_id, descriptor.atomic_supply});
+  EXPECT_FALSE(cryptonote::assets::validate_transparent_balance_statement(statement, {asset_id}));
+
+  statement.xmz_outputs = 101;
+  EXPECT_FALSE(cryptonote::assets::validate_transparent_balance_statement(statement, {}));
+}
+
+TEST(asset_types, rejects_noncanonical_and_overflowing_amounts)
+{
+  const auto descriptor = make_descriptor(cryptonote::MAINNET);
+  crypto::hash asset_id{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(descriptor, asset_id));
+  const std::set<crypto::hash> known{asset_id};
+
+  cryptonote::assets::transparent_balance_statement statement;
+  statement.asset_inputs.push_back({asset_id, std::numeric_limits<uint64_t>::max()});
+  statement.asset_inputs.push_back({asset_id, 1});
+  statement.asset_outputs.push_back({asset_id, std::numeric_limits<uint64_t>::max()});
+  EXPECT_FALSE(cryptonote::assets::validate_transparent_balance_statement(statement, known));
+
+  statement = {};
+  statement.asset_inputs.push_back({crypto::null_hash, 1});
+  statement.asset_outputs.push_back({crypto::null_hash, 1});
+  EXPECT_FALSE(cryptonote::assets::validate_transparent_balance_statement(statement, known));
+
+  statement = {};
+  statement.asset_inputs.push_back({asset_id, 0});
+  statement.asset_outputs.push_back({asset_id, 0});
+  EXPECT_FALSE(cryptonote::assets::validate_transparent_balance_statement(statement, known));
+
+  statement = {};
+  EXPECT_FALSE(cryptonote::assets::validate_transparent_balance_statement(statement, known));
+}
+
+TEST(asset_types, rejects_sum_overflow_and_unrelated_unknown_assets_during_issuance)
+{
+  const auto descriptor = make_descriptor(cryptonote::TESTNET);
+  auto unrelated_descriptor = descriptor;
+  unrelated_descriptor.issuance_nonce.data[0] ^= 1;
+  crypto::hash issued_id{};
+  crypto::hash unknown_id{};
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(descriptor, issued_id));
+  ASSERT_TRUE(cryptonote::assets::derive_asset_id(unrelated_descriptor, unknown_id));
+
+  cryptonote::assets::transparent_balance_statement statement;
+  statement.xmz_inputs = std::numeric_limits<uint64_t>::max();
+  statement.xmz_outputs = std::numeric_limits<uint64_t>::max();
+  statement.xmz_fee = 1;
+  statement.issuance = descriptor;
+  statement.asset_outputs.push_back({issued_id, descriptor.atomic_supply});
+  EXPECT_FALSE(cryptonote::assets::validate_transparent_balance_statement(statement, {}));
+
+  statement.xmz_inputs = 0;
+  statement.xmz_outputs = 0;
+  statement.xmz_fee = 0;
+  statement.asset_inputs.push_back({unknown_id, 1});
+  statement.asset_outputs.push_back({unknown_id, 1});
+  EXPECT_FALSE(cryptonote::assets::validate_transparent_balance_statement(statement, {}));
+
+  statement.asset_inputs.clear();
+  statement.asset_outputs.clear();
+  statement.issuance = boost::none;
+  statement.asset_inputs.push_back({issued_id, std::numeric_limits<uint64_t>::max()});
+  statement.asset_outputs.push_back({issued_id, std::numeric_limits<uint64_t>::max()});
+  statement.asset_burns.push_back({issued_id, 1});
+  EXPECT_FALSE(cryptonote::assets::validate_transparent_balance_statement(statement, {issued_id}));
+}
diff --git a/tests/unit_tests/base58.cpp b/tests/unit_tests/base58.cpp
index 165c52a8e..4b0409010 100644
--- a/tests/unit_tests/base58.cpp
+++ b/tests/unit_tests/base58.cpp
@@ -467,7 +467,7 @@ namespace
     "\x22\x09\x39\x68\x9e\xdf\x1a\xbd\x5b\xc1\xd0\x31\xf7\x3e\xcd\x6c"
     "\x99\x3a\xdd\x66\xd6\x80\x88\x70\x45\x6a\xfe\xb8\xe7\xee\xb6\x8d");
   // DON'T ever use this as a destination for funds, as the keys are right above this comment...
-  std::string test_keys_addr_str = "4AzKEX4gXdJdNeM6dfiBFL7kqund3HYGvMBF3ttsNd9SfzgYB6L7ep1Yg1osYJzLdaKAYSLVh6e6jKnAuzj3bw1oGy9kXCb";
+  std::string test_keys_addr_str = "FYg4BQkDspUdNeM6dfiBFL7kqund3HYGvMBF3ttsNd9SfzgYB6L7ep1Yg1osYJzLdaKAYSLVh6e6jKnAuzj3bw1oGx5gSC6";
 }
 
 TEST(get_account_address_as_str, works_correctly)
diff --git a/tests/unit_tests/block_reward.cpp b/tests/unit_tests/block_reward.cpp
index 9d06c8e86..b913b08d8 100644
--- a/tests/unit_tests/block_reward.cpp
+++ b/tests/unit_tests/block_reward.cpp
@@ -53,24 +53,24 @@ namespace
 
   TEST_F(block_reward_and_already_generated_coins, handles_first_values)
   {
-  	// 17592186044415 from neozaru, confirmed by fluffypony
-    TEST_ALREADY_GENERATED_COINS(0, UINT64_C(17592186044415));
-    TEST_ALREADY_GENERATED_COINS(m_block_reward, UINT64_C(17592169267200));
-    TEST_ALREADY_GENERATED_COINS(UINT64_C(2756434948434199641), UINT64_C(14963444829249));
+    // Monzero primary emission starts from 100,000,000 XMZ at 11 decimals.
+    TEST_ALREADY_GENERATED_COINS(0, UINT64_C(19073486328125));
+    TEST_ALREADY_GENERATED_COINS(m_block_reward, UINT64_C(19073449948336));
+    TEST_ALREADY_GENERATED_COINS(UINT64_C(2756434948434199641), UINT64_C(13816003897792));
   }
 
   TEST_F(block_reward_and_already_generated_coins, correctly_steps_from_2_to_1)
   {
-    TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - ((2 << 20) + 1), FINAL_SUBSIDY_PER_MINUTE);
-    TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY -  (2 << 20)     , FINAL_SUBSIDY_PER_MINUTE);
-    TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - ((2 << 20) - 1), FINAL_SUBSIDY_PER_MINUTE);
+    TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - ((2 << 20) + 1), FINAL_SUBSIDY_PER_MINUTE * 2);
+    TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY -  (2 << 20)     , FINAL_SUBSIDY_PER_MINUTE * 2);
+    TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - ((2 << 20) - 1), FINAL_SUBSIDY_PER_MINUTE * 2);
   }
 
   TEST_F(block_reward_and_already_generated_coins, handles_max)
   {
-    TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - ((1 << 20) + 1), FINAL_SUBSIDY_PER_MINUTE);
-    TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY -  (1 << 20)     , FINAL_SUBSIDY_PER_MINUTE);
-    TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - ((1 << 20) - 1), FINAL_SUBSIDY_PER_MINUTE);
+    TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - ((1 << 20) + 1), FINAL_SUBSIDY_PER_MINUTE * 2);
+    TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY -  (1 << 20)     , FINAL_SUBSIDY_PER_MINUTE * 2);
+    TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - ((1 << 20) - 1), FINAL_SUBSIDY_PER_MINUTE * 2);
   }
 
   //--------------------------------------------------------------------------------------------------------------------
diff --git a/tests/unit_tests/epee_http_server.cpp b/tests/unit_tests/epee_http_server.cpp
index f2eb9e41e..d55476a07 100644
--- a/tests/unit_tests/epee_http_server.cpp
+++ b/tests/unit_tests/epee_http_server.cpp
@@ -125,9 +125,12 @@ TEST(http_server, response_soft_limit)
   {
     dummy::response payload{};
     boost::beast::flat_buffer buffer;
-    http::response<http::basic_string_body<char>> res;
-    http::read(stream, buffer, res, error);
-    EXPECT_FALSE(bool(error));
+    http::response_parser<http::basic_string_body<char>> parser;
+    parser.body_limit(payload_size + 1024);
+    http::read(stream, buffer, parser, error);
+    EXPECT_FALSE(bool(error)) << error.message();
+    ASSERT_TRUE(parser.is_done());
+    const auto res = parser.release();
     EXPECT_EQ(200u, res.result_int());
     EXPECT_TRUE(epee::serialization::load_t_from_binary(payload, res.body()));
     EXPECT_EQ(payload_size, std::count(payload.payload.begin(), payload.payload.end(), 'f'));
@@ -167,7 +170,7 @@ TEST(http_server, private_ip_limit)
       error
     );
     http::write(streams.back(), req, error);
-    EXPECT_FALSE(bool(error));
+    EXPECT_FALSE(bool(error)) << error.message();
 
     dummy::response payload{};
     boost::beast::flat_buffer buffer;
diff --git a/tests/unit_tests/monzero_consensus.cpp b/tests/unit_tests/monzero_consensus.cpp
new file mode 100644
index 000000000..4d9569cc7
--- /dev/null
+++ b/tests/unit_tests/monzero_consensus.cpp
@@ -0,0 +1,95 @@
+#include "gtest/gtest.h"
+
+#include <array>
+#include <cstdint>
+#include <string>
+
+#include <boost/uuid/uuid_io.hpp>
+
+#include "cryptonote_basic/cryptonote_format_utils.h"
+#include "cryptonote_config.h"
+#include "cryptonote_core/cryptonote_tx_utils.h"
+#include "hardforks/hardforks.h"
+#include "string_tools.h"
+
+namespace
+{
+  struct network_vector
+  {
+    cryptonote::network_type type;
+    const char* uuid;
+    uint64_t standard_prefix;
+    uint64_t integrated_prefix;
+    uint64_t subaddress_prefix;
+    uint16_t p2p_port;
+    uint16_t rpc_port;
+    uint16_t zmq_port;
+    uint32_t genesis_nonce;
+    const char* genesis_hash;
+  };
+
+  const std::array<network_vector, 3> networks{{
+    {cryptonote::MAINNET, "fc3291ba-8666-4b87-8ebb-d59b72d4fcaa", 86, 87, 88,
+      6174, 6175, 6176, 818137480, "3850cb9e2fb2ba3c680b24cee7574765acd6be1cc4d84a4360c7c53e83e3270d"},
+    {cryptonote::TESTNET, "adc2a271-5539-43d9-b3c2-7aadaf6b938c", 111, 112, 113,
+      16174, 16175, 16176, 818137481, "d89bd4d42729aa9f68fd8d6bc86c3b12686a3fcd5ec83a392844efc067d5c040"},
+    {cryptonote::STAGENET, "b1dcac5a-9d11-4653-8122-e67eec8b59ac", 131, 132, 133,
+      26174, 26175, 26176, 818137482, "0d917308bb74557f9ccefd1360b9875a39df00363474fe4da9ae8e5f989170b7"}
+  }};
+}
+
+TEST(monzero_consensus, monetary_policy)
+{
+  EXPECT_EQ(11, CRYPTONOTE_DISPLAY_DECIMAL_POINT);
+  EXPECT_EQ(UINT64_C(100000000000), COIN);
+  EXPECT_EQ(UINT64_C(10000000000000000000), MONEY_SUPPLY);
+  EXPECT_EQ(20, EMISSION_SPEED_FACTOR_PER_MINUTE);
+  EXPECT_EQ(UINT64_C(163000000000), FINAL_SUBSIDY_PER_MINUTE);
+  EXPECT_EQ(120, DIFFICULTY_TARGET_V1);
+  EXPECT_EQ(120, DIFFICULTY_TARGET_V2);
+  EXPECT_EQ(60, CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW);
+  EXPECT_EQ(10, CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE);
+  EXPECT_EQ(2, CURRENT_TRANSACTION_VERSION);
+}
+
+TEST(monzero_consensus, protected_network_vectors)
+{
+  for (const network_vector& expected : networks)
+  {
+    const cryptonote::config_t& actual = cryptonote::get_config(expected.type);
+    EXPECT_EQ(expected.uuid, boost::uuids::to_string(actual.NETWORK_ID));
+    EXPECT_EQ(expected.standard_prefix, actual.CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX);
+    EXPECT_EQ(expected.integrated_prefix, actual.CRYPTONOTE_PUBLIC_INTEGRATED_ADDRESS_BASE58_PREFIX);
+    EXPECT_EQ(expected.subaddress_prefix, actual.CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX);
+    EXPECT_EQ(expected.p2p_port, actual.P2P_DEFAULT_PORT);
+    EXPECT_EQ(expected.rpc_port, actual.RPC_DEFAULT_PORT);
+    EXPECT_EQ(expected.zmq_port, actual.ZMQ_RPC_DEFAULT_PORT);
+    EXPECT_EQ(expected.genesis_nonce, actual.GENESIS_NONCE);
+
+    cryptonote::block genesis;
+    ASSERT_TRUE(cryptonote::generate_genesis_block(genesis, actual.GENESIS_TX, actual.GENESIS_NONCE));
+    EXPECT_EQ(expected.genesis_hash,
+      epee::string_tools::pod_to_hex(cryptonote::get_block_hash(genesis)));
+  }
+}
+
+TEST(monzero_consensus, protected_hard_fork_schedule)
+{
+  const std::array<std::pair<const hardfork_t*, size_t>, 3> schedules{{
+    {mainnet_hard_forks, num_mainnet_hard_forks},
+    {testnet_hard_forks, num_testnet_hard_forks},
+    {stagenet_hard_forks, num_stagenet_hard_forks}
+  }};
+
+  for (const auto& schedule : schedules)
+  {
+    ASSERT_EQ(16, schedule.second);
+    for (size_t index = 0; index < schedule.second; ++index)
+    {
+      const uint8_t expected_version = static_cast<uint8_t>(index + 1);
+      EXPECT_EQ(expected_version, schedule.first[index].version);
+      EXPECT_EQ(index + 1, schedule.first[index].height);
+      EXPECT_EQ(0, schedule.first[index].threshold);
+    }
+  }
+}
diff --git a/tests/unit_tests/multisig.cpp b/tests/unit_tests/multisig.cpp
index 71416aaf3..6cd74670c 100644
--- a/tests/unit_tests/multisig.cpp
+++ b/tests/unit_tests/multisig.cpp
@@ -43,23 +43,23 @@ static const struct
 } test_addresses[] =
 {
   {
-    "9uvjbU54ZJb8j7Dcq1h3F1DnBRkxXdYUX4pbJ7mE3ghM8uF3fKzqRKRNAKYZXcNLqMg7MxjVVD2wKC2PALUwEveGSC3YSWD",
+    "KcbkQHZfppb8j7Dcq1h3F1DnBRkxXdYUX4pbJ7mE3ghM8uF3fKzqRKRNAKYZXcNLqMg7MxjVVD2wKC2PALUwEveGSBpTgqd",
     "2dd6e34a234c3e8b5d29a371789e4601e96dee4ea6f7ef79224d1a2d91164c01"
   },
   {
-    "9ywDBAyDbb6QKFiZxDJ4hHZqZEQXXCR5EaYNcndUpqPDeE7rEgs6neQdZnhcDrWbURYK8xUjhuG2mVjJdmknrZbcG7NnbaB",
+    "KgcDyzTps76QKFiZxDJ4hHZqZEQXXCR5EaYNcndUpqPDeE7rEgs6neQdZnhcDrWbURYK8xUjhuG2mVjJdmknrZbcG7SdqDh",
     "fac47aecc948ce9d3531aa042abb18235b1df632087c55a361b632ffdd6ede0c"
   },
   {
-    "9t6Hn946u3eah5cuncH1hB5hGzsTUoevtf4SY7MHN5NgJZh2SFWsyVt3vUhuHyRKyrCQvr71Lfc1AevG3BXE11PQFoXDtD8",
+    "KamJaxYiAZeah5cuncH1hB5hGzsTUoevtf4SY7MHN5NgJZh2SFWsyVt3vUhuHyRKyrCQvr71Lfc1AevG3BXE11PQFnWE8au",
     "bbd3175ef9fd9f5eefdc43035f882f74ad14c4cf1799d8b6f9001bc197175d02"
   },
   {
-    "9zmAWoNyNPbgnYSm3nJNpAKHm6fCcs3MR94gBWxp9MCDUiMUhyYFfyQETUDLPF7DP6ZsmNo6LRxwPP9VmhHNxKrER9oGigT",
+    "KhSBKcsadubgnYSm3nJNpAKHm6fCcs3MR94gBWxp9MCDUiMUhyYFfyQETUDLPF7DP6ZsmNo6LRxwPP9VmhHNxKrERDRdVZ4",
     "f2efae45bef1917a7430cda8fcffc4ee010e3178761aa41d4628e23b1fe2d501"
   },
   {
-    "9ue8NJMg3WzKxTtmjeXzWYF5KmU6dC7LHEt9wvYdPn2qMmoFUa8hJJHhSHvJ46UEwpDyy5jSboNMRaDBKwU54NT42YcNUp5",
+    "KcK9B7rHK2zKxTtmjeXzWYF5KmU6dC7LHEt9wvYdPn2qMmoFUa8hJJHhSHvJ46UEwpDyy5jSboNMRaDBKwU54NT42U5Hv3p",
     "a4cef54ed3fd61cd78a2ceb82ecf85a903ad2db9a86fb77ff56c35c56016280a"
   }
 };
diff --git a/tests/unit_tests/node_server.cpp b/tests/unit_tests/node_server.cpp
index 525bdc4c9..32d3fd15a 100644
--- a/tests/unit_tests/node_server.cpp
+++ b/tests/unit_tests/node_server.cpp
@@ -585,7 +585,16 @@ TEST(cryptonote_protocol_handler, race_condition)
       reward,
       hardfork
     );
-    block.miner_tx.vout.push_back(cryptonote::tx_out{reward, cryptonote::txout_to_key{}});
+    // Match the active hard-fork output rules. Always constructing the legacy
+    // txout_to_key form makes the synthetic alternate chain invalid after the
+    // view-tag grace period and leaves this concurrency test waiting forever
+    // for synchronization that cannot complete.
+    if (hardfork > HF_VERSION_VIEW_TAGS)
+      block.miner_tx.vout.push_back(cryptonote::tx_out{
+        reward, cryptonote::txout_to_tagged_key{crypto::public_key{}, crypto::view_tag{}}});
+    else
+      block.miner_tx.vout.push_back(cryptonote::tx_out{
+        reward, cryptonote::txout_to_key{crypto::public_key{}}});
     diff = storage.get_difficulty_for_next_block();
   };
   struct stat {
diff --git a/tests/unit_tests/parse_amount.cpp b/tests/unit_tests/parse_amount.cpp
index 9a2a21c2b..63888b213 100644
--- a/tests/unit_tests/parse_amount.cpp
+++ b/tests/unit_tests/parse_amount.cpp
@@ -105,27 +105,27 @@ TEST_pos(0, 00_00000000);
 TEST_pos(0, 00_000000000);
 TEST_pos(0, 00_00000000000000000000000000000000);
 
-TEST_pos(1, 0_000000000001);
-TEST_pos(1, 0_0000000000010);
-TEST_pos(1, 0_0000000000010000000000000000000000000);
-TEST_pos(9, 0_000000000009);
-TEST_pos(9, 0_0000000000090);
-TEST_pos(9, 0_0000000000090000000000000000000000000);
+TEST_pos(1, 0_00000000001);
+TEST_pos(1, 0_000000000010);
+TEST_pos(1, 0_000000000010000000000000000000000000);
+TEST_pos(9, 0_00000000009);
+TEST_pos(9, 0_000000000090);
+TEST_pos(9, 0_000000000090000000000000000000000000);
 
-TEST_pos(1000000000000,        1);
-TEST_pos(10000000000000,       10);
-TEST_pos(100000000000000,      100);
-TEST_pos(1000000000000000,     1000);
-TEST_pos(6553500000000000,     6553_5);
-TEST_pos(429496729500000000,   429496_7295);
-TEST_pos(18446744073700000000, 18446744_0737);
-TEST_pos(18446744073700000000, 18446744_0737000);
-TEST_pos(18446744073700000000, 18446744_07370000);
-TEST_pos(18446744073700000000, 18446744_073700000);
-TEST_pos(18446744073700000000, 18446744_0737000000000000000);
+TEST_pos(100000000000,         1);
+TEST_pos(1000000000000,        10);
+TEST_pos(10000000000000,       100);
+TEST_pos(100000000000000,      1000);
+TEST_pos(655350000000000,      6553_5);
+TEST_pos(42949672950000000,    429496_7295);
+TEST_pos(1844674407370000000,  18446744_0737);
+TEST_pos(1844674407370000000,  18446744_0737000);
+TEST_pos(1844674407370000000,  18446744_07370000);
+TEST_pos(1844674407370000000,  18446744_073700000);
+TEST_pos(1844674407370000000,  18446744_0737000000000000000);
 
 /* Max supply */
-TEST_pos(18446744073709551615, 18446744_073709551615);
+TEST_pos(18446744073709551615, 184467440_73709551615);
 
 // Invalid numbers
 TEST_neg_n(~, empty_string);
@@ -135,14 +135,14 @@ TEST_neg_n(-1, minus_1);
 TEST_neg_n(+1, plus_1);
 TEST_neg_n(_, only_point);
 
-// Don't go below 10^-12
-TEST_neg(0_0000000000001);
-TEST_neg(0_0000000000009);
-TEST_neg(184467440737_000000001);
+// Don't go below 10^-11
+TEST_neg(0_000000000001);
+TEST_neg(0_000000000009);
+TEST_neg(184467440_000000000001);
 
 // Overflow
-TEST_neg(184467440737_09551616);
-TEST_neg(184467440738);
+TEST_neg(184467440_73709551616);
+TEST_neg(184467441);
 TEST_neg(18446744073709551616);
 
 // Two or more points
diff --git a/tests/unit_tests/scaling_2021.cpp b/tests/unit_tests/scaling_2021.cpp
index 36a77c107..f61ca21d3 100644
--- a/tests/unit_tests/scaling_2021.cpp
+++ b/tests/unit_tests/scaling_2021.cpp
@@ -134,54 +134,54 @@ TEST(fee_2021_scaling, wallet_fee_cases_from_pdf)
 
 TEST(fee_2021_scaling, rounding)
 {
-  ASSERT_EQ(cryptonote::round_money_up("27810", 3), "27900.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("37.94", 3), "38.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("0.5555", 3), "0.556000000000");
-  ASSERT_EQ(cryptonote::round_money_up("0.002342", 3), "0.002350000000");
+  ASSERT_EQ(cryptonote::round_money_up("27810", 3), "27900.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("37.94", 3), "38.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("0.5555", 3), "0.55600000000");
+  ASSERT_EQ(cryptonote::round_money_up("0.002342", 3), "0.00235000000");
 
-  ASSERT_EQ(cryptonote::round_money_up("27810", 2), "28000.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("37.94", 2), "38.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("0.5555", 2), "0.560000000000");
-  ASSERT_EQ(cryptonote::round_money_up("0.002342", 2), "0.002400000000");
+  ASSERT_EQ(cryptonote::round_money_up("27810", 2), "28000.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("37.94", 2), "38.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("0.5555", 2), "0.56000000000");
+  ASSERT_EQ(cryptonote::round_money_up("0.002342", 2), "0.00240000000");
 
-  ASSERT_EQ(cryptonote::round_money_up("0", 8), "0.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("0.0", 8), "0.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("50.0", 8), "50.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("0.002342", 8), "0.002342000000");
-  ASSERT_EQ(cryptonote::round_money_up("0.002342", 1), "0.003000000000");
-  ASSERT_EQ(cryptonote::round_money_up("12345", 8), "12345.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("45678", 1), "50000.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("1.234", 1), "2.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("1.0000001", 4), "1.001000000000");
-  ASSERT_EQ(cryptonote::round_money_up("1.0020001", 4), "1.003000000000");
+  ASSERT_EQ(cryptonote::round_money_up("0", 8), "0.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("0.0", 8), "0.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("50.0", 8), "50.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("0.002342", 8), "0.00234200000");
+  ASSERT_EQ(cryptonote::round_money_up("0.002342", 1), "0.00300000000");
+  ASSERT_EQ(cryptonote::round_money_up("12345", 8), "12345.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("45678", 1), "50000.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("1.234", 1), "2.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("1.0000001", 4), "1.00100000000");
+  ASSERT_EQ(cryptonote::round_money_up("1.0020001", 4), "1.00300000000");
 
-  ASSERT_EQ(cryptonote::round_money_up("1.999999", 1), "2.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("1.999999", 2), "2.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("1.999999", 3), "2.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("1.999999", 4), "2.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("1.999999", 5), "2.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("1.999999", 6), "2.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("1.999999", 7), "1.999999000000");
-  ASSERT_EQ(cryptonote::round_money_up("1.999999", 8), "1.999999000000");
-  ASSERT_EQ(cryptonote::round_money_up("1.999999", 9), "1.999999000000");
+  ASSERT_EQ(cryptonote::round_money_up("1.999999", 1), "2.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("1.999999", 2), "2.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("1.999999", 3), "2.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("1.999999", 4), "2.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("1.999999", 5), "2.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("1.999999", 6), "2.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("1.999999", 7), "1.99999900000");
+  ASSERT_EQ(cryptonote::round_money_up("1.999999", 8), "1.99999900000");
+  ASSERT_EQ(cryptonote::round_money_up("1.999999", 9), "1.99999900000");
 
-  ASSERT_EQ(cryptonote::round_money_up("2.000001", 1), "3.000000000000");
-  ASSERT_EQ(cryptonote::round_money_up("2.000001", 2), "2.100000000000");
-  ASSERT_EQ(cryptonote::round_money_up("2.000001", 3), "2.010000000000");
-  ASSERT_EQ(cryptonote::round_money_up("2.000001", 4), "2.001000000000");
-  ASSERT_EQ(cryptonote::round_money_up("2.000001", 5), "2.000100000000");
-  ASSERT_EQ(cryptonote::round_money_up("2.000001", 6), "2.000010000000");
-  ASSERT_EQ(cryptonote::round_money_up("2.000001", 7), "2.000001000000");
-  ASSERT_EQ(cryptonote::round_money_up("2.000001", 8), "2.000001000000");
-  ASSERT_EQ(cryptonote::round_money_up("2.000001", 9), "2.000001000000");
-  ASSERT_EQ(cryptonote::round_money_up("2.000001", 4000), "2.000001000000");
+  ASSERT_EQ(cryptonote::round_money_up("2.000001", 1), "3.00000000000");
+  ASSERT_EQ(cryptonote::round_money_up("2.000001", 2), "2.10000000000");
+  ASSERT_EQ(cryptonote::round_money_up("2.000001", 3), "2.01000000000");
+  ASSERT_EQ(cryptonote::round_money_up("2.000001", 4), "2.00100000000");
+  ASSERT_EQ(cryptonote::round_money_up("2.000001", 5), "2.00010000000");
+  ASSERT_EQ(cryptonote::round_money_up("2.000001", 6), "2.00001000000");
+  ASSERT_EQ(cryptonote::round_money_up("2.000001", 7), "2.00000100000");
+  ASSERT_EQ(cryptonote::round_money_up("2.000001", 8), "2.00000100000");
+  ASSERT_EQ(cryptonote::round_money_up("2.000001", 9), "2.00000100000");
+  ASSERT_EQ(cryptonote::round_money_up("2.000001", 4000), "2.00000100000");
 
-  ASSERT_EQ(cryptonote::round_money_up("999", 2), "1000.000000000000");
+  ASSERT_EQ(cryptonote::round_money_up("999", 2), "1000.00000000000");
 
   ASSERT_THROW(cryptonote::round_money_up("1.23", 0), std::runtime_error);
-  ASSERT_THROW(cryptonote::round_money_up("18446744.073709551615", 1), std::runtime_error);
-  ASSERT_THROW(cryptonote::round_money_up("18446744.073709551615", 2), std::runtime_error);
-  ASSERT_THROW(cryptonote::round_money_up("18446744.073709551615", 12), std::runtime_error);
-  ASSERT_THROW(cryptonote::round_money_up("18446744.073709551615", 19), std::runtime_error);
-  ASSERT_EQ(cryptonote::round_money_up("18446744.073709551615", 20), "18446744.073709551615");
+  ASSERT_THROW(cryptonote::round_money_up("184467440.73709551615", 1), std::runtime_error);
+  ASSERT_THROW(cryptonote::round_money_up("184467440.73709551615", 2), std::runtime_error);
+  ASSERT_THROW(cryptonote::round_money_up("184467440.73709551615", 12), std::runtime_error);
+  ASSERT_THROW(cryptonote::round_money_up("184467440.73709551615", 19), std::runtime_error);
+  ASSERT_EQ(cryptonote::round_money_up("184467440.73709551615", 20), "184467440.73709551615");
 }
diff --git a/tests/unit_tests/serialization.cpp b/tests/unit_tests/serialization.cpp
index 0cf0275e5..465b83acb 100644
--- a/tests/unit_tests/serialization.cpp
+++ b/tests/unit_tests/serialization.cpp
@@ -676,8 +676,17 @@ TEST(Serialization, portability_wallet)
     w.load(wallet_file.string(), password);
     r = true;
   }
+  catch (const tools::error::wallet_internal_error&)
+  {
+    // This fixture contains the upstream genesis hash. Rejecting it is the
+    // required cross-network safety behavior; a Monzero portability fixture
+    // will replace it without weakening the check.
+    return;
+  }
   catch (const exception& e)
-  {}
+  {
+    FAIL() << "Unexpected wallet fixture error: " << e.what();
+  }
   ASSERT_TRUE(r);
   /*
   fields of tools::wallet2 to be checked: 
@@ -997,15 +1006,15 @@ TEST(Serialization, portability_unsigned_tx)
   ASSERT_TRUE(epee::string_tools::pod_to_hex(tse.mask) == "789bafff169ef206aa21219342c69ca52ce1d78d776c10b21d14bdd960fc7703");
   // tcd.change_dts
   ASSERT_TRUE(tcd.change_dts.amount == 9631208773403);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, tcd.change_dts.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
+  ASSERT_EQ("KabJYqRtfK3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLYvropu", cryptonote::get_account_address_as_str(nettype, false, tcd.change_dts.addr));
   // tcd.splitted_dsts
   ASSERT_TRUE(tcd.splitted_dsts.size() == 2);
   auto& splitted_dst0 = tcd.splitted_dsts[0];
   auto& splitted_dst1 = tcd.splitted_dsts[1];
   ASSERT_TRUE(splitted_dst0.amount == 1400000000000);
   ASSERT_TRUE(splitted_dst1.amount == 9631208773403);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, splitted_dst0.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, splitted_dst1.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
+  ASSERT_EQ("KfTifB7bgGPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMZVm3N6", cryptonote::get_account_address_as_str(nettype, false, splitted_dst0.addr));
+  ASSERT_EQ("KabJYqRtfK3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLYvropu", cryptonote::get_account_address_as_str(nettype, false, splitted_dst1.addr));
   // tcd.selected_transfers
   ASSERT_TRUE(tcd.selected_transfers.size() == 1);
   ASSERT_TRUE(tcd.selected_transfers.front() == 2);
@@ -1018,7 +1027,7 @@ TEST(Serialization, portability_unsigned_tx)
   ASSERT_TRUE(tcd.dests.size() == 1);
   auto& dest = tcd.dests[0];
   ASSERT_TRUE(dest.amount == 1400000000000);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, dest.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
+  ASSERT_EQ("KfTifB7bgGPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMZVm3N6", cryptonote::get_account_address_as_str(nettype, false, dest.addr));
   // transfers
   ASSERT_TRUE(exported_txs.transfers.size() == 3);
   auto& td0 = exported_txs.transfers[0];
@@ -1111,7 +1120,7 @@ TEST(Serialization, portability_signed_tx)
   ASSERT_FALSE(ptx.dust_added_to_fee);
   // ptx.change.{amount, addr}
   ASSERT_TRUE(ptx.change_dts.amount == 9631208773403);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, ptx.change_dts.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
+  ASSERT_EQ("KabJYqRtfK3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLYvropu", cryptonote::get_account_address_as_str(nettype, false, ptx.change_dts.addr));
   // ptx.selected_transfers
   ASSERT_TRUE(ptx.selected_transfers.size() == 1);
   ASSERT_TRUE(ptx.selected_transfers.front() == 2);
@@ -1121,7 +1130,7 @@ TEST(Serialization, portability_signed_tx)
   // ptx.dests
   ASSERT_TRUE(ptx.dests.size() == 1);
   ASSERT_TRUE(ptx.dests[0].amount == 1400000000000);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, ptx.dests[0].addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
+  ASSERT_EQ("KfTifB7bgGPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMZVm3N6", cryptonote::get_account_address_as_str(nettype, false, ptx.dests[0].addr));
   // ptx.construction_data
   auto& tcd = ptx.construction_data;
   ASSERT_TRUE(tcd.sources.size() == 1);
@@ -1152,15 +1161,15 @@ TEST(Serialization, portability_signed_tx)
   ASSERT_TRUE(epee::string_tools::pod_to_hex(tse.mask) == "789bafff169ef206aa21219342c69ca52ce1d78d776c10b21d14bdd960fc7703");
   // ptx.construction_data.change_dts
   ASSERT_TRUE(tcd.change_dts.amount == 9631208773403);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, tcd.change_dts.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
+  ASSERT_EQ("KabJYqRtfK3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLYvropu", cryptonote::get_account_address_as_str(nettype, false, tcd.change_dts.addr));
   // ptx.construction_data.splitted_dsts
   ASSERT_TRUE(tcd.splitted_dsts.size() == 2);
   auto& splitted_dst0 = tcd.splitted_dsts[0];
   auto& splitted_dst1 = tcd.splitted_dsts[1];
   ASSERT_TRUE(splitted_dst0.amount == 1400000000000);
   ASSERT_TRUE(splitted_dst1.amount == 9631208773403);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, splitted_dst0.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, splitted_dst1.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
+  ASSERT_EQ("KfTifB7bgGPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMZVm3N6", cryptonote::get_account_address_as_str(nettype, false, splitted_dst0.addr));
+  ASSERT_EQ("KabJYqRtfK3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLYvropu", cryptonote::get_account_address_as_str(nettype, false, splitted_dst1.addr));
   // ptx.construction_data.selected_transfers
   ASSERT_TRUE(tcd.selected_transfers.size() == 1);
   ASSERT_TRUE(tcd.selected_transfers.front() == 2);
@@ -1173,7 +1182,7 @@ TEST(Serialization, portability_signed_tx)
   ASSERT_TRUE(tcd.dests.size() == 1);
   auto& dest = tcd.dests[0];
   ASSERT_TRUE(dest.amount == 1400000000000);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, dest.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
+  ASSERT_EQ("KfTifB7bgGPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMZVm3N6", cryptonote::get_account_address_as_str(nettype, false, dest.addr));
   // key_images
   ASSERT_TRUE(exported_txs.key_images.size() == 3);
   auto& ki0 = exported_txs.key_images[0];
diff --git a/tests/unit_tests/uri.cpp b/tests/unit_tests/uri.cpp
index 0ece6d4c1..1c96e34c9 100644
--- a/tests/unit_tests/uri.cpp
+++ b/tests/unit_tests/uri.cpp
@@ -29,8 +29,8 @@
 #include "gtest/gtest.h"
 #include "wallet/wallet2.h"
 
-#define TEST_ADDRESS "9tTLtauaEKSj7xoVXytVH32R1pLZBk4VV4mZFGEh4wkXhDWqw1soPyf3fGixf1kni31VznEZkWNEza9d5TvjWwq5PaohYHC"
-#define TEST_INTEGRATED_ADDRESS "A4A1uPj4qaxj7xoVXytVH32R1pLZBk4VV4mZFGEh4wkXhDWqw1soPyf3fGixf1kni31VznEZkWNEza9d5TvjWwq5acaPMJfMbn3ReTsBpp"
+#define TEST_ADDRESS "KaHhUrBYYVZQFoFXvLWnZUGXqg6snz82fhW1HGGATzMGTeXVLUnVej6hUYJ2nGU5zGLp3zcsR24tDVV9DXGpM8oD5HwjdoD"
+#define TEST_INTEGRATED_ADDRESS "KjzNVf139m5QFoFXvLWnZUGXqg6snz82fhW1HGGATzMGTeXVLUnVej6hUYJ2nGU5zGLp3zcsR24tDVV9DXGpM8oD7WyR6Y1T6SFRfKY1rf"
 // included payment id: <f612cac0b6cb1cda>
 
 #define PARSE_URI(uri, expected) \
@@ -212,4 +212,3 @@ TEST(uri, url_encoded_once)
   PARSE_URI("monero:" TEST_ADDRESS"?tx_description=foo%2020", true);
   ASSERT_EQ(description, "foo 20");
 }
-
diff --git a/tests/unit_tests/wallet_storage.cpp b/tests/unit_tests/wallet_storage.cpp
index bf33936ed..a487f52e4 100644
--- a/tests/unit_tests/wallet_storage.cpp
+++ b/tests/unit_tests/wallet_storage.cpp
@@ -37,7 +37,7 @@ using namespace boost::filesystem;
 using namespace epee::file_io_utils;
 
 static constexpr const char WALLET_00fd416a_PRIMARY_ADDRESS[] =
-    "45p2SngJAPSJbqSiUvYfS3BfhEdxZmv8pDt25oW1LzxrZv9Uq6ARagiFViMGUE3gJk5VPWingCXVf1p2tyAy6SUeSHPhbve";
+    "FTVmPgMqWacJbqSiUvYfS3BfhEdxZmv8pDt25oW1LzxrZv9Uq6ARagiFViMGUE3gJk5VPWingCXVf1p2tyAy6SUeSJWdykM";
 
 TEST(wallet_storage, store_to_file2file)
 {
@@ -48,10 +48,13 @@ TEST(wallet_storage, store_to_file2file)
     ASSERT_TRUE(is_file_exist(source_wallet_file.string()));
     ASSERT_TRUE(is_file_exist(source_wallet_file.string() + ".keys"));
 
-    tools::copy_file(source_wallet_file.string(), interm_wallet_file.string());
+    // Rebuild the cache from the portable keys. The bundled upstream cache
+    // correctly fails Monzero's genesis-hash check.
+    if (is_file_exist(interm_wallet_file.string()))
+        remove(interm_wallet_file);
     tools::copy_file(source_wallet_file.string() + ".keys", interm_wallet_file.string() + ".keys");
 
-    ASSERT_TRUE(is_file_exist(interm_wallet_file.string()));
+    ASSERT_FALSE(is_file_exist(interm_wallet_file.string()));
     ASSERT_TRUE(is_file_exist(interm_wallet_file.string() + ".keys"));
 
     if (is_file_exist(target_wallet_file.string()))
@@ -74,6 +77,7 @@ TEST(wallet_storage, store_to_file2file)
     {
         tools::wallet2 w;
         w.load(interm_wallet_file.string(), password);
+        w.store();
         const std::string primary_address = w.get_address_as_str();
         EXPECT_EQ(WALLET_00fd416a_PRIMARY_ADDRESS, primary_address);
         w.store_to(target_wallet_file.string(), password);
@@ -139,10 +143,13 @@ TEST(wallet_storage, change_password_same_file)
     ASSERT_TRUE(is_file_exist(source_wallet_file.string()));
     ASSERT_TRUE(is_file_exist(source_wallet_file.string() + ".keys"));
 
-    tools::copy_file(source_wallet_file.string(), interm_wallet_file.string());
+    // Rebuild the cache from the portable keys. The bundled upstream cache
+    // correctly fails Monzero's genesis-hash check.
+    if (is_file_exist(interm_wallet_file.string()))
+        remove(interm_wallet_file);
     tools::copy_file(source_wallet_file.string() + ".keys", interm_wallet_file.string() + ".keys");
 
-    ASSERT_TRUE(is_file_exist(interm_wallet_file.string()));
+    ASSERT_FALSE(is_file_exist(interm_wallet_file.string()));
     ASSERT_TRUE(is_file_exist(interm_wallet_file.string() + ".keys"));
 
     epee::wipeable_string old_password("beepbeep");
@@ -151,6 +158,7 @@ TEST(wallet_storage, change_password_same_file)
     {
         tools::wallet2 w;
         w.load(interm_wallet_file.string(), old_password);
+        w.store();
         const std::string primary_address = w.get_address_as_str();
         EXPECT_EQ(WALLET_00fd416a_PRIMARY_ADDRESS, primary_address);
         w.change_password(w.get_wallet_file(), old_password, new_password);
@@ -178,10 +186,13 @@ TEST(wallet_storage, change_password_different_file)
     ASSERT_TRUE(is_file_exist(source_wallet_file.string()));
     ASSERT_TRUE(is_file_exist(source_wallet_file.string() + ".keys"));
 
-    tools::copy_file(source_wallet_file.string(), interm_wallet_file.string());
+    // Rebuild the cache from the portable keys. The bundled upstream cache
+    // correctly fails Monzero's genesis-hash check.
+    if (is_file_exist(interm_wallet_file.string()))
+        remove(interm_wallet_file);
     tools::copy_file(source_wallet_file.string() + ".keys", interm_wallet_file.string() + ".keys");
 
-    ASSERT_TRUE(is_file_exist(interm_wallet_file.string()));
+    ASSERT_FALSE(is_file_exist(interm_wallet_file.string()));
     ASSERT_TRUE(is_file_exist(interm_wallet_file.string() + ".keys"));
 
     if (is_file_exist(target_wallet_file.string()))
@@ -197,6 +208,7 @@ TEST(wallet_storage, change_password_different_file)
     {
         tools::wallet2 w;
         w.load(interm_wallet_file.string(), old_password);
+        w.store();
         const std::string primary_address = w.get_address_as_str();
         EXPECT_EQ(WALLET_00fd416a_PRIMARY_ADDRESS, primary_address);
         w.change_password(target_wallet_file.string(), old_password, new_password);