def run_test(self):
self.log.info("test -blocknotify")
block_count = 10
blocks = self.nodes[1].generatetoaddress(
block_count, self.nodes[1].getnewaddress()
if self.is_wallet_compiled() else ADDRESS_BCRT1_UNSPENDABLE)
# wait at most 10 seconds for expected number of files before reading the content
wait_until(
lambda: len(os.listdir(self.blocknotify_dir)) == block_count,
timeout=10)
# directory content should equal the generated blocks hashes
assert_equal(sorted(blocks), sorted(os.listdir(self.blocknotify_dir)))
if self.is_wallet_compiled():
self.log.info("test -walletnotify")
# wait at most 10 seconds for expected number of files before reading the content
wait_until(
lambda: len(os.listdir(self.walletnotify_dir)) == block_count,
timeout=10)
# directory content should equal the generated transaction hashes
txids_rpc = list(
map(lambda t: notify_outputname(self.wallet, t['txid']),
self.nodes[1].listtransactions("*", block_count)))
assert_equal(sorted(txids_rpc),
sorted(os.listdir(self.walletnotify_dir)))
self.stop_node(1)
for tx_file in os.listdir(self.walletnotify_dir):
os.remove(os.path.join(self.walletnotify_dir, tx_file))
self.log.info("test -walletnotify after rescan")
# restart node to rescan to force wallet notifications
self.start_node(1)
connect_nodes(self.nodes[0], 1)
wait_until(
lambda: len(os.listdir(self.walletnotify_dir)) == block_count,
timeout=10)
# directory content should equal the generated transaction hashes
txids_rpc = list(
map(lambda t: notify_outputname(self.wallet, t['txid']),
self.nodes[1].listtransactions("*", block_count)))
assert_equal(sorted(txids_rpc),
sorted(os.listdir(self.walletnotify_dir)))
for tx_file in os.listdir(self.walletnotify_dir):
os.remove(os.path.join(self.walletnotify_dir, tx_file))
# Conflicting transactions tests. Give node 0 same wallet seed as
# node 1, generate spends from node 0, and check notifications
# triggered by node 1
self.log.info("test -walletnotify with conflicting transactions")
self.nodes[0].sethdseed(seed=self.nodes[1].dumpprivkey(
keyhash_to_p2pkh(
hex_str_to_bytes(self.nodes[1].getwalletinfo()['hdseedid'])
[::-1])))
self.nodes[0].rescanblockchain()
self.nodes[0].generatetoaddress(100, ADDRESS_BCRT1_UNSPENDABLE)
self.sync_blocks()
# Generate transaction on node 0, sync mempools, and check for
# notification on node 1.
tx1 = self.nodes[0].sendtoaddress(
address=ADDRESS_BCRT1_UNSPENDABLE, amount=1, replaceable=True)
assert_equal(tx1 in self.nodes[0].getrawmempool(), True)
self.sync_mempools()
self.expect_wallet_notify([tx1])
# Generate bump transaction, sync mempools, and check for bump1
# notification. In the future, per
# https://github.com/bitcoin/bitcoin/pull/9371, it might be better
# to have notifications for both tx1 and bump1.
bump1 = self.nodes[0].bumpfee(tx1)["txid"]
assert_equal(bump1 in self.nodes[0].getrawmempool(), True)
self.sync_mempools()
self.expect_wallet_notify([bump1])
# Add bump1 transaction to new block, checking for a notification
# and the correct number of confirmations.
self.nodes[0].generatetoaddress(1, ADDRESS_BCRT1_UNSPENDABLE)
self.sync_blocks()
self.expect_wallet_notify([bump1])
assert_equal(self.nodes[1].gettransaction(bump1)["confirmations"],
1)
# Generate a second transaction to be bumped.
tx2 = self.nodes[0].sendtoaddress(
address=ADDRESS_BCRT1_UNSPENDABLE, amount=1, replaceable=True)
assert_equal(tx2 in self.nodes[0].getrawmempool(), True)
self.sync_mempools()
self.expect_wallet_notify([tx2])
# Bump tx2 as bump2 and generate a block on node 0 while
# disconnected, then reconnect and check for notifications on node 1
# about newly confirmed bump2 and newly conflicted tx2.
disconnect_nodes(self.nodes[0], 1)
bump2 = self.nodes[0].bumpfee(tx2)["txid"]
self.nodes[0].generatetoaddress(1, ADDRESS_BCRT1_UNSPENDABLE)
assert_equal(self.nodes[0].gettransaction(bump2)["confirmations"],
1)
assert_equal(tx2 in self.nodes[1].getrawmempool(), True)
connect_nodes(self.nodes[0], 1)
self.sync_blocks()
self.expect_wallet_notify([bump2, tx2])
assert_equal(self.nodes[1].gettransaction(bump2)["confirmations"],
1)
def keyhash_to_p2pkh_part(b):
return keyhash_to_p2pkh(b, False, False)
def keyhash_to_p2pkh_mpwr(b):
return keyhash_to_p2pkh(b, False, False)
def keyhash_to_p2pkh_rhom(b):
return keyhash_to_p2pkh(b, False, False)
def run_test(self):
self.log.info("test -blocknotify")
block_count = 10
blocks = self.nodes[1].generatetoaddress(
block_count, self.nodes[1].getnewaddress()
if self.is_wallet_compiled() else ADDRESS_ECREG_UNSPENDABLE)
# wait at most 10 seconds for expected number of files before reading
# the content
self.wait_until(
lambda: len(os.listdir(self.blocknotify_dir)) == block_count,
timeout=10)
# directory content should equal the generated blocks hashes
assert_equal(sorted(blocks), sorted(os.listdir(self.blocknotify_dir)))
if self.is_wallet_compiled():
self.log.info("test -walletnotify")
# wait at most 10 seconds for expected number of files before
# reading the content
self.wait_until(
lambda: len(os.listdir(self.walletnotify_dir)) == block_count,
timeout=10)
# directory content should equal the generated transaction hashes
txids_rpc = list(
map(lambda t: notify_outputname(self.wallet, t['txid']),
self.nodes[1].listtransactions("*", block_count)))
assert_equal(sorted(txids_rpc),
sorted(os.listdir(self.walletnotify_dir)))
self.stop_node(1)
for tx_file in os.listdir(self.walletnotify_dir):
os.remove(os.path.join(self.walletnotify_dir, tx_file))
self.log.info("test -walletnotify after rescan")
# restart node to rescan to force wallet notifications
self.start_node(1)
self.connect_nodes(0, 1)
self.wait_until(
lambda: len(os.listdir(self.walletnotify_dir)) == block_count,
timeout=10)
# directory content should equal the generated transaction hashes
txids_rpc = list(
map(lambda t: notify_outputname(self.wallet, t['txid']),
self.nodes[1].listtransactions("*", block_count)))
assert_equal(sorted(txids_rpc),
sorted(os.listdir(self.walletnotify_dir)))
for tx_file in os.listdir(self.walletnotify_dir):
os.remove(os.path.join(self.walletnotify_dir, tx_file))
# Conflicting transactions tests. Give node 0 same wallet seed as
# node 1, generate spends from node 0, and check notifications
# triggered by node 1
self.log.info("test -walletnotify with conflicting transactions")
self.nodes[0].sethdseed(seed=self.nodes[1].dumpprivkey(
keyhash_to_p2pkh(
hex_str_to_bytes(self.nodes[1].getwalletinfo()['hdseedid'])
[::-1])))
self.nodes[0].rescanblockchain()
self.nodes[0].generatetoaddress(100, ADDRESS_ECREG_UNSPENDABLE)
# Generate transaction on node 0, sync mempools, and check for
# notification on node 1.
tx1 = self.nodes[0].sendtoaddress(
address=ADDRESS_ECREG_UNSPENDABLE, amount=100)
assert_equal(tx1 in self.nodes[0].getrawmempool(), True)
self.sync_mempools()
self.expect_wallet_notify([tx1])
# Add tx1 transaction to new block, checking for a notification
# and the correct number of confirmations.
self.nodes[0].generatetoaddress(1, ADDRESS_ECREG_UNSPENDABLE)
self.sync_blocks()
self.expect_wallet_notify([tx1])
assert_equal(self.nodes[1].gettransaction(tx1)["confirmations"], 1)
# Generate conflicting transactions with the nodes disconnected.
# Sending almost the entire available balance on each node, but
# with a slightly different amount, ensures that there will be
# a conflict.
balance = self.nodes[0].getbalance()
self.disconnect_nodes(0, 1)
tx2_node0 = self.nodes[0].sendtoaddress(
address=ADDRESS_ECREG_UNSPENDABLE, amount=balance - 20)
tx2_node1 = self.nodes[1].sendtoaddress(
address=ADDRESS_ECREG_UNSPENDABLE, amount=balance - 21)
assert tx2_node0 != tx2_node1
self.expect_wallet_notify([tx2_node1])
# So far tx2_node1 has no conflicting tx
assert not self.nodes[1].gettransaction(
tx2_node1)['walletconflicts']
# Mine a block on node0, reconnect the nodes, check that tx2_node1
# has a conflicting tx after syncing with node0.
self.nodes[0].generatetoaddress(1, ADDRESS_ECREG_UNSPENDABLE)
self.connect_nodes(0, 1)
self.sync_blocks()
assert tx2_node0 in self.nodes[1].gettransaction(
tx2_node1)['walletconflicts']
# node1's wallet will notify of the new confirmed transaction tx2_0
# and about the conflicted transaction tx2_1.
self.expect_wallet_notify([tx2_node0, tx2_node1])
# Create an invalid chain and ensure the node warns.
self.log.info("test -alertnotify for forked chain")
fork_block = self.nodes[0].getbestblockhash()
self.nodes[0].generatetoaddress(1, ADDRESS_ECREG_UNSPENDABLE)
invalid_block = self.nodes[0].getbestblockhash()
self.nodes[0].generatetoaddress(7, ADDRESS_ECREG_UNSPENDABLE)
# Invalidate a large branch, which should trigger an alert.
self.nodes[0].invalidateblock(invalid_block)
# Give bitcoind 10 seconds to write the alert notification
self.wait_until(lambda: len(os.listdir(self.alertnotify_dir)),
timeout=10)
# The notification command is unable to properly handle the spaces on
# windows. Skip the content check in this case.
if os.name != 'nt':
assert FORK_WARNING_MESSAGE.format(fork_block) in os.listdir(
self.alertnotify_dir)
for notify_file in os.listdir(self.alertnotify_dir):
os.remove(os.path.join(self.alertnotify_dir, notify_file))
def keyhash_to_p2pkh_RBX(b):
return keyhash_to_p2pkh(b, False, False)
