Inside Bitcoin

251        self.log.info('A transaction with too large output value')
252        tx = tx_from_hex(raw_tx_reference)
253        tx.vout[0].nValue = MAX_MONEY + 1
254        self.check_mempool_result(
255            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'bad-txns-vout-toolarge'}],
256            rawtxs=[tx.serialize().hex()],
257        )
258
259        self.log.info('A transaction with too large sum of output values')
260        tx = tx_from_hex(raw_tx_reference)
261        tx.vout = [tx.vout[0]] * 2
262        tx.vout[0].nValue = MAX_MONEY
263        self.check_mempool_result(
264            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'bad-txns-txouttotal-toolarge'}],
265            rawtxs=[tx.serialize().hex()],
266        )
267
268        self.log.info('A transaction with duplicate inputs')
269        tx = tx_from_hex(raw_tx_reference)
270        tx.vin = [tx.vin[0]] * 2
271        self.check_mempool_result(
272            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'bad-txns-inputs-duplicate'}],
273            rawtxs=[tx.serialize().hex()],
274        )
275
276        self.log.info('A non-coinbase transaction with coinbase-like outpoint')
277        tx = tx_from_hex(raw_tx_reference)
278        tx.vin.append(CTxIn(COutPoint(hash=0, n=0xffffffff)))
279        self.check_mempool_result(
280            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'bad-txns-prevout-null'}],
281            rawtxs=[tx.serialize().hex()],
282        )
283
284        self.log.info('A coinbase transaction')
285        # Pick the input of the first tx we created, so it has to be a coinbase tx
286        sync_txindex(self, node)
287        raw_tx_coinbase_spent = node.getrawtransaction(txid=node.decoderawtransaction(hexstring=raw_tx_in_block)['vin'][0]['txid'])
288        tx = tx_from_hex(raw_tx_coinbase_spent)
289        self.check_mempool_result(
290            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'coinbase'}],
291            rawtxs=[tx.serialize().hex()],
292        )
293
294        self.log.info('Some nonstandard transactions')
295        tx = tx_from_hex(raw_tx_reference)
296        tx.version = 4  # A version currently non-standard
297        self.check_mempool_result(
298            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'version'}],
299            rawtxs=[tx.serialize().hex()],
300        )
301        tx = tx_from_hex(raw_tx_reference)
302        tx.vout[0].scriptPubKey = CScript([OP_0])  # Some non-standard script
303        self.check_mempool_result(
304            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'scriptpubkey'}],
305            rawtxs=[tx.serialize().hex()],
306        )
307        tx = tx_from_hex(raw_tx_reference)
308        _, pubkey = generate_keypair()
309        tx.vout[0].scriptPubKey = keys_to_multisig_script([pubkey] * 3, k=2)  # Some bare multisig script (2-of-3)
310        self.check_mempool_result(
311            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'bare-multisig'}],
312            rawtxs=[tx.serialize().hex()],
313        )
314        tx = tx_from_hex(raw_tx_reference)
315        tx.vin[0].scriptSig = CScript([OP_HASH160])  # Some not-pushonly scriptSig
316        self.check_mempool_result(
317            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'scriptsig-not-pushonly'}],
318            rawtxs=[tx.serialize().hex()],
319        )
320        tx = tx_from_hex(raw_tx_reference)
321        tx.vin[0].scriptSig = CScript([b'a' * 1648]) # Some too large scriptSig (>1650 bytes)
322        self.check_mempool_result(
323            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'scriptsig-size'}],
324            rawtxs=[tx.serialize().hex()],
325        )
326        tx = tx_from_hex(raw_tx_reference)
327        output_p2sh_burn = CTxOut(nValue=540, scriptPubKey=script_to_p2sh_script(b'burn'))
328        num_scripts = 100000 // len(output_p2sh_burn.serialize())  # Use enough outputs to make the tx too large for our policy
329        tx.vout = [output_p2sh_burn] * num_scripts
330        self.check_mempool_result(
331            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'tx-size'}],
332            rawtxs=[tx.serialize().hex()],
333        )
334        tx = tx_from_hex(raw_tx_reference)
335        tx.vout[0] = output_p2sh_burn
336        tx.vout[0].nValue -= 1  # Make output smaller, such that it is dust for our policy
337        self.check_mempool_result(
338            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'dust'}],
339            rawtxs=[tx.serialize().hex()],
340        )
341
342        # OP_RETURN followed by non-push
343        tx = tx_from_hex(raw_tx_reference)
344        tx.vout[0].scriptPubKey = CScript([OP_RETURN, OP_HASH160])
345        self.check_mempool_result(
346            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'scriptpubkey'}],
347            rawtxs=[tx.serialize().hex()],
348        )
349
350        # Multiple OP_RETURN and more than 83 bytes, even if over MAX_SCRIPT_ELEMENT_SIZE
351        # are standard since v30
352        tx = tx_from_hex(raw_tx_reference)
353        tx.vout.append(CTxOut(0, CScript([OP_RETURN, b'\xff'])))
354        tx.vout.append(CTxOut(0, CScript([OP_RETURN, b'\xff' * 50000])))
355
356        self.check_mempool_result(
357            result_expected=[{'txid': tx.txid_hex, 'allowed': True, 'vsize_adjusted': tx.get_vsize(), 'vsize': tx.get_vsize(), 'vsize_bip141': tx.get_vsize(), 'fees': {'base': Decimal('0.05')}}],
358            rawtxs=[tx.serialize().hex()],
359            maxfeerate=0
360        )
361
362        self.log.info("A transaction with several OP_RETURN outputs.")
363        tx = tx_from_hex(raw_tx_reference)
364        op_return_count = 42
365        tx.vout[0].nValue = int(tx.vout[0].nValue / op_return_count)
366        tx.vout[0].scriptPubKey = CScript([OP_RETURN, b'\xff'])
367        tx.vout = [tx.vout[0]] * op_return_count
368        self.check_mempool_result(
369            result_expected=[{"txid": tx.txid_hex, "allowed": True, "vsize_adjusted": tx.get_vsize(), "vsize": tx.get_vsize(), 'vsize_bip141': tx.get_vsize(), "fees": {"base": Decimal("0.05000026")}}],
370            rawtxs=[tx.serialize().hex()],
371        )
372
373        self.log.info("A transaction with an OP_RETURN output that bumps into the max standardness tx size.")
374        tx = tx_from_hex(raw_tx_reference)
375        tx.vout[0].scriptPubKey = CScript([OP_RETURN])
376        data_len = int(MAX_STANDARD_TX_WEIGHT / 4) - tx.get_vsize() - 5 - 4  # -5 for PUSHDATA4 and -4 for script size
377        tx.vout[0].scriptPubKey = CScript([OP_RETURN, b"\xff" * (data_len)])
378        assert_equal(tx.get_vsize(), int(MAX_STANDARD_TX_WEIGHT / 4))
379        self.check_mempool_result(
380            result_expected=[{"txid": tx.txid_hex, "allowed": True, "vsize_adjusted": tx.get_vsize(), "vsize": tx.get_vsize(), 'vsize_bip141': tx.get_vsize(), "fees": {"base": Decimal("0.1") - Decimal("0.05")}}],
381            rawtxs=[tx.serialize().hex()],
382        )
383        tx.vout[0].scriptPubKey = CScript([OP_RETURN, b"\xff" * (data_len + 1)])
384        assert_greater_than(tx.get_vsize(), int(MAX_STANDARD_TX_WEIGHT / 4))
385        self.check_mempool_result(
386            result_expected=[{"txid": tx.txid_hex, "allowed": False, "reject-reason": "tx-size"}],
387            rawtxs=[tx.serialize().hex()],
388        )
389
390        self.log.info('A timelocked transaction')
391        tx = tx_from_hex(raw_tx_reference)
392        tx.vin[0].nSequence -= 1  # Should be non-max, so locktime is not ignored
393        tx.nLockTime = node.getblockcount() + 1
394        self.check_mempool_result(
395            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'non-final'}],
396            rawtxs=[tx.serialize().hex()],
397        )
398
399        self.log.info('A transaction that is locked by BIP68 sequence logic')
400        tx = tx_from_hex(raw_tx_reference)
401        tx.vin[0].nSequence = 2  # We could include it in the second block mined from now, but not the very next one
402        self.check_mempool_result(
403            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'non-BIP68-final'}],
404            rawtxs=[tx.serialize().hex()],
405            maxfeerate=0,
406        )
407
408        # Prep for tiny-tx tests with wsh(OP_TRUE) output
409        seed_tx = self.wallet.send_to(from_node=node, scriptPubKey=script_to_p2wsh_script(CScript([OP_TRUE])), amount=COIN)
410        self.generate(node, 1)
411
412        self.log.info('A tiny transaction(in non-witness bytes) that is disallowed')
413        tx = CTransaction()
414        tx.vin.append(CTxIn(COutPoint(int(seed_tx["txid"], 16), seed_tx["sent_vout"]), b"", SEQUENCE_FINAL))
415        tx.wit.vtxinwit = [CTxInWitness()]
416        tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([OP_TRUE])]
417        tx.vout.append(CTxOut(0, CScript([OP_RETURN] + ([OP_0] * (MIN_PADDING - 2)))))
418        # Note it's only non-witness size that matters!
419        assert_equal(len(tx.serialize_without_witness()), 64)
420        assert_equal(MIN_STANDARD_TX_NONWITNESS_SIZE - 1, 64)
421        assert_greater_than(len(tx.serialize()), 64)
422
423        self.check_mempool_result(
424            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'tx-size-small'}],
425            rawtxs=[tx.serialize().hex()],
426            maxfeerate=0,
427        )
428
429        self.log.info('Minimally-small transaction(in non-witness bytes) that is allowed')
430        tx.vout[0] = CTxOut(COIN - 1000, DUMMY_MIN_OP_RETURN_SCRIPT)
431        assert_equal(len(tx.serialize_without_witness()), MIN_STANDARD_TX_NONWITNESS_SIZE)
432        self.check_mempool_result(
433            result_expected=[{'txid': tx.txid_hex, 'allowed': True, 'vsize_adjusted': tx.get_vsize(), 'vsize': tx.get_vsize(), 'vsize_bip141': tx.get_vsize(), 'fees': { 'base': Decimal('0.00001000')}}],
434            rawtxs=[tx.serialize().hex()],
435            maxfeerate=0,
436        )
437
438        self.log.info('OP_1 <0x4e73> is able to be created and spent')
439        anchor_value = 10000
440        create_anchor_tx = self.wallet.send_to(from_node=node, scriptPubKey=PAY_TO_ANCHOR, amount=anchor_value)
441        self.generate(node, 1)
442
443        # First spend has non-empty witness, will be rejected to prevent third party wtxid malleability
444        anchor_nonempty_wit_spend = CTransaction()
445        anchor_nonempty_wit_spend.vin.append(CTxIn(COutPoint(int(create_anchor_tx["txid"], 16), create_anchor_tx["sent_vout"]), b""))
446        anchor_nonempty_wit_spend.vout.append(CTxOut(anchor_value - int(fee*COIN), script_to_p2wsh_script(CScript([OP_TRUE]))))
447        anchor_nonempty_wit_spend.wit.vtxinwit.append(CTxInWitness())
448        anchor_nonempty_wit_spend.wit.vtxinwit[0].scriptWitness.stack.append(b"f")
449
450        self.check_mempool_result(
451            result_expected=[{'txid': anchor_nonempty_wit_spend.txid_hex, 'allowed': False, 'reject-reason': 'bad-witness-nonstandard'}],
452            rawtxs=[anchor_nonempty_wit_spend.serialize().hex()],
453            maxfeerate=0,
454        )
455
456        # but is consensus-legal
457        self.generateblock(node, self.wallet.get_address(), [anchor_nonempty_wit_spend.serialize().hex()])
458
459        # Without witness elements it is standard
460        create_anchor_tx = self.wallet.send_to(from_node=node, scriptPubKey=PAY_TO_ANCHOR, amount=anchor_value)
461        self.generate(node, 1)
462
463        anchor_spend = CTransaction()
464        anchor_spend.vin.append(CTxIn(COutPoint(int(create_anchor_tx["txid"], 16), create_anchor_tx["sent_vout"]), b""))
465        anchor_spend.vout.append(CTxOut(anchor_value - int(fee*COIN), script_to_p2wsh_script(CScript([OP_TRUE]))))
466        anchor_spend.wit.vtxinwit.append(CTxInWitness())
467        # It's "segwit" but txid == wtxid since there is no witness data
468        assert_equal(anchor_spend.txid_hex, anchor_spend.wtxid_hex)
469
470        self.check_mempool_result(
471            result_expected=[{'txid': anchor_spend.txid_hex, 'allowed': True, 'vsize_adjusted': anchor_spend.get_vsize(), 'vsize': anchor_spend.get_vsize(), 'vsize_bip141': anchor_spend.get_vsize(), 'fees': { 'base': Decimal('0.00000700')}}],
472            rawtxs=[anchor_spend.serialize().hex()],
473            maxfeerate=0,
474        )
475
476        self.log.info('But cannot be spent if nested sh()')
477        nested_anchor_tx = self.wallet.create_self_transfer(sequence=SEQUENCE_FINAL)['tx']
478        nested_anchor_tx.vout[0].scriptPubKey = script_to_p2sh_script(PAY_TO_ANCHOR)
479        self.generateblock(node, self.wallet.get_address(), [nested_anchor_tx.serialize().hex()])
480
481        nested_anchor_spend = CTransaction()
482        nested_anchor_spend.vin.append(CTxIn(COutPoint(nested_anchor_tx.txid_int, 0), b""))
483        nested_anchor_spend.vin[0].scriptSig = CScript([bytes(PAY_TO_ANCHOR)])
484        nested_anchor_spend.vout.append(CTxOut(nested_anchor_tx.vout[0].nValue - int(fee*COIN), script_to_p2wsh_script(CScript([OP_TRUE]))))
485
486        self.check_mempool_result(
487            result_expected=[{'txid': nested_anchor_spend.txid_hex, 'allowed': False, 'reject-reason': 'mempool-script-verify-flag-failed (Witness version reserved for soft-fork upgrades)'}],
488            rawtxs=[nested_anchor_spend.serialize().hex()],
489            maxfeerate=0,
490        )
491        # but is consensus-legal
492        self.generateblock(node, self.wallet.get_address(), [nested_anchor_spend.serialize().hex()])
493
494        self.log.info('Spending a confirmed bare multisig is okay')
495        address = self.wallet.get_address()
496        tx = tx_from_hex(raw_tx_reference)
497        privkey, pubkey = generate_keypair()
498        tx.vout[0].scriptPubKey = keys_to_multisig_script([pubkey] * 3, k=1)  # Some bare multisig script (1-of-3)
499        self.generateblock(node, address, [tx.serialize().hex()])
500        tx_spend = CTransaction()