Inside Bitcoin

251        inputs  = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
252        outputs = { self.nodes[0].getnewaddress() : 1.0 }
253        rawtx   = self.nodes[2].createrawtransaction(inputs, outputs)
254        dec_tx  = self.nodes[2].decoderawtransaction(rawtx)
255        assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
256
257        rawtxfund = self.nodes[2].fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)
258        fee = rawtxfund['fee']
259        self.test_no_change_fee = fee  # Use the same fee for the next tx
260        dec_tx  = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
261        totalOut = 0
262        for out in dec_tx['vout']:
263            totalOut += out['value']
264
265        assert_equal(fee + totalOut, utx['amount']) #compare vin total and totalout+fee
266
267    def test_no_change(self):
268        self.log.info("Test fundrawtxn not having a change output")
269        utx = get_unspent(self.nodes[2].listunspent(), 5)
270
271        inputs  = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
272        outputs = {self.nodes[0].getnewaddress(): Decimal(5.0) - self.test_no_change_fee - self.fee_tolerance}
273        rawtx   = self.nodes[2].createrawtransaction(inputs, outputs)
274        dec_tx  = self.nodes[2].decoderawtransaction(rawtx)
275        assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
276
277        rawtxfund = self.nodes[2].fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)
278        fee = rawtxfund['fee']
279        dec_tx  = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
280        totalOut = 0
281        for out in dec_tx['vout']:
282            totalOut += out['value']
283
284        assert_equal(rawtxfund['changepos'], -1)
285        assert_equal(fee + totalOut, utx['amount']) #compare vin total and totalout+fee
286
287    def test_invalid_option(self):
288        self.log.info("Test fundrawtxn with an invalid option")
289        utx = get_unspent(self.nodes[2].listunspent(), 5)
290
291        inputs  = [ {'txid' : utx['txid'], 'vout' : utx['vout']} ]
292        outputs = { self.nodes[0].getnewaddress() : Decimal(4.0) }
293        rawtx   = self.nodes[2].createrawtransaction(inputs, outputs)
294        dec_tx  = self.nodes[2].decoderawtransaction(rawtx)
295        assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
296
297        assert_raises_rpc_error(-8, "Unknown named parameter foo", self.nodes[2].fundrawtransaction, rawtx, foo='bar')
298        assert_raises_rpc_error(-3, "JSON value of type bool is not of expected type object", self.nodes[2].fundrawtransaction, rawtx, True)
299
300        # reserveChangeKey was deprecated and is now removed
301        assert_raises_rpc_error(-8, "Unknown named parameter reserveChangeKey", lambda: self.nodes[2].fundrawtransaction(hexstring=rawtx, reserveChangeKey=True))
302
303    def test_invalid_change_address(self):
304        self.log.info("Test fundrawtxn with an invalid change address")
305        utx = get_unspent(self.nodes[2].listunspent(), 5)
306
307        inputs  = [ {'txid' : utx['txid'], 'vout' : utx['vout']} ]
308        outputs = { self.nodes[0].getnewaddress() : Decimal(4.0) }
309        rawtx   = self.nodes[2].createrawtransaction(inputs, outputs)
310        dec_tx  = self.nodes[2].decoderawtransaction(rawtx)
311        assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
312
313        assert_raises_rpc_error(-5, "Change address must be a valid bitcoin address", self.nodes[2].fundrawtransaction, rawtx, changeAddress='foobar')
314
315    def test_valid_change_address(self):
316        self.log.info("Test fundrawtxn with a provided change address")
317        utx = get_unspent(self.nodes[2].listunspent(), 5)
318
319        inputs  = [ {'txid' : utx['txid'], 'vout' : utx['vout']} ]
320        outputs = { self.nodes[0].getnewaddress() : Decimal(4.0) }
321        rawtx   = self.nodes[2].createrawtransaction(inputs, outputs)
322        dec_tx  = self.nodes[2].decoderawtransaction(rawtx)
323        assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
324
325        change = self.nodes[2].getnewaddress()
326        assert_raises_rpc_error(-8, "changePosition out of bounds", self.nodes[2].fundrawtransaction, rawtx, changeAddress=change, changePosition=2)
327        rawtxfund = self.nodes[2].fundrawtransaction(rawtx, changeAddress=change, changePosition=0, fee_rate=self.fee_rate_sats_per_vb)
328        dec_tx  = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
329        out = dec_tx['vout'][0]
330        assert_equal(change, out['scriptPubKey']['address'])
331
332    def test_change_type(self):
333        self.log.info("Test fundrawtxn with a provided change type")
334        utx = get_unspent(self.nodes[2].listunspent(), 5)
335
336        inputs  = [ {'txid' : utx['txid'], 'vout' : utx['vout']} ]
337        outputs = { self.nodes[0].getnewaddress() : Decimal(4.0) }
338        rawtx   = self.nodes[2].createrawtransaction(inputs, outputs)
339        assert_raises_rpc_error(-3, "JSON value of type null is not of expected type string", self.nodes[2].fundrawtransaction, rawtx, change_type=None)
340        assert_raises_rpc_error(-5, "Unknown change type ''", self.nodes[2].fundrawtransaction, rawtx, change_type='')
341        rawtx = self.nodes[2].fundrawtransaction(rawtx, change_type='bech32', fee_rate=self.fee_rate_sats_per_vb)
342        dec_tx = self.nodes[2].decoderawtransaction(rawtx['hex'])
343        assert_equal('witness_v0_keyhash', dec_tx['vout'][rawtx['changepos']]['scriptPubKey']['type'])
344
345    def test_coin_selection(self):
346        self.log.info("Test fundrawtxn with a vin < required amount")
347        utx = get_unspent(self.nodes[2].listunspent(), 1)
348
349        inputs  = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
350        outputs = { self.nodes[0].getnewaddress() : 1.0 }
351        rawtx   = self.nodes[2].createrawtransaction(inputs, outputs)
352
353        # 4-byte version + 1-byte vin count + 36-byte prevout then script_len
354        rawtx = rawtx[:82] + "0100" + rawtx[84:]
355
356        dec_tx  = self.nodes[2].decoderawtransaction(rawtx)
357        assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
358        assert_equal("00", dec_tx['vin'][0]['scriptSig']['hex'])
359
360        # Should fail without add_inputs:
361        assert_raises_rpc_error(-4, ERR_NOT_ENOUGH_PRESET_INPUTS, self.nodes[2].fundrawtransaction, rawtx, add_inputs=False)
362        # add_inputs is enabled by default
363        rawtxfund = self.nodes[2].fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)
364
365        dec_tx  = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
366        matchingOuts = 0
367        for i, out in enumerate(dec_tx['vout']):
368            if out['scriptPubKey']['address'] in outputs:
369                matchingOuts+=1
370            else:
371                assert_equal(i, rawtxfund['changepos'])
372
373        assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
374        assert_equal("00", dec_tx['vin'][0]['scriptSig']['hex'])
375
376        assert_equal(matchingOuts, 1)
377        assert_equal(len(dec_tx['vout']), 2)
378
379    def test_two_vin(self):
380        self.log.info("Test fundrawtxn with 2 vins")
381        utx = get_unspent(self.nodes[2].listunspent(), 1)
382        utx2 = get_unspent(self.nodes[2].listunspent(), 5)
383
384        inputs  = [ {'txid' : utx['txid'], 'vout' : utx['vout']},{'txid' : utx2['txid'], 'vout' : utx2['vout']} ]
385        outputs = { self.nodes[0].getnewaddress() : 6.0 }
386        rawtx   = self.nodes[2].createrawtransaction(inputs, outputs)
387        dec_tx  = self.nodes[2].decoderawtransaction(rawtx)
388        assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
389
390        # Should fail without add_inputs:
391        assert_raises_rpc_error(-4, ERR_NOT_ENOUGH_PRESET_INPUTS, self.nodes[2].fundrawtransaction, rawtx, add_inputs=False)
392        rawtxfund = self.nodes[2].fundrawtransaction(rawtx, add_inputs=True, fee_rate=self.fee_rate_sats_per_vb)
393        dec_tx  = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
394        matchingOuts = 0
395        for out in dec_tx['vout']:
396            if out['scriptPubKey']['address'] in outputs:
397                matchingOuts+=1
398
399        assert_equal(matchingOuts, 1)
400        assert_equal(len(dec_tx['vout']), 2)
401
402        matchingIns = 0
403        for vinOut in dec_tx['vin']:
404            for vinIn in inputs:
405                if vinIn['txid'] == vinOut['txid']:
406                    matchingIns+=1
407
408        assert_equal(matchingIns, 2) #we now must see two vins identical to vins given as params
409
410    def test_two_vin_two_vout(self):
411        self.log.info("Test fundrawtxn with 2 vins and 2 vouts")
412        utx = get_unspent(self.nodes[2].listunspent(), 1)
413        utx2 = get_unspent(self.nodes[2].listunspent(), 5)
414
415        inputs  = [ {'txid' : utx['txid'], 'vout' : utx['vout']},{'txid' : utx2['txid'], 'vout' : utx2['vout']} ]
416        outputs = { self.nodes[0].getnewaddress() : 6.0, self.nodes[0].getnewaddress() : 1.0 }
417        rawtx   = self.nodes[2].createrawtransaction(inputs, outputs)
418        dec_tx  = self.nodes[2].decoderawtransaction(rawtx)
419        assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
420
421        # Should fail without add_inputs:
422        assert_raises_rpc_error(-4, ERR_NOT_ENOUGH_PRESET_INPUTS, self.nodes[2].fundrawtransaction, rawtx, add_inputs=False)
423        rawtxfund = self.nodes[2].fundrawtransaction(rawtx, add_inputs=True, fee_rate=self.fee_rate_sats_per_vb)
424
425        dec_tx  = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
426        matchingOuts = 0
427        for out in dec_tx['vout']:
428            if out['scriptPubKey']['address'] in outputs:
429                matchingOuts+=1
430
431        assert_equal(matchingOuts, 2)
432        assert_equal(len(dec_tx['vout']), 3)
433
434    def test_invalid_input(self):
435        self.log.info("Test fundrawtxn with an invalid vin")
436        txid = "1c7f966dab21119bac53213a2bc7532bff1fa844c124fd750a7d0b1332440bd1"
437        vout = 0
438        inputs  = [ {'txid' : txid, 'vout' : vout} ] #invalid vin!
439        outputs = { self.nodes[0].getnewaddress() : 1.0}
440        rawtx   = self.nodes[2].createrawtransaction(inputs, outputs)
441        assert_raises_rpc_error(-4, "Unable to find UTXO for external input", self.nodes[2].fundrawtransaction, rawtx)
442
443    def test_fee_p2pkh(self):
444        """Compare fee of a standard pubkeyhash transaction."""
445        self.log.info("Test fundrawtxn p2pkh fee")
446        self.lock_outputs_type(self.nodes[0], "p2pkh")
447        inputs = []
448        outputs = {self.nodes[1].getnewaddress():1.1}
449        rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
450        fundedTx = self.nodes[0].fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)
451
452        # Create same transaction over sendtoaddress.
453        txId = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1.1, fee_rate=self.fee_rate_sats_per_vb)
454        signedFee = self.nodes[0].getmempoolentry(txId)['fees']['base']
455
456        # Compare fee.
457        feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
458        assert feeDelta >= 0 and feeDelta <= self.fee_tolerance
459
460        self.unlock_utxos(self.nodes[0])
461
462    def test_fee_p2pkh_multi_out(self):
463        """Compare fee of a standard pubkeyhash transaction with multiple outputs."""
464        self.log.info("Test fundrawtxn p2pkh fee with multiple outputs")
465        self.lock_outputs_type(self.nodes[0], "p2pkh")
466        inputs = []
467        outputs = {
468            self.nodes[1].getnewaddress():1.1,
469            self.nodes[1].getnewaddress():1.2,
470            self.nodes[1].getnewaddress():0.1,
471            self.nodes[1].getnewaddress():1.3,
472            self.nodes[1].getnewaddress():0.2,
473            self.nodes[1].getnewaddress():0.3,
474        }
475        rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
476        fundedTx = self.nodes[0].fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)
477
478        # Create same transaction over sendtoaddress.
479        txId = self.nodes[0].sendmany("", outputs, fee_rate=self.fee_rate_sats_per_vb)
480        signedFee = self.nodes[0].getmempoolentry(txId)['fees']['base']
481
482        # Compare fee.
483        feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
484        assert feeDelta >= 0 and feeDelta <= self.fee_tolerance
485
486        self.unlock_utxos(self.nodes[0])
487
488    def test_fee_p2sh(self):
489        """Compare fee of a 2-of-2 multisig p2sh transaction."""
490        self.lock_outputs_type(self.nodes[0], "p2pkh")
491        # Create 2-of-2 addr.
492        addr1 = self.nodes[1].getnewaddress()
493        addr2 = self.nodes[1].getnewaddress()
494
495        addr1Obj = self.nodes[1].getaddressinfo(addr1)
496        addr2Obj = self.nodes[1].getaddressinfo(addr2)
497
498        mSigObj = self.nodes[3].createmultisig(2, [addr1Obj['pubkey'], addr2Obj['pubkey']])['address']
499
500        inputs = []