Inside Bitcoin

251        self.generate(self.nodes[2], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
252        node_2_bal -= Decimal('10')
253        assert_equal(self.nodes[2].getbalance(), node_2_bal)
254        node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), Decimal('20'), fee_per_byte, self.get_vsize(self.nodes[2].gettransaction(txid)['hex']))
255
256        self.log.info("Test sendmany")
257
258        # Sendmany 10 BTC
259        txid = self.nodes[2].sendmany('', {address: 10}, 0, "", [], fee_rate=fee_rate_sat_vb)
260        self.generate(self.nodes[2], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
261        node_0_bal += Decimal('10')
262        node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), node_2_bal - Decimal('10'), fee_per_byte, self.get_vsize(self.nodes[2].gettransaction(txid)['hex']))
263        assert_equal(self.nodes[0].getbalance(), node_0_bal)
264
265        # Sendmany 10 BTC with subtract fee from amount
266        txid = self.nodes[2].sendmany('', {address: 10}, 0, "", [address], fee_rate=fee_rate_sat_vb)
267        self.generate(self.nodes[2], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
268        node_2_bal -= Decimal('10')
269        assert_equal(self.nodes[2].getbalance(), node_2_bal)
270        node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), node_0_bal + Decimal('10'), fee_per_byte, self.get_vsize(self.nodes[2].gettransaction(txid)['hex']))
271
272        # Sendmany 5 BTC to two addresses with subtracting fee from both addresses
273        a0 = self.nodes[0].getnewaddress()
274        a1 = self.nodes[0].getnewaddress()
275        txid = self.nodes[2].sendmany(dummy='', amounts={a0: 5, a1: 5}, subtractfeefrom=[a0, a1], fee_rate=fee_rate_sat_vb)
276        self.generate(self.nodes[2], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
277        node_2_bal -= Decimal('10')
278        assert_equal(self.nodes[2].getbalance(), node_2_bal)
279        tx = self.nodes[2].gettransaction(txid)
280        node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), node_0_bal + Decimal('10'), fee_per_byte, self.get_vsize(tx['hex']))
281        assert_equal(self.nodes[0].getbalance(), node_0_bal)
282        expected_bal = Decimal('5') + (tx['fee'] / 2)
283        assert_equal(self.nodes[0].getreceivedbyaddress(a0), expected_bal)
284        assert_equal(self.nodes[0].getreceivedbyaddress(a1), expected_bal)
285
286        self.log.info("Test sendmany with fee_rate param (explicit fee rate in sat/vB)")
287        fee_rate_sat_vb = 2
288        fee_rate_btc_kvb = fee_rate_sat_vb * 1e3 / 1e8
289        explicit_fee_rate_btc_kvb = Decimal(fee_rate_btc_kvb) / 1000
290
291        # Test passing fee_rate as a string
292        txid = self.nodes[2].sendmany(amounts={address: 10}, fee_rate=str(fee_rate_sat_vb))
293        self.generate(self.nodes[2], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
294        balance = self.nodes[2].getbalance()
295        node_2_bal = self.check_fee_amount(balance, node_2_bal - Decimal('10'), explicit_fee_rate_btc_kvb, self.get_vsize(self.nodes[2].gettransaction(txid)['hex']))
296        assert_equal(balance, node_2_bal)
297        node_0_bal += Decimal('10')
298        assert_equal(self.nodes[0].getbalance(), node_0_bal)
299
300        # Test passing fee_rate as an integer
301        amount = Decimal("0.0001")
302        txid = self.nodes[2].sendmany(amounts={address: amount}, fee_rate=fee_rate_sat_vb)
303        self.generate(self.nodes[2], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
304        balance = self.nodes[2].getbalance()
305        node_2_bal = self.check_fee_amount(balance, node_2_bal - amount, explicit_fee_rate_btc_kvb, self.get_vsize(self.nodes[2].gettransaction(txid)['hex']))
306        assert_equal(balance, node_2_bal)
307        node_0_bal += amount
308        assert_equal(self.nodes[0].getbalance(), node_0_bal)
309
310        assert_raises_rpc_error(-8, "Unknown named parameter feeRate", self.nodes[2].sendtoaddress, address=address, amount=1, fee_rate=1, feeRate=1)
311
312        # Test setting explicit fee rate just below the minimum.
313        self.log.info("Test sendmany raises 'fee rate too low' if fee_rate of 0.99999999 is passed")
314        assert_raises_rpc_error(-6, "Fee rate (0.999 sat/vB) is lower than the minimum fee rate setting (1.000 sat/vB)",
315            self.nodes[2].sendmany, amounts={address: 10}, fee_rate=0.999)
316
317        self.log.info("Test sendmany raises if an invalid fee_rate is passed")
318        # Test fee_rate with zero values.
319        msg = "Fee rate (0.000 sat/vB) is lower than the minimum fee rate setting (1.000 sat/vB)"
320        for zero_value in [0, 0.000, 0.00000000, "0", "0.000", "0.00000000"]:
321            assert_raises_rpc_error(-6, msg, self.nodes[2].sendmany, amounts={address: 1}, fee_rate=zero_value)
322        msg = "Invalid amount"
323        # Test fee_rate values that don't pass fixed-point parsing checks.
324        for invalid_value in ["", 0.000000001, 1e-09, 1.111111111, 1111111111111111, "31.999999999999999999999"]:
325            assert_raises_rpc_error(-3, msg, self.nodes[2].sendmany, amounts={address: 1.0}, fee_rate=invalid_value)
326        # Test fee_rate values that cannot be represented in sat/vB.
327        for invalid_value in [0.0001, 0.00000001, 0.00099999, 31.99999999]:
328            assert_raises_rpc_error(-3, msg, self.nodes[2].sendmany, amounts={address: 10}, fee_rate=invalid_value)
329        # Test fee_rate out of range (negative number).
330        assert_raises_rpc_error(-3, OUT_OF_RANGE, self.nodes[2].sendmany, amounts={address: 10}, fee_rate=-1)
331        # Test type error.
332        for invalid_value in [True, {"foo": "bar"}]:
333            assert_raises_rpc_error(-3, NOT_A_NUMBER_OR_STRING, self.nodes[2].sendmany, amounts={address: 10}, fee_rate=invalid_value)
334
335        self.log.info("Test sendmany raises if an invalid conf_target or estimate_mode is passed")
336        for target, mode in product([-1, 0, 1009], ["economical", "conservative"]):
337            assert_raises_rpc_error(-8, "Invalid conf_target, must be between 1 and 1008",  # max value of 1008 per src/policy/fees/block_policy_estimator.h
338                self.nodes[2].sendmany, amounts={address: 1}, conf_target=target, estimate_mode=mode)
339        for target, mode in product([-1, 0], ["btc/kb", "sat/b"]):
340            assert_raises_rpc_error(-8, 'Invalid estimate_mode parameter, must be one of: "unset", "economical", "conservative"',
341                self.nodes[2].sendmany, amounts={address: 1}, conf_target=target, estimate_mode=mode)
342
343        self.start_node(3, self.nodes[3].extra_args)
344        self.connect_nodes(0, 3)
345        self.sync_all()
346
347        # check if we can list zero value tx as available coins
348        # 1. create raw_tx
349        # 2. hex-changed one output to 0.0
350        # 3. sign and send
351        # 4. check if recipient (node0) can list the zero value tx
352        usp = self.nodes[1].listunspent(query_options={'minimumAmount': '49.998'})[0]
353        inputs = [{"txid": usp['txid'], "vout": usp['vout']}]
354        outputs = {self.nodes[1].getnewaddress(): 49.998, self.nodes[0].getnewaddress(): 11.11}
355
356        raw_tx = self.nodes[1].createrawtransaction(inputs, outputs).replace("c0833842", "00000000")  # replace 11.11 with 0.0 (int32)
357        signed_raw_tx = self.nodes[1].signrawtransactionwithwallet(raw_tx)
358        decoded_raw_tx = self.nodes[1].decoderawtransaction(signed_raw_tx['hex'])
359        zero_value_txid = decoded_raw_tx['txid']
360        self.nodes[1].sendrawtransaction(signed_raw_tx['hex'])
361
362        self.sync_all()
363        self.generate(self.nodes[1], 1)  # mine a block
364
365        unspent_txs = self.nodes[0].listunspent()  # zero value tx must be in listunspents output
366        found = False
367        for uTx in unspent_txs:
368            if uTx['txid'] == zero_value_txid:
369                found = True
370                assert_equal(uTx['amount'], Decimal('0'))
371        assert found
372
373        self.log.info("Test -walletbroadcast")
374        self.stop_nodes()
375        self.start_node(0, ["-walletbroadcast=0"])
376        self.start_node(1, ["-walletbroadcast=0"])
377        self.start_node(2, ["-walletbroadcast=0"])
378        self.connect_nodes(0, 1)
379        self.connect_nodes(1, 2)
380        self.connect_nodes(0, 2)
381        self.sync_all(self.nodes[0:3])
382
383        txid_not_broadcast = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 2)
384        tx_obj_not_broadcast = self.nodes[0].gettransaction(txid_not_broadcast)
385        self.generate(self.nodes[1], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))  # mine a block, tx should not be in there
386        assert_equal(self.nodes[2].getbalance(), node_2_bal)  # should not be changed because tx was not broadcasted
387
388        # now broadcast from another node, mine a block, sync, and check the balance
389        self.nodes[1].sendrawtransaction(tx_obj_not_broadcast['hex'])
390        self.generate(self.nodes[1], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
391        node_2_bal += 2
392        tx_obj_not_broadcast = self.nodes[0].gettransaction(txid_not_broadcast)
393        assert_equal(self.nodes[2].getbalance(), node_2_bal)
394
395        # create another tx
396        self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 2)
397
398        # restart the nodes with -walletbroadcast=1
399        self.stop_nodes()
400        self.start_node(0)
401        self.start_node(1)
402        self.start_node(2)
403        self.connect_nodes(0, 1)
404        self.connect_nodes(1, 2)
405        self.connect_nodes(0, 2)
406        self.sync_blocks(self.nodes[0:3])
407
408        self.generate(self.nodes[0], 1, sync_fun=lambda: self.sync_blocks(self.nodes[0:3]))
409        node_2_bal += 2
410
411        # tx should be added to balance because after restarting the nodes tx should be broadcast
412        assert_equal(self.nodes[2].getbalance(), node_2_bal)
413
414        # send a tx with value in a string (PR#6380 +)
415        txid = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "2")
416        tx_obj = self.nodes[0].gettransaction(txid)
417        assert_equal(tx_obj['amount'], Decimal('-2'))
418
419        txid = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "0.0001")
420        tx_obj = self.nodes[0].gettransaction(txid)
421        assert_equal(tx_obj['amount'], Decimal('-0.0001'))
422
423        # check if JSON parser can handle scientific notation in strings
424        txid = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "1e-4")
425        tx_obj = self.nodes[0].gettransaction(txid)
426        assert_equal(tx_obj['amount'], Decimal('-0.0001'))
427
428        # General checks for errors from incorrect inputs
429        # This will raise an exception because the amount is negative
430        assert_raises_rpc_error(-3, OUT_OF_RANGE, self.nodes[0].sendtoaddress, self.nodes[2].getnewaddress(), "-1")
431
432        # This will raise an exception because the amount type is wrong
433        assert_raises_rpc_error(-3, "Invalid amount", self.nodes[0].sendtoaddress, self.nodes[2].getnewaddress(), "1f-4")
434
435        # This will raise an exception since generate does not accept a string
436        assert_raises_rpc_error(-3, "not of expected type number", self.generate, self.nodes[0], "2")
437
438        # Mine a block from node0 to an address from node1
439        coinbase_addr = self.nodes[1].getnewaddress()
440        block_hash = self.generatetoaddress(self.nodes[0], 1, coinbase_addr, sync_fun=lambda: self.sync_all(self.nodes[0:3]))[0]
441        coinbase_txid = self.nodes[0].getblock(block_hash)['tx'][0]
442
443        # Check that the txid and balance is found by node1
444        self.nodes[1].gettransaction(coinbase_txid)
445
446        # check if wallet or blockchain maintenance changes the balance
447        self.sync_all(self.nodes[0:3])
448        blocks = self.generate(self.nodes[0], 2, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
449        balance_nodes = [self.nodes[i].getbalance() for i in range(3)]
450        block_count = self.nodes[0].getblockcount()
451
452        # Check modes:
453        #   - True: unicode escaped as \u....
454        #   - False: unicode directly as UTF-8
455        for mode in [True, False]:
456            self.nodes[0]._rpc.ensure_ascii = mode
457            # unicode check: Basic Multilingual Plane, Supplementary Plane respectively
458            for label in [u'рыба', u'𝅘𝅥𝅯']:
459                addr = self.nodes[0].getnewaddress()
460                self.nodes[0].setlabel(addr, label)
461                test_address(self.nodes[0], addr, labels=[label])
462                assert label in self.nodes[0].listlabels()
463        self.nodes[0]._rpc.ensure_ascii = True  # restore to default
464
465        # -reindex tests
466        chainlimit = 6
467        self.log.info("Test -reindex")
468        self.stop_nodes()
469        # set lower ancestor limit for later
470        self.start_node(0, ['-reindex', "-walletrejectlongchains=0", "-limitancestorcount=" + str(chainlimit), "-limitclustercount=" + str(chainlimit)])
471        self.start_node(1, ['-reindex', "-limitclustercount=" + str(chainlimit)])
472        self.start_node(2, ['-reindex', "-limitclustercount=" + str(chainlimit)])
473        # reindex will leave rpc warm up "early"; Wait for it to finish
474        self.wait_until(lambda: [block_count] * 3 == [self.nodes[i].getblockcount() for i in range(3)])
475        assert_equal(balance_nodes, [self.nodes[i].getbalance() for i in range(3)])
476
477        # Exercise listsinceblock with the last two blocks
478        coinbase_tx_1 = self.nodes[0].listsinceblock(blocks[0])
479        assert_equal(coinbase_tx_1["lastblock"], blocks[1])
480        assert_equal(len(coinbase_tx_1["transactions"]), 1)
481        assert_equal(coinbase_tx_1["transactions"][0]["blockhash"], blocks[1])
482        assert_equal(len(self.nodes[0].listsinceblock(blocks[1])["transactions"]), 0)
483
484        # ==Check that wallet prefers to use coins that don't exceed mempool limits =====
485
486        # Get all non-zero utxos together and split into two chains
487        chain_addrs = [self.nodes[0].getnewaddress(), self.nodes[0].getnewaddress()]
488        self.nodes[0].sendall(recipients=chain_addrs)
489        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
490
491        # Make a long chain of unconfirmed payments without hitting mempool limit
492        # Each tx we make leaves only one output of change on a chain 1 longer
493        # Since the amount to send is always much less than the outputs, we only ever need one output
494        # So we should be able to generate exactly chainlimit txs for each original output
495        sending_addr = self.nodes[1].getnewaddress()
496        txid_list = []
497        for _ in range(chainlimit * 2):
498            txid_list.append(self.nodes[0].sendtoaddress(sending_addr, Decimal('0.0001')))
499        assert_equal(self.nodes[0].getmempoolinfo()['size'], chainlimit * 2)
500        assert_equal(len(txid_list), chainlimit * 2)