Inside Bitcoin

251            txids[i] = create_lots_of_big_transactions(
252                self.wallet,
253                self.nodes[0],
254                (i+1) * base_fee,
255                end_range - start_range,
256                self.txouts,
257                utxos[start_range:end_range])
258
259        # Make sure that the size of each group of transactions exceeds
260        # MAX_BLOCK_WEIGHT // 4 -- otherwise the test needs to be revised to
261        # create more transactions.
262        mempool = self.nodes[0].getrawmempool(True)
263        sizes = [0, 0, 0]
264        for i in range(3):
265            for j in txids[i]:
266                assert j in mempool
267                sizes[i] += mempool[j]['vsize']
268            assert sizes[i] > MAX_BLOCK_WEIGHT // 4  # Fail => raise utxo_count
269
270        assert_equal(self.nodes[0].getprioritisedtransactions(), {})
271        # add a fee delta to something in the cheapest bucket and make sure it gets mined
272        # also check that a different entry in the cheapest bucket is NOT mined
273        self.nodes[0].prioritisetransaction(txid=txids[0][0], fee_delta=int(3*base_fee*COIN))
274        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)}})
275
276        # Priority disappears when prioritisetransaction is called with an inverse value...
277        self.nodes[0].prioritisetransaction(txid=txids[0][0], fee_delta=int(-3*base_fee*COIN))
278        assert txids[0][0] not in self.nodes[0].getprioritisedtransactions()
279        # ... and reappears when prioritisetransaction is called again.
280        self.nodes[0].prioritisetransaction(txid=txids[0][0], fee_delta=int(3*base_fee*COIN))
281        assert txids[0][0] in self.nodes[0].getprioritisedtransactions()
282
283        self.generate(self.nodes[0], 1)
284
285        mempool = self.nodes[0].getrawmempool()
286        self.log.info("Assert that prioritised transaction was mined")
287        assert txids[0][0] not in mempool
288        assert txids[0][1] in mempool
289
290        high_fee_tx = None
291        for x in txids[2]:
292            if x not in mempool:
293                high_fee_tx = x
294
295        # Something high-fee should have been mined!
296        assert high_fee_tx is not None
297
298        # Add a prioritisation before a tx is in the mempool (de-prioritising a
299        # high-fee transaction so that it's now low fee).
300        self.nodes[0].prioritisetransaction(txid=high_fee_tx, fee_delta=-int(2*base_fee*COIN))
301        assert_equal(self.nodes[0].getprioritisedtransactions()[high_fee_tx], { "fee_delta" : -2*base_fee*COIN, "in_mempool" : False})
302
303        # Add everything back to mempool
304        self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
305
306        # Check to make sure our high fee rate tx is back in the mempool
307        mempool = self.nodes[0].getrawmempool()
308        assert high_fee_tx in mempool
309
310        # Now verify the modified-high feerate transaction isn't mined before
311        # the other high fee transactions. Keep mining until our mempool has
312        # decreased by all the high fee size that we calculated above.
313        while (self.nodes[0].getmempoolinfo()['bytes'] > sizes[0] + sizes[1]):
314            self.generate(self.nodes[0], 1, sync_fun=self.no_op)
315
316        # High fee transaction should not have been mined, but other high fee rate
317        # transactions should have been.
318        mempool = self.nodes[0].getrawmempool()
319        self.log.info("Assert that de-prioritised transaction is still in mempool")
320        assert high_fee_tx in mempool
321        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)})
322        for x in txids[2]:
323            if (x != high_fee_tx):
324                assert x not in mempool
325
326
327        self.log.info("Assert that 0 delta is never added to mapDeltas")
328        tx_id_zero_del = self.wallet.create_self_transfer()['txid']
329        self.nodes[0].prioritisetransaction(txid=tx_id_zero_del, fee_delta=0)
330        assert tx_id_zero_del not in self.nodes[0].getprioritisedtransactions()
331
332        # Create a free transaction.  Should be rejected.
333        tx_res = self.wallet.create_self_transfer(fee_rate=0)
334        tx_hex = tx_res['hex']
335        tx_id = tx_res['txid']
336
337        # This will raise an exception due to min relay fee not being met
338        assert_raises_rpc_error(-26, "min relay fee not met", self.nodes[0].sendrawtransaction, tx_hex)
339        assert tx_id not in self.nodes[0].getrawmempool()
340
341        # This is a less than 1000-byte transaction, so just set the fee
342        # to be the minimum for a 1000-byte transaction and check that it is
343        # accepted.
344        self.nodes[0].prioritisetransaction(txid=tx_id, fee_delta=int(self.relayfee*COIN))
345        assert_equal(self.nodes[0].getprioritisedtransactions()[tx_id], { "fee_delta" : self.relayfee*COIN, "in_mempool" : False})
346
347        self.log.info("Assert that prioritised free transaction is accepted to mempool")
348        assert_equal(self.nodes[0].sendrawtransaction(tx_hex), tx_id)
349        assert tx_id in self.nodes[0].getrawmempool()
350        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"])})
351
352        # Test that calling prioritisetransaction is sufficient to trigger
353        # getblocktemplate to (eventually) return a new block.
354        mock_time = int(time.time())
355        self.nodes[0].setmocktime(mock_time)
356        template = self.nodes[0].getblocktemplate(NORMAL_GBT_REQUEST_PARAMS)
357        self.nodes[0].prioritisetransaction(txid=tx_id, fee_delta=-int(self.relayfee*COIN))
358
359        # Calling prioritisetransaction with the inverse amount should delete its prioritisation entry
360        assert tx_id not in self.nodes[0].getprioritisedtransactions()
361
362        self.nodes[0].setmocktime(mock_time+10)
363        new_template = self.nodes[0].getblocktemplate(NORMAL_GBT_REQUEST_PARAMS)
364
365        assert_not_equal(template, new_template)
366
367if __name__ == '__main__':
368    PrioritiseTransactionTest(__file__).main()
369