Ejemplo n.º 1
0
    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
Ejemplo n.º 2
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'])
Ejemplo n.º 3
0
    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
Ejemplo n.º 6
0
    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()
Ejemplo n.º 7
0
    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))
Ejemplo n.º 8
0
    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)