def test_basic(self):
import zmq
# Invalid zmq arguments don't take down the node, see #17185.
self.restart_node(0, ["-zmqpubrawtx=foo", "-zmqpubhashtx=bar"])
address = 'tcp://127.0.0.1:13604'
sockets = []
subs = []
services = [b"hashblock", b"hashtx", b"rawblock", b"rawtx"]
for service in services:
sockets.append(self.ctx.socket(zmq.SUB))
sockets[-1].set(zmq.RCVTIMEO, 60000)
subs.append(ZMQSubscriber(sockets[-1], service))
# Subscribe to all available topics.
hashblock = subs[0]
hashtx = subs[1]
rawblock = subs[2]
rawtx = subs[3]
self.restart_node(0, [
"-zmqpub{}={}".format(sub.topic.decode(), address)
for sub in [hashblock, hashtx, rawblock, rawtx]
])
connect_nodes(self.nodes[0], self.nodes[1])
for socket in sockets:
socket.connect(address)
# Relax so that the subscriber is ready before publishing zmq messages
sleep(0.2)
num_blocks = 5
self.log.info(
"Generate {0} blocks (and {0} coinbase txes)".format(num_blocks))
genhashes = self.nodes[0].generatetoaddress(
num_blocks, ADDRESS_BCHREG_UNSPENDABLE)
self.sync_all()
for x in range(num_blocks):
# Should receive the coinbase txid.
txid = hashtx.receive()
# Should receive the coinbase raw transaction.
rawtx_bytes = rawtx.receive()
tx = CTransaction()
tx.deserialize(BytesIO(rawtx_bytes))
tx.rehash()
assert_equal(tx.txid_hex, txid.hex())
# Should receive the generated raw block.
block = rawblock.receive()
assert_equal(genhashes[x], block_hash_reversed(block[:160]).hex())
# Should receive the generated block hash.
hash = hashblock.receive().hex()
assert_equal(genhashes[x], hash)
# The block should only have the coinbase txid.
assert_equal([txid.hex()], self.nodes[1].getblock(hash)["tx"])
if self.is_wallet_compiled():
self.log.info("Wait for tx from second node")
payment_txid = self.nodes[1].sendtoaddress(
self.nodes[0].getnewaddress(), 1.0)
self.sync_all()
# Should receive the broadcasted txid.
txid = hashtx.receive()
assert_equal(payment_txid, txid.hex())
# Should receive the broadcasted raw transaction.
rawtx_bytes = rawtx.receive()
tx = CTransaction()
tx.deserialize(BytesIO(rawtx_bytes))
tx.calc_txid()
assert_equal(payment_txid, tx.txid_hex)
# Mining the block with this tx should result in second notification
# after coinbase tx notification
self.nodes[0].generatetoaddress(1, ADDRESS_BCHREG_UNSPENDABLE)
hashtx.receive()
txid = hashtx.receive()
assert_equal(payment_txid, txid.hex())
self.log.info("Test the getzmqnotifications RPC")
assert_equal(self.nodes[0].getzmqnotifications(), [
{
"type": "pubhashblock",
"address": address,
"hwm": 1000
},
{
"type": "pubhashtx",
"address": address,
"hwm": 1000
},
{
"type": "pubrawblock",
"address": address,
"hwm": 1000
},
{
"type": "pubrawtx",
"address": address,
"hwm": 1000
},
])
assert_equal(self.nodes[1].getzmqnotifications(), [])
def run_test(self):
node = self.nodes[0] # convenience reference to the node
self.bootstrap_p2p() # Add one p2p connection to the node
best_block = self.nodes[0].getbestblockhash()
tip = int(best_block, 16)
best_block_time = self.nodes[0].getblock(best_block)['time']
block_time = best_block_time + 1
self.log.info("Create a new block with an anyone-can-spend coinbase.")
height = 1
blocks = []
for _ in invalid_txs.iter_all_templates():
block = create_block(tip, create_coinbase(height), block_time)
block.nHeight = height
prepare_block(block)
block_time = block.nTime + 1
height += 1
# Save the coinbase for later
blocks.append(block)
tip = block.sha256
node.p2p.send_blocks_and_test([block], node, success=True)
self.log.info("Mature the blocks.")
self.nodes[0].generatetoaddress(
100, self.nodes[0].get_deterministic_priv_key().address)
# Iterate through a list of known invalid transaction types, ensuring each is
# rejected. Some are consensus invalid and some just violate policy.
setup_txs = []
for block, BadTxTemplate in zip(blocks,
invalid_txs.iter_all_templates()):
self.log.info("Testing invalid transaction: %s",
BadTxTemplate.__name__)
template = BadTxTemplate(spend_block=block)
setup_tx = template.get_setup_tx()
if setup_tx is not None:
node.p2p.send_txs_and_test([setup_tx], node)
setup_txs.append(setup_tx)
tx = template.get_tx(setup_tx)
else:
tx = template.get_tx()
node.p2p.send_txs_and_test(
[tx],
node,
success=False,
expect_disconnect=template.expect_disconnect,
reject_reason=template.reject_reason,
)
if template.expect_disconnect:
self.log.info("Reconnecting to peer")
self.reconnect_p2p()
# Make two p2p connections to provide the node with orphans
# * p2ps[0] will send valid orphan txs (one with low fee)
# * p2ps[1] will send an invalid orphan tx (and is later disconnected for that)
self.reconnect_p2p(num_connections=2)
self.log.info('Test orphan transaction handling ... ')
# Create a root transaction that we withold until all dependend transactions
# are sent out and in the orphan cache
SCRIPT_PUB_KEY_OP_TRUE = CScript([OP_TRUE])
tx_withhold = CTransaction()
tx_withhold.vin.append(
CTxIn(outpoint=COutPoint(blocks[0].vtx[0].txid, 1)))
tx_withhold.vout.append(
CTxOut(nValue=int(SUBSIDY * COIN) - 12000,
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
pad_tx(tx_withhold)
tx_withhold.calc_txid()
# Our first orphan tx with some outputs to create further orphan txs
tx_orphan_1 = CTransaction()
tx_orphan_1.vin.append(CTxIn(outpoint=COutPoint(tx_withhold.txid, 0)))
tx_orphan_1.vout = [
CTxOut(nValue=int(0.1 * COIN), scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE)
] * 3
pad_tx(tx_orphan_1)
tx_orphan_1.calc_txid()
# A valid transaction with low fee
tx_orphan_2_no_fee = CTransaction()
tx_orphan_2_no_fee.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.txid, 0)))
tx_orphan_2_no_fee.vout.append(
CTxOut(nValue=int(0.1 * COIN),
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
pad_tx(tx_orphan_2_no_fee)
# A valid transaction with sufficient fee
tx_orphan_2_valid = CTransaction()
tx_orphan_2_valid.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.txid, 1)))
tx_orphan_2_valid.vout.append(
CTxOut(nValue=int(0.1 * COIN) - 12000,
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
tx_orphan_2_valid.calc_txid()
pad_tx(tx_orphan_2_valid)
# An invalid transaction with negative fee
tx_orphan_2_invalid = CTransaction()
tx_orphan_2_invalid.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.txid, 2)))
tx_orphan_2_invalid.vout.append(
CTxOut(nValue=int(1.1 * COIN),
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
pad_tx(tx_orphan_2_invalid)
tx_orphan_2_invalid.calc_txid()
self.log.info('Send the orphans ... ')
# Send valid orphan txs from p2ps[0]
node.p2p.send_txs_and_test(
[tx_orphan_1, tx_orphan_2_no_fee, tx_orphan_2_valid],
node,
success=False)
# Send invalid tx from p2ps[1]
node.p2ps[1].send_txs_and_test([tx_orphan_2_invalid],
node,
success=False)
# Mempool should only have setup txs
assert_equal(len(setup_txs), node.getmempoolinfo()['size'])
# p2ps[1] is still connected
assert_equal(2, len(node.getpeerinfo()))
self.log.info('Send the withhold tx ... ')
with node.assert_debug_log(expected_msgs=["bad-txns-in-belowout"]):
node.p2p.send_txs_and_test([tx_withhold], node, success=True)
# Transactions that should end up in the mempool
expected_mempool = {
t.txid_hex
for t in [
tx_withhold, # The transaction that is the root for all orphans
tx_orphan_1, # The orphan transaction that splits the coins
# The valid transaction (with sufficient fee)
tx_orphan_2_valid,
] + setup_txs # The setup transactions we added in the beginning
}
# Transactions that do not end up in the mempool
# tx_orphan_no_fee, because it has too low fee (p2ps[0] is not disconnected for relaying that tx)
# tx_orphan_invaid, because it has negative fee (p2ps[1] is
# disconnected for relaying that tx)
# p2ps[1] is no longer connected
wait_until(lambda: 1 == len(node.getpeerinfo()), timeout=12)
assert_equal(expected_mempool, set(node.getrawmempool()))
self.log.info('Test orphan pool overflow')
orphan_tx_pool = [CTransaction() for _ in range(101)]
for i in range(len(orphan_tx_pool)):
orphan_tx_pool[i].vin.append(CTxIn(outpoint=COutPoint(i, 333)))
orphan_tx_pool[i].vout.append(
CTxOut(nValue=int(1.1 * COIN),
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
pad_tx(orphan_tx_pool[i])
with node.assert_debug_log(['mapOrphan overflow, removed 1 tx']):
node.p2p.send_txs_and_test(orphan_tx_pool, node, success=False)
rejected_parent = CTransaction()
rejected_parent.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_2_invalid.txid, 0)))
rejected_parent.vout.append(
CTxOut(nValue=int(1.1 * COIN),
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
pad_tx(rejected_parent)
rejected_parent.rehash()
with node.assert_debug_log([
'not keeping orphan with rejected parents {}'.format(
rejected_parent.txid_hex)
]):
node.p2p.send_txs_and_test([rejected_parent], node, success=False)