2016-03-19 16:58:06 -03:00
#!/usr/bin/env python3
2022-12-24 20:49:50 -03:00
# Copyright (c) 2015-2022 The Bitcoin Core developers
2015-11-18 22:55:52 -03:00
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
2017-01-17 20:34:40 -03:00
""" Test the prioritisetransaction mining RPC. """
2015-11-18 22:55:52 -03:00
2022-03-21 07:43:49 -03:00
from decimal import Decimal
2018-07-06 18:10:35 -04:00
import time
2022-04-12 15:53:02 -04:00
from test_framework . messages import (
COIN ,
MAX_BLOCK_WEIGHT ,
)
2015-11-18 22:55:52 -03:00
from test_framework . test_framework import BitcoinTestFramework
2022-04-12 15:53:02 -04:00
from test_framework . util import (
assert_equal ,
assert_raises_rpc_error ,
create_lots_of_big_transactions ,
gen_return_txouts ,
)
2022-03-21 07:43:49 -03:00
from test_framework . wallet import MiniWallet
2015-11-18 22:55:52 -03:00
class PrioritiseTransactionTest ( BitcoinTestFramework ) :
2017-06-09 18:21:21 -04:00
def set_test_params ( self ) :
2021-10-19 06:13:40 -03:00
self . num_nodes = 1
2019-04-24 17:55:58 -04:00
self . extra_args = [ [
" -printpriority=1 " ,
2022-06-29 11:51:39 -04:00
" -datacarriersize=100000 " ,
2019-04-24 17:55:58 -04:00
] ] * self . num_nodes
2019-12-06 11:37:49 -03:00
self . supports_cli = False
2015-11-18 22:55:52 -03:00
2023-04-16 03:49:24 -04:00
def clear_prioritisation ( self , node ) :
for txid , info in node . getprioritisedtransactions ( ) . items ( ) :
delta = info [ " fee_delta " ]
node . prioritisetransaction ( txid , 0 , - delta )
assert_equal ( node . getprioritisedtransactions ( ) , { } )
2023-04-20 10:09:24 -04:00
def test_replacement ( self ) :
self . log . info ( " Test tx prioritisation stays after a tx is replaced " )
conflicting_input = self . wallet . get_utxo ( )
tx_replacee = self . wallet . create_self_transfer ( utxo_to_spend = conflicting_input , fee_rate = Decimal ( " 0.0001 " ) )
tx_replacement = self . wallet . create_self_transfer ( utxo_to_spend = conflicting_input , fee_rate = Decimal ( " 0.005 " ) )
# Add 1 satoshi fee delta to replacee
self . nodes [ 0 ] . prioritisetransaction ( tx_replacee [ " txid " ] , 0 , 100 )
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) , { tx_replacee [ " txid " ] : { " fee_delta " : 100 , " in_mempool " : False } } )
self . nodes [ 0 ] . sendrawtransaction ( tx_replacee [ " hex " ] )
2024-01-08 21:59:39 -03:00
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) , { tx_replacee [ " txid " ] : { " fee_delta " : 100 , " in_mempool " : True , " modified_fee " : int ( tx_replacee [ " fee " ] * COIN + 100 ) } } )
2023-04-20 10:09:24 -04:00
self . nodes [ 0 ] . sendrawtransaction ( tx_replacement [ " hex " ] )
assert tx_replacee [ " txid " ] not in self . nodes [ 0 ] . getrawmempool ( )
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) , { tx_replacee [ " txid " ] : { " fee_delta " : 100 , " in_mempool " : False } } )
# PrioritiseTransaction is additive
self . nodes [ 0 ] . prioritisetransaction ( tx_replacee [ " txid " ] , 0 , COIN )
self . nodes [ 0 ] . sendrawtransaction ( tx_replacee [ " hex " ] )
2024-01-08 21:59:39 -03:00
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) , { tx_replacee [ " txid " ] : { " fee_delta " : COIN + 100 , " in_mempool " : True , " modified_fee " : int ( tx_replacee [ " fee " ] * COIN + COIN + 100 ) } } )
2023-04-20 10:09:24 -04:00
self . generate ( self . nodes [ 0 ] , 1 )
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) , { } )
2022-03-21 07:43:49 -03:00
def test_diamond ( self ) :
self . log . info ( " Test diamond-shape package with priority " )
mock_time = int ( time . time ( ) )
self . nodes [ 0 ] . setmocktime ( mock_time )
# tx_a
# / \
# / \
# tx_b tx_c
# \ /
# \ /
# tx_d
tx_o_a = self . wallet . send_self_transfer_multi (
from_node = self . nodes [ 0 ] ,
num_outputs = 2 ,
)
txid_a = tx_o_a [ " txid " ]
tx_o_b , tx_o_c = [ self . wallet . send_self_transfer (
from_node = self . nodes [ 0 ] ,
utxo_to_spend = u ,
) for u in tx_o_a [ " new_utxos " ] ]
txid_b = tx_o_b [ " txid " ]
txid_c = tx_o_c [ " txid " ]
tx_o_d = self . wallet . send_self_transfer_multi (
from_node = self . nodes [ 0 ] ,
utxos_to_spend = [
self . wallet . get_utxo ( txid = txid_b ) ,
self . wallet . get_utxo ( txid = txid_c ) ,
] ,
)
txid_d = tx_o_d [ " txid " ]
self . log . info ( " Test priority while txs are in mempool " )
raw_before = self . nodes [ 0 ] . getrawmempool ( verbose = True )
fee_delta_b = Decimal ( 9999 ) / COIN
fee_delta_c_1 = Decimal ( - 1234 ) / COIN
fee_delta_c_2 = Decimal ( 8888 ) / COIN
self . nodes [ 0 ] . prioritisetransaction ( txid = txid_b , fee_delta = int ( fee_delta_b * COIN ) )
self . nodes [ 0 ] . prioritisetransaction ( txid = txid_c , fee_delta = int ( fee_delta_c_1 * COIN ) )
self . nodes [ 0 ] . prioritisetransaction ( txid = txid_c , fee_delta = int ( fee_delta_c_2 * COIN ) )
raw_before [ txid_a ] [ " fees " ] [ " descendant " ] + = fee_delta_b + fee_delta_c_1 + fee_delta_c_2
raw_before [ txid_b ] [ " fees " ] [ " modified " ] + = fee_delta_b
raw_before [ txid_b ] [ " fees " ] [ " ancestor " ] + = fee_delta_b
raw_before [ txid_b ] [ " fees " ] [ " descendant " ] + = fee_delta_b
raw_before [ txid_c ] [ " fees " ] [ " modified " ] + = fee_delta_c_1 + fee_delta_c_2
raw_before [ txid_c ] [ " fees " ] [ " ancestor " ] + = fee_delta_c_1 + fee_delta_c_2
raw_before [ txid_c ] [ " fees " ] [ " descendant " ] + = fee_delta_c_1 + fee_delta_c_2
raw_before [ txid_d ] [ " fees " ] [ " ancestor " ] + = fee_delta_b + fee_delta_c_1 + fee_delta_c_2
raw_after = self . nodes [ 0 ] . getrawmempool ( verbose = True )
assert_equal ( raw_before [ txid_a ] , raw_after [ txid_a ] )
assert_equal ( raw_before , raw_after )
2024-01-08 21:59:39 -03:00
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) , { txid_b : { " fee_delta " : fee_delta_b * COIN , " in_mempool " : True , " modified_fee " : int ( fee_delta_b * COIN + COIN * tx_o_b [ " fee " ] ) } , txid_c : { " fee_delta " : ( fee_delta_c_1 + fee_delta_c_2 ) * COIN , " in_mempool " : True , " modified_fee " : int ( ( fee_delta_c_1 + fee_delta_c_2 ) * COIN + COIN * tx_o_c [ " fee " ] ) } } )
2023-04-16 03:49:24 -04:00
# Clear prioritisation, otherwise the transactions' fee deltas are persisted to mempool.dat and loaded again when the node
# is restarted at the end of this subtest. Deltas are removed when a transaction is mined, but only at that time. We do
# not check whether mapDeltas transactions were mined when loading from mempool.dat.
self . clear_prioritisation ( node = self . nodes [ 0 ] )
2022-03-21 07:43:49 -03:00
self . log . info ( " Test priority while txs are not in mempool " )
self . restart_node ( 0 , extra_args = [ " -nopersistmempool " ] )
self . nodes [ 0 ] . setmocktime ( mock_time )
assert_equal ( self . nodes [ 0 ] . getmempoolinfo ( ) [ " size " ] , 0 )
self . nodes [ 0 ] . prioritisetransaction ( txid = txid_b , fee_delta = int ( fee_delta_b * COIN ) )
self . nodes [ 0 ] . prioritisetransaction ( txid = txid_c , fee_delta = int ( fee_delta_c_1 * COIN ) )
self . nodes [ 0 ] . prioritisetransaction ( txid = txid_c , fee_delta = int ( fee_delta_c_2 * COIN ) )
2023-11-13 15:48:16 -03:00
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) , { txid_b : { " fee_delta " : fee_delta_b * COIN , " in_mempool " : False } , txid_c : { " fee_delta " : ( fee_delta_c_1 + fee_delta_c_2 ) * COIN , " in_mempool " : False } } )
2022-03-21 07:43:49 -03:00
for t in [ tx_o_a [ " hex " ] , tx_o_b [ " hex " ] , tx_o_c [ " hex " ] , tx_o_d [ " hex " ] ] :
self . nodes [ 0 ] . sendrawtransaction ( t )
raw_after = self . nodes [ 0 ] . getrawmempool ( verbose = True )
assert_equal ( raw_before [ txid_a ] , raw_after [ txid_a ] )
assert_equal ( raw_before , raw_after )
2024-01-08 21:59:39 -03:00
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) , { txid_b : { " fee_delta " : fee_delta_b * COIN , " in_mempool " : True , " modified_fee " : int ( fee_delta_b * COIN + COIN * tx_o_b [ " fee " ] ) } , txid_c : { " fee_delta " : ( fee_delta_c_1 + fee_delta_c_2 ) * COIN , " in_mempool " : True , " modified_fee " : int ( ( fee_delta_c_1 + fee_delta_c_2 ) * COIN + COIN * tx_o_c [ " fee " ] ) } } )
2022-03-21 07:43:49 -03:00
# Clear mempool
self . generate ( self . nodes [ 0 ] , 1 )
2023-04-20 07:38:44 -04:00
# Prioritisation for transactions is automatically deleted after they are mined.
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) , { } )
2022-03-21 07:43:49 -03:00
# Use default extra_args
self . restart_node ( 0 )
2023-04-16 03:49:24 -04:00
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) , { } )
2022-03-21 07:43:49 -03:00
2017-04-03 10:34:04 -03:00
def run_test ( self ) :
2022-03-21 07:43:49 -03:00
self . wallet = MiniWallet ( self . nodes [ 0 ] )
2018-01-02 22:48:20 -03:00
# 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 )
2023-04-20 07:38:44 -04:00
# Test `getprioritisedtransactions` invalid parameters
assert_raises_rpc_error ( - 1 , " getprioritisedtransactions " ,
self . nodes [ 0 ] . getprioritisedtransactions , True )
2018-01-02 22:48:20 -03:00
# Test `prioritisetransaction` invalid `txid`
2018-06-08 14:16:07 -04:00
assert_raises_rpc_error ( - 8 , " txid must be of length 64 (not 3, for ' foo ' ) " , self . nodes [ 0 ] . prioritisetransaction , txid = ' foo ' , fee_delta = 0 )
assert_raises_rpc_error ( - 8 , " txid must be hexadecimal string (not ' Zd1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000 ' ) " , self . nodes [ 0 ] . prioritisetransaction , txid = ' Zd1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000 ' , fee_delta = 0 )
2018-01-02 22:48:20 -03:00
# Test `prioritisetransaction` invalid `dummy`
txid = ' 1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000 '
2022-09-14 12:13:58 -03:00
assert_raises_rpc_error ( - 3 , " JSON value of type string is not of expected type number " , self . nodes [ 0 ] . prioritisetransaction , txid , ' foo ' , 0 )
2018-01-02 22:48:20 -03:00
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`
2022-09-14 12:13:58 -03:00
assert_raises_rpc_error ( - 3 , " JSON value of type string is not of expected type number " , self . nodes [ 0 ] . prioritisetransaction , txid = txid , fee_delta = ' foo ' )
2018-01-02 22:48:20 -03:00
2023-04-20 10:09:24 -04:00
self . test_replacement ( )
2022-03-21 07:43:49 -03:00
self . test_diamond ( )
2016-05-14 08:01:31 -03:00
self . txouts = gen_return_txouts ( )
2015-11-18 22:55:52 -03:00
self . relayfee = self . nodes [ 0 ] . getnetworkinfo ( ) [ ' relayfee ' ]
2016-03-01 11:28:16 -03:00
utxo_count = 90
2022-04-12 15:53:02 -04:00
utxos = self . wallet . send_self_transfer_multi ( from_node = self . nodes [ 0 ] , num_outputs = utxo_count ) [ ' new_utxos ' ]
self . generate ( self . wallet , 1 )
assert_equal ( len ( self . nodes [ 0 ] . getrawmempool ( ) ) , 0 )
2015-11-18 22:55:52 -03:00
base_fee = self . relayfee * 100 # our transactions are smaller than 100kb
txids = [ ]
# Create 3 batches of transactions at 3 different fee rate levels
2016-03-01 11:28:16 -03:00
range_size = utxo_count / / 3
2016-03-19 16:58:06 -03:00
for i in range ( 3 ) :
2015-11-18 22:55:52 -03:00
txids . append ( [ ] )
2016-03-01 11:28:16 -03:00
start_range = i * range_size
end_range = start_range + range_size
2022-04-12 15:53:02 -04:00
txids [ i ] = create_lots_of_big_transactions (
self . wallet ,
self . nodes [ 0 ] ,
( i + 1 ) * base_fee ,
end_range - start_range ,
self . txouts ,
utxos [ start_range : end_range ] )
2016-03-01 11:28:16 -03:00
# Make sure that the size of each group of transactions exceeds
2021-06-30 19:43:45 -04:00
# MAX_BLOCK_WEIGHT // 4 -- otherwise the test needs to be revised to
# create more transactions.
2016-03-01 11:28:16 -03:00
mempool = self . nodes [ 0 ] . getrawmempool ( True )
sizes = [ 0 , 0 , 0 ]
2016-03-19 16:58:06 -03:00
for i in range ( 3 ) :
2016-03-01 11:28:16 -03:00
for j in txids [ i ] :
2019-02-19 19:43:44 -03:00
assert j in mempool
2018-04-17 15:17:13 -03:00
sizes [ i ] + = mempool [ j ] [ ' vsize ' ]
2021-06-30 19:43:45 -04:00
assert sizes [ i ] > MAX_BLOCK_WEIGHT / / 4 # Fail => raise utxo_count
2015-11-18 22:55:52 -03:00
2023-04-16 03:49:24 -04:00
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) , { } )
2015-11-18 22:55:52 -03:00
# add a fee delta to something in the cheapest bucket and make sure it gets mined
2017-01-20 00:46:50 -03:00
# also check that a different entry in the cheapest bucket is NOT mined
2017-04-21 13:41:01 -03:00
self . nodes [ 0 ] . prioritisetransaction ( txid = txids [ 0 ] [ 0 ] , fee_delta = int ( 3 * base_fee * COIN ) )
2024-01-08 21:59:39 -03:00
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) , { txids [ 0 ] [ 0 ] : { " fee_delta " : 3 * base_fee * COIN , " in_mempool " : True , " modified_fee " : int ( 3 * base_fee * COIN + COIN * 1 * base_fee ) } } )
2023-04-16 03:49:24 -04:00
# Priority disappears when prioritisetransaction is called with an inverse value...
self . nodes [ 0 ] . prioritisetransaction ( txid = txids [ 0 ] [ 0 ] , fee_delta = int ( - 3 * base_fee * COIN ) )
assert txids [ 0 ] [ 0 ] not in self . nodes [ 0 ] . getprioritisedtransactions ( )
# ... and reappears when prioritisetransaction is called again.
self . nodes [ 0 ] . prioritisetransaction ( txid = txids [ 0 ] [ 0 ] , fee_delta = int ( 3 * base_fee * COIN ) )
assert txids [ 0 ] [ 0 ] in self . nodes [ 0 ] . getprioritisedtransactions ( )
2015-11-18 22:55:52 -03:00
2021-08-19 11:10:24 -04:00
self . generate ( self . nodes [ 0 ] , 1 )
2015-11-18 22:55:52 -03:00
mempool = self . nodes [ 0 ] . getrawmempool ( )
2017-03-07 20:46:17 -03:00
self . log . info ( " Assert that prioritised transaction was mined " )
2019-02-19 19:43:44 -03:00
assert txids [ 0 ] [ 0 ] not in mempool
assert txids [ 0 ] [ 1 ] in mempool
2015-11-18 22:55:52 -03:00
high_fee_tx = None
for x in txids [ 2 ] :
if x not in mempool :
high_fee_tx = x
# Something high-fee should have been mined!
2019-02-19 19:43:44 -03:00
assert high_fee_tx is not None
2015-11-18 22:55:52 -03:00
# Add a prioritisation before a tx is in the mempool (de-prioritising a
2016-03-01 11:28:16 -03:00
# high-fee transaction so that it's now low fee).
2017-04-21 13:41:01 -03:00
self . nodes [ 0 ] . prioritisetransaction ( txid = high_fee_tx , fee_delta = - int ( 2 * base_fee * COIN ) )
2023-04-20 07:38:44 -04:00
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) [ high_fee_tx ] , { " fee_delta " : - 2 * base_fee * COIN , " in_mempool " : False } )
2015-11-18 22:55:52 -03:00
# 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 ( )
2019-02-19 19:43:44 -03:00
assert high_fee_tx in mempool
2015-11-18 22:55:52 -03:00
2016-03-01 11:28:16 -03:00
# 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 ] ) :
2020-11-10 14:02:31 -03:00
self . generate ( self . nodes [ 0 ] , 1 , sync_fun = self . no_op )
2015-11-18 22:55:52 -03:00
# High fee transaction should not have been mined, but other high fee rate
# transactions should have been.
mempool = self . nodes [ 0 ] . getrawmempool ( )
2017-03-07 20:46:17 -03:00
self . log . info ( " Assert that de-prioritised transaction is still in mempool " )
2019-02-19 19:43:44 -03:00
assert high_fee_tx in mempool
2024-01-08 21:59:39 -03:00
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) [ high_fee_tx ] , { " fee_delta " : - 2 * base_fee * COIN , " in_mempool " : True , " modified_fee " : int ( - 2 * base_fee * COIN + COIN * 3 * base_fee ) } )
2015-11-18 22:55:52 -03:00
for x in txids [ 2 ] :
if ( x != high_fee_tx ) :
2019-02-19 19:43:44 -03:00
assert x not in mempool
2015-11-18 22:55:52 -03:00
2023-11-14 19:11:25 -03:00
self . log . info ( " Assert that 0 delta is never added to mapDeltas " )
tx_id_zero_del = self . wallet . create_self_transfer ( ) [ ' txid ' ]
self . nodes [ 0 ] . prioritisetransaction ( txid = tx_id_zero_del , fee_delta = 0 )
assert tx_id_zero_del not in self . nodes [ 0 ] . getprioritisedtransactions ( )
2017-01-20 00:46:50 -03:00
# Create a free transaction. Should be rejected.
2022-06-21 05:25:54 -04:00
tx_res = self . wallet . create_self_transfer ( fee_rate = 0 )
2022-04-12 15:53:02 -04:00
tx_hex = tx_res [ ' hex ' ]
tx_id = tx_res [ ' txid ' ]
2015-12-02 11:37:18 -03:00
2017-03-07 16:08:59 -03:00
# This will raise an exception due to min relay fee not being met
2018-04-25 18:30:38 -03:00
assert_raises_rpc_error ( - 26 , " min relay fee not met " , self . nodes [ 0 ] . sendrawtransaction , tx_hex )
2019-02-19 19:43:44 -03:00
assert tx_id not in self . nodes [ 0 ] . getrawmempool ( )
2015-12-02 11:37:18 -03:00
# This is a less than 1000-byte transaction, so just set the fee
2018-03-18 11:26:45 -03:00
# to be the minimum for a 1000-byte transaction and check that it is
2015-12-02 11:37:18 -03:00
# accepted.
2017-04-21 13:41:01 -03:00
self . nodes [ 0 ] . prioritisetransaction ( txid = tx_id , fee_delta = int ( self . relayfee * COIN ) )
2023-04-20 07:38:44 -04:00
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) [ tx_id ] , { " fee_delta " : self . relayfee * COIN , " in_mempool " : False } )
2015-12-02 11:37:18 -03:00
2017-03-07 20:46:17 -03:00
self . log . info ( " Assert that prioritised free transaction is accepted to mempool " )
2017-01-20 00:46:50 -03:00
assert_equal ( self . nodes [ 0 ] . sendrawtransaction ( tx_hex ) , tx_id )
2019-02-19 19:43:44 -03:00
assert tx_id in self . nodes [ 0 ] . getrawmempool ( )
2024-01-08 21:59:39 -03:00
assert_equal ( self . nodes [ 0 ] . getprioritisedtransactions ( ) [ tx_id ] , { " fee_delta " : self . relayfee * COIN , " in_mempool " : True , " modified_fee " : int ( self . relayfee * COIN + COIN * tx_res [ " fee " ] ) } )
2015-12-02 11:37:18 -03:00
2017-04-18 13:52:08 -03:00
# 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 )
2018-11-26 13:17:38 -03:00
template = self . nodes [ 0 ] . getblocktemplate ( { ' rules ' : [ ' segwit ' ] } )
2017-04-21 13:41:01 -03:00
self . nodes [ 0 ] . prioritisetransaction ( txid = tx_id , fee_delta = - int ( self . relayfee * COIN ) )
2023-04-20 07:38:44 -04:00
2023-04-16 03:49:24 -04:00
# Calling prioritisetransaction with the inverse amount should delete its prioritisation entry
assert tx_id not in self . nodes [ 0 ] . getprioritisedtransactions ( )
2023-04-20 07:38:44 -04:00
2017-04-18 13:52:08 -03:00
self . nodes [ 0 ] . setmocktime ( mock_time + 10 )
2018-11-26 13:17:38 -03:00
new_template = self . nodes [ 0 ] . getblocktemplate ( { ' rules ' : [ ' segwit ' ] } )
2017-04-18 13:52:08 -03:00
2019-02-19 19:43:44 -03:00
assert template != new_template
2017-04-18 13:52:08 -03:00
2015-11-18 22:55:52 -03:00
if __name__ == ' __main__ ' :
2024-07-16 17:05:14 -04:00
PrioritiseTransactionTest ( __file__ ) . main ( )