Inside Bitcoin

751
752        self.nodes[3].loadwallet('wwatch')
753        wwatch = self.nodes[3].get_wallet_rpc('wwatch')
754        # Setup change addresses for the watchonly wallet
755        desc_import = [{
756            "desc": descsum_create("wpkh(tpubD6NzVbkrYhZ4YNXVQbNhMK1WqguFsUXceaVJKbmno2aZ3B6QfbMeraaYvnBSGpV3vxLyTTK9DYT1yoEck4XUScMzXoQ2U2oSmE2JyMedq3H/1/*)"),
757            "timestamp": "now",
758            "internal": True,
759            "active": True,
760            "keypool": True,
761            "range": [0, 100],
762            "watchonly": True,
763        }]
764        wwatch.importdescriptors(desc_import)
765
766        result = wwatch.fundrawtransaction(rawtx)
767        res_dec = self.nodes[0].decoderawtransaction(result["hex"])
768        assert_equal(len(res_dec["vin"]), 1)
769        assert_equal(res_dec["vin"][0]["txid"], self.watchonly_utxo['txid'])
770
771        assert "fee" in result.keys()
772        assert_greater_than(result["changepos"], -1)
773
774        wwatch.unloadwallet()
775
776    def test_all_watched_funds(self):
777        self.log.info("Test fundrawtxn using entirety of watched funds")
778
779        inputs = []
780        outputs = {self.nodes[2].getnewaddress(): self.watchonly_amount}
781        rawtx = self.nodes[3].createrawtransaction(inputs, outputs)
782
783        self.nodes[3].loadwallet('wwatch')
784        wwatch = self.nodes[3].get_wallet_rpc('wwatch')
785        w3 = self.nodes[3].get_wallet_rpc(self.default_wallet_name)
786        result = wwatch.fundrawtransaction(rawtx, changeAddress=w3.getrawchangeaddress(), subtractFeeFromOutputs=[0])
787        res_dec = self.nodes[0].decoderawtransaction(result["hex"])
788        assert_equal(len(res_dec["vin"]), 1)
789        assert_equal(res_dec["vin"][0]["txid"], self.watchonly_utxo['txid'])
790
791        assert_greater_than(result["fee"], 0)
792        assert_equal(result["changepos"], -1)
793        assert_equal(result["fee"] + res_dec["vout"][0]["value"], self.watchonly_amount)
794
795        signedtx = wwatch.signrawtransactionwithwallet(result["hex"])
796        assert not signedtx["complete"]
797        signedtx = self.nodes[0].signrawtransactionwithwallet(signedtx["hex"])
798        assert signedtx["complete"]
799        self.nodes[0].sendrawtransaction(signedtx["hex"])
800        self.generate(self.nodes[0], 1)
801
802        wwatch.unloadwallet()
803
804    def test_option_feerate(self):
805        self.log.info("Test fundrawtxn with explicit fee rates (fee_rate sat/vB and feeRate BTC/kvB)")
806        node = self.nodes[3]
807        # Make sure there is exactly one input so coin selection can't skew the result.
808        assert_equal(len(self.nodes[3].listunspent(1)), 1)
809        inputs = []
810        outputs = {node.getnewaddress() : 1}
811        rawtx = node.createrawtransaction(inputs, outputs)
812
813        result = node.fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)  # uses self.min_relay_tx_fee (set by fee_rate in sat/vB)
814        btc_kvb_to_sat_vb = 100000  # (1e5)
815        result1 = node.fundrawtransaction(rawtx, fee_rate=str(2 * btc_kvb_to_sat_vb * self.min_relay_tx_fee))
816        result2 = node.fundrawtransaction(rawtx, feeRate=2 * self.min_relay_tx_fee)
817        result3 = node.fundrawtransaction(rawtx, fee_rate=10 * btc_kvb_to_sat_vb * self.min_relay_tx_fee)
818        result4 = node.fundrawtransaction(rawtx, feeRate=str(10 * self.min_relay_tx_fee))
819
820        result_fee_rate = result['fee'] * 1000 / count_bytes(result['hex'])
821        assert_fee_amount(result1['fee'], count_bytes(result1['hex']), 2 * result_fee_rate)
822        assert_fee_amount(result2['fee'], count_bytes(result2['hex']), 2 * result_fee_rate)
823        assert_fee_amount(result3['fee'], count_bytes(result3['hex']), 10 * result_fee_rate)
824        assert_fee_amount(result4['fee'], count_bytes(result4['hex']), 10 * result_fee_rate)
825
826        # Test that funding non-standard "zero-fee" transactions is valid.
827        for param, zero_value in product(["fee_rate", "feeRate"], [0, 0.000, 0.00000000, "0", "0.000", "0.00000000"]):
828            assert_equal(self.nodes[3].fundrawtransaction(rawtx, {param: zero_value})["fee"], 0)
829
830        # With no arguments passed, expect fee of 141 satoshis.
831        assert_approx(node.fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)["fee"], vexp=0.00000141, vspan=0.00000001)
832        # Expect fee to be 10,000x higher when an explicit fee rate 10,000x greater is specified.
833        result = node.fundrawtransaction(rawtx, fee_rate=10000)
834        assert_approx(result["fee"], vexp=0.0141, vspan=0.0001)
835
836        self.log.info("Test fundrawtxn with invalid estimate_mode settings")
837        for k, v in {"number": 42, "object": {"foo": "bar"}}.items():
838            assert_raises_rpc_error(-3, f"JSON value of type {k} for field estimate_mode is not of expected type string",
839                node.fundrawtransaction, rawtx, estimate_mode=v, conf_target=0.1, add_inputs=True)
840        for mode in ["", "foo", Decimal("3.141592")]:
841            assert_raises_rpc_error(-8, 'Invalid estimate_mode parameter, must be one of: "unset", "economical", "conservative"',
842                node.fundrawtransaction, rawtx, estimate_mode=mode, conf_target=0.1, add_inputs=True)
843
844        self.log.info("Test fundrawtxn with invalid conf_target settings")
845        for mode in ["unset", "economical", "conservative"]:
846            self.log.debug("{}".format(mode))
847            for k, v in {"string": "", "object": {"foo": "bar"}}.items():
848                assert_raises_rpc_error(-3, f"JSON value of type {k} for field conf_target is not of expected type number",
849                    node.fundrawtransaction, rawtx, estimate_mode=mode, conf_target=v, add_inputs=True)
850            for n in [-1, 0, 1009]:
851                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
852                    node.fundrawtransaction, rawtx, estimate_mode=mode, conf_target=n, add_inputs=True)
853
854        self.log.info("Test invalid fee rate settings")
855        for param, value in {("fee_rate", 100000), ("feeRate", 1.000)}:
856            assert_raises_rpc_error(-4, "Fee exceeds maximum configured by user (e.g. -maxtxfee, maxfeerate)",
857                node.fundrawtransaction, rawtx, add_inputs=True, **{param: value})
858            assert_raises_rpc_error(-3, "Amount out of range",
859                node.fundrawtransaction, rawtx, add_inputs=True, **{param: -1})
860            assert_raises_rpc_error(-3, "Amount is not a number or string",
861                node.fundrawtransaction, rawtx, add_inputs=True, **{param: {"foo": "bar"}})
862            # Test fee rate values that don't pass fixed-point parsing checks.
863            for invalid_value in ["", 0.000000001, 1e-09, 1.111111111, 1111111111111111, "31.999999999999999999999"]:
864                assert_raises_rpc_error(-3, "Invalid amount", node.fundrawtransaction, rawtx, add_inputs=True, **{param: invalid_value})
865        # Test fee_rate values that cannot be represented in sat/vB.
866        for invalid_value in [0.0001, 0.00000001, 0.00099999, 31.99999999]:
867            assert_raises_rpc_error(-3, "Invalid amount",
868                node.fundrawtransaction, rawtx, fee_rate=invalid_value, add_inputs=True)
869
870        self.log.info("Test min fee rate checks are bypassed with fundrawtxn, e.g. a fee_rate under 1 sat/vB is allowed")
871        node.fundrawtransaction(rawtx, fee_rate=0.999, add_inputs=True)
872        node.fundrawtransaction(rawtx, feeRate=0.00000999, add_inputs=True)
873
874        self.log.info("- raises RPC error if both feeRate and fee_rate are passed")
875        assert_raises_rpc_error(-8, "Cannot specify both fee_rate (sat/vB) and feeRate (BTC/kvB)",
876            node.fundrawtransaction, rawtx, fee_rate=0.1, feeRate=0.1, add_inputs=True)
877
878        self.log.info("- raises RPC error if both feeRate and estimate_mode passed")
879        assert_raises_rpc_error(-8, "Cannot specify both estimate_mode and feeRate",
880            node.fundrawtransaction, rawtx, estimate_mode="economical", feeRate=0.1, add_inputs=True)
881
882        for param in ["feeRate", "fee_rate"]:
883            self.log.info("- raises RPC error if both {} and conf_target are passed".format(param))
884            assert_raises_rpc_error(-8, "Cannot specify both conf_target and {}. Please provide either a confirmation "
885                "target in blocks for automatic fee estimation, or an explicit fee rate.".format(param),
886                node.fundrawtransaction, rawtx, {param: 1, "conf_target": 1, "add_inputs": True})
887
888        self.log.info("- raises RPC error if both fee_rate and estimate_mode are passed")
889        assert_raises_rpc_error(-8, "Cannot specify both estimate_mode and fee_rate",
890            node.fundrawtransaction, rawtx, fee_rate=1, estimate_mode="economical", add_inputs=True)
891
892    def test_address_reuse(self):
893        """Test no address reuse occurs."""
894        self.log.info("Test fundrawtxn does not reuse addresses")
895
896        rawtx = self.nodes[3].createrawtransaction(inputs=[], outputs={self.nodes[3].getnewaddress(): 1})
897        result3 = self.nodes[3].fundrawtransaction(rawtx)
898        res_dec = self.nodes[0].decoderawtransaction(result3["hex"])
899        changeaddress = ""
900        for out in res_dec['vout']:
901            if out['value'] > 1.0:
902                changeaddress += out['scriptPubKey']['address']
903        assert_not_equal(changeaddress, "")
904        nextaddr = self.nodes[3].getnewaddress()
905        # Now the change address key should be removed from the keypool.
906        assert_not_equal(changeaddress, nextaddr)
907
908    def test_option_subtract_fee_from_outputs(self):
909        self.log.info("Test fundrawtxn subtractFeeFromOutputs option")
910
911        # Make sure there is exactly one input so coin selection can't skew the result.
912        assert_equal(len(self.nodes[3].listunspent(1)), 1)
913
914        inputs = []
915        outputs = {self.nodes[2].getnewaddress(): 1}
916        rawtx = self.nodes[3].createrawtransaction(inputs, outputs)
917
918        # Test subtract fee from outputs with feeRate (BTC/kvB)
919        result = [self.nodes[3].fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb),
920            self.nodes[3].fundrawtransaction(rawtx, subtractFeeFromOutputs=[], fee_rate=self.fee_rate_sats_per_vb),  # empty subtraction list
921            self.nodes[3].fundrawtransaction(rawtx, subtractFeeFromOutputs=[0], fee_rate=self.fee_rate_sats_per_vb), # uses self.min_relay_tx_fee (set by fee_rate in sat/vB)
922            self.nodes[3].fundrawtransaction(rawtx, feeRate=2 * self.min_relay_tx_fee),
923            self.nodes[3].fundrawtransaction(rawtx, feeRate=2 * self.min_relay_tx_fee, subtractFeeFromOutputs=[0]),]
924        dec_tx = [self.nodes[3].decoderawtransaction(tx_['hex']) for tx_ in result]
925        output = [d['vout'][1 - r['changepos']]['value'] for d, r in zip(dec_tx, result)]
926        change = [d['vout'][r['changepos']]['value'] for d, r in zip(dec_tx, result)]
927
928        assert_equal(result[0]['fee'], result[1]['fee'], result[2]['fee'])
929        assert_equal(result[3]['fee'], result[4]['fee'])
930        assert_equal(change[0], change[1])
931        assert_equal(output[0], output[1])
932        assert_equal(output[0], output[2] + result[2]['fee'])
933        assert_equal(change[0] + result[0]['fee'], change[2])
934        assert_equal(output[3], output[4] + result[4]['fee'])
935        assert_equal(change[3] + result[3]['fee'], change[4])
936
937        # Test subtract fee from outputs with fee_rate (sat/vB)
938        btc_kvb_to_sat_vb = 100000  # (1e5)
939        result = [self.nodes[3].fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb),  # uses self.min_relay_tx_fee (set by fee_rate in sat/vB)
940            self.nodes[3].fundrawtransaction(rawtx, subtractFeeFromOutputs=[], fee_rate=self.fee_rate_sats_per_vb),  # empty subtraction list
941            self.nodes[3].fundrawtransaction(rawtx, subtractFeeFromOutputs=[0], fee_rate=self.fee_rate_sats_per_vb),  # uses self.min_relay_tx_fee (set by fee_rate in sat/vB)
942            self.nodes[3].fundrawtransaction(rawtx, fee_rate=2 * btc_kvb_to_sat_vb * self.min_relay_tx_fee),
943            self.nodes[3].fundrawtransaction(rawtx, fee_rate=2 * btc_kvb_to_sat_vb * self.min_relay_tx_fee, subtractFeeFromOutputs=[0]),]
944        dec_tx = [self.nodes[3].decoderawtransaction(tx_['hex']) for tx_ in result]
945        output = [d['vout'][1 - r['changepos']]['value'] for d, r in zip(dec_tx, result)]
946        change = [d['vout'][r['changepos']]['value'] for d, r in zip(dec_tx, result)]
947
948        assert_equal(result[0]['fee'], result[1]['fee'], result[2]['fee'])
949        assert_equal(result[3]['fee'], result[4]['fee'])
950        assert_equal(change[0], change[1])
951        assert_equal(output[0], output[1])
952        assert_equal(output[0], output[2] + result[2]['fee'])
953        assert_equal(change[0] + result[0]['fee'], change[2])
954        assert_equal(output[3], output[4] + result[4]['fee'])
955        assert_equal(change[3] + result[3]['fee'], change[4])
956
957        inputs = []
958        outputs = {self.nodes[2].getnewaddress(): value for value in (1.0, 1.1, 1.2, 1.3)}
959        rawtx = self.nodes[3].createrawtransaction(inputs, outputs)
960
961        result = [self.nodes[3].fundrawtransaction(rawtx),
962                  # Split the fee between outputs 0, 2, and 3, but not output 1.
963                  self.nodes[3].fundrawtransaction(rawtx, subtractFeeFromOutputs=[0, 2, 3])]
964
965        dec_tx = [self.nodes[3].decoderawtransaction(result[0]['hex']),
966                  self.nodes[3].decoderawtransaction(result[1]['hex'])]
967
968        # Nested list of non-change output amounts for each transaction.
969        output = [[out['value'] for i, out in enumerate(d['vout']) if i != r['changepos']]
970                  for d, r in zip(dec_tx, result)]
971
972        # List of differences in output amounts between normal and subtractFee transactions.
973        share = [o0 - o1 for o0, o1 in zip(output[0], output[1])]
974
975        # Output 1 is the same in both transactions.
976        assert_equal(share[1], 0)
977
978        # The other 3 outputs are smaller as a result of subtractFeeFromOutputs.
979        assert_greater_than(share[0], 0)
980        assert_greater_than(share[2], 0)
981        assert_greater_than(share[3], 0)
982
983        # Outputs 2 and 3 take the same share of the fee.
984        assert_equal(share[2], share[3])
985
986        # Output 0 takes at least as much share of the fee, and no more than 2
987        # satoshis more, than outputs 2 and 3.
988        assert_greater_than_or_equal(share[0], share[2])
989        assert_greater_than_or_equal(share[2] + Decimal(2e-8), share[0])
990
991        # The fee is the same in both transactions.
992        assert_equal(result[0]['fee'], result[1]['fee'])
993
994        # The total subtracted from the outputs is equal to the fee.
995        assert_equal(share[0] + share[2] + share[3], result[0]['fee'])
996
997    def test_subtract_fee_with_presets(self):
998        self.log.info("Test fundrawtxn subtract fee from outputs with preset inputs that are sufficient")
999
1000        addr = self.nodes[0].getnewaddress()