def create_and_send_transactions(self, conn, spendtx, num_of_transactions, money_to_spend=5000000000):
for i in range(0, num_of_transactions):
money_to_spend = money_to_spend - 500000000 # Large fee required for big txns
tx = create_tx(spendtx, 0, money_to_spend, script=CScript([OP_DROP, OP_TRUE]))
tx.vout.append(CTxOut(0, CScript([OP_FALSE, OP_RETURN, bytearray([0x00] * (ONE_MEGABYTE * 880))])))
self.sign_tx(tx, spendtx, 0)
tx.rehash()
conn.send_message(msg_tx(tx))
wait_until(lambda: tx.hash in conn.rpc.getrawmempool(), timeout=int(360 * self.options.timeoutfactor))
logger.info("Submitted txn {} of {}".format(i+1, num_of_transactions))
assert conn.rpc.getmempoolinfo()['size'] == i+1
spendtx = tx
def run_test(self):
# Get out of IBD
self.nodes[0].generate(1)
self.sync_all()
# Stop node so we can restart it with our connections
self.stop_node(0)
# Disconnect node1 and node2 for now
disconnect_nodes_bi(self.nodes, 1, 2)
connArgs = [ { "versionNum":MY_VERSION }, { "versionNum":70015 } ]
with self.run_node_with_connections("Test old and new protocol versions", 0, self.nodeArgs, number_of_connections=2,
connArgs=connArgs, cb_class=MyConnCB) as (newVerConn,oldVerConn):
assert newVerConn.connected
assert oldVerConn.connected
# Generate small block, verify we get it over both connections
self.nodes[0].generate(1)
wait_until(lambda: newVerConn.cb.block_count == 1, timeout=int(30 * self.options.timeoutfactor))
wait_until(lambda: oldVerConn.cb.block_count == 1, timeout=int(30 * self.options.timeoutfactor))
# Get us a spendable output
coinbase_tx = self.make_coinbase(newVerConn)
self.nodes[0].generate(100)
# Put some large txns into the nodes mempool until it exceeds 4GB in size
self.create_and_send_transactions(newVerConn, coinbase_tx, 5)
# Reconnect node0 and node2 and sync their blocks. Node2 will end up receiving the
# large block via compact blocks
connect_nodes(self.nodes, 0, 2)
sync_blocks(itemgetter(0,2)(self.nodes))
# Mine a >4GB block, verify we only get it over the new connection
old_block_count = newVerConn.cb.block_count
logger.info("Mining a big block")
self.nodes[0].generate(1)
assert(self.nodes[0].getmempoolinfo()['size'] == 0)
logger.info("Waiting for block to arrive at test")
wait_until(lambda: newVerConn.cb.block_count == old_block_count+1, timeout=int(1200 * self.options.timeoutfactor))
# Look for log message saying we won't send to old peer
wait_until(lambda: check_for_log_msg(self, "cannot be sent because it exceeds max P2P message limit", "/node0"))
# Verify node2 gets the big block via a (not very) compact block
wait_until(lambda: self.nodes[0].getbestblockhash() == self.nodes[2].getbestblockhash())
peerinfo = self.nodes[2].getpeerinfo()
assert(peerinfo[0]['bytesrecv_per_msg']['cmpctblock'] > 0)
assert(peerinfo[0]['bytesrecv_per_msg']['blocktxn'] > 0)
# Reconnect node0 to node1
logger.info("Syncing bitcoind nodes to big block")
connect_nodes(self.nodes, 0, 1)
self.sync_all(timeout=int(1200 * self.options.timeoutfactor))
# Verify node1 also got the big block
assert(self.nodes[0].getbestblockhash() == self.nodes[1].getbestblockhash())
def bad_message(self, message):
self.unexpected_msg = True
logger.info("should not have received message: %s" % message.command)