Inside Bitcoin

251
252    def createrawtransaction_tests(self):
253        self.log.info("Test createrawtransaction")
254        # Test `createrawtransaction` required parameters
255        assert_raises_rpc_error(-1, "createrawtransaction", self.nodes[0].createrawtransaction)
256        assert_raises_rpc_error(-1, "createrawtransaction", self.nodes[0].createrawtransaction, [])
257
258        # Test `createrawtransaction` invalid extra parameters
259        assert_raises_rpc_error(-1, "createrawtransaction", self.nodes[0].createrawtransaction, [], {}, 0, False, 2, 3, 'foo')
260
261        # Test `createrawtransaction` invalid version parameters
262        assert_raises_rpc_error(-8, f"Invalid parameter, version out of range({TX_MIN_STANDARD_VERSION}~{TX_MAX_STANDARD_VERSION})", self.nodes[0].createrawtransaction, [], {}, 0, False, TX_MIN_STANDARD_VERSION - 1)
263        assert_raises_rpc_error(-8, f"Invalid parameter, version out of range({TX_MIN_STANDARD_VERSION}~{TX_MAX_STANDARD_VERSION})", self.nodes[0].createrawtransaction, [], {}, 0, False, TX_MAX_STANDARD_VERSION + 1)
264
265        # Test `createrawtransaction` invalid `inputs`
266        assert_raises_rpc_error(-3, "JSON value of type string is not of expected type array", self.nodes[0].createrawtransaction, 'foo', {})
267        assert_raises_rpc_error(-3, "JSON value of type string is not of expected type object", self.nodes[0].createrawtransaction, ['foo'], {})
268        assert_raises_rpc_error(-3, "JSON value of type null is not of expected type string", self.nodes[0].createrawtransaction, [{}], {})
269        assert_raises_rpc_error(-8, "txid must be of length 64 (not 3, for 'foo')", self.nodes[0].createrawtransaction, [{'txid': 'foo'}], {})
270        txid = "ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844"
271        assert_raises_rpc_error(-8, f"txid must be hexadecimal string (not '{txid}')", self.nodes[0].createrawtransaction, [{'txid': txid}], {})
272        assert_raises_rpc_error(-8, "Invalid parameter, missing vout key", self.nodes[0].createrawtransaction, [{'txid': TXID}], {})
273        assert_raises_rpc_error(-8, "Invalid parameter, missing vout key", self.nodes[0].createrawtransaction, [{'txid': TXID, 'vout': 'foo'}], {})
274        assert_raises_rpc_error(-8, "Invalid parameter, vout cannot be negative", self.nodes[0].createrawtransaction, [{'txid': TXID, 'vout': -1}], {})
275        # sequence number out of range
276        for invalid_seq in [-1, 4294967296]:
277            inputs = [{'txid': TXID, 'vout': 1, 'sequence': invalid_seq}]
278            address = getnewdestination()[2]
279            outputs = {address: 1}
280            assert_raises_rpc_error(-8, 'Invalid parameter, sequence number is out of range',
281                                    self.nodes[0].createrawtransaction, inputs, outputs)
282        # with valid sequence number
283        for valid_seq in [1000, 4294967294]:
284            inputs = [{'txid': TXID, 'vout': 1, 'sequence': valid_seq}]
285            address = getnewdestination()[2]
286            outputs = {address: 1}
287            rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
288            decrawtx = self.nodes[0].decoderawtransaction(rawtx)
289            assert_equal(decrawtx['vin'][0]['sequence'], valid_seq)
290
291        # Test `createrawtransaction` invalid `outputs`
292        address = getnewdestination()[2]
293        assert_raises_rpc_error(-3, "JSON value of type string is not of expected type array", self.nodes[0].createrawtransaction, [], 'foo')
294        self.nodes[0].createrawtransaction(inputs=[], outputs={})  # Should not throw for backwards compatibility
295        self.nodes[0].createrawtransaction(inputs=[], outputs=[])
296        assert_raises_rpc_error(-8, "Data must be hexadecimal string", self.nodes[0].createrawtransaction, [], {'data': 'foo'})
297        assert_raises_rpc_error(-5, "Invalid Bitcoin address", self.nodes[0].createrawtransaction, [], {'foo': 0})
298        assert_raises_rpc_error(-3, "Invalid amount", self.nodes[0].createrawtransaction, [], {address: 'foo'})
299        assert_raises_rpc_error(-3, "Amount out of range", self.nodes[0].createrawtransaction, [], {address: -1})
300        assert_raises_rpc_error(-8, "Invalid parameter, duplicated address: %s" % address, self.nodes[0].createrawtransaction, [], multidict([(address, 1), (address, 1)]))
301        assert_raises_rpc_error(-8, "Invalid parameter, duplicated address: %s" % address, self.nodes[0].createrawtransaction, [], [{address: 1}, {address: 1}])
302        assert_raises_rpc_error(-8, "Invalid parameter, duplicate key: data", self.nodes[0].createrawtransaction, [], [{"data": 'aa'}, {"data": "bb"}])
303        assert_raises_rpc_error(-8, "Invalid parameter, duplicate key: data", self.nodes[0].createrawtransaction, [], multidict([("data", 'aa'), ("data", "bb")]))
304        assert_raises_rpc_error(-8, "Invalid parameter, key-value pair must contain exactly one key", self.nodes[0].createrawtransaction, [], [{'a': 1, 'b': 2}])
305        assert_raises_rpc_error(-8, "Invalid parameter, key-value pair not an object as expected", self.nodes[0].createrawtransaction, [], [['key-value pair1'], ['2']])
306
307        # Test `createrawtransaction` mismatch between sequence number(s) and `replaceable` option
308        assert_raises_rpc_error(-8, "Invalid parameter combination: Sequence number(s) contradict replaceable option",
309                                self.nodes[0].createrawtransaction, [{'txid': TXID, 'vout': 0, 'sequence': MAX_BIP125_RBF_SEQUENCE+1}], {}, 0, True)
310
311        # Test `createrawtransaction` invalid `locktime`
312        assert_raises_rpc_error(-3, "JSON value of type string is not of expected type number", self.nodes[0].createrawtransaction, [], {}, 'foo')
313        assert_raises_rpc_error(-8, "Invalid parameter, locktime out of range", self.nodes[0].createrawtransaction, [], {}, -1)
314        assert_raises_rpc_error(-8, "Invalid parameter, locktime out of range", self.nodes[0].createrawtransaction, [], {}, 4294967296)
315
316        # Test `createrawtransaction` invalid `replaceable`
317        assert_raises_rpc_error(-3, "JSON value of type string is not of expected type bool", self.nodes[0].createrawtransaction, [], {}, 0, 'foo')
318
319        # Test that createrawtransaction accepts an array and object as outputs
320        # One output
321        tx = tx_from_hex(self.nodes[2].createrawtransaction(inputs=[{'txid': TXID, 'vout': 9}], outputs={address: 99}))
322        assert_equal(len(tx.vout), 1)
323        assert_equal(
324            tx.serialize().hex(),
325            self.nodes[2].createrawtransaction(inputs=[{'txid': TXID, 'vout': 9}], outputs=[{address: 99}]),
326        )
327        # Two outputs
328        address2 = getnewdestination()[2]
329        tx = tx_from_hex(self.nodes[2].createrawtransaction(inputs=[{'txid': TXID, 'vout': 9}], outputs=OrderedDict([(address, 99), (address2, 99)])))
330        assert_equal(len(tx.vout), 2)
331        assert_equal(
332            tx.serialize().hex(),
333            self.nodes[2].createrawtransaction(inputs=[{'txid': TXID, 'vout': 9}], outputs=[{address: 99}, {address2: 99}]),
334        )
335        # Multiple mixed outputs
336        tx = tx_from_hex(self.nodes[2].createrawtransaction(inputs=[{'txid': TXID, 'vout': 9}], outputs=multidict([(address, 99), (address2, 99), ('data', '99')])))
337        assert_equal(len(tx.vout), 3)
338        assert_equal(
339            tx.serialize().hex(),
340            self.nodes[2].createrawtransaction(inputs=[{'txid': TXID, 'vout': 9}], outputs=[{address: 99}, {address2: 99}, {'data': '99'}]),
341        )
342
343        for version in range(TX_MIN_STANDARD_VERSION, TX_MAX_STANDARD_VERSION + 1):
344            rawtx = self.nodes[2].createrawtransaction(inputs=[{'txid': TXID, 'vout': 9}], outputs=OrderedDict([(address, 99), (address2, 99)]), version=version)
345            tx = tx_from_hex(rawtx)
346            assert_equal(tx.version, version)
347
348    def sendrawtransaction_tests(self):
349        self.log.info("Test sendrawtransaction with missing input")
350        inputs = [{'txid': TXID, 'vout': 1}]  # won't exist
351        address = getnewdestination()[2]
352        outputs = {address: 4.998}
353        rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
354        assert_raises_rpc_error(-25, "bad-txns-inputs-missingorspent", self.nodes[2].sendrawtransaction, rawtx)
355
356        self.log.info("Test sendrawtransaction exceeding, falling short of, and equaling maxburnamount")
357        max_burn_exceeded = "Unspendable output exceeds maximum configured by user (maxburnamount)"
358
359
360        # Test that spendable transaction with default maxburnamount (0) gets sent
361        tx = self.wallet.create_self_transfer()['tx']
362        tx_hex = tx.serialize().hex()
363        self.nodes[2].sendrawtransaction(hexstring=tx_hex)
364
365        # Test that datacarrier transaction with default maxburnamount (0) does not get sent
366        tx = self.wallet.create_self_transfer()['tx']
367        tx_val = 0.001
368        tx.vout = [CTxOut(int(Decimal(tx_val) * COIN), CScript([OP_RETURN] + [OP_FALSE] * 30))]
369        tx_hex = tx.serialize().hex()
370        assert_raises_rpc_error(-25, max_burn_exceeded, self.nodes[2].sendrawtransaction, tx_hex)
371
372        # Test that oversized script gets rejected by sendrawtransaction
373        tx = self.wallet.create_self_transfer()['tx']
374        tx_val = 0.001
375        tx.vout = [CTxOut(int(Decimal(tx_val) * COIN), CScript([OP_FALSE] * 10001))]
376        tx_hex = tx.serialize().hex()
377        assert_raises_rpc_error(-25, max_burn_exceeded, self.nodes[2].sendrawtransaction, tx_hex)
378
379        # Test that script containing invalid opcode gets rejected by sendrawtransaction
380        tx = self.wallet.create_self_transfer()['tx']
381        tx_val = 0.01
382        tx.vout = [CTxOut(int(Decimal(tx_val) * COIN), CScript([OP_INVALIDOPCODE]))]
383        tx_hex = tx.serialize().hex()
384        assert_raises_rpc_error(-25, max_burn_exceeded, self.nodes[2].sendrawtransaction, tx_hex)
385
386        # Test a transaction where our burn exceeds maxburnamount
387        tx = self.wallet.create_self_transfer()['tx']
388        tx_val = 0.001
389        tx.vout = [CTxOut(int(Decimal(tx_val) * COIN), CScript([OP_RETURN] + [OP_FALSE] * 30))]
390        tx_hex = tx.serialize().hex()
391        assert_raises_rpc_error(-25, max_burn_exceeded, self.nodes[2].sendrawtransaction, tx_hex, 0, 0.0009)
392
393        # Test a transaction where our burn falls short of maxburnamount
394        tx = self.wallet.create_self_transfer()['tx']
395        tx_val = 0.001
396        tx.vout = [CTxOut(int(Decimal(tx_val) * COIN), CScript([OP_RETURN] + [OP_FALSE] * 30))]
397        tx_hex = tx.serialize().hex()
398        self.nodes[2].sendrawtransaction(hexstring=tx_hex, maxfeerate='0', maxburnamount='0.0011')
399
400        # Test a transaction where our burn equals maxburnamount
401        tx = self.wallet.create_self_transfer()['tx']
402        tx_val = 0.001
403        tx.vout = [CTxOut(int(Decimal(tx_val) * COIN), CScript([OP_RETURN] + [OP_FALSE] * 30))]
404        tx_hex = tx.serialize().hex()
405        self.nodes[2].sendrawtransaction(hexstring=tx_hex, maxfeerate='0', maxburnamount='0.001')
406
407    def sendrawtransaction_testmempoolaccept_tests(self):
408        self.log.info("Test sendrawtransaction/testmempoolaccept with maxfeerate")
409        fee_exceeds_max = "Fee exceeds maximum configured by user (e.g. -maxtxfee, maxfeerate)"
410
411        # Test a transaction with a small fee.
412        # Fee rate is 0.00100000 BTC/kvB
413        tx = self.wallet.create_self_transfer(fee_rate=Decimal('0.00100000'))
414        # Thus, testmempoolaccept should reject
415        testres = self.nodes[2].testmempoolaccept([tx['hex']], 0.00001000)[0]
416        assert_equal(testres['allowed'], False)
417        assert_equal(testres['reject-reason'], 'max-fee-exceeded')
418        # and sendrawtransaction should throw
419        assert_raises_rpc_error(-25, fee_exceeds_max, self.nodes[2].sendrawtransaction, tx['hex'], 0.00001000)
420        # and the following calls should both succeed
421        testres = self.nodes[2].testmempoolaccept(rawtxs=[tx['hex']])[0]
422        assert_equal(testres['allowed'], True)
423        self.nodes[2].sendrawtransaction(hexstring=tx['hex'])
424
425        # Test a transaction with a large fee.
426        # Fee rate is 0.20000000 BTC/kvB
427        tx = self.wallet.create_self_transfer(fee_rate=Decimal("0.20000000"))
428        # Thus, testmempoolaccept should reject
429        testres = self.nodes[2].testmempoolaccept([tx['hex']])[0]
430        assert_equal(testres['allowed'], False)
431        assert_equal(testres['reject-reason'], 'max-fee-exceeded')
432        # and sendrawtransaction should throw
433        assert_raises_rpc_error(-25, fee_exceeds_max, self.nodes[2].sendrawtransaction, tx['hex'])
434        # and the following calls should both succeed
435        testres = self.nodes[2].testmempoolaccept(rawtxs=[tx['hex']], maxfeerate='0.20000000')[0]
436        assert_equal(testres['allowed'], True)
437        self.nodes[2].sendrawtransaction(hexstring=tx['hex'], maxfeerate='0.20000000')
438
439        self.log.info("Test sendrawtransaction/testmempoolaccept with tx outputs already in the utxo set")
440        self.generate(self.nodes[2], 1)
441        for node in self.nodes:
442            testres = node.testmempoolaccept([tx['hex']])[0]
443            assert_equal(testres['allowed'], False)
444            assert_equal(testres['reject-reason'], 'txn-already-known')
445            assert_raises_rpc_error(-27, 'Transaction outputs already in utxo set', node.sendrawtransaction, tx['hex'])
446
447    def decoderawtransaction_tests(self):
448        self.log.info("Test decoderawtransaction")
449        # witness transaction
450        encrawtx = "010000000001010000000000000072c1a6a246ae63f74f931e8365e15a089c68d61900000000000000000000ffffffff0100e1f50500000000000102616100000000"
451        decrawtx = self.nodes[0].decoderawtransaction(encrawtx, True)  # decode as witness transaction
452        assert_equal(decrawtx['vout'][0]['value'], Decimal('1.00000000'))
453        assert_raises_rpc_error(-22, 'TX decode failed', self.nodes[0].decoderawtransaction, encrawtx, False) # force decode as non-witness transaction
454        # non-witness transaction
455        encrawtx = "01000000010000000000000072c1a6a246ae63f74f931e8365e15a089c68d61900000000000000000000ffffffff0100e1f505000000000000000000"
456        decrawtx = self.nodes[0].decoderawtransaction(encrawtx, False)  # decode as non-witness transaction
457        assert_equal(decrawtx['vout'][0]['value'], Decimal('1.00000000'))
458        # known ambiguous transaction in the chain (see https://github.com/bitcoin/bitcoin/issues/20579)
459        coinbase = "03c68708046ff8415c622f4254432e434f4d2ffabe6d6de1965d02c68f928e5b244ab1965115a36f56eb997633c7f690124bbf43644e23080000000ca3d3af6d005a65ff0200fd00000000"
460        encrawtx = f"020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff4b{coinbase}" \
461                   "ffffffff03f4c1fb4b0000000016001497cfc76442fe717f2a3f0cc9c175f7561b6619970000000000000000266a24aa21a9ed957d1036a80343e0d1b659497e1b48a38ebe876a056d45965fac4a85cda84e1900000000000000002952534b424c4f434b3a8e092581ab01986cbadc84f4b43f4fa4bb9e7a2e2a0caf9b7cf64d939028e22c0120000000000000000000000000000000000000000000000000000000000000000000000000"
462        decrawtx = self.nodes[0].decoderawtransaction(encrawtx)
463        decrawtx_wit = self.nodes[0].decoderawtransaction(encrawtx, True)
464        assert_raises_rpc_error(-22, 'TX decode failed', self.nodes[0].decoderawtransaction, encrawtx, False)  # fails to decode as non-witness transaction
465        assert_equal(decrawtx, decrawtx_wit)  # the witness interpretation should be chosen
466        assert_equal(decrawtx['vin'][0]['coinbase'], coinbase)
467
468    def transaction_version_number_tests(self):
469        self.log.info("Test transaction version numbers")
470
471        # Test the minimum transaction version number that fits in a signed 32-bit integer.
472        # As transaction version is serialized unsigned, this should convert to its unsigned equivalent.
473        tx = CTransaction()
474        tx.version = 0x80000000
475        rawtx = tx.serialize().hex()
476        decrawtx = self.nodes[0].decoderawtransaction(rawtx)
477        assert_equal(decrawtx['version'], 0x80000000)
478
479        # Test the maximum transaction version number that fits in a signed 32-bit integer.
480        tx = CTransaction()
481        tx.version = 0x7fffffff
482        rawtx = tx.serialize().hex()
483        decrawtx = self.nodes[0].decoderawtransaction(rawtx)
484        assert_equal(decrawtx['version'], 0x7fffffff)
485
486        # Test the minimum transaction version number that fits in an unsigned 32-bit integer.
487        tx = CTransaction()
488        tx.version = 0
489        rawtx = tx.serialize().hex()
490        decrawtx = self.nodes[0].decoderawtransaction(rawtx)
491        assert_equal(decrawtx['version'], 0)
492
493        # Test the maximum transaction version number that fits in an unsigned 32-bit integer.
494        tx = CTransaction()
495        tx.version = 0xffffffff
496        rawtx = tx.serialize().hex()
497        decrawtx = self.nodes[0].decoderawtransaction(rawtx)
498        assert_equal(decrawtx['version'], 0xffffffff)
499
500if __name__ == '__main__':