def run_test(self):
relayfee = self.nodes[0].getnetworkinfo()['relayfee']
txids = []
utxo_groups = 4
utxos = create_confirmed_utxos(self.nodes[0], 1 + 30 * utxo_groups)
# create a mempool tx that will be evicted
us0 = utxos.pop()
inputs = [{"txid": us0["txid"], "vout": us0["vout"]}]
outputs = {self.nodes[0].getnewaddress(): 0.0001}
tx = self.nodes[0].createrawtransaction(inputs, outputs)
# specifically fund this tx with low fee
self.nodes[0].settxfee(relayfee)
txF = self.nodes[0].fundrawtransaction(tx)
# return to automatic fee selection
self.nodes[0].settxfee(0)
txFS = self.nodes[0].signrawtransaction(txF['hex'])
txid = self.nodes[0].sendrawtransaction(txFS['hex'])
for i in range(utxo_groups):
txids.append([])
txids[i] = send_big_transactions(self.nodes[0],
utxos[30 * i:30 * i + 30], 30,
10 * (i + 1))
# by now, the tx should be evicted, check confirmation state
assert (txid not in self.nodes[0].getrawmempool())
txdata = self.nodes[0].gettransaction(txid)
assert (txdata['confirmations'] == 0) # confirmation should still be 0
def run_test(self):
relayfee = self.nodes[0].getnetworkinfo()['relayfee']
self.log.info('Check that mempoolminfee is minrelytxfee')
assert_equal(self.nodes[0].getmempoolinfo()['minrelaytxfee'],
Decimal('0.00001000'))
assert_equal(self.nodes[0].getmempoolinfo()['mempoolminfee'],
Decimal('0.00001000'))
txids = []
utxo_groups = 4
utxos = create_confirmed_utxos(self.nodes[0], 1 + 30 * utxo_groups)
self.log.info('Create a mempool tx that will be evicted')
us0 = utxos.pop()
inputs = [{"txid": us0["txid"], "vout": us0["vout"]}]
outputs = {self.nodes[0].getnewaddress(): 0.0001}
tx = self.nodes[0].createrawtransaction(inputs, outputs)
# specifically fund this tx with low fee
self.nodes[0].settxfee(relayfee)
txF = self.nodes[0].fundrawtransaction(tx)
# return to automatic fee selection
self.nodes[0].settxfee(0)
txFS = self.nodes[0].signrawtransactionwithwallet(txF['hex'])
txid = self.nodes[0].sendrawtransaction(txFS['hex'])
for i in range(utxo_groups):
txids.append([])
txids[i] = send_big_transactions(self.nodes[0],
utxos[30 * i:30 * i + 30], 30,
10 * (i + 1))
self.log.info('The tx should be evicted by now')
assert txid not in self.nodes[0].getrawmempool()
txdata = self.nodes[0].gettransaction(txid)
# confirmation should still be 0
assert txdata['confirmations'] == 0
self.log.info('Check that mempoolminfee is larger than minrelytxfee')
assert_equal(self.nodes[0].getmempoolinfo()['minrelaytxfee'],
Decimal('0.00001000'))
assert_greater_than(self.nodes[0].getmempoolinfo()['mempoolminfee'],
Decimal('0.00001000'))
self.log.info('Create a mempool tx that will not pass mempoolminfee')
us0 = utxos.pop()
inputs = [{"txid": us0["txid"], "vout": us0["vout"]}]
outputs = {self.nodes[0].getnewaddress(): 0.0001}
tx = self.nodes[0].createrawtransaction(inputs, outputs)
# specifically fund this tx with a fee < mempoolminfee, >= than
# minrelaytxfee
txF = self.nodes[0].fundrawtransaction(tx, {'feeRate': relayfee})
txFS = self.nodes[0].signrawtransactionwithwallet(txF['hex'])
assert_raises_rpc_error(-26, "mempool min fee not met",
self.nodes[0].sendrawtransaction, txFS['hex'])
def generate_high_priotransactions(self, node, count):
# create 150 simple one input one output hi prio txns
hiprio_utxo_count = 150
age = 250
# be sure to make this utxo aged enough
hiprio_utxos = create_confirmed_utxos(node, hiprio_utxo_count, age)
# Create hiprio_utxo_count number of txns with 0 fee
txids = self.create_small_transactions(node, hiprio_utxos,
hiprio_utxo_count, 0)
return txids
def generate_high_priotransactions(self, node, count):
# generate a bunch of spendable utxos
self.txouts = gen_return_txouts()
# create 150 simple one input one output hi prio txns
hiprio_utxo_count = 150
age = 250
# be sure to make this utxo aged enough
hiprio_utxos = create_confirmed_utxos(node, hiprio_utxo_count, age)
txids = []
# Create hiprio_utxo_count number of txns with 0 fee
range_size = [0, hiprio_utxo_count]
start_range = range_size[0]
end_range = range_size[1]
txids = self.create_small_transactions(
node, hiprio_utxos[start_range:end_range], end_range - start_range,
0)
return txids
def run_test(self):
# Test `prioritisetransaction` required parameters
assert_raises_rpc_error(-1, "prioritisetransaction",
self.nodes[0].prioritisetransaction)
assert_raises_rpc_error(-1, "prioritisetransaction",
self.nodes[0].prioritisetransaction, '')
assert_raises_rpc_error(-1, "prioritisetransaction",
self.nodes[0].prioritisetransaction, '', 0)
# Test `prioritisetransaction` invalid extra parameters
assert_raises_rpc_error(-1, "prioritisetransaction",
self.nodes[0].prioritisetransaction, '', 0, 0,
0)
# Test `prioritisetransaction` invalid `txid`
assert_raises_rpc_error(-1,
"txid must be hexadecimal string",
self.nodes[0].prioritisetransaction,
txid='foo',
fee_delta=0)
# Test `prioritisetransaction` invalid `dummy`
txid = '1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000'
assert_raises_rpc_error(-1, "JSON value is not a number as expected",
self.nodes[0].prioritisetransaction, txid,
'foo', 0)
assert_raises_rpc_error(
-8,
"Priority is no longer supported, dummy argument to prioritisetransaction must be 0.",
self.nodes[0].prioritisetransaction, txid, 1, 0)
# Test `prioritisetransaction` invalid `fee_delta`
assert_raises_rpc_error(-1,
"JSON value is not an integer as expected",
self.nodes[0].prioritisetransaction,
txid=txid,
fee_delta='foo')
self.relayfee = self.nodes[0].getnetworkinfo()['relayfee']
utxo_count = 90
utxos = create_confirmed_utxos(self.nodes[0], utxo_count)
txids = []
# Create 3 batches of transactions at 3 different fee rate levels
range_size = utxo_count // 3
for i in range(3):
txids.append([])
start_range = i * range_size
end_range = start_range + range_size
txids[i] = send_big_transactions(self.nodes[0],
utxos[start_range:end_range],
end_range - start_range,
10 * (i + 1))
# Make sure that the size of each group of transactions exceeds
# LEGACY_MAX_BLOCK_SIZE -- otherwise the test needs to be revised to create
# more transactions.
mempool = self.nodes[0].getrawmempool(True)
sizes = [0, 0, 0]
for i in range(3):
for j in txids[i]:
assert j in mempool
sizes[i] += mempool[j]['size']
# Fail => raise utxo_count
assert sizes[i] > LEGACY_MAX_BLOCK_SIZE
# add a fee delta to something in the cheapest bucket and make sure it gets mined
# also check that a different entry in the cheapest bucket is NOT mined
self.nodes[0].prioritisetransaction(
txid=txids[0][0],
fee_delta=100 * self.nodes[0].calculate_fee_from_txid(txids[0][0]))
self.nodes[0].generate(1)
mempool = self.nodes[0].getrawmempool()
self.log.info("Assert that prioritised transaction was mined")
assert txids[0][0] not in mempool
assert txids[0][1] in mempool
confirmed_transactions = self.nodes[0].getblock(
self.nodes[0].getbestblockhash())['tx']
# Pull the highest fee-rate transaction from a block
high_fee_tx = confirmed_transactions[1]
# Something high-fee should have been mined!
assert high_fee_tx is not None
# Add a prioritisation before a tx is in the mempool (de-prioritising a
# high-fee transaction so that it's now low fee).
#
# NOTE WELL: gettransaction returns the fee as a negative number and
# as fractional coins. However, the prioritisetransaction expects a
# number of satoshi to add or subtract from the actual fee.
# Thus the conversation here is simply int(tx_fee*COIN) to remove all fees, and then
# we add the minimum fee back.
tx_fee = self.nodes[0].gettransaction(high_fee_tx)['fee']
self.nodes[0].prioritisetransaction(
txid=high_fee_tx,
fee_delta=int(tx_fee * COIN) +
self.nodes[0].calculate_fee_from_txid(high_fee_tx))
# Add everything back to mempool
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
# Check to make sure our high fee rate tx is back in the mempool
mempool = self.nodes[0].getrawmempool()
assert high_fee_tx in mempool
# Now verify the modified-high feerate transaction isn't mined before
# the other high fee transactions. Keep mining until our mempool has
# decreased by all the high fee size that we calculated above.
while (self.nodes[0].getmempoolinfo()['bytes'] > sizes[0] + sizes[1]):
self.nodes[0].generate(1)
# High fee transaction should not have been mined, but other high fee rate
# transactions should have been.
mempool = self.nodes[0].getrawmempool()
self.log.info(
"Assert that de-prioritised transaction is still in mempool")
assert high_fee_tx in mempool
for x in txids[2]:
if (x != high_fee_tx):
assert x not in mempool
# Create a free transaction. Should be rejected.
utxo_list = self.nodes[0].listunspent()
assert len(utxo_list) > 0
utxo = utxo_list[0]
inputs = []
outputs = {}
inputs.append({"txid": utxo["txid"], "vout": utxo["vout"]})
outputs[self.nodes[0].getnewaddress()] = utxo["amount"]
raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
tx_hex = self.nodes[0].signrawtransactionwithwallet(raw_tx)["hex"]
tx_id = self.nodes[0].decoderawtransaction(tx_hex)["txid"]
# This will raise an exception due to min relay fee not being met
assert_raises_rpc_error(-26, "min relay fee not met (code 66)",
self.nodes[0].sendrawtransaction, tx_hex)
assert tx_id not in self.nodes[0].getrawmempool()
# This is a less than 1000-byte transaction, so just set the fee
# to be the minimum for a 1000-byte transaction and check that it is
# accepted.
self.nodes[0].prioritisetransaction(txid=tx_id,
fee_delta=int(self.relayfee *
COIN))
self.log.info(
"Assert that prioritised free transaction is accepted to mempool")
assert_equal(self.nodes[0].sendrawtransaction(tx_hex), tx_id)
assert tx_id in self.nodes[0].getrawmempool()
# Test that calling prioritisetransaction is sufficient to trigger
# getblocktemplate to (eventually) return a new block.
mock_time = int(time.time())
self.nodes[0].setmocktime(mock_time)
template = self.nodes[0].getblocktemplate()
self.nodes[0].prioritisetransaction(
txid=tx_id, fee_delta=-int(self.relayfee * COIN))
self.nodes[0].setmocktime(mock_time + 10)
new_template = self.nodes[0].getblocktemplate()
assert template != new_template
def test_broadcast(self):
self.log.info(
"Test that mempool reattempts delivery of locally submitted transaction")
node = self.nodes[0]
min_relay_fee = node.getnetworkinfo()["relayfee"]
create_confirmed_utxos(node, 10)
disconnect_nodes(node, self.nodes[1])
self.log.info("Generate transactions that only node 0 knows about")
# generate a wallet txn
addr = node.getnewaddress()
wallet_tx_hsh = node.sendtoaddress(addr, 1)
utxos = node.listunspent()
# generate a txn using sendrawtransaction
us0 = utxos.pop()
inputs = [{"txid": us0["txid"], "vout": us0["vout"]}]
outputs = {addr: 1}
tx = node.createrawtransaction(inputs, outputs)
node.settxfee(min_relay_fee)
txF = node.fundrawtransaction(tx)
txFS = node.signrawtransactionwithwallet(txF["hex"])
rpc_tx_hsh = node.sendrawtransaction(txFS["hex"])
# check transactions are in unbroadcast using rpc
mempoolinfo = self.nodes[0].getmempoolinfo()
assert_equal(mempoolinfo['unbroadcastcount'], 2)
mempool = self.nodes[0].getrawmempool(True)
for tx in mempool:
assert_equal(mempool[tx]['unbroadcast'], True)
# check that second node doesn't have these two txns
mempool = self.nodes[1].getrawmempool()
assert rpc_tx_hsh not in mempool
assert wallet_tx_hsh not in mempool
# ensure that unbroadcast txs are persisted to mempool.dat
self.restart_node(0)
self.log.info("Reconnect nodes & check if they are sent to node 1")
connect_nodes(node, self.nodes[1])
# fast forward into the future & ensure that the second node has the
# txns
node.mockscheduler(MAX_INITIAL_BROADCAST_DELAY)
self.sync_mempools(timeout=30)
mempool = self.nodes[1].getrawmempool()
assert rpc_tx_hsh in mempool
assert wallet_tx_hsh in mempool
# check that transactions are no longer in first node's unbroadcast set
mempool = self.nodes[0].getrawmempool(True)
for tx in mempool:
assert_equal(mempool[tx]['unbroadcast'], False)
self.log.info(
"Add another connection & ensure transactions aren't broadcast again")
conn = node.add_p2p_connection(P2PTxInvStore())
node.mockscheduler(MAX_INITIAL_BROADCAST_DELAY)
# allow sufficient time for possibility of broadcast
time.sleep(2)
assert_equal(len(conn.get_invs()), 0)
disconnect_nodes(node, self.nodes[1])
node.disconnect_p2ps()
def run_test(self):
# Track test coverage statistics
self.restart_counts = [0, 0, 0] # Track the restarts for nodes 0-2
self.crashed_on_restart = 0 # Track count of crashes during recovery
# Start by creating a lot of utxos on node3
initial_height = self.nodes[3].getblockcount()
utxo_list = create_confirmed_utxos(self.nodes[3], 5000)
self.log.info("Prepped {} utxo entries".format(len(utxo_list)))
# Sync these blocks with the other nodes
block_hashes_to_sync = []
for height in range(initial_height + 1,
self.nodes[3].getblockcount() + 1):
block_hashes_to_sync.append(self.nodes[3].getblockhash(height))
self.log.debug("Syncing {} blocks with other nodes".format(
len(block_hashes_to_sync)))
# Syncing the blocks could cause nodes to crash, so the test begins
# here.
self.sync_node3blocks(block_hashes_to_sync)
starting_tip_height = self.nodes[3].getblockcount()
# Set mock time to the last block time. This will allow us to increase
# the time at each loop so the block hash will always differ for the
# same block height, and avoid duplication.
# Note that the current time can be behind the block time due to the
# way the miner sets the block time.
tip = self.nodes[3].getbestblockhash()
block_time = self.nodes[3].getblockheader(tip)['time']
self.nodes[3].setmocktime(block_time)
# Main test loop:
# each time through the loop, generate a bunch of transactions,
# and then either mine a single new block on the tip, or some-sized
# reorg.
for i in range(40):
block_time += 10
self.nodes[3].setmocktime(block_time)
self.log.info(
"Iteration {}, generating 2500 transactions {}".format(
i, self.restart_counts))
# Generate a bunch of small-ish transactions
self.generate_small_transactions(self.nodes[3], 2500, utxo_list)
# Pick a random block between current tip, and starting tip
current_height = self.nodes[3].getblockcount()
random_height = random.randint(starting_tip_height, current_height)
self.log.debug("At height {}, considering height {}".format(
current_height, random_height))
if random_height > starting_tip_height:
# Randomly reorg from this point with some probability (1/4 for
# tip, 1/5 for tip-1, ...)
if random.random() < 1.0 / (current_height + 4 -
random_height):
self.log.debug("Invalidating block at height {}".format(
random_height))
self.nodes[3].invalidateblock(
self.nodes[3].getblockhash(random_height))
# Now generate new blocks until we pass the old tip height
self.log.debug("Mining longer tip")
block_hashes = []
while current_height + 1 > self.nodes[3].getblockcount():
block_hashes.extend(self.nodes[3].generate(
min(10,
current_height + 1 - self.nodes[3].getblockcount())))
self.log.debug("Syncing {} new blocks...".format(
len(block_hashes)))
self.sync_node3blocks(block_hashes)
utxo_list = self.nodes[3].listunspent()
self.log.debug("Node3 utxo count: {}".format(len(utxo_list)))
# Check that the utxo hashes agree with node3
# Useful side effect: each utxo cache gets flushed here, so that we
# won't get crashes on shutdown at the end of the test.
self.verify_utxo_hash()
# Check the test coverage
self.log.info("Restarted nodes: {}; crashes on restart: {}".format(
self.restart_counts, self.crashed_on_restart))
# If no nodes were restarted, we didn't test anything.
assert self.restart_counts != [0, 0, 0]
# Make sure we tested the case of crash-during-recovery.
assert self.crashed_on_restart > 0
# Warn if any of the nodes escaped restart.
for i in range(3):
if self.restart_counts[i] == 0:
self.log.warning(
"Node {} never crashed during utxo flush!".format(i))
def run_test(self):
self.relayfee = self.nodes[0].getnetworkinfo()['relayfee']
utxo_count = 90
utxos = create_confirmed_utxos(self.nodes[0], utxo_count)
# our transactions are smaller than 100kb
base_fee = self.relayfee * 100
txids = []
# Create 3 batches of transactions at 3 different fee rate levels
range_size = utxo_count // 3
for i in range(3):
txids.append([])
start_range = i * range_size
end_range = start_range + range_size
txids[i] = send_big_transactions(self.nodes[0],
utxos[start_range:end_range],
end_range - start_range,
10 * (i + 1))
# Make sure that the size of each group of transactions exceeds
# LEGACY_MAX_BLOCK_SIZE -- otherwise the test needs to be revised to create
# more transactions.
mempool = self.nodes[0].getrawmempool(True)
sizes = [0, 0, 0]
for i in range(3):
for j in txids[i]:
assert (j in mempool)
sizes[i] += mempool[j]['size']
# Fail => raise utxo_count
assert (sizes[i] > LEGACY_MAX_BLOCK_SIZE)
# add a fee delta to something in the cheapest bucket and make sure it gets mined
# also check that a different entry in the cheapest bucket is NOT mined (lower
# the priority to ensure its not mined due to priority)
self.nodes[0].prioritisetransaction(
txids[0][0], 0,
100 * self.nodes[0].calculate_fee_from_txid(txids[0][0]))
self.nodes[0].prioritisetransaction(txids[0][1], -1e15, 0)
self.nodes[0].generate(1)
mempool = self.nodes[0].getrawmempool()
self.log.info("Assert that prioritised transaction was mined")
assert (txids[0][0] not in mempool)
assert (txids[0][1] in mempool)
confirmed_transactions = self.nodes[0].getblock(
self.nodes[0].getbestblockhash())['tx']
# Pull the highest fee-rate transaction from a block
high_fee_tx = confirmed_transactions[1]
# Something high-fee should have been mined!
assert (high_fee_tx != None)
# Add a prioritisation before a tx is in the mempool (de-prioritising a
# high-fee transaction so that it's now low fee).
#
# NOTE WELL: gettransaction returns the fee as a negative number and
# as fractional coins. However, the prioritisetransaction expects a
# number of satoshi to add or subtract from the actual fee.
# Thus the conversation here is simply int(tx_fee*COIN) to remove all fees, and then
# we add the minimum fee back.
tx_fee = self.nodes[0].gettransaction(high_fee_tx)['fee']
self.nodes[0].prioritisetransaction(
high_fee_tx, -1e15,
int(tx_fee * COIN) +
self.nodes[0].calculate_fee_from_txid(high_fee_tx))
# Add everything back to mempool
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
# Check to make sure our high fee rate tx is back in the mempool
mempool = self.nodes[0].getrawmempool()
assert (high_fee_tx in mempool)
# Now verify the modified-high feerate transaction isn't mined before
# the other high fee transactions. Keep mining until our mempool has
# decreased by all the high fee size that we calculated above.
while (self.nodes[0].getmempoolinfo()['bytes'] > sizes[0] + sizes[1]):
self.nodes[0].generate(1)
# High fee transaction should not have been mined, but other high fee rate
# transactions should have been.
mempool = self.nodes[0].getrawmempool()
self.log.info(
"Assert that de-prioritised transaction is still in mempool")
assert (high_fee_tx in mempool)
for x in txids[2]:
if (x != high_fee_tx):
assert (x not in mempool)
# Create a free, low priority transaction. Should be rejected.
utxo_list = self.nodes[0].listunspent()
assert (len(utxo_list) > 0)
utxo = utxo_list[0]
inputs = []
outputs = {}
inputs.append({"txid": utxo["txid"], "vout": utxo["vout"]})
outputs[self.nodes[0].getnewaddress()] = utxo["amount"] - self.relayfee
raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
tx_hex = self.nodes[0].signrawtransaction(raw_tx)["hex"]
txid = self.nodes[0].sendrawtransaction(tx_hex)
# A tx that spends an in-mempool tx has 0 priority, so we can use it to
# test the effect of using prioritise transaction for mempool
# acceptance
inputs = []
inputs.append({"txid": txid, "vout": 0})
outputs = {}
outputs[self.nodes[0].getnewaddress()] = utxo["amount"] - self.relayfee
raw_tx2 = self.nodes[0].createrawtransaction(inputs, outputs)
tx2_hex = self.nodes[0].signrawtransaction(raw_tx2)["hex"]
tx2_id = self.nodes[0].decoderawtransaction(tx2_hex)["txid"]
# This will raise an exception due to min relay fee not being met
assert_raises_rpc_error(-26, "66: insufficient priority",
self.nodes[0].sendrawtransaction, tx2_hex)
assert (tx2_id not in self.nodes[0].getrawmempool())
# This is a less than 1000-byte transaction, so just set the fee
# to be the minimum for a 1000 byte transaction and check that it is
# accepted.
self.nodes[0].prioritisetransaction(tx2_id, 0,
int(self.relayfee * COIN))
self.log.info(
"Assert that prioritised free transaction is accepted to mempool")
assert_equal(self.nodes[0].sendrawtransaction(tx2_hex), tx2_id)
assert (tx2_id in self.nodes[0].getrawmempool())
# Test that calling prioritisetransaction is sufficient to trigger
# getblocktemplate to (eventually) return a new block.
mock_time = int(time.time())
self.nodes[0].setmocktime(mock_time)
template = self.nodes[0].getblocktemplate()
self.nodes[0].prioritisetransaction(txid, 0,
-int(self.relayfee * COIN))
self.nodes[0].setmocktime(mock_time + 10)
new_template = self.nodes[0].getblocktemplate()
assert (template != new_template)