DanS
c5fde12485
Ports qa/rpc-tests from 6 python3 files to 18. Ran every ported test against
the freshly built v1.3.0 dragonxd. Results, honestly:
PASS (1) getblocktemplate_proposals.py
NOT APPLICABLE (7) wallet.py, walletbackup.py, wallet_protectcoinbase.py,
wallet_listnotes.py, wallet_mergetoaddress.py,
getblocktemplate.py, wallet_shieldcoinbase.py
BLOCKED (4) wallet_sapling, wallet_nullifiers, wallet_persistence,
wallet_treestate
The "not applicable" seven are inherited Zcash/Hush-era tests that exercise
features DragonX deliberately removed. They assume transparent t->t value
transfer, but ASSETCHAINS_PRIVATE=1 (hush_utils.h:1826) makes sendtoaddress
and sendmany consensus-refuse; they assume Sprout joinsplits, which are gone
from the RPC layer entirely; and they hardcode Bitcoin economics (10 coin/block,
100-block maturity) against DragonX's 3 DRGX and COINBASE_MATURITY=1. They are
ported and left in place rather than deleted, but they cannot pass on this chain
without being rewritten around z_shieldcoinbase/autoshield.
Three framework fixes in test_framework/util.py, each of which broke every
multi-node test:
- initialize_chain() passed -connect=0, and init.cpp soft-sets -listen=0 when
-connect is present, so cache node0 never opened its p2p port and nodes 1-3
could never sync to it -- initialize_chain() hung forever in sync_blocks().
Now passes -listen=1 -bind=127.0.0.1 -dnsseed=0 explicitly (an explicit arg
beats SoftSetBoolArg) while keeping the cache nodes off the public network.
- cache cleanup removed files from <datadir> when dragonxd writes them one
level deeper into the net-specific <datadir>/regtest.
- set_node_times() did print("..." + t) with t an int -> TypeError.
- default binary paths corrected to src/dragonxd and src/dragonx-cli.
The four BLOCKED tests are blocked by a daemon assert, not by the port; see the
follow-up commit/report on BLOCK_VALID_CONTEXT.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FU87LdsJZiZkfq1eXubpeo
266 lines
11 KiB
Python
Executable File
266 lines
11 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# Copyright (c) 2016-2024 The Hush developers
|
|
# Copyright (c) 2014 The Bitcoin Core developers
|
|
# Distributed under the GPLv3 software license, see the accompanying
|
|
# file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
|
|
|
|
"""
|
|
Exercise the wallet backup code. Ported from walletbackup.sh.
|
|
|
|
Test case is:
|
|
4 nodes. 1 2 and 3 send transactions between each other,
|
|
fourth node is a miner.
|
|
1 2 3 each mine a block to start, then
|
|
Miner creates 100 blocks so 1 2 3 each have 40 mature
|
|
coins to spend.
|
|
Then 5 iterations of 1/2/3 sending coins amongst
|
|
themselves to get transactions in the wallets,
|
|
and the miner mining one block.
|
|
|
|
Wallets are backed up using dumpwallet/backupwallet.
|
|
Then 5 more iterations of transactions and mining a block.
|
|
|
|
Miner then generates 101 more blocks, so any
|
|
transaction fees paid mature.
|
|
|
|
Sanity check:
|
|
Sum(1,2,3,4 balances) == 114*40
|
|
|
|
1/2/3 are shutdown, and their wallets erased.
|
|
Then restore using wallet.dat backup. And
|
|
confirm 1/2/3/4 balances are same as before.
|
|
|
|
Shutdown again, restore using importwallet,
|
|
and confirm again balances are correct.
|
|
"""
|
|
|
|
from test_framework.test_framework import BitcoinTestFramework
|
|
from test_framework.authproxy import JSONRPCException
|
|
from test_framework.util import assert_equal, initialize_chain_clean, \
|
|
start_nodes, start_node, connect_nodes, \
|
|
sync_blocks, sync_mempools, bitcoind_processes
|
|
|
|
import os
|
|
import shutil
|
|
from random import randint
|
|
from decimal import Decimal
|
|
import logging
|
|
|
|
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.INFO)
|
|
|
|
# Three node flags this test has to supply for itself, because test_framework.util.start_node()
|
|
# cannot give it a usable isolated regtest network on DragonX:
|
|
#
|
|
# -listen=1: start_node() passes "-connect=0" to every node. In DragonX (as in Bitcoin) the
|
|
# presence of a -connect argument SoftSetBoolArg()s -listen to false, so no test node ever
|
|
# binds its p2p port and connect_nodes() cannot build the loopback topology this test needs.
|
|
# Verified on a live run: only the RPC ports were listening and getpeerinfo showed zero
|
|
# 127.0.0.1 peers on all four nodes. SoftSetBoolArg does not override an explicit value.
|
|
#
|
|
# -dns=0: hush_args() unconditionally appends node1..node10.dragonx.is to -addnode whenever the
|
|
# chain name is DRAGONX, regardless of network, and -connect=0 does not suppress it. On a live
|
|
# run every "regtest" node ended up with 7-8 established connections to production mainnet
|
|
# nodes on port 21768, was flooded with mainnet headers ("AcceptBlockHeader: hashPrevBlock ...
|
|
# not found"), and one of them aborted on CheckBlockIndex(). -dns=0 stops the hostnames from
|
|
# resolving while leaving the literal 127.0.0.1:PORT addnodes connect_nodes() uses intact.
|
|
#
|
|
# -allowlist=127.0.0.1: "-connect=0" does not mean "no connections". The daemon resolves the
|
|
# literal "0" to 0.0.0.0 and dials it on the chain's default p2p port, i.e. 127.0.0.1:21768 --
|
|
# which on a machine that also runs a real node is the PRODUCTION daemon (observed:
|
|
# ESTAB 127.0.0.1:41282 -> 127.0.0.1:21768 from every test node, peer subver /DragonX:1.0.3/,
|
|
# startingheight 3254254). That peer is outbound, so it is the node's only preferred-download
|
|
# peer; main.cpp:8398 then computes fFetch=false for every inbound peer, and node3 -- which in
|
|
# this test's topology is dialed by everyone and dials no one -- never downloads an announced
|
|
# block, so sync_blocks() hangs forever. Allowlisting loopback makes inbound test peers
|
|
# preferred-download too (main.cpp:381), which restores block propagation.
|
|
LISTEN = "-listen=1"
|
|
NODNS = "-dns=0"
|
|
ALLOWLIST = "-allowlist=127.0.0.1"
|
|
|
|
|
|
def stop_node_and_reap(node, i):
|
|
# Equivalent to test_framework.util.stop_node(), which cannot be called: it does
|
|
# print("Stopping node " + i) with the int index that every caller passes, which raises
|
|
# TypeError. Reimplemented here rather than editing shared framework code other tests use.
|
|
print("Stopping node %d" % i)
|
|
node.stop()
|
|
bitcoind_processes[i].wait()
|
|
del bitcoind_processes[i]
|
|
|
|
|
|
class WalletBackupTest(BitcoinTestFramework):
|
|
|
|
def setup_chain(self):
|
|
logging.info("Initializing test directory "+self.options.tmpdir)
|
|
initialize_chain_clean(self.options.tmpdir, 4)
|
|
|
|
# This mirrors how the network was setup in the bash test
|
|
def setup_network(self, split=False):
|
|
# -exportdir option means we must provide a valid path to the destination folder for wallet backups
|
|
ed0 = "-exportdir=" + self.options.tmpdir + "/node0"
|
|
ed1 = "-exportdir=" + self.options.tmpdir + "/node1"
|
|
ed2 = "-exportdir=" + self.options.tmpdir + "/node2"
|
|
|
|
# nodes 1, 2,3 are spenders, let's give them a keypool=100
|
|
extra_args = [["-keypool=100", ed0, LISTEN, NODNS, ALLOWLIST],
|
|
["-keypool=100", ed1, LISTEN, NODNS, ALLOWLIST],
|
|
["-keypool=100", ed2, LISTEN, NODNS, ALLOWLIST],
|
|
[LISTEN, NODNS, ALLOWLIST]]
|
|
self.nodes = start_nodes(4, self.options.tmpdir, extra_args)
|
|
connect_nodes(self.nodes[0], 3)
|
|
connect_nodes(self.nodes[1], 3)
|
|
connect_nodes(self.nodes[2], 3)
|
|
connect_nodes(self.nodes[2], 0)
|
|
self.is_network_split=False
|
|
self.sync_all()
|
|
|
|
def one_send(self, from_node, to_address):
|
|
if (randint(1,2) == 1):
|
|
amount = Decimal(randint(1,10)) / Decimal(10)
|
|
self.nodes[from_node].sendtoaddress(to_address, amount)
|
|
|
|
def do_one_round(self):
|
|
a0 = self.nodes[0].getnewaddress()
|
|
a1 = self.nodes[1].getnewaddress()
|
|
a2 = self.nodes[2].getnewaddress()
|
|
|
|
self.one_send(0, a1)
|
|
self.one_send(0, a2)
|
|
self.one_send(1, a0)
|
|
self.one_send(1, a2)
|
|
self.one_send(2, a0)
|
|
self.one_send(2, a1)
|
|
|
|
# Have the miner (node3) mine a block.
|
|
# Must sync mempools before mining.
|
|
sync_mempools(self.nodes)
|
|
self.nodes[3].generate(1)
|
|
|
|
# As above, this mirrors the original bash test.
|
|
def start_three(self):
|
|
self.nodes[0] = start_node(0, self.options.tmpdir, [LISTEN, NODNS, ALLOWLIST])
|
|
self.nodes[1] = start_node(1, self.options.tmpdir, [LISTEN, NODNS, ALLOWLIST])
|
|
self.nodes[2] = start_node(2, self.options.tmpdir, [LISTEN, NODNS, ALLOWLIST])
|
|
connect_nodes(self.nodes[0], 3)
|
|
connect_nodes(self.nodes[1], 3)
|
|
connect_nodes(self.nodes[2], 3)
|
|
connect_nodes(self.nodes[2], 0)
|
|
|
|
def stop_three(self):
|
|
stop_node_and_reap(self.nodes[0], 0)
|
|
stop_node_and_reap(self.nodes[1], 1)
|
|
stop_node_and_reap(self.nodes[2], 2)
|
|
|
|
def erase_three(self):
|
|
os.remove(self.options.tmpdir + "/node0/regtest/wallet.dat")
|
|
os.remove(self.options.tmpdir + "/node1/regtest/wallet.dat")
|
|
os.remove(self.options.tmpdir + "/node2/regtest/wallet.dat")
|
|
|
|
def run_test(self):
|
|
logging.info("Generating initial blockchain")
|
|
self.nodes[0].generate(1)
|
|
sync_blocks(self.nodes)
|
|
self.nodes[1].generate(1)
|
|
sync_blocks(self.nodes)
|
|
self.nodes[2].generate(1)
|
|
sync_blocks(self.nodes)
|
|
self.nodes[3].generate(100)
|
|
sync_blocks(self.nodes)
|
|
|
|
assert_equal(self.nodes[0].getbalance(), 10)
|
|
assert_equal(self.nodes[1].getbalance(), 10)
|
|
assert_equal(self.nodes[2].getbalance(), 10)
|
|
assert_equal(self.nodes[3].getbalance(), 0)
|
|
|
|
logging.info("Creating transactions")
|
|
# Five rounds of sending each other transactions.
|
|
for i in range(5):
|
|
self.do_one_round()
|
|
|
|
logging.info("Backing up")
|
|
tmpdir = self.options.tmpdir
|
|
self.nodes[0].backupwallet("walletbak")
|
|
self.nodes[0].dumpwallet("walletdump")
|
|
self.nodes[1].backupwallet("walletbak")
|
|
self.nodes[1].dumpwallet("walletdump")
|
|
self.nodes[2].backupwallet("walletbak")
|
|
self.nodes[2].dumpwallet("walletdump")
|
|
|
|
# Verify dumpwallet cannot overwrite an existing file
|
|
try:
|
|
self.nodes[2].dumpwallet("walletdump")
|
|
assert(False)
|
|
except JSONRPCException as e:
|
|
errorString = e.error['message']
|
|
assert("Cannot overwrite existing file" in errorString)
|
|
|
|
logging.info("More transactions")
|
|
for i in range(5):
|
|
self.do_one_round()
|
|
|
|
# Generate 101 more blocks, so any fees paid mature
|
|
self.nodes[3].generate(101)
|
|
self.sync_all()
|
|
|
|
balance0 = self.nodes[0].getbalance()
|
|
balance1 = self.nodes[1].getbalance()
|
|
balance2 = self.nodes[2].getbalance()
|
|
balance3 = self.nodes[3].getbalance()
|
|
total = balance0 + balance1 + balance2 + balance3
|
|
|
|
# At this point, there are 214 blocks (103 for setup, then 10 rounds, then 101.)
|
|
# 114 are mature, so the sum of all wallets should be 114 * 10 = 1140.
|
|
assert_equal(total, 1140)
|
|
|
|
##
|
|
# Test restoring spender wallets from backups
|
|
##
|
|
logging.info("Restoring using wallet.dat")
|
|
self.stop_three()
|
|
self.erase_three()
|
|
|
|
# Start node2 with no chain
|
|
shutil.rmtree(self.options.tmpdir + "/node2/regtest/blocks")
|
|
shutil.rmtree(self.options.tmpdir + "/node2/regtest/chainstate")
|
|
|
|
# Restore wallets from backup
|
|
shutil.copyfile(tmpdir + "/node0/walletbak", tmpdir + "/node0/regtest/wallet.dat")
|
|
shutil.copyfile(tmpdir + "/node1/walletbak", tmpdir + "/node1/regtest/wallet.dat")
|
|
shutil.copyfile(tmpdir + "/node2/walletbak", tmpdir + "/node2/regtest/wallet.dat")
|
|
|
|
logging.info("Re-starting nodes")
|
|
self.start_three()
|
|
sync_blocks(self.nodes)
|
|
|
|
assert_equal(self.nodes[0].getbalance(), balance0)
|
|
assert_equal(self.nodes[1].getbalance(), balance1)
|
|
assert_equal(self.nodes[2].getbalance(), balance2)
|
|
|
|
logging.info("Restoring using dumped wallet")
|
|
self.stop_three()
|
|
self.erase_three()
|
|
|
|
#start node2 with no chain
|
|
shutil.rmtree(self.options.tmpdir + "/node2/regtest/blocks")
|
|
shutil.rmtree(self.options.tmpdir + "/node2/regtest/chainstate")
|
|
|
|
self.start_three()
|
|
|
|
assert_equal(self.nodes[0].getbalance(), 0)
|
|
assert_equal(self.nodes[1].getbalance(), 0)
|
|
assert_equal(self.nodes[2].getbalance(), 0)
|
|
|
|
self.nodes[0].importwallet(tmpdir + "/node0/walletdump")
|
|
self.nodes[1].importwallet(tmpdir + "/node1/walletdump")
|
|
self.nodes[2].importwallet(tmpdir + "/node2/walletdump")
|
|
|
|
sync_blocks(self.nodes)
|
|
|
|
assert_equal(self.nodes[0].getbalance(), balance0)
|
|
assert_equal(self.nodes[1].getbalance(), balance1)
|
|
assert_equal(self.nodes[2].getbalance(), balance2)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
WalletBackupTest().main()
|