test/functional/p2p-feefilter.py

   1 #!/usr/bin/env python3
   2 # Copyright (c) 2016 The Bitcoin Core developers
   3 # Distributed under the MIT software license, see the accompanying
   4 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5 """Test processing of feefilter messages."""
   6
   7 from test_framework.mininode import *
   8 from test_framework.test_framework import BitcoinTestFramework
   9 from test_framework.util import *
  10 import time
  11
  12
  13 def hashToHex(hash):
  14     return format(hash, '064x')
  15
  16 # Wait up to 60 secs to see if the testnode has received all the expected invs
  17 def allInvsMatch(invsExpected, testnode):
  18     for x in range(60):
  19         with mininode_lock:
  20             if (sorted(invsExpected) == sorted(testnode.txinvs)):
  21                 return True
  22         time.sleep(1)
  23     return False
  24
  25 class TestNode(NodeConnCB):
  26     def __init__(self):
  27         super().__init__()
  28         self.txinvs = []
  29
  30     def on_inv(self, conn, message):
  31         for i in message.inv:
  32             if (i.type == 1):
  33                 self.txinvs.append(hashToHex(i.hash))
  34
  35     def clear_invs(self):
  36         with mininode_lock:
  37             self.txinvs = []
  38
  39 class FeeFilterTest(BitcoinTestFramework):
  40     def set_test_params(self):
  41         self.num_nodes = 2
  42
  43     def run_test(self):
  44         node1 = self.nodes[1]
  45         node0 = self.nodes[0]
  46         # Get out of IBD
  47         node1.generate(1)
  48         sync_blocks(self.nodes)
  49
  50         # Setup the p2p connections and start up the network thread.
  51         test_node = TestNode()
  52         connection = NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_node)
  53         test_node.add_connection(connection)
  54         NetworkThread().start()
  55         test_node.wait_for_verack()
  56
  57         # Test that invs are received for all txs at feerate of 20 sat/byte
  58         node1.settxfee(Decimal("0.00020000"))
  59         txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
  60         assert(allInvsMatch(txids, test_node))
  61         test_node.clear_invs()
  62
  63         # Set a filter of 15 sat/byte
  64         test_node.send_and_ping(msg_feefilter(15000))
  65
  66         # Test that txs are still being received (paying 20 sat/byte)
  67         txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
  68         assert(allInvsMatch(txids, test_node))
  69         test_node.clear_invs()
  70
  71         # Change tx fee rate to 10 sat/byte and test they are no longer received
  72         node1.settxfee(Decimal("0.00010000"))
  73         [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
  74         sync_mempools(self.nodes) # must be sure node 0 has received all txs
  75
  76         # Send one transaction from node0 that should be received, so that we
  77         # we can sync the test on receipt (if node1's txs were relayed, they'd
  78         # be received by the time this node0 tx is received). This is
  79         # unfortunately reliant on the current relay behavior where we batch up
  80         # to 35 entries in an inv, which means that when this next transaction
  81         # is eligible for relay, the prior transactions from node1 are eligible
  82         # as well.
  83         node0.settxfee(Decimal("0.00020000"))
  84         txids = [node0.sendtoaddress(node0.getnewaddress(), 1)]
  85         assert(allInvsMatch(txids, test_node))
  86         test_node.clear_invs()
  87
  88         # Remove fee filter and check that txs are received again
  89         test_node.send_and_ping(msg_feefilter(0))
  90         txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
  91         assert(allInvsMatch(txids, test_node))
  92         test_node.clear_invs()
  93
  94 if __name__ == '__main__':
  95     FeeFilterTest().main()