def serialize(self):
r = b''
outpoint = COutPoint()
outpoint.hash = self.prevout.hash
outpoint.n = self.prevout.n
outpoint.n |= OUTPOINT_ISSUANCE_FLAG
r += outpoint.serialize()
r += ser_string(self.scriptSig)
r += struct.pack("<I", self.nSequence)
r += self.assetIssuance.serialize()
return r
def run_test(self):
self.nodes[0].generate(161) # block 161
self.log.info(
"Verify sigops are counted in GBT with pre-BIP141 rules before the fork"
)
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
tmpl = self.nodes[0].getblocktemplate({'rules': ['segwit']})
assert tmpl['sizelimit'] == 1000000 * 16
assert 'weightlimit' not in tmpl
assert tmpl['sigoplimit'] == 20000 * 16
assert tmpl['transactions'][0]['hash'] == txid
assert tmpl['transactions'][0]['sigops'] == 2
tmpl = self.nodes[0].getblocktemplate({'rules': ['segwit']})
assert tmpl['sizelimit'] == 1000000 * 16
assert 'weightlimit' not in tmpl
assert tmpl['sigoplimit'] == 20000 * 16
assert tmpl['transactions'][0]['hash'] == txid
assert tmpl['transactions'][0]['sigops'] == 2
self.nodes[0].generate(1) # block 162
balance_presetup = self.nodes[0].getbalance()
self.pubkey = []
p2sh_ids = [
] # p2sh_ids[NODE][VER] is an array of txids that spend to a witness version VER pkscript to an address for NODE embedded in p2sh
wit_ids = [
] # wit_ids[NODE][VER] is an array of txids that spend to a witness version VER pkscript to an address for NODE via bare witness
for i in range(3):
newaddress = self.nodes[i].getnewaddress()
self.pubkey.append(
self.nodes[i].getaddressinfo(newaddress)["pubkey"])
multiscript = CScript([
OP_1,
hex_str_to_bytes(self.pubkey[-1]), OP_1, OP_CHECKMULTISIG
])
p2sh_ms_addr = self.nodes[i].addmultisigaddress(
1, [self.pubkey[-1]], '', 'p2sh-segwit')['address']
bip173_ms_addr = self.nodes[i].addmultisigaddress(
1, [self.pubkey[-1]], '', 'bech32')['address']
assert_equal(p2sh_ms_addr, script_to_p2sh_p2wsh(multiscript))
assert_equal(bip173_ms_addr, script_to_p2wsh(multiscript))
p2sh_ids.append([])
wit_ids.append([])
for v in range(2):
p2sh_ids[i].append([])
wit_ids[i].append([])
for i in range(5):
for n in range(3):
for v in range(2):
wit_ids[n][v].append(
send_to_witness(v, self.nodes[0],
find_spendable_utxo(self.nodes[0], 50),
self.pubkey[n], False,
Decimal("49.999")))
p2sh_ids[n][v].append(
send_to_witness(v, self.nodes[0],
find_spendable_utxo(self.nodes[0], 50),
self.pubkey[n], True,
Decimal("49.999")))
self.nodes[0].generate(1) # block 163
# self.sync_blocks()
self.sync_all()
# Make sure all nodes recognize the transactions as theirs
assert_equal(self.nodes[0].getbalance(),
balance_presetup - 60 * 50 + 20 * Decimal("49.999") + 50)
assert_equal(self.nodes[1].getbalance(), 20 * Decimal("49.999"))
assert_equal(self.nodes[2].getbalance(), 20 * Decimal("49.999"))
self.nodes[0].generate(260) # block 423
self.sync_blocks()
self.log.info(
"Verify witness txs are skipped for mining before the fork")
self.skip_mine(self.nodes[2], wit_ids[NODE_2][WIT_V0][0],
True) # block 424
self.skip_mine(self.nodes[2], wit_ids[NODE_2][WIT_V1][0],
True) # block 425
self.skip_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V0][0],
True) # block 426
self.skip_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V1][0],
True) # block 427
self.log.info(
"Verify unsigned p2sh witness txs without a redeem script are invalid"
)
self.fail_accept(self.nodes[2], "mandatory-script-verify-flag",
p2sh_ids[NODE_2][WIT_V0][1], False)
self.fail_accept(self.nodes[2], "mandatory-script-verify-flag",
p2sh_ids[NODE_2][WIT_V1][1], False)
self.nodes[2].generate(4) # blocks 428-431
self.log.info(
"Verify previous witness txs skipped for mining can now be mined")
assert_equal(len(self.nodes[2].getrawmempool()), 4)
blockhash = self.nodes[2].generate(1)[
0] # block 432 (first block with new rules; 432 = 144 * 3)
self.sync_blocks()
assert_equal(len(self.nodes[2].getrawmempool()), 0)
segwit_tx_list = self.nodes[2].getblock(blockhash)["tx"]
assert_equal(len(segwit_tx_list), 5)
self.log.info(
"Verify default node can't accept txs with missing witness")
# unsigned, no scriptsig
self.fail_accept(self.nodes[0], "mandatory-script-verify-flag",
wit_ids[NODE_0][WIT_V0][0], False)
self.fail_accept(self.nodes[0], "mandatory-script-verify-flag",
wit_ids[NODE_0][WIT_V1][0], False)
self.fail_accept(self.nodes[0], "mandatory-script-verify-flag",
p2sh_ids[NODE_0][WIT_V0][0], False)
self.fail_accept(self.nodes[0], "mandatory-script-verify-flag",
p2sh_ids[NODE_0][WIT_V1][0], False)
# unsigned with redeem script
self.fail_accept(self.nodes[0], "mandatory-script-verify-flag",
p2sh_ids[NODE_0][WIT_V0][0], False,
witness_script(False, self.pubkey[0]))
self.fail_accept(self.nodes[0], "mandatory-script-verify-flag",
p2sh_ids[NODE_0][WIT_V1][0], False,
witness_script(True, self.pubkey[0]))
self.log.info(
"Verify block and transaction serialization rpcs return differing serializations depending on rpc serialization flag"
)
assert self.nodes[2].getblock(
blockhash, False) != self.nodes[0].getblock(blockhash, False)
assert self.nodes[1].getblock(blockhash,
False) == self.nodes[2].getblock(
blockhash, False)
for tx_id in segwit_tx_list:
tx = FromHex(CTransaction(),
self.nodes[2].gettransaction(tx_id)["hex"])
assert self.nodes[2].getrawtransaction(
tx_id, False, blockhash) != self.nodes[0].getrawtransaction(
tx_id, False, blockhash)
assert self.nodes[1].getrawtransaction(
tx_id, False, blockhash) == self.nodes[2].getrawtransaction(
tx_id, False, blockhash)
assert self.nodes[0].getrawtransaction(
tx_id, False,
blockhash) != self.nodes[2].gettransaction(tx_id)["hex"]
assert self.nodes[1].getrawtransaction(
tx_id, False,
blockhash) == self.nodes[2].gettransaction(tx_id)["hex"]
assert self.nodes[0].getrawtransaction(
tx_id, False,
blockhash) == tx.serialize_without_witness().hex()
self.log.info(
"Verify witness txs without witness data are invalid after the fork"
)
self.fail_accept(
self.nodes[2],
'non-mandatory-script-verify-flag (Witness program hash mismatch) (code 64)',
wit_ids[NODE_2][WIT_V0][2],
sign=False)
self.fail_accept(
self.nodes[2],
'non-mandatory-script-verify-flag (Witness program was passed an empty witness) (code 64)',
wit_ids[NODE_2][WIT_V1][2],
sign=False)
self.fail_accept(
self.nodes[2],
'non-mandatory-script-verify-flag (Witness program hash mismatch) (code 64)',
p2sh_ids[NODE_2][WIT_V0][2],
sign=False,
redeem_script=witness_script(False, self.pubkey[2]))
self.fail_accept(
self.nodes[2],
'non-mandatory-script-verify-flag (Witness program was passed an empty witness) (code 64)',
p2sh_ids[NODE_2][WIT_V1][2],
sign=False,
redeem_script=witness_script(True, self.pubkey[2]))
self.log.info("Verify default node can now use witness txs")
self.success_mine(self.nodes[0], wit_ids[NODE_0][WIT_V0][0],
True) # block 432
self.success_mine(self.nodes[0], wit_ids[NODE_0][WIT_V1][0],
True) # block 433
self.success_mine(self.nodes[0], p2sh_ids[NODE_0][WIT_V0][0],
True) # block 434
self.success_mine(self.nodes[0], p2sh_ids[NODE_0][WIT_V1][0],
True) # block 435
self.log.info(
"Verify sigops are counted in GBT with BIP141 rules after the fork"
)
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
tmpl = self.nodes[0].getblocktemplate({'rules': ['segwit']})
assert tmpl[
'sizelimit'] >= 63999577 # actual maximum size is lower due to minimum mandatory non-witness data
assert tmpl['weightlimit'] == 4000000 * 16
assert tmpl['sigoplimit'] == 80000 * 16
assert tmpl['transactions'][0]['txid'] == txid
assert tmpl['transactions'][0]['sigops'] == 8
self.nodes[0].generate(1) # Mine a block to clear the gbt cache
self.log.info(
"Non-segwit miners are able to use GBT response after activation.")
# Create a 3-tx chain: tx1 (non-segwit input, paying to a segwit output) ->
# tx2 (segwit input, paying to a non-segwit output) ->
# tx3 (non-segwit input, paying to a non-segwit output).
# tx1 is allowed to appear in the block, but no others.
txid1 = send_to_witness(1, self.nodes[0],
find_spendable_utxo(self.nodes[0], 50),
self.pubkey[0], False, Decimal("49.996"))
hex_tx = self.nodes[0].gettransaction(txid)['hex']
tx = FromHex(CTransaction(), hex_tx)
assert tx.wit.is_null() # This should not be a segwit input
assert txid1 in self.nodes[0].getrawmempool()
tx1_hex = self.nodes[0].gettransaction(txid1)['hex']
tx1 = FromHex(CTransaction(), tx1_hex)
# Check that wtxid is properly reported in mempool entry (txid1)
assert_equal(int(self.nodes[0].getmempoolentry(txid1)["wtxid"], 16),
tx1.calc_sha256(True))
# Check that weight and vsize are properly reported in mempool entry (txid1)
assert_equal(self.nodes[0].getmempoolentry(txid1)["vsize"],
(self.nodes[0].getmempoolentry(txid1)["weight"] + 3) // 4)
assert_equal(
self.nodes[0].getmempoolentry(txid1)["weight"],
len(tx1.serialize_without_witness()) * 3 +
len(tx1.serialize_with_witness()))
# Now create tx2, which will spend from txid1.
tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(int(txid1, 16), 0), b''))
tx.vout.append(
CTxOut(int(49.99 * COIN),
CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
tx2_hex = self.nodes[0].signrawtransactionwithwallet(ToHex(tx))['hex']
txid2 = self.nodes[0].sendrawtransaction(tx2_hex)
tx = FromHex(CTransaction(), tx2_hex)
assert not tx.wit.is_null()
# Check that wtxid is properly reported in mempool entry (txid2)
assert_equal(int(self.nodes[0].getmempoolentry(txid2)["wtxid"], 16),
tx.calc_sha256(True))
# Check that weight and vsize are properly reported in mempool entry (txid2)
assert_equal(self.nodes[0].getmempoolentry(txid2)["vsize"],
(self.nodes[0].getmempoolentry(txid2)["weight"] + 3) // 4)
assert_equal(
self.nodes[0].getmempoolentry(txid2)["weight"],
len(tx.serialize_without_witness()) * 3 +
len(tx.serialize_with_witness()))
# Now create tx3, which will spend from txid2
tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(int(txid2, 16), 0), b""))
tx.vout.append(
CTxOut(int(49.95 * COIN),
CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE]))) # Huge fee
tx.calc_sha256()
txid3 = self.nodes[0].sendrawtransaction(ToHex(tx))
assert tx.wit.is_null()
assert txid3 in self.nodes[0].getrawmempool()
# Check that getblocktemplate includes all transactions.
template = self.nodes[0].getblocktemplate({"rules": ["segwit"]})
template_txids = [t['txid'] for t in template['transactions']]
assert txid1 in template_txids
assert txid2 in template_txids
assert txid3 in template_txids
# Check that wtxid is properly reported in mempool entry (txid3)
assert_equal(int(self.nodes[0].getmempoolentry(txid3)["wtxid"], 16),
tx.calc_sha256(True))
# Check that weight and vsize are properly reported in mempool entry (txid3)
assert_equal(self.nodes[0].getmempoolentry(txid3)["vsize"],
(self.nodes[0].getmempoolentry(txid3)["weight"] + 3) // 4)
assert_equal(
self.nodes[0].getmempoolentry(txid3)["weight"],
len(tx.serialize_without_witness()) * 3 +
len(tx.serialize_with_witness()))
# Mine a block to clear the gbt cache again.
self.nodes[0].generate(1)
self.log.info("Verify behaviour of importaddress and listunspent")
# Some public keys to be used later
pubkeys = [
"0363D44AABD0F1699138239DF2F042C3282C0671CC7A76826A55C8203D90E39242", # cPiM8Ub4heR9NBYmgVzJQiUH1if44GSBGiqaeJySuL2BKxubvgwb
"02D3E626B3E616FC8662B489C123349FECBFC611E778E5BE739B257EAE4721E5BF", # cPpAdHaD6VoYbW78kveN2bsvb45Q7G5PhaPApVUGwvF8VQ9brD97
"04A47F2CBCEFFA7B9BCDA184E7D5668D3DA6F9079AD41E422FA5FD7B2D458F2538A62F5BD8EC85C2477F39650BD391EA6250207065B2A81DA8B009FC891E898F0E", # 91zqCU5B9sdWxzMt1ca3VzbtVm2YM6Hi5Rxn4UDtxEaN9C9nzXV
"02A47F2CBCEFFA7B9BCDA184E7D5668D3DA6F9079AD41E422FA5FD7B2D458F2538", # cPQFjcVRpAUBG8BA9hzr2yEzHwKoMgLkJZBBtK9vJnvGJgMjzTbd
"036722F784214129FEB9E8129D626324F3F6716555B603FFE8300BBCB882151228", # cQGtcm34xiLjB1v7bkRa4V3aAc9tS2UTuBZ1UnZGeSeNy627fN66
"0266A8396EE936BF6D99D17920DB21C6C7B1AB14C639D5CD72B300297E416FD2EC", # cTW5mR5M45vHxXkeChZdtSPozrFwFgmEvTNnanCW6wrqwaCZ1X7K
"0450A38BD7F0AC212FEBA77354A9B036A32E0F7C81FC4E0C5ADCA7C549C4505D2522458C2D9AE3CEFD684E039194B72C8A10F9CB9D4764AB26FCC2718D421D3B84", # 92h2XPssjBpsJN5CqSP7v9a7cf2kgDunBC6PDFwJHMACM1rrVBJ
]
# Import a compressed key and an uncompressed key, generate some multisig addresses
self.nodes[0].importprivkey(
"92e6XLo5jVAVwrQKPNTs93oQco8f8sDNBcpv73Dsrs397fQtFQn")
uncompressed_spendable_address = ["mvozP4UwyGD2mGZU4D2eMvMLPB9WkMmMQu"]
self.nodes[0].importprivkey(
"cNC8eQ5dg3mFAVePDX4ddmPYpPbw41r9bm2jd1nLJT77e6RrzTRR")
compressed_spendable_address = ["mmWQubrDomqpgSYekvsU7HWEVjLFHAakLe"]
assert not self.nodes[0].getaddressinfo(
uncompressed_spendable_address[0])['iscompressed']
assert self.nodes[0].getaddressinfo(
compressed_spendable_address[0])['iscompressed']
self.nodes[0].importpubkey(pubkeys[0])
compressed_solvable_address = [key_to_p2pkh(pubkeys[0])]
self.nodes[0].importpubkey(pubkeys[1])
compressed_solvable_address.append(key_to_p2pkh(pubkeys[1]))
self.nodes[0].importpubkey(pubkeys[2])
uncompressed_solvable_address = [key_to_p2pkh(pubkeys[2])]
spendable_anytime = [
] # These outputs should be seen anytime after importprivkey and addmultisigaddress
spendable_after_importaddress = [
] # These outputs should be seen after importaddress
solvable_after_importaddress = [
] # These outputs should be seen after importaddress but not spendable
unsolvable_after_importaddress = [
] # These outputs should be unsolvable after importaddress
solvable_anytime = [
] # These outputs should be solvable after importpubkey
unseen_anytime = [] # These outputs should never be seen
uncompressed_spendable_address.append(self.nodes[0].addmultisigaddress(
2, [
uncompressed_spendable_address[0],
compressed_spendable_address[0]
])['address'])
uncompressed_spendable_address.append(self.nodes[0].addmultisigaddress(
2, [
uncompressed_spendable_address[0],
uncompressed_spendable_address[0]
])['address'])
compressed_spendable_address.append(self.nodes[0].addmultisigaddress(
2,
[compressed_spendable_address[0], compressed_spendable_address[0]
])['address'])
uncompressed_solvable_address.append(self.nodes[0].addmultisigaddress(
2, [
compressed_spendable_address[0],
uncompressed_solvable_address[0]
])['address'])
compressed_solvable_address.append(self.nodes[0].addmultisigaddress(
2,
[compressed_spendable_address[0], compressed_solvable_address[0]
])['address'])
compressed_solvable_address.append(self.nodes[0].addmultisigaddress(
2,
[compressed_solvable_address[0], compressed_solvable_address[1]
])['address'])
# Test multisig_without_privkey
# We have 2 public keys without private keys, use addmultisigaddress to add to wallet.
# Money sent to P2SH of multisig of this should only be seen after importaddress with the BASE58 P2SH address.
multisig_without_privkey_address = self.nodes[0].addmultisigaddress(
2, [pubkeys[3], pubkeys[4]])['address']
script = CScript([
OP_2,
hex_str_to_bytes(pubkeys[3]),
hex_str_to_bytes(pubkeys[4]), OP_2, OP_CHECKMULTISIG
])
solvable_after_importaddress.append(
CScript([OP_HASH160, hash160(script), OP_EQUAL]))
for i in compressed_spendable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
[bare, p2sh, p2wsh,
p2sh_p2wsh] = self.p2sh_address_to_script(v)
# p2sh multisig with compressed keys should always be spendable
spendable_anytime.extend([p2sh])
# bare multisig can be watched and signed, but is not treated as ours
solvable_after_importaddress.extend([bare])
# P2WSH and P2SH(P2WSH) multisig with compressed keys are spendable after direct importaddress
spendable_after_importaddress.extend([p2wsh, p2sh_p2wsh])
else:
[
p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh,
p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh
] = self.p2pkh_address_to_script(v)
# normal P2PKH and P2PK with compressed keys should always be spendable
spendable_anytime.extend([p2pkh, p2pk])
# P2SH_P2PK, P2SH_P2PKH with compressed keys are spendable after direct importaddress
spendable_after_importaddress.extend([
p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh,
p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh
])
# P2WPKH and P2SH_P2WPKH with compressed keys should always be spendable
spendable_anytime.extend([p2wpkh, p2sh_p2wpkh])
for i in uncompressed_spendable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
[bare, p2sh, p2wsh,
p2sh_p2wsh] = self.p2sh_address_to_script(v)
# p2sh multisig with uncompressed keys should always be spendable
spendable_anytime.extend([p2sh])
# bare multisig can be watched and signed, but is not treated as ours
solvable_after_importaddress.extend([bare])
# P2WSH and P2SH(P2WSH) multisig with uncompressed keys are never seen
unseen_anytime.extend([p2wsh, p2sh_p2wsh])
else:
[
p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh,
p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh
] = self.p2pkh_address_to_script(v)
# normal P2PKH and P2PK with uncompressed keys should always be spendable
spendable_anytime.extend([p2pkh, p2pk])
# P2SH_P2PK and P2SH_P2PKH are spendable after direct importaddress
spendable_after_importaddress.extend([p2sh_p2pk, p2sh_p2pkh])
# Witness output types with uncompressed keys are never seen
unseen_anytime.extend([
p2wpkh, p2sh_p2wpkh, p2wsh_p2pk, p2wsh_p2pkh,
p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh
])
for i in compressed_solvable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
# Multisig without private is not seen after addmultisigaddress, but seen after importaddress
[bare, p2sh, p2wsh,
p2sh_p2wsh] = self.p2sh_address_to_script(v)
solvable_after_importaddress.extend(
[bare, p2sh, p2wsh, p2sh_p2wsh])
else:
[
p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh,
p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh
] = self.p2pkh_address_to_script(v)
# normal P2PKH, P2PK, P2WPKH and P2SH_P2WPKH with compressed keys should always be seen
solvable_anytime.extend([p2pkh, p2pk, p2wpkh, p2sh_p2wpkh])
# P2SH_P2PK, P2SH_P2PKH with compressed keys are seen after direct importaddress
solvable_after_importaddress.extend([
p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh,
p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh
])
for i in uncompressed_solvable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
[bare, p2sh, p2wsh,
p2sh_p2wsh] = self.p2sh_address_to_script(v)
# Base uncompressed multisig without private is not seen after addmultisigaddress, but seen after importaddress
solvable_after_importaddress.extend([bare, p2sh])
# P2WSH and P2SH(P2WSH) multisig with uncompressed keys are never seen
unseen_anytime.extend([p2wsh, p2sh_p2wsh])
else:
[
p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh,
p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh
] = self.p2pkh_address_to_script(v)
# normal P2PKH and P2PK with uncompressed keys should always be seen
solvable_anytime.extend([p2pkh, p2pk])
# P2SH_P2PK, P2SH_P2PKH with uncompressed keys are seen after direct importaddress
solvable_after_importaddress.extend([p2sh_p2pk, p2sh_p2pkh])
# Witness output types with uncompressed keys are never seen
unseen_anytime.extend([
p2wpkh, p2sh_p2wpkh, p2wsh_p2pk, p2wsh_p2pkh,
p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh
])
op1 = CScript([OP_1])
op0 = CScript([OP_0])
# 2N7MGY19ti4KDMSzRfPAssP6Pxyuxoi6jLe is the P2SH(P2PKH) version of mjoE3sSrb8ByYEvgnC3Aox86u1CHnfJA4V
unsolvable_address_key = hex_str_to_bytes(
"02341AEC7587A51CDE5279E0630A531AEA2615A9F80B17E8D9376327BAEAA59E3D"
)
unsolvablep2pkh = CScript([
OP_DUP, OP_HASH160,
hash160(unsolvable_address_key), OP_EQUALVERIFY, OP_CHECKSIG
])
unsolvablep2wshp2pkh = CScript([OP_0, sha256(unsolvablep2pkh)])
p2shop0 = CScript([OP_HASH160, hash160(op0), OP_EQUAL])
p2wshop1 = CScript([OP_0, sha256(op1)])
unsolvable_after_importaddress.append(unsolvablep2pkh)
unsolvable_after_importaddress.append(unsolvablep2wshp2pkh)
unsolvable_after_importaddress.append(
op1) # OP_1 will be imported as script
unsolvable_after_importaddress.append(p2wshop1)
unseen_anytime.append(
op0
) # OP_0 will be imported as P2SH address with no script provided
unsolvable_after_importaddress.append(p2shop0)
spendable_txid = []
solvable_txid = []
spendable_txid.append(
self.mine_and_test_listunspent(spendable_anytime, 2))
solvable_txid.append(
self.mine_and_test_listunspent(solvable_anytime, 1))
self.mine_and_test_listunspent(
spendable_after_importaddress + solvable_after_importaddress +
unseen_anytime + unsolvable_after_importaddress, 0)
importlist = []
for i in compressed_spendable_address + uncompressed_spendable_address + compressed_solvable_address + uncompressed_solvable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
bare = hex_str_to_bytes(v['hex'])
importlist.append(bare.hex())
importlist.append(CScript([OP_0, sha256(bare)]).hex())
else:
pubkey = hex_str_to_bytes(v['pubkey'])
p2pk = CScript([pubkey, OP_CHECKSIG])
p2pkh = CScript([
OP_DUP, OP_HASH160,
hash160(pubkey), OP_EQUALVERIFY, OP_CHECKSIG
])
importlist.append(p2pk.hex())
importlist.append(p2pkh.hex())
importlist.append(CScript([OP_0, hash160(pubkey)]).hex())
importlist.append(CScript([OP_0, sha256(p2pk)]).hex())
importlist.append(CScript([OP_0, sha256(p2pkh)]).hex())
importlist.append(unsolvablep2pkh.hex())
importlist.append(unsolvablep2wshp2pkh.hex())
importlist.append(op1.hex())
importlist.append(p2wshop1.hex())
for i in importlist:
# import all generated addresses. The wallet already has the private keys for some of these, so catch JSON RPC
# exceptions and continue.
try_rpc(
-4,
"The wallet already contains the private key for this address or script",
self.nodes[0].importaddress, i, "", False, True)
self.nodes[0].importaddress(
script_to_p2sh(op0)) # import OP_0 as address only
self.nodes[0].importaddress(
multisig_without_privkey_address) # Test multisig_without_privkey
spendable_txid.append(
self.mine_and_test_listunspent(
spendable_anytime + spendable_after_importaddress, 2))
solvable_txid.append(
self.mine_and_test_listunspent(
solvable_anytime + solvable_after_importaddress, 1))
self.mine_and_test_listunspent(unsolvable_after_importaddress, 1)
self.mine_and_test_listunspent(unseen_anytime, 0)
spendable_txid.append(
self.mine_and_test_listunspent(
spendable_anytime + spendable_after_importaddress, 2))
solvable_txid.append(
self.mine_and_test_listunspent(
solvable_anytime + solvable_after_importaddress, 1))
self.mine_and_test_listunspent(unsolvable_after_importaddress, 1)
self.mine_and_test_listunspent(unseen_anytime, 0)
# Repeat some tests. This time we don't add witness scripts with importaddress
# Import a compressed key and an uncompressed key, generate some multisig addresses
self.nodes[0].importprivkey(
"927pw6RW8ZekycnXqBQ2JS5nPyo1yRfGNN8oq74HeddWSpafDJH")
uncompressed_spendable_address = ["mguN2vNSCEUh6rJaXoAVwY3YZwZvEmf5xi"]
self.nodes[0].importprivkey(
"cMcrXaaUC48ZKpcyydfFo8PxHAjpsYLhdsp6nmtB3E2ER9UUHWnw")
compressed_spendable_address = ["n1UNmpmbVUJ9ytXYXiurmGPQ3TRrXqPWKL"]
self.nodes[0].importpubkey(pubkeys[5])
compressed_solvable_address = [key_to_p2pkh(pubkeys[5])]
self.nodes[0].importpubkey(pubkeys[6])
uncompressed_solvable_address = [key_to_p2pkh(pubkeys[6])]
unseen_anytime = [] # These outputs should never be seen
solvable_anytime = [
] # These outputs should be solvable after importpubkey
unseen_anytime = [] # These outputs should never be seen
uncompressed_spendable_address.append(self.nodes[0].addmultisigaddress(
2, [
uncompressed_spendable_address[0],
compressed_spendable_address[0]
])['address'])
uncompressed_spendable_address.append(self.nodes[0].addmultisigaddress(
2, [
uncompressed_spendable_address[0],
uncompressed_spendable_address[0]
])['address'])
compressed_spendable_address.append(self.nodes[0].addmultisigaddress(
2,
[compressed_spendable_address[0], compressed_spendable_address[0]
])['address'])
uncompressed_solvable_address.append(self.nodes[0].addmultisigaddress(
2,
[compressed_solvable_address[0], uncompressed_solvable_address[0]
])['address'])
compressed_solvable_address.append(self.nodes[0].addmultisigaddress(
2,
[compressed_spendable_address[0], compressed_solvable_address[0]
])['address'])
premature_witaddress = []
for i in compressed_spendable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
[bare, p2sh, p2wsh,
p2sh_p2wsh] = self.p2sh_address_to_script(v)
premature_witaddress.append(script_to_p2sh(p2wsh))
else:
[
p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh,
p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh
] = self.p2pkh_address_to_script(v)
# P2WPKH, P2SH_P2WPKH are always spendable
spendable_anytime.extend([p2wpkh, p2sh_p2wpkh])
for i in uncompressed_spendable_address + uncompressed_solvable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
[bare, p2sh, p2wsh,
p2sh_p2wsh] = self.p2sh_address_to_script(v)
# P2WSH and P2SH(P2WSH) multisig with uncompressed keys are never seen
unseen_anytime.extend([p2wsh, p2sh_p2wsh])
else:
[
p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh,
p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh
] = self.p2pkh_address_to_script(v)
# P2WPKH, P2SH_P2WPKH with uncompressed keys are never seen
unseen_anytime.extend([p2wpkh, p2sh_p2wpkh])
for i in compressed_solvable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
[bare, p2sh, p2wsh,
p2sh_p2wsh] = self.p2sh_address_to_script(v)
premature_witaddress.append(script_to_p2sh(p2wsh))
else:
[
p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh,
p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh
] = self.p2pkh_address_to_script(v)
# P2SH_P2PK, P2SH_P2PKH with compressed keys are always solvable
solvable_anytime.extend([p2wpkh, p2sh_p2wpkh])
self.mine_and_test_listunspent(spendable_anytime, 2)
self.mine_and_test_listunspent(solvable_anytime, 1)
self.mine_and_test_listunspent(unseen_anytime, 0)
# Check that createrawtransaction/decoderawtransaction with non-v0 Bech32 works
v1_addr = program_to_witness(1, [3, 5])
v1_tx = self.nodes[0].createrawtransaction(
[getutxo(spendable_txid[0])], {v1_addr: 1})
v1_decoded = self.nodes[1].decoderawtransaction(v1_tx)
assert_equal(v1_decoded['vout'][0]['scriptPubKey']['addresses'][0],
v1_addr)
assert_equal(v1_decoded['vout'][0]['scriptPubKey']['hex'], "51020305")
# Check that spendable outputs are really spendable
self.create_and_mine_tx_from_txids(spendable_txid)
# import all the private keys so solvable addresses become spendable
self.nodes[0].importprivkey(
"cPiM8Ub4heR9NBYmgVzJQiUH1if44GSBGiqaeJySuL2BKxubvgwb")
self.nodes[0].importprivkey(
"cPpAdHaD6VoYbW78kveN2bsvb45Q7G5PhaPApVUGwvF8VQ9brD97")
self.nodes[0].importprivkey(
"91zqCU5B9sdWxzMt1ca3VzbtVm2YM6Hi5Rxn4UDtxEaN9C9nzXV")
self.nodes[0].importprivkey(
"cPQFjcVRpAUBG8BA9hzr2yEzHwKoMgLkJZBBtK9vJnvGJgMjzTbd")
self.nodes[0].importprivkey(
"cQGtcm34xiLjB1v7bkRa4V3aAc9tS2UTuBZ1UnZGeSeNy627fN66")
self.nodes[0].importprivkey(
"cTW5mR5M45vHxXkeChZdtSPozrFwFgmEvTNnanCW6wrqwaCZ1X7K")
self.create_and_mine_tx_from_txids(solvable_txid)
# Test that importing native P2WPKH/P2WSH scripts works
for use_p2wsh in [False, True]:
if use_p2wsh:
scriptPubKey = "00203a59f3f56b713fdcf5d1a57357f02c44342cbf306ffe0c4741046837bf90561a"
transaction = "01000000000100e1f505000000002200203a59f3f56b713fdcf5d1a57357f02c44342cbf306ffe0c4741046837bf90561a00000000"
else:
scriptPubKey = "a9142f8c469c2f0084c48e11f998ffbe7efa7549f26d87"
transaction = "01000000000100e1f5050000000017a9142f8c469c2f0084c48e11f998ffbe7efa7549f26d8700000000"
self.nodes[1].importaddress(scriptPubKey, "", False)
rawtxfund = self.nodes[1].fundrawtransaction(transaction)['hex']
rawtxfund = self.nodes[1].signrawtransactionwithwallet(
rawtxfund)["hex"]
txid = self.nodes[1].sendrawtransaction(rawtxfund)
assert_equal(self.nodes[1].gettransaction(txid, True)["txid"],
txid)
assert_equal(
self.nodes[1].listtransactions("*", 1, 0, True)[0]["txid"],
txid)
# Assert it is properly saved
self.stop_node(1)
self.start_node(1)
assert_equal(self.nodes[1].gettransaction(txid, True)["txid"],
txid)
assert_equal(
self.nodes[1].listtransactions("*", 1, 0, True)[0]["txid"],
txid)
def fake_stake(self,
staking_utxo_list,
nHeight=-1,
fDoubleSpend=False):
""" General method to create, send and test the spam blocks
:param staking_utxo_list: (string list) utxos to use for staking
nHeight: (int, optional) height of the staked block.
Used only for fork chain. In main chain it's current height + 1
fDoubleSpend: (bool) if true, stake input is double spent in block.vtx
:return:
"""
def get_prev_modifier(prevBlockHash):
prevBlock = self.nodes[1].getblock(prevBlockHash)
if prevBlock['height'] > 250:
return prevBlock['stakeModifier']
return "0"
# Get block number, block time and prevBlock hash and modifier
currHeight = self.nodes[1].getblockcount()
isMainChain = (nHeight == -1)
chainName = "main" if isMainChain else "forked"
nTime = self.mocktime
if isMainChain:
nHeight = currHeight + 1
prevBlockHash = self.nodes[1].getblockhash(nHeight - 1)
prevModifier = get_prev_modifier(prevBlockHash)
nTime += (nHeight - currHeight) * 60
# New block hash, coinstake input and list of txes
bHash = None
stakedUtxo = None
# For each test, send three blocks.
# On main chain they are all the same height.
# On fork chain, send three blocks where both the second and third block sent,
# are built on top of the first one.
for i in range(3):
fMustBeAccepted = (not isMainChain and i != 1)
block_txes = []
# update block number and prevBlock hash on second block sent on forked chain
if not isMainChain and i == 1:
nHeight += 1
nTime += 60
prevBlockHash = bHash
prevModifier = get_prev_modifier(prevBlockHash)
stakeInputs = self.get_prevouts(1, staking_utxo_list)
# Update stake inputs for second block sent on forked chain (must stake the same input)
if not isMainChain and i == 1:
stakeInputs = self.get_prevouts(1, [stakedUtxo])
# Make spam txes sending the inputs to DUMMY_KEY in order to test double spends
if fDoubleSpend:
spending_prevouts = self.get_prevouts(1, staking_utxo_list)
block_txes = self.make_txes(1, spending_prevouts, self.DUMMY_KEY.get_pubkey())
# Stake the spam block
block = self.stake_block(1, 7, nHeight, prevBlockHash, prevModifier, "0", stakeInputs,
nTime, "", block_txes, fDoubleSpend)
# Log stake input
prevout = COutPoint()
prevout.deserialize_uniqueness(BytesIO(block.prevoutStake))
self.log.info("Staked input: [%s...-%s]" % ('{:x}'.format(prevout.hash)[:12], prevout.n))
# Try submitblock and check result
self.log.info("Trying to send block [%s...] with height=%d" % (block.hash[:16], nHeight))
var = self.nodes[1].submitblock(bytes_to_hex_str(block.serialize()))
sleep(1)
if (not fMustBeAccepted and var not in [None, "rejected"]):
raise AssertionError("Error, block submitted (%s) in %s chain" % (var, chainName))
elif (fMustBeAccepted and var != "inconclusive"):
raise AssertionError("Error, block not submitted (%s) in %s chain" % (var, chainName))
self.log.info("Done. Updating context...")
# Sync and check block hash
bHash = block.hash
self.checkBlockHash(bHash, fMustBeAccepted)
# Update curr block data
stakedUtxo = [x for x in staking_utxo_list if COutPoint(
int(x['txid'], 16), x['vout']).serialize_uniqueness() == block.prevoutStake][0]
# Remove the used coinstake input (except before second block on fork chain)
if isMainChain or i != 0:
staking_utxo_list.remove(stakedUtxo)
self.log.info("All blocks sent")
def test_sequence_lock_unconfirmed_inputs(self):
# Store height so we can easily reset the chain at the end of the test
cur_height = self.nodes[0].getblockcount()
# Create a mempool tx.
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 2)
tx1 = FromHex(CTransaction(), self.nodes[0].getrawtransaction(txid))
tx1.rehash()
# Anyone-can-spend mempool tx.
# Sequence lock of 0 should pass.
tx2 = CTransaction()
tx2.nVersion = 2
tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)]
tx2.vout = [
CTxOut(int(tx1.vout[0].nValue - self.relayfee * COIN),
CScript([b'a']))
]
tx2_raw = self.nodes[0].signrawtransactionwithwallet(ToHex(tx2))["hex"]
tx2 = FromHex(tx2, tx2_raw)
tx2.rehash()
self.nodes[0].sendrawtransaction(tx2_raw)
# Create a spend of the 0th output of orig_tx with a sequence lock
# of 1, and test what happens when submitting.
# orig_tx.vout[0] must be an anyone-can-spend output
def test_nonzero_locks(orig_tx, node, relayfee, use_height_lock):
sequence_value = 1
if not use_height_lock:
sequence_value |= SEQUENCE_LOCKTIME_TYPE_FLAG
tx = CTransaction()
tx.nVersion = 2
tx.vin = [
CTxIn(COutPoint(orig_tx.sha256, 0), nSequence=sequence_value)
]
tx.vout = [
CTxOut(int(orig_tx.vout[0].nValue - relayfee * COIN),
CScript([b'a' * 35]))
]
tx.rehash()
if (orig_tx.hash in node.getrawmempool()):
# sendrawtransaction should fail if the tx is in the mempool
assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
node.sendrawtransaction, ToHex(tx))
else:
# sendrawtransaction should succeed if the tx is not in the mempool
node.sendrawtransaction(ToHex(tx))
return tx
test_nonzero_locks(tx2,
self.nodes[0],
self.relayfee,
use_height_lock=True)
test_nonzero_locks(tx2,
self.nodes[0],
self.relayfee,
use_height_lock=False)
# Now mine some blocks, but make sure tx2 doesn't get mined.
# Use prioritisetransaction to lower the effective feerate to 0
self.nodes[0].prioritisetransaction(txid=tx2.hash,
fee_delta=int(-self.relayfee *
COIN))
cur_time = int(time.time())
for i in range(10):
self.nodes[0].setmocktime(cur_time + 600)
self.nodes[0].generate(1)
cur_time += 600
assert (tx2.hash in self.nodes[0].getrawmempool())
test_nonzero_locks(tx2,
self.nodes[0],
self.relayfee,
use_height_lock=True)
test_nonzero_locks(tx2,
self.nodes[0],
self.relayfee,
use_height_lock=False)
# Mine tx2, and then try again
self.nodes[0].prioritisetransaction(txid=tx2.hash,
fee_delta=int(self.relayfee *
COIN))
# Advance the time on the node so that we can test timelocks
self.nodes[0].setmocktime(cur_time + 600)
self.nodes[0].generate(1)
assert (tx2.hash not in self.nodes[0].getrawmempool())
# Now that tx2 is not in the mempool, a sequence locked spend should
# succeed
tx3 = test_nonzero_locks(tx2,
self.nodes[0],
self.relayfee,
use_height_lock=False)
assert (tx3.hash in self.nodes[0].getrawmempool())
self.nodes[0].generate(1)
assert (tx3.hash not in self.nodes[0].getrawmempool())
# One more test, this time using height locks
tx4 = test_nonzero_locks(tx3,
self.nodes[0],
self.relayfee,
use_height_lock=True)
assert (tx4.hash in self.nodes[0].getrawmempool())
# Now try combining confirmed and unconfirmed inputs
tx5 = test_nonzero_locks(tx4,
self.nodes[0],
self.relayfee,
use_height_lock=True)
assert (tx5.hash not in self.nodes[0].getrawmempool())
utxos = self.nodes[0].listunspent()
tx5.vin.append(
CTxIn(COutPoint(int(utxos[0]["txid"], 16), utxos[0]["vout"]),
nSequence=1))
tx5.vout[0].nValue += int(utxos[0]["amount"] * COIN)
raw_tx5 = self.nodes[0].signrawtransactionwithwallet(ToHex(tx5))["hex"]
assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
self.nodes[0].sendrawtransaction, raw_tx5)
# Test mempool-BIP68 consistency after reorg
#
# State of the transactions in the last blocks:
# ... -> [ tx2 ] -> [ tx3 ]
# tip-1 tip
# And currently tx4 is in the mempool.
#
# If we invalidate the tip, tx3 should get added to the mempool, causing
# tx4 to be removed (fails sequence-lock).
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
assert (tx4.hash not in self.nodes[0].getrawmempool())
assert (tx3.hash in self.nodes[0].getrawmempool())
# Now mine 2 empty blocks to reorg out the current tip (labeled tip-1 in
# diagram above).
# This would cause tx2 to be added back to the mempool, which in turn causes
# tx3 to be removed.
tip = int(
self.nodes[0].getblockhash(self.nodes[0].getblockcount() - 1), 16)
height = self.nodes[0].getblockcount()
for i in range(2):
block = create_block(tip, create_coinbase(height), cur_time)
block.nVersion = 3
block.rehash()
block.solve()
tip = block.sha256
height += 1
self.nodes[0].submitblock(ToHex(block))
cur_time += 1
mempool = self.nodes[0].getrawmempool()
assert (tx3.hash not in mempool)
assert (tx2.hash in mempool)
# Reset the chain and get rid of the mocktimed-blocks
self.nodes[0].setmocktime(0)
self.nodes[0].invalidateblock(self.nodes[0].getblockhash(cur_height +
1))
self.nodes[0].generate(10)
def run_test(self):
node = self.nodes[0] # convenience reference to the node
self.bootstrap_p2p() # Add one p2p connection to the node
best_block = self.nodes[0].getbestblockhash()
tip = int(best_block, 16)
best_block_time = self.nodes[0].getblock(best_block)['time']
block_time = best_block_time + 1
self.log.info("Create a new block with an anyone-can-spend coinbase.")
height = 1
block = create_block(tip, create_coinbase(height), block_time)
block.solve()
# Save the coinbase for later
block1 = block
tip = block.sha256
node.p2p.send_blocks_and_test([block], node, success=True)
self.log.info("Mature the block.")
self.nodes[0].generatetoaddress(
100, self.nodes[0].get_deterministic_priv_key().address)
# Iterate through a list of known invalid transaction types, ensuring each is
# rejected. Some are consensus invalid and some just violate policy.
for BadTxTemplate in invalid_txs.iter_all_templates():
self.log.info("Testing invalid transaction: %s",
BadTxTemplate.__name__)
template = BadTxTemplate(spend_block=block1)
tx = template.get_tx()
node.p2p.send_txs_and_test(
[tx],
node,
success=False,
expect_disconnect=template.expect_disconnect,
reject_reason=template.reject_reason,
)
if template.expect_disconnect:
self.log.info("Reconnecting to peer")
self.reconnect_p2p()
# Make two p2p connections to provide the node with orphans
# * p2ps[0] will send valid orphan txs (one with low fee)
# * p2ps[1] will send an invalid orphan tx (and is later disconnected for that)
self.reconnect_p2p(num_connections=2)
self.log.info('Test orphan transaction handling ... ')
# Create a root transaction that we withhold until all dependent transactions
# are sent out and in the orphan cache
SCRIPT_PUB_KEY_OP_TRUE = b'\x51\x75' * 15 + b'\x51'
tx_withhold = CTransaction()
tx_withhold.vin.append(
CTxIn(outpoint=COutPoint(block1.vtx[0].sha256, 0)))
tx_withhold.vout.append(
CTxOut(nValue=50 * COIN - 12000,
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
tx_withhold.calc_sha256()
# Our first orphan tx with some outputs to create further orphan txs
tx_orphan_1 = CTransaction()
tx_orphan_1.vin.append(
CTxIn(outpoint=COutPoint(tx_withhold.sha256, 0)))
tx_orphan_1.vout = [
CTxOut(nValue=10 * COIN, scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE)
] * 3
tx_orphan_1.calc_sha256()
# A valid transaction with low fee
tx_orphan_2_no_fee = CTransaction()
tx_orphan_2_no_fee.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 0)))
tx_orphan_2_no_fee.vout.append(
CTxOut(nValue=10 * COIN, scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
# A valid transaction with sufficient fee
tx_orphan_2_valid = CTransaction()
tx_orphan_2_valid.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 1)))
tx_orphan_2_valid.vout.append(
CTxOut(nValue=10 * COIN - 12000,
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
tx_orphan_2_valid.calc_sha256()
# An invalid transaction with negative fee
tx_orphan_2_invalid = CTransaction()
tx_orphan_2_invalid.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 2)))
tx_orphan_2_invalid.vout.append(
CTxOut(nValue=11 * COIN, scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
self.log.info('Send the orphans ... ')
# Send valid orphan txs from p2ps[0]
node.p2p.send_txs_and_test(
[tx_orphan_1, tx_orphan_2_no_fee, tx_orphan_2_valid],
node,
success=False)
# Send invalid tx from p2ps[1]
node.p2ps[1].send_txs_and_test([tx_orphan_2_invalid],
node,
success=False)
assert_equal(0,
node.getmempoolinfo()['size']) # Mempool should be empty
assert_equal(2, len(node.getpeerinfo())) # p2ps[1] is still connected
self.log.info('Send the withhold tx ... ')
with node.assert_debug_log(expected_msgs=["bad-txns-in-belowout"]):
node.p2p.send_txs_and_test([tx_withhold], node, success=True)
# Transactions that should end up in the mempool
expected_mempool = {
t.hash
for t in [
tx_withhold, # The transaction that is the root for all orphans
tx_orphan_1, # The orphan transaction that splits the coins
tx_orphan_2_valid, # The valid transaction (with sufficient fee)
]
}
# Transactions that do not end up in the mempool
# tx_orphan_no_fee, because it has too low fee (p2ps[0] is not disconnected for relaying that tx)
# tx_orphan_invaid, because it has negative fee (p2ps[1] is disconnected for relaying that tx)
wait_until(lambda: 1 == len(node.getpeerinfo()),
timeout=12) # p2ps[1] is no longer connected
assert_equal(expected_mempool, set(node.getrawmempool()))
def test_sequence_lock_unconfirmed_inputs(self):
# Store height so we can easily reset the chain at the end of the test
cur_height = self.nodes[0].getblockcount()
# Create a mempool tx.
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(),
2000000)
tx1 = FromHex(CTransaction(), self.nodes[0].getrawtransaction(txid))
tx1.rehash()
# As the fees are calculated prior to the transaction being signed,
# there is some uncertainty that calculate fee provides the correct
# minimal fee. Since regtest coins are free, let's go ahead and
# increase the fee by an order of magnitude to ensure this test
# passes.
fee_multiplier = 10
# Anyone-can-spend mempool tx.
# Sequence lock of 0 should pass.
tx2 = CTransaction()
tx2.nVersion = 2
tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)]
tx2.vout = [CTxOut(int(0), CScript([b'a']))]
tx2.vout[0].nValue = tx1.vout[0].nValue - \
fee_multiplier * self.nodes[0].calculate_fee(tx2)
tx2_raw = self.nodes[0].signrawtransactionwithwallet(ToHex(tx2))["hex"]
tx2 = FromHex(tx2, tx2_raw)
tx2.rehash()
self.nodes[0].sendrawtransaction(tx2_raw)
# Create a spend of the 0th output of orig_tx with a sequence lock
# of 1, and test what happens when submitting.
# orig_tx.vout[0] must be an anyone-can-spend output
def test_nonzero_locks(orig_tx, node, use_height_lock):
sequence_value = 1
if not use_height_lock:
sequence_value |= SEQUENCE_LOCKTIME_TYPE_FLAG
tx = CTransaction()
tx.nVersion = 2
tx.vin = [
CTxIn(COutPoint(orig_tx.sha256, 0), nSequence=sequence_value)
]
tx.vout = [
CTxOut(
int(orig_tx.vout[0].nValue -
fee_multiplier * node.calculate_fee(tx)),
CScript([b'a']))
]
pad_tx(tx)
tx.rehash()
if (orig_tx.hash in node.getrawmempool()):
# sendrawtransaction should fail if the tx is in the mempool
assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
node.sendrawtransaction, ToHex(tx))
else:
# sendrawtransaction should succeed if the tx is not in the
# mempool
node.sendrawtransaction(ToHex(tx))
return tx
test_nonzero_locks(tx2, self.nodes[0], use_height_lock=True)
test_nonzero_locks(tx2, self.nodes[0], use_height_lock=False)
# Now mine some blocks, but make sure tx2 doesn't get mined.
# Use prioritisetransaction to lower the effective feerate to 0
self.nodes[0].prioritisetransaction(txid=tx2.hash,
fee_delta=-fee_multiplier *
self.nodes[0].calculate_fee(tx2))
cur_time = int(time.time())
for _ in range(10):
self.nodes[0].setmocktime(cur_time + 600)
self.nodes[0].generate(1)
cur_time += 600
assert tx2.hash in self.nodes[0].getrawmempool()
test_nonzero_locks(tx2, self.nodes[0], use_height_lock=True)
test_nonzero_locks(tx2, self.nodes[0], use_height_lock=False)
# Mine tx2, and then try again
self.nodes[0].prioritisetransaction(txid=tx2.hash,
fee_delta=fee_multiplier *
self.nodes[0].calculate_fee(tx2))
# Advance the time on the node so that we can test timelocks
self.nodes[0].setmocktime(cur_time + 600)
# Save block template now to use for the reorg later
tmpl = self.nodes[0].getblocktemplate()
self.nodes[0].generate(1)
assert tx2.hash not in self.nodes[0].getrawmempool()
# Now that tx2 is not in the mempool, a sequence locked spend should
# succeed
tx3 = test_nonzero_locks(tx2, self.nodes[0], use_height_lock=False)
assert tx3.hash in self.nodes[0].getrawmempool()
self.nodes[0].generate(1)
assert tx3.hash not in self.nodes[0].getrawmempool()
# One more test, this time using height locks
tx4 = test_nonzero_locks(tx3, self.nodes[0], use_height_lock=True)
assert tx4.hash in self.nodes[0].getrawmempool()
# Now try combining confirmed and unconfirmed inputs
tx5 = test_nonzero_locks(tx4, self.nodes[0], use_height_lock=True)
assert tx5.hash not in self.nodes[0].getrawmempool()
utxos = self.nodes[0].listunspent()
tx5.vin.append(
CTxIn(COutPoint(int(utxos[0]["txid"], 16), utxos[0]["vout"]),
nSequence=1))
tx5.vout[0].nValue += int(utxos[0]["amount"] * XEC)
raw_tx5 = self.nodes[0].signrawtransactionwithwallet(ToHex(tx5))["hex"]
assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
self.nodes[0].sendrawtransaction, raw_tx5)
# Test mempool-BIP68 consistency after reorg
#
# State of the transactions in the last blocks:
# ... -> [ tx2 ] -> [ tx3 ]
# tip-1 tip
# And currently tx4 is in the mempool.
#
# If we invalidate the tip, tx3 should get added to the mempool, causing
# tx4 to be removed (fails sequence-lock).
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
assert tx4.hash not in self.nodes[0].getrawmempool()
assert tx3.hash in self.nodes[0].getrawmempool()
# Now mine 2 empty blocks to reorg out the current tip (labeled tip-1 in
# diagram above).
# This would cause tx2 to be added back to the mempool, which in turn causes
# tx3 to be removed.
for i in range(2):
block = create_block(tmpl=tmpl, ntime=cur_time)
block.rehash()
block.solve()
tip = block.sha256
assert_equal(None if i == 1 else 'inconclusive',
self.nodes[0].submitblock(ToHex(block)))
tmpl = self.nodes[0].getblocktemplate()
tmpl['previousblockhash'] = f"{tip:x}"
tmpl['transactions'] = []
cur_time += 1
mempool = self.nodes[0].getrawmempool()
assert tx3.hash not in mempool
assert tx2.hash in mempool
# Reset the chain and get rid of the mocktimed-blocks
self.nodes[0].setmocktime(0)
self.nodes[0].invalidateblock(self.nodes[0].getblockhash(cur_height +
1))
self.nodes[0].generate(10)
def run_test(self):
self.import_deterministic_coinbase_privkeys(
) # Create wallets for all nodes
parent = self.nodes[0]
#parent2 = self.nodes[1]
sidechain = self.nodes[2]
sidechain2 = self.nodes[3]
# If we're testing post-transition, force a fedpegscript transition and
# getting rid of old fedpegscript by making at least another epoch pass by
WSH_OP_TRUE = self.nodes[0].decodescript("51")["segwit"]["hex"]
# We just randomize the keys a bit to get another valid fedpegscript
new_fedpegscript = sidechain.tweakfedpegscript("f00dbabe")["script"]
if self.options.post_transition:
print("Running test post-transition")
for _ in range(30):
block_hex = sidechain.getnewblockhex(
0, {
"signblockscript": WSH_OP_TRUE,
"max_block_witness": 10,
"fedpegscript": new_fedpegscript,
"extension_space": []
})
sidechain.submitblock(block_hex)
assert_equal(sidechain.getsidechaininfo()["current_fedpegscripts"],
[new_fedpegscript] * 2)
if self.options.pre_transition:
print(
"Running test pre-transition, dynafed activated from first block"
)
for node in self.nodes:
node.importprivkey(privkey=node.get_deterministic_priv_key().key,
label="mining")
util.node_fastmerkle = sidechain
parent.generate(101)
sidechain.generate(101)
self.log.info("sidechain info: {}".format(
sidechain.getsidechaininfo()))
addrs = sidechain.getpeginaddress()
addr = addrs["mainchain_address"]
assert_equal(
sidechain.decodescript(addrs["claim_script"])["type"],
"witness_v0_keyhash")
txid1 = parent.sendtoaddress(addr, 24)
vout = find_vout_for_address(parent, txid1, addr)
# 10+2 confirms required to get into mempool and confirm
assert_equal(sidechain.getsidechaininfo()["pegin_confirmation_depth"],
10)
parent.generate(1)
time.sleep(2)
proof = parent.gettxoutproof([txid1])
raw = parent.gettransaction(txid1)["hex"]
# Create a wallet in order to test that multi-wallet support works correctly for claimpegin
# (Regression test for https://github.com/ElementsProject/elements/issues/812 .)
sidechain.createwallet("throwaway")
# Set up our sidechain RPCs to use the first wallet (with empty name). We do this by
# overriding the RPC object in a hacky way, to avoid breaking a different hack on TestNode
# that enables generate() to work despite the deprecation of the generate RPC.
sidechain.rpc = sidechain.get_wallet_rpc("")
print("Attempting peg-ins")
# First attempt fails the consensus check but gives useful result
try:
pegtxid = sidechain.claimpegin(raw, proof)
raise Exception(
"Peg-in should not be mature enough yet, need another block.")
except JSONRPCException as e:
assert "Peg-in Bitcoin transaction needs more confirmations to be sent." in e.error[
"message"]
# Second attempt simply doesn't hit mempool bar
parent.generate(10)
try:
pegtxid = sidechain.claimpegin(raw, proof)
raise Exception(
"Peg-in should not be mature enough yet, need another block.")
except JSONRPCException as e:
assert "Peg-in Bitcoin transaction needs more confirmations to be sent." in e.error[
"message"]
try:
pegtxid = sidechain.createrawpegin(raw, proof, 'AEIOU')
raise Exception("Peg-in with non-hex claim_script should fail.")
except JSONRPCException as e:
assert "Given claim_script is not hex." in e.error["message"]
# Should fail due to non-matching wallet address
try:
scriptpubkey = sidechain.getaddressinfo(
get_new_unconfidential_address(sidechain))["scriptPubKey"]
pegtxid = sidechain.claimpegin(raw, proof, scriptpubkey)
raise Exception(
"Peg-in with non-matching claim_script should fail.")
except JSONRPCException as e:
assert "Given claim_script does not match the given Bitcoin transaction." in e.error[
"message"]
# 12 confirms allows in mempool
parent.generate(1)
# Make sure that a tx with a duplicate pegin claim input gets rejected.
raw_pegin = sidechain.createrawpegin(raw, proof)["hex"]
raw_pegin = FromHex(CTransaction(), raw_pegin)
raw_pegin.vin.append(raw_pegin.vin[0]) # duplicate the pegin input
raw_pegin = sidechain.signrawtransactionwithwallet(
raw_pegin.serialize().hex())["hex"]
assert_raises_rpc_error(-26, "bad-txns-inputs-duplicate",
sidechain.sendrawtransaction, raw_pegin)
# Also try including this tx in a block manually and submitting it.
doublespendblock = FromHex(CBlock(), sidechain.getnewblockhex())
doublespendblock.vtx.append(FromHex(CTransaction(), raw_pegin))
doublespendblock.hashMerkleRoot = doublespendblock.calc_merkle_root()
add_witness_commitment(doublespendblock)
doublespendblock.solve()
block_hex = doublespendblock.serialize(True).hex()
assert_raises_rpc_error(-25, "bad-txns-inputs-duplicate",
sidechain.testproposedblock, block_hex, True)
# Should succeed via wallet lookup for address match, and when given
raw_pegin = sidechain.createrawpegin(raw, proof)['hex']
signed_pegin = sidechain.signrawtransactionwithwallet(raw_pegin)
# Find the address that the peg-in used
outputs = []
for pegin_vout in sidechain.decoderawtransaction(raw_pegin)['vout']:
if pegin_vout['scriptPubKey']['type'] == 'witness_v0_keyhash':
outputs.append({
pegin_vout['scriptPubKey']['addresses'][0]:
pegin_vout['value']
})
elif pegin_vout['scriptPubKey']['type'] == 'fee':
outputs.append({"fee": pegin_vout['value']})
# Check the createrawtransaction makes the same unsigned peg-in transaction
raw_pegin2 = sidechain.createrawtransaction(
[{
"txid": txid1,
"vout": vout,
"pegin_bitcoin_tx": raw,
"pegin_txout_proof": proof,
"pegin_claim_script": addrs["claim_script"]
}], outputs)
assert_equal(raw_pegin, raw_pegin2)
# Check that createpsbt makes the correct unsigned peg-in
pegin_psbt = sidechain.createpsbt(
[{
"txid": txid1,
"vout": vout,
"pegin_bitcoin_tx": raw,
"pegin_txout_proof": proof,
"pegin_claim_script": addrs["claim_script"]
}], outputs)
decoded_psbt = sidechain.decodepsbt(pegin_psbt)
# Check that pegin_bitcoin_tx == raw, but due to stripping witnesses, we need to compare their txids
txid1 = parent.decoderawtransaction(
decoded_psbt['inputs'][0]['pegin_bitcoin_tx'])['txid']
txid2 = parent.decoderawtransaction(raw)['txid']
assert_equal(txid1, txid2)
# Check the rest
assert_equal(decoded_psbt['inputs'][0]['pegin_claim_script'],
addrs["claim_script"])
assert_equal(decoded_psbt['inputs'][0]['pegin_txout_proof'], proof)
assert_equal(decoded_psbt['inputs'][0]['pegin_genesis_hash'],
parent.getblockhash(0))
# Make a psbt without those peg-in data and merge them
merge_pegin_psbt = sidechain.createpsbt([{
"txid": txid1,
"vout": vout
}], outputs)
decoded_psbt = sidechain.decodepsbt(merge_pegin_psbt)
assert 'pegin_bitcoin_tx' not in decoded_psbt['inputs'][0]
assert 'pegin_claim_script' not in decoded_psbt['inputs'][0]
assert 'pegin_txout_proof' not in decoded_psbt['inputs'][0]
assert 'pegin_genesis_hash' not in decoded_psbt['inputs'][0]
merged_pegin_psbt = sidechain.combinepsbt(
[pegin_psbt, merge_pegin_psbt])
assert_equal(pegin_psbt, merged_pegin_psbt)
# Now sign the psbt
signed_psbt = sidechain.walletsignpsbt(pegin_psbt)
# Finalize and extract and compare
fin_psbt = sidechain.finalizepsbt(signed_psbt['psbt'])
assert_equal(fin_psbt, signed_pegin)
# Try funding a psbt with the peg-in
assert_equal(sidechain.getbalance()['bitcoin'], 50)
out_bal = 0
outputs.append({sidechain.getnewaddress(): 49.999})
for out in outputs:
for val in out.values():
out_bal += Decimal(val)
assert_greater_than(out_bal, 50)
pegin_psbt = sidechain.walletcreatefundedpsbt(
[{
"txid": txid1,
"vout": vout,
"pegin_bitcoin_tx": raw,
"pegin_txout_proof": proof,
"pegin_claim_script": addrs["claim_script"]
}], outputs, 0, {'add_inputs': True})
signed_psbt = sidechain.walletsignpsbt(pegin_psbt['psbt'])
fin_psbt = sidechain.finalizepsbt(signed_psbt['psbt'])
assert fin_psbt['complete']
sample_pegin_struct = FromHex(CTransaction(), signed_pegin["hex"])
# Round-trip peg-in transaction using python serialization
assert_equal(signed_pegin["hex"],
sample_pegin_struct.serialize().hex())
# Store this for later (evil laugh)
sample_pegin_witness = sample_pegin_struct.wit.vtxinwit[0].peginWitness
pegtxid1 = sidechain.claimpegin(raw, proof)
# Make sure a second pegin claim does not get accepted in the mempool when
# another mempool tx already claims that pegin.
assert_raises_rpc_error(-4, "txn-mempool-conflict",
sidechain.claimpegin, raw, proof)
# Will invalidate the block that confirms this transaction later
for node_group in self.node_groups:
self.sync_all(node_group)
blockhash = sidechain2.generate(1)
for node_group in self.node_groups:
self.sync_all(node_group)
sidechain.generate(5)
tx1 = sidechain.gettransaction(pegtxid1)
if "confirmations" in tx1 and tx1["confirmations"] == 6:
print("Peg-in is confirmed: Success!")
else:
raise Exception("Peg-in confirmation has failed.")
# Look at pegin fields
decoded = sidechain.decoderawtransaction(tx1["hex"])
assert decoded["vin"][0]["is_pegin"] == True
assert len(decoded["vin"][0]["pegin_witness"]) > 0
# Check that there's sufficient fee for the peg-in
vsize = decoded["vsize"]
fee_output = decoded["vout"][1]
fallbackfee_pervbyte = Decimal("0.00001") / Decimal("1000")
assert fee_output["scriptPubKey"]["type"] == "fee"
assert fee_output["value"] >= fallbackfee_pervbyte * vsize
# Quick reorg checks of pegs
sidechain.invalidateblock(blockhash[0])
if sidechain.gettransaction(pegtxid1)["confirmations"] != 0:
raise Exception(
"Peg-in didn't unconfirm after invalidateblock call.")
# Re-org causes peg-ins to get booted(wallet will resubmit in 10 minutes)
assert_equal(sidechain.getrawmempool(), [])
sidechain.sendrawtransaction(tx1["hex"])
# Create duplicate claim, put it in block along with current one in mempool
# to test duplicate-in-block claims between two txs that are in the same block.
raw_pegin = sidechain.createrawpegin(raw, proof)["hex"]
raw_pegin = sidechain.signrawtransactionwithwallet(raw_pegin)["hex"]
raw_pegin = FromHex(CTransaction(), raw_pegin)
doublespendblock = FromHex(CBlock(), sidechain.getnewblockhex())
assert len(doublespendblock.vtx) == 2 # coinbase and pegin
doublespendblock.vtx.append(raw_pegin)
doublespendblock.hashMerkleRoot = doublespendblock.calc_merkle_root()
add_witness_commitment(doublespendblock)
doublespendblock.solve()
block_hex = doublespendblock.serialize(True).hex()
assert_raises_rpc_error(-25, "bad-txns-double-pegin",
sidechain.testproposedblock, block_hex, True)
# Re-enters block
sidechain.generate(1)
if sidechain.gettransaction(pegtxid1)["confirmations"] != 1:
raise Exception("Peg-in should have one confirm on side block.")
sidechain.reconsiderblock(blockhash[0])
if sidechain.gettransaction(pegtxid1)["confirmations"] != 6:
raise Exception("Peg-in should be back to 6 confirms.")
# Now the pegin is already claimed in a confirmed tx.
# In that case, a duplicate claim should (1) not be accepted in the mempool
# and (2) not be accepted in a block.
assert_raises_rpc_error(-4, "pegin-already-claimed",
sidechain.claimpegin, raw, proof)
# For case (2), manually craft a block and include the tx.
doublespendblock = FromHex(CBlock(), sidechain.getnewblockhex())
doublespendblock.vtx.append(raw_pegin)
doublespendblock.hashMerkleRoot = doublespendblock.calc_merkle_root()
add_witness_commitment(doublespendblock)
doublespendblock.solve()
block_hex = doublespendblock.serialize(True).hex()
assert_raises_rpc_error(-25, "bad-txns-double-pegin",
sidechain.testproposedblock, block_hex, True)
# Do multiple claims in mempool
n_claims = 6
print("Flooding mempool with a few claims")
pegtxs = []
sidechain.generate(101)
# Do mixture of raw peg-in and automatic peg-in tx construction
# where raw creation is done on another node
for i in range(n_claims):
addrs = sidechain.getpeginaddress()
txid = parent.sendtoaddress(addrs["mainchain_address"], 1)
parent.generate(1)
proof = parent.gettxoutproof([txid])
raw = parent.gettransaction(txid)["hex"]
if i % 2 == 0:
parent.generate(11)
pegtxs += [sidechain.claimpegin(raw, proof)]
else:
# The raw API doesn't check for the additional 2 confirmation buffer
# So we only get 10 confirms then send off. Miners will add to block anyways.
# Don't mature whole way yet to test signing immature peg-in input
parent.generate(8)
# Wallet in sidechain2 gets funds instead of sidechain
raw_pegin = sidechain2.createrawpegin(
raw, proof, addrs["claim_script"])["hex"]
# First node should also be able to make a valid transaction with or without 3rd arg
# since this wallet originated the claim_script itself
sidechain.createrawpegin(raw, proof, addrs["claim_script"])
sidechain.createrawpegin(raw, proof)
signed_pegin = sidechain.signrawtransactionwithwallet(
raw_pegin)
assert signed_pegin["complete"]
assert "warning" in signed_pegin # warning for immature peg-in
# fully mature them now
parent.generate(1)
pegtxs += [sidechain.sendrawtransaction(signed_pegin["hex"])]
for node_group in self.node_groups:
self.sync_all(node_group)
sidechain2.generate(1)
for i, pegtxid in enumerate(pegtxs):
if i % 2 == 0:
tx = sidechain.gettransaction(pegtxid)
else:
tx = sidechain2.gettransaction(pegtxid)
if "confirmations" not in tx or tx["confirmations"] == 0:
raise Exception("Peg-in confirmation has failed.")
print("Test pegouts")
self.test_pegout(get_new_unconfidential_address(parent, "legacy"),
sidechain)
self.test_pegout(get_new_unconfidential_address(parent, "p2sh-segwit"),
sidechain)
self.test_pegout(get_new_unconfidential_address(parent, "bech32"),
sidechain)
print("Test pegout P2SH")
parent_chain_addr = get_new_unconfidential_address(parent)
parent_pubkey = parent.getaddressinfo(parent_chain_addr)["pubkey"]
parent_chain_p2sh_addr = parent.createmultisig(
1, [parent_pubkey])["address"]
self.test_pegout(parent_chain_p2sh_addr, sidechain)
print("Test pegout Garbage")
parent_chain_addr = "garbage"
try:
self.test_pegout(parent_chain_addr, sidechain)
raise Exception("A garbage address should fail.")
except JSONRPCException as e:
assert "Invalid Bitcoin address" in e.error["message"]
print("Test pegout Garbage valid")
prev_txid = sidechain.sendtoaddress(sidechain.getnewaddress(), 1)
sidechain.generate(1)
pegout_chain = 'a' * 64
pegout_hex = 'b' * 500
inputs = [{"txid": prev_txid, "vout": 0}]
outputs = {"vdata": [pegout_chain, pegout_hex]}
rawtx = sidechain.createrawtransaction(inputs, outputs)
raw_pegout = sidechain.decoderawtransaction(rawtx)
assert 'vout' in raw_pegout and len(raw_pegout['vout']) > 0
pegout_tested = False
for output in raw_pegout['vout']:
scriptPubKey = output['scriptPubKey']
if 'type' in scriptPubKey and scriptPubKey['type'] == 'nulldata':
assert 'pegout_hex' in scriptPubKey and 'pegout_asm' in scriptPubKey and 'pegout_type' in scriptPubKey
assert 'pegout_chain' in scriptPubKey and 'pegout_reqSigs' not in scriptPubKey and 'pegout_addresses' not in scriptPubKey
assert scriptPubKey['pegout_type'] == 'nonstandard'
assert scriptPubKey['pegout_chain'] == pegout_chain
assert scriptPubKey['pegout_hex'] == pegout_hex
pegout_tested = True
break
assert pegout_tested
print(
"Now test failure to validate peg-ins based on intermittent bitcoind rpc failure"
)
self.stop_node(1)
txid = parent.sendtoaddress(addr, 1)
parent.generate(12)
proof = parent.gettxoutproof([txid])
raw = parent.gettransaction(txid)["hex"]
sidechain.claimpegin(raw, proof) # stuck peg
sidechain.generate(1)
print("Waiting to ensure block is being rejected by sidechain2")
time.sleep(5)
assert sidechain.getblockcount() != sidechain2.getblockcount()
print("Restarting parent2")
self.start_node(1)
self.connect_nodes(0, 1)
# Don't make a block, race condition when pegin-invalid block
# is awaiting further validation, nodes reject subsequent blocks
# even ones they create
print(
"Now waiting for node to re-evaluate peg-in witness failed block... should take a few seconds"
)
for node_group in self.node_groups:
self.sync_all(node_group)
print("Completed!\n")
print("Now send funds out in two stages, partial, and full")
some_btc_addr = get_new_unconfidential_address(parent)
bal_1 = sidechain.getwalletinfo()["balance"]['bitcoin']
try:
sidechain.sendtomainchain(some_btc_addr, bal_1 + 1)
raise Exception("Sending out too much; should have failed")
except JSONRPCException as e:
assert "Insufficient funds" in e.error["message"]
assert sidechain.getwalletinfo()["balance"]["bitcoin"] == bal_1
try:
sidechain.sendtomainchain(some_btc_addr + "b", bal_1 - 1)
raise Exception("Sending to invalid address; should have failed")
except JSONRPCException as e:
assert "Invalid Bitcoin address" in e.error["message"]
assert sidechain.getwalletinfo()["balance"]["bitcoin"] == bal_1
try:
sidechain.sendtomainchain("1Nro9WkpaKm9axmcfPVp79dAJU1Gx7VmMZ",
bal_1 - 1)
raise Exception(
"Sending to mainchain address when should have been testnet; should have failed"
)
except JSONRPCException as e:
assert "Invalid Bitcoin address" in e.error["message"]
assert sidechain.getwalletinfo()["balance"]["bitcoin"] == bal_1
# Test superfluous peg-in witness data on regular spend before we have no funds
raw_spend = sidechain.createrawtransaction(
[], {sidechain.getnewaddress(): 1})
fund_spend = sidechain.fundrawtransaction(raw_spend)
sign_spend = sidechain.signrawtransactionwithwallet(fund_spend["hex"])
signed_struct = FromHex(CTransaction(), sign_spend["hex"])
# Non-witness tx has no witness serialized yet
if len(signed_struct.wit.vtxinwit) == 0:
signed_struct.wit.vtxinwit = [CTxInWitness()]
signed_struct.wit.vtxinwit[
0].peginWitness.stack = sample_pegin_witness.stack
assert_equal(
sidechain.testmempoolaccept([signed_struct.serialize().hex()
])[0]["allowed"], False)
assert_equal(
sidechain.testmempoolaccept([signed_struct.serialize().hex()
])[0]["reject-reason"],
"extra-pegin-witness")
signed_struct.wit.vtxinwit[0].peginWitness.stack = [b'\x00' * 100000
] # lol
assert_equal(
sidechain.testmempoolaccept([signed_struct.serialize().hex()
])[0]["allowed"], False)
assert_equal(
sidechain.testmempoolaccept([signed_struct.serialize().hex()
])[0]["reject-reason"],
"extra-pegin-witness")
peg_out_txid = sidechain.sendtomainchain(some_btc_addr, 1)
peg_out_details = sidechain.decoderawtransaction(
sidechain.getrawtransaction(peg_out_txid))
# peg-out, change, fee
assert len(peg_out_details["vout"]) == 3
found_pegout_value = False
for output in peg_out_details["vout"]:
if "value" in output and output["value"] == 1:
found_pegout_value = True
assert found_pegout_value
bal_2 = sidechain.getwalletinfo()["balance"]["bitcoin"]
# Make sure balance went down
assert bal_2 + 1 < bal_1
# Send rest of coins using subtractfee from output arg
sidechain.sendtomainchain(some_btc_addr, bal_2, True)
assert sidechain.getwalletinfo()["balance"]['bitcoin'] == 0
print('Test coinbase peg-in maturity rules')
# Have bitcoin output go directly into a claim output
pegin_info = sidechain.getpeginaddress()
mainchain_addr = pegin_info["mainchain_address"]
# Watch the address so we can get tx without txindex
parent.importaddress(mainchain_addr)
claim_block = parent.generatetoaddress(50, mainchain_addr)[0]
for node_group in self.node_groups:
self.sync_all(node_group)
block_coinbase = parent.getblock(claim_block, 2)["tx"][0]
claim_txid = block_coinbase["txid"]
claim_tx = block_coinbase["hex"]
claim_proof = parent.gettxoutproof([claim_txid], claim_block)
# Can't claim something even though it has 50 confirms since it's coinbase
assert_raises_rpc_error(
-8,
"Peg-in Bitcoin transaction needs more confirmations to be sent.",
sidechain.claimpegin, claim_tx, claim_proof)
# If done via raw API, still doesn't work
coinbase_pegin = sidechain.createrawpegin(claim_tx, claim_proof)
assert_equal(coinbase_pegin["mature"], False)
signed_pegin = sidechain.signrawtransactionwithwallet(
coinbase_pegin["hex"])["hex"]
assert_raises_rpc_error(
-26, "bad-pegin-witness, Needs more confirmations.",
sidechain.sendrawtransaction, signed_pegin)
# 50 more blocks to allow wallet to make it succeed by relay and consensus
parent.generatetoaddress(50, parent.getnewaddress())
for node_group in self.node_groups:
self.sync_all(node_group)
# Wallet still doesn't want to for 2 more confirms
assert_equal(
sidechain.createrawpegin(claim_tx, claim_proof)["mature"], False)
# But we can just shoot it off
claim_txid = sidechain.sendrawtransaction(signed_pegin)
sidechain.generatetoaddress(1, sidechain.getnewaddress())
for node_group in self.node_groups:
self.sync_all(node_group)
assert_equal(sidechain.gettransaction(claim_txid)["confirmations"], 1)
# Test a confidential pegin.
print("Performing a confidential pegin.")
# start pegin
pegin_addrs = sidechain.getpeginaddress()
assert_equal(
sidechain.decodescript(pegin_addrs["claim_script"])["type"],
"witness_v0_keyhash")
pegin_addr = addrs["mainchain_address"]
txid_fund = parent.sendtoaddress(pegin_addr, 10)
# 10+2 confirms required to get into mempool and confirm
parent.generate(11)
for node_group in self.node_groups:
self.sync_all(node_group)
proof = parent.gettxoutproof([txid_fund])
assert_equal(sidechain.gettransaction(claim_txid)["confirmations"], 1)
# Test a confidential pegin.
print("Performing a confidential pegin.")
# start pegin
pegin_addrs = sidechain.getpeginaddress()
assert_equal(
sidechain.decodescript(pegin_addrs["claim_script"])["type"],
"witness_v0_keyhash")
pegin_addr = addrs["mainchain_address"]
txid_fund = parent.sendtoaddress(pegin_addr, 10)
# 10+2 confirms required to get into mempool and confirm
parent.generate(11)
for node_group in self.node_groups:
self.sync_all(node_group)
proof = parent.gettxoutproof([txid_fund])
raw = parent.gettransaction(txid_fund)["hex"]
raw_pegin = sidechain.createrawpegin(raw, proof)['hex']
pegin = FromHex(CTransaction(), raw_pegin)
# add new blinding pubkey for the pegin output
pegin.vout[0].nNonce = CTxOutNonce(
hex_str_to_bytes(
sidechain.getaddressinfo(sidechain.getnewaddress(
"", "blech32"))["confidential_key"]))
# now add an extra input and output from listunspent; we need a blinded output for this
blind_addr = sidechain.getnewaddress("", "blech32")
sidechain.sendtoaddress(blind_addr, 15)
sidechain.generate(6)
# Make sure sidechain2 knows about the same input
for node_group in self.node_groups:
self.sync_all(node_group)
unspent = [
u for u in sidechain.listunspent(6, 6) if u["amount"] == 15
][0]
assert (unspent["spendable"])
assert ("amountcommitment" in unspent)
pegin.vin.append(
CTxIn(COutPoint(int(unspent["txid"], 16), unspent["vout"])))
# insert corresponding output before fee output
new_destination = sidechain.getaddressinfo(
sidechain.getnewaddress("", "blech32"))
new_dest_script_pk = hex_str_to_bytes(new_destination["scriptPubKey"])
new_dest_nonce = CTxOutNonce(
hex_str_to_bytes(new_destination["confidential_key"]))
new_dest_asset = pegin.vout[0].nAsset
pegin.vout.insert(
1,
CTxOut(
int(unspent["amount"] * COIN) - 10000, new_dest_script_pk,
new_dest_asset, new_dest_nonce))
# add the 10 ksat fee
pegin.vout[2].nValue.setToAmount(pegin.vout[2].nValue.getAmount() +
10000)
pegin_hex = ToHex(pegin)
# test with both blindraw and rawblindraw
raw_pegin_blinded1 = sidechain.blindrawtransaction(pegin_hex)
raw_pegin_blinded2 = sidechain.rawblindrawtransaction(
pegin_hex, ["", unspent["amountblinder"]], [10, 15],
[unspent["asset"]] * 2, ["", unspent["assetblinder"]], "", False)
pegin_signed1 = sidechain.signrawtransactionwithwallet(
raw_pegin_blinded1)
pegin_signed2 = sidechain.signrawtransactionwithwallet(
raw_pegin_blinded2)
for pegin_signed in [pegin_signed1, pegin_signed2]:
final_decoded = sidechain.decoderawtransaction(pegin_signed["hex"])
assert (final_decoded["vin"][0]["is_pegin"])
assert (not final_decoded["vin"][1]["is_pegin"])
assert ("assetcommitment" in final_decoded["vout"][0])
assert ("valuecommitment" in final_decoded["vout"][0])
assert ("commitmentnonce" in final_decoded["vout"][0])
assert ("value" not in final_decoded["vout"][0])
assert ("asset" not in final_decoded["vout"][0])
assert (final_decoded["vout"][0]["commitmentnonce_fully_valid"])
assert ("assetcommitment" in final_decoded["vout"][1])
assert ("valuecommitment" in final_decoded["vout"][1])
assert ("commitmentnonce" in final_decoded["vout"][1])
assert ("value" not in final_decoded["vout"][1])
assert ("asset" not in final_decoded["vout"][1])
assert (final_decoded["vout"][1]["commitmentnonce_fully_valid"])
assert ("value" in final_decoded["vout"][2])
assert ("asset" in final_decoded["vout"][2])
# check that it is accepted in either mempool
accepted = sidechain.testmempoolaccept([pegin_signed["hex"]])[0]
if not accepted["allowed"]:
raise Exception(accepted["reject-reason"])
accepted = sidechain2.testmempoolaccept([pegin_signed["hex"]])[0]
if not accepted["allowed"]:
raise Exception(accepted["reject-reason"])
print("Blinded transaction looks ok!"
) # need this print to distinguish failures in for loop
print('Success!')
# Manually stop sidechains first, then the parent chains.
self.stop_node(2)
self.stop_node(3)
self.stop_node(0)
self.stop_node(1)
def test_namescript_p2sh(self):
"""
Tests how name prefixes interact with P2SH outputs and redeem scripts.
"""
self.log.info("Testing name prefix and P2SH interactions...")
# This test only needs a single node and no syncing.
node = self.nodes[0]
name = "d/p2sh"
value = val("value")
node.name_register(name, value)
node.generate(1)
baseHeight = node.getblockcount()
self.checkNameWithHeight(0, name, value, baseHeight)
# Prepare some scripts and P2SH addresses we use later. We build the
# name script prefix for an update to our testname, so that we can build
# P2SH redeem scripts with (or without) it.
nameBytes = codecs.encode(name, 'ascii')
valueBytes = codecs.encode(value, 'ascii')
updOps = [OP_NAME_UPDATE, nameBytes, valueBytes, OP_2DROP, OP_DROP]
anyoneOps = [OP_TRUE]
updScript = CScript(updOps)
anyoneScript = CScript(anyoneOps)
updAndAnyoneScript = CScript(updOps + anyoneOps)
anyoneAddr = self.getP2SH(0, anyoneScript)
updAndAnyoneAddr = self.getP2SH(0, updAndAnyoneScript)
# Send the name to the anyone-can-spend name-update script directly.
# This is expected to update the name (verifies the update script is good).
tx = CTransaction()
data = node.name_show(name)
tx.vin.append(CTxIn(COutPoint(int(data['txid'], 16), data['vout'])))
tx.vout.append(CTxOut(COIN // 100, updAndAnyoneScript))
txHex = tx.serialize().hex()
txHex = node.fundrawtransaction(txHex)['hex']
signed = node.signrawtransactionwithwallet(txHex)
assert signed['complete']
node.sendrawtransaction(signed['hex'])
node.generate(1)
self.checkNameWithHeight(0, name, value, baseHeight + 1)
# Send the name to the anyone-can-spend P2SH address. This should just
# work fine and update the name.
self.updateAnyoneCanSpendName(0, name, val("value2"), anyoneAddr, [])
node.generate(1)
self.checkNameWithHeight(0, name, val("value2"), baseHeight + 2)
# Send a coin to the P2SH address with name prefix. This should just
# work fine but not update the name. We should be able to spend the coin
# again from that address.
txid = node.sendtoaddress(updAndAnyoneAddr, 2)
tx = node.getrawtransaction(txid)
ind = self.rawtxOutputIndex(0, tx, updAndAnyoneAddr)
node.generate(1)
ins = [{"txid": txid, "vout": ind}]
addr = node.getnewaddress()
out = {addr: 1}
tx = node.createrawtransaction(ins, out)
tx = self.setScriptSigOps(tx, 0, [updAndAnyoneScript])
node.sendrawtransaction(tx, 0)
node.generate(1)
self.checkNameWithHeight(0, name, val("value2"), baseHeight + 2)
found = False
for u in node.listunspent():
if u['address'] == addr and u['amount'] == 1:
found = True
break
if not found:
raise AssertionError("Coin not sent to expected address")
# Send the name to the P2SH address with name prefix and then spend it
# again. Spending should work fine, and the name should just be updated
# ordinarily; the name prefix of the redeem script should have no effect.
self.updateAnyoneCanSpendName(0, name, val("value3"), updAndAnyoneAddr,
[anyoneScript])
node.generate(1)
self.checkNameWithHeight(0, name, val("value3"), baseHeight + 5)
self.updateAnyoneCanSpendName(0, name, val("value4"), anyoneAddr,
[updAndAnyoneScript])
node.generate(1)
self.checkNameWithHeight(0, name, val("value4"), baseHeight + 6)
def test_too_many_replacements(self):
"""Replacements that evict too many transactions are rejected"""
# Try directly replacing more than MAX_REPLACEMENT_LIMIT
# transactions
# Start by creating a single transaction with many outputs
initial_nValue = 10 * COIN
utxo = make_utxo(self.nodes[0], initial_nValue)
fee = int(0.0001 * COIN)
split_value = int((initial_nValue - fee) / (MAX_REPLACEMENT_LIMIT + 1))
outputs = []
for _ in range(MAX_REPLACEMENT_LIMIT + 1):
outputs.append(CTxOut(split_value, CScript([1])))
splitting_tx = CTransaction()
splitting_tx.vin = [CTxIn(utxo, nSequence=0)]
splitting_tx.vout = outputs + [
CTxOut(
int(initial_nValue -
(MAX_REPLACEMENT_LIMIT + 1) * split_value))
]
splitting_tx_hex = txToHex(splitting_tx)
txid = self.nodes[0].sendrawtransaction(splitting_tx_hex, 0)
txid = int(txid, 16)
# Now spend each of those outputs individually
for i in range(MAX_REPLACEMENT_LIMIT + 1):
tx_i = CTransaction()
tx_i.vin = [CTxIn(COutPoint(txid, i), nSequence=0)]
tx_i.vout = [
CTxOut(split_value - fee, DUMMY_P2WPKH_SCRIPT),
CTxOut(fee)
]
tx_i_hex = txToHex(tx_i)
self.nodes[0].sendrawtransaction(tx_i_hex, 0)
# Now create doublespend of the whole lot; should fail.
# Need a big enough fee to cover all spending transactions and have
# a higher fee rate
double_spend_value = (split_value -
100 * fee) * (MAX_REPLACEMENT_LIMIT + 1)
inputs = []
for i in range(MAX_REPLACEMENT_LIMIT + 1):
inputs.append(CTxIn(COutPoint(txid, i), nSequence=0))
double_tx = CTransaction()
double_tx.vin = inputs
double_tx.vout = [
CTxOut(double_spend_value, CScript([b'a'])),
CTxOut(
int(split_value * (MAX_REPLACEMENT_LIMIT + 1) -
double_spend_value))
]
double_tx_hex = txToHex(double_tx)
# This will raise an exception
assert_raises_rpc_error(-26, "too many potential replacements",
self.nodes[0].sendrawtransaction,
double_tx_hex, 0)
# If we remove an input, it should pass
double_tx = CTransaction()
double_tx.vin = inputs[0:-1]
double_tx.vout = [
CTxOut(double_spend_value, CScript([b'a'])),
CTxOut(
int(split_value * (MAX_REPLACEMENT_LIMIT) -
double_spend_value))
]
double_tx_hex = txToHex(double_tx)
self.nodes[0].sendrawtransaction(double_tx_hex, 0)
def run_test(self):
(node, std_node) = self.nodes
node.add_p2p_connection(P2PDataStore())
std_node.add_p2p_connection(P2PDataStore())
# Get out of IBD
node.generatetoaddress(1, node.get_deterministic_priv_key().address)
tip = self.getbestblock(node)
self.log.info("Create some blocks with OP_1 coinbase for spending.")
blocks = []
for _ in range(20):
tip = self.build_block(tip)
blocks.append(tip)
node.p2p.send_blocks_and_test(blocks, node, success=True)
self.spendable_outputs = deque(block.vtx[0] for block in blocks)
self.log.info("Mature the blocks.")
node.generatetoaddress(100, node.get_deterministic_priv_key().address)
tip = self.getbestblock(node)
self.log.info("Generating some high-sigop transactions.")
# Tx with 4001 sigops (valid but non standard)
tx_4001 = create_transaction(self.spendable_outputs.popleft(), [
OP_CHECKMULTISIG] * 200 + [OP_CHECKDATASIG])
# Tx with 20001 sigops (consensus-invalid)
tx_20001 = create_transaction(self.spendable_outputs.popleft(), [
OP_CHECKMULTISIG] * 1000 + [OP_CHECKDATASIG])
# P2SH tx with too many sigops (valid but nonstandard for std_node)
redeem_script = bytes(
[OP_IF, OP_CHECKMULTISIG, OP_ENDIF, OP_TRUE])
p2sh_script = CScript([OP_HASH160, hash160(redeem_script), OP_EQUAL])
tx_fundp2sh = create_transaction(
self.spendable_outputs.popleft(), p2sh_script)
tx_spendp2sh = CTransaction()
tx_spendp2sh.vin.append(
CTxIn(COutPoint(tx_fundp2sh.sha256, 1), CScript([OP_FALSE, redeem_script])))
tx_spendp2sh.vout.append(
CTxOut(0, CScript([OP_RETURN, b'pad' * 20])))
tx_spendp2sh.rehash()
# Chain of 10 txes with 2000 sigops each.
txes_10x2000_sigops = []
tx = self.spendable_outputs.popleft()
for _ in range(10):
tx = create_transaction(tx, [OP_CHECKMULTISIG] * 100)
txes_10x2000_sigops.append(tx)
def make_hightotalsigop_block():
# 20001 total sigops
return self.build_block(
tip, txes_10x2000_sigops, cbextrascript=bytes([OP_CHECKDATASIG]))
def make_highsigop_coinbase_block():
# 60000 sigops in the coinbase
return self.build_block(
tip, cbextrascript=bytes([OP_CHECKMULTISIG] * 3000))
self.log.info(
"Try various high-sigop transactions in blocks / mempool before upgrade")
# mempool refuses over 4001.
check_for_no_ban_on_rejected_tx(node, tx_4001, MEMPOOL_TXSIGOPS_ERROR)
# it used to be that exceeding 20000 would cause a ban, but it's
# important that this causes no ban: we want that upgraded nodes
# can't get themselves banned by relaying huge-sigops transactions.
check_for_no_ban_on_rejected_tx(node, tx_20001, MEMPOOL_TXSIGOPS_ERROR)
# the 20001 tx can't be mined
check_for_ban_on_rejected_block(node, self.build_block(
tip, [tx_20001]), BLOCK_TXSIGOPS_ERROR)
self.log.info(
"The P2SH script has too many sigops (20 > 15) for a standard node.")
# Mine the P2SH funding first because it's nonstandard.
tip = self.build_block(tip, [tx_fundp2sh])
std_node.p2p.send_blocks_and_test([tip], node)
assert_raises_rpc_error(-26, MEMPOOL_P2SH_SIGOPS_ERROR,
std_node.sendrawtransaction, ToHex(tx_spendp2sh))
self.log.info(
"A bunch of 2000-sigops txes can be put in mempool but not mined all at once.")
# Send the 2000-sigop transactions, which are acceptable.
for tx in txes_10x2000_sigops:
node.sendrawtransaction(ToHex(tx))
# They can't be mined all at once if the coinbase has a single sigop
# (total 20001)
check_for_ban_on_rejected_block(
node, make_hightotalsigop_block(), BLOCK_TOTALSIGOPS_ERROR)
# Activation tests
self.log.info("Approach to just before upgrade activation")
# Move our clock to the uprade time so we will accept such
# future-timestamped blocks.
node.setmocktime(SIGOPS_DEACTIVATION_TIME)
std_node.setmocktime(SIGOPS_DEACTIVATION_TIME)
# Mine six blocks with timestamp starting at SIGOPS_DEACTIVATION_TIME-1
blocks = []
for i in range(-1, 5):
tip = self.build_block(tip, nTime=SIGOPS_DEACTIVATION_TIME + i)
blocks.append(tip)
node.p2p.send_blocks_and_test(blocks, node)
assert_equal(node.getblockchaininfo()[
'mediantime'], SIGOPS_DEACTIVATION_TIME - 1)
self.log.info(
"The next block will activate, but the activation block itself must follow old rules")
check_for_ban_on_rejected_block(node, self.build_block(
tip, [tx_20001]), BLOCK_TXSIGOPS_ERROR)
check_for_ban_on_rejected_block(
node, make_hightotalsigop_block(), BLOCK_TOTALSIGOPS_ERROR)
check_for_ban_on_rejected_block(
node, make_highsigop_coinbase_block(), BLOCK_TXSIGOPS_ERROR)
self.log.info("Mine the activation block itself")
tip = self.build_block(tip)
node.p2p.send_blocks_and_test([tip], node)
sync_blocks(self.nodes)
self.log.info("We have activated!")
assert_equal(node.getblockchaininfo()[
'mediantime'], SIGOPS_DEACTIVATION_TIME)
assert_equal(std_node.getblockchaininfo()[
'mediantime'], SIGOPS_DEACTIVATION_TIME)
# save this tip for later
upgrade_block = tip
self.log.info(
"The mempool is now a free-for-all, and we can get all the high-sigops transactions in")
std_node.sendrawtransaction(ToHex(tx_spendp2sh))
node.sendrawtransaction(ToHex(tx_spendp2sh))
node.sendrawtransaction(ToHex(tx_4001))
node.sendrawtransaction(ToHex(tx_20001))
# resend the 2000-sigop transactions, which will have expired due to
# setmocktime.
for tx in txes_10x2000_sigops:
node.sendrawtransaction(ToHex(tx))
alltxes = set(tx.hash for tx in [
tx_spendp2sh, tx_4001, tx_20001] + txes_10x2000_sigops)
assert_equal(set(node.getrawmempool()), alltxes)
self.log.info(
"The miner will include all the high-sigops transactions at once, without issue.")
node.generatetoaddress(1, node.get_deterministic_priv_key().address)
tip = self.getbestblock(node)
assert_equal(set(tx.rehash() for tx in tip.vtx[1:]), alltxes)
# even though it is far smaller than one megabyte, we got in something
# like 44000 sigops
assert len(tip.serialize()) < ONE_MEGABYTE
# save this tip for later
postupgrade_block = tip
# Deactivation tests
self.log.info(
"Invalidating the post-upgrade block returns the transactions to mempool")
node.invalidateblock(postupgrade_block.hash)
assert_equal(set(node.getrawmempool()), alltxes)
self.log.info("Test some weird alternative blocks")
tip = upgrade_block
self.log.info("A 40000-sigop coinbase is acceptable now")
tip = make_highsigop_coinbase_block()
node.p2p.send_blocks_and_test([tip], node)
self.log.info("We can get in our 20001 sigop total block")
tip = make_hightotalsigop_block()
node.p2p.send_blocks_and_test([tip], node)
self.log.info(
"Invalidating the upgrade block evicts the bad txes")
goodtxes = alltxes - {tx_4001.hash, tx_20001.hash}
# loose-rules node just evicts the too-many-sigops transactions
node.invalidateblock(upgrade_block.hash)
assert_equal(set(node.getrawmempool()), goodtxes)
# std_node evicts everything as either nonstandard scriptpubkey or p2sh
# too-many-sigops.
std_node.invalidateblock(upgrade_block.hash)
assert_equal(std_node.getrawmempool(), [])
def run_test(self):
node = self.nodes[0] # convenience reference to the node
self.bootstrap_p2p() # Add one p2p connection to the node
best_block = self.nodes[0].getbestblockhash()
tip = int(best_block, 16)
best_block_time = self.nodes[0].getblock(best_block)['time']
block_time = best_block_time + 1
self.log.info("Create a new block with an anyone-can-spend coinbase.")
height = 1
block = create_block(tip, create_coinbase(height), block_time)
block.solve()
# Save the coinbase for later
block1 = block
tip = block.sha256
node.p2p.send_blocks_and_test([block], node, success=True)
self.log.info("Mature the block.")
self.nodes[0].generate(100)
# b'\x64' is OP_NOTIF
# Transaction will be rejected with code 16 (REJECT_INVALID)
# and we get disconnected immediately
self.log.info('Test a transaction that is rejected')
tx1 = create_transaction(block1.vtx[0], 0, b'\x64', 50 * COIN - 12000)
node.p2p.send_txs_and_test([tx1],
node,
success=False,
expect_disconnect=True)
# Make two p2p connections to provide the node with orphans
# * p2ps[0] will send valid orphan txs (one with low fee)
# * p2ps[1] will send an invalid orphan tx (and is later disconnected for that)
self.reconnect_p2p(num_connections=2)
self.log.info('Test orphan transaction handling ... ')
# Create a root transaction that we withold until all dependend transactions
# are sent out and in the orphan cache
tx_withhold = CTransaction()
tx_withhold.vin.append(
CTxIn(outpoint=COutPoint(block1.vtx[0].sha256, 0)))
tx_withhold.vout.append(
CTxOut(nValue=50 * COIN - 12000, scriptPubKey=b'\x51'))
tx_withhold.calc_sha256()
# Our first orphan tx with some outputs to create further orphan txs
tx_orphan_1 = CTransaction()
tx_orphan_1.vin.append(
CTxIn(outpoint=COutPoint(tx_withhold.sha256, 0)))
tx_orphan_1.vout = [CTxOut(nValue=10 * COIN, scriptPubKey=b'\x51')] * 3
tx_orphan_1.calc_sha256()
# A valid transaction with low fee
tx_orphan_2_no_fee = CTransaction()
tx_orphan_2_no_fee.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 0)))
tx_orphan_2_no_fee.vout.append(
CTxOut(nValue=10 * COIN, scriptPubKey=b'\x51'))
# A valid transaction with sufficient fee
tx_orphan_2_valid = CTransaction()
tx_orphan_2_valid.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 1)))
tx_orphan_2_valid.vout.append(
CTxOut(nValue=10 * COIN - 12000, scriptPubKey=b'\x51'))
tx_orphan_2_valid.calc_sha256()
# An invalid transaction with negative fee
tx_orphan_2_invalid = CTransaction()
tx_orphan_2_invalid.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 2)))
tx_orphan_2_invalid.vout.append(
CTxOut(nValue=11 * COIN, scriptPubKey=b'\x51'))
self.log.info('Send the orphans ... ')
# Send valid orphan txs from p2ps[0]
node.p2p.send_txs_and_test(
[tx_orphan_1, tx_orphan_2_no_fee, tx_orphan_2_valid],
node,
success=False)
# Send invalid tx from p2ps[1]
node.p2ps[1].send_txs_and_test([tx_orphan_2_invalid],
node,
success=False)
assert_equal(0,
node.getmempoolinfo()['size']) # Mempool should be empty
assert_equal(2, len(node.getpeerinfo())) # p2ps[1] is still connected
self.log.info('Send the withhold tx ... ')
node.p2p.send_txs_and_test([tx_withhold], node, success=True)
# Transactions that should end up in the mempool
expected_mempool = {
t.hash
for t in [
tx_withhold, # The transaction that is the root for all orphans
tx_orphan_1, # The orphan transaction that splits the coins
tx_orphan_2_valid, # The valid transaction (with sufficient fee)
]
}
# Transactions that do not end up in the mempool
# tx_orphan_no_fee, because it has too low fee (p2ps[0] is not disconnected for relaying that tx)
# tx_orphan_invaid, because it has negative fee (p2ps[1] is disconnected for relaying that tx)
wait_until(lambda: 1 == len(node.getpeerinfo()),
timeout=12) # p2ps[1] is no longer connected
assert_equal(expected_mempool, set(node.getrawmempool()))
def run_test(self):
self.nodes[0].generate(161) # block 161
self.log.info("Verify sigops are counted in GBT with pre-BIP141 rules before the fork")
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
tmpl = self.nodes[0].getblocktemplate({'rules': ['segwit']})
assert tmpl['sizelimit'] == 100000
assert 'weightlimit' not in tmpl
assert tmpl['sigoplimit'] == 2000
assert tmpl['transactions'][0]['hash'] == txid
assert tmpl['transactions'][0]['sigops'] == 2
tmpl = self.nodes[0].getblocktemplate({'rules': ['segwit']})
assert tmpl['sizelimit'] == 100000
assert 'weightlimit' not in tmpl
assert tmpl['sigoplimit'] == 2000
assert tmpl['transactions'][0]['hash'] == txid
assert tmpl['transactions'][0]['sigops'] == 2
self.nodes[0].generate(1) # block 162
balance_presetup = self.nodes[0].getbalance()
self.pubkey = []
p2sh_ids = [] # p2sh_ids[NODE][VER] is an array of txids that spend to a witness version VER pkscript to an address for NODE embedded in p2sh
wit_ids = [] # wit_ids[NODE][VER] is an array of txids that spend to a witness version VER pkscript to an address for NODE via bare witness
for i in range(3):
newaddress = self.nodes[i].getnewaddress()
self.pubkey.append(self.nodes[i].getaddressinfo(newaddress)["pubkey"])
multiscript = CScript([OP_1, hex_str_to_bytes(self.pubkey[-1]), OP_1, OP_CHECKMULTISIG])
p2sh_ms_addr = self.nodes[i].addmultisigaddress(1, [self.pubkey[-1]], '', 'p2sh-segwit')['address']
bip173_ms_addr = self.nodes[i].addmultisigaddress(1, [self.pubkey[-1]], '', 'bech32')['address']
assert_equal(p2sh_ms_addr, script_to_p2sh_p2wsh(multiscript))
assert_equal(bip173_ms_addr, script_to_p2wsh(multiscript))
p2sh_ids.append([])
wit_ids.append([])
for v in range(2):
p2sh_ids[i].append([])
wit_ids[i].append([])
for i in range(5):
for n in range(3):
for v in range(2):
wit_ids[n][v].append(send_to_witness(v, self.nodes[0], find_spendable_utxo(self.nodes[0], 50), self.pubkey[n], False, Decimal("49.999")))
p2sh_ids[n][v].append(send_to_witness(v, self.nodes[0], find_spendable_utxo(self.nodes[0], 50), self.pubkey[n], True, Decimal("49.999")))
self.nodes[0].generate(1) # block 163
self.sync_blocks()
# Make sure all nodes recognize the transactions as theirs
assert_equal(self.nodes[0].getbalance(), balance_presetup - 60 * 50 + 20 * Decimal("49.999") + 50)
assert_equal(self.nodes[1].getbalance(), 20 * Decimal("49.999"))
assert_equal(self.nodes[2].getbalance(), 20 * Decimal("49.999"))
self.nodes[0].generate(260) # block 423
self.sync_blocks()
self.log.info("Verify witness txs are skipped for mining before the fork")
self.skip_mine(self.nodes[2], wit_ids[NODE_2][WIT_V0][0], True) # block 424
self.skip_mine(self.nodes[2], wit_ids[NODE_2][WIT_V1][0], True) # block 425
self.skip_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V0][0], True) # block 426
self.skip_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V1][0], True) # block 427
self.log.info("Verify unsigned p2sh witness txs without a redeem script are invalid")
self.fail_accept(self.nodes[2], "mandatory-script-verify-flag", p2sh_ids[NODE_2][WIT_V0][1], False)
self.fail_accept(self.nodes[2], "mandatory-script-verify-flag", p2sh_ids[NODE_2][WIT_V1][1], False)
self.nodes[2].generate(4) # blocks 428-431
self.log.info("Verify previous witness txs skipped for mining can now be mined")
assert_equal(len(self.nodes[2].getrawmempool()), 4)
blockhash = self.nodes[2].generate(1)[0] # block 432 (first block with new rules; 432 = 144 * 3)
self.sync_blocks()
assert_equal(len(self.nodes[2].getrawmempool()), 0)
segwit_tx_list = self.nodes[2].getblock(blockhash)["tx"]
assert_equal(len(segwit_tx_list), 5)
self.log.info("Verify default node can't accept txs with missing witness")
# unsigned, no scriptsig
self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", wit_ids[NODE_0][WIT_V0][0], False)
self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", wit_ids[NODE_0][WIT_V1][0], False)
self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", p2sh_ids[NODE_0][WIT_V0][0], False)
self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", p2sh_ids[NODE_0][WIT_V1][0], False)
# unsigned with redeem script
self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", p2sh_ids[NODE_0][WIT_V0][0], False, witness_script(False, self.pubkey[0]))
self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", p2sh_ids[NODE_0][WIT_V1][0], False, witness_script(True, self.pubkey[0]))
self.log.info("Verify block and transaction serialization rpcs return differing serializations depending on rpc serialization flag")
assert self.nodes[2].getblock(blockhash, False) != self.nodes[0].getblock(blockhash, False)
assert self.nodes[1].getblock(blockhash, False) == self.nodes[2].getblock(blockhash, False)
for tx_id in segwit_tx_list:
tx = FromHex(CTransaction(), self.nodes[2].gettransaction(tx_id)["hex"])
assert self.nodes[2].getrawtransaction(tx_id, False, blockhash) != self.nodes[0].getrawtransaction(tx_id, False, blockhash)
assert self.nodes[1].getrawtransaction(tx_id, False, blockhash) == self.nodes[2].getrawtransaction(tx_id, False, blockhash)
assert self.nodes[0].getrawtransaction(tx_id, False, blockhash) != self.nodes[2].gettransaction(tx_id)["hex"]
assert self.nodes[1].getrawtransaction(tx_id, False, blockhash) == self.nodes[2].gettransaction(tx_id)["hex"]
assert self.nodes[0].getrawtransaction(tx_id, False, blockhash) == tx.serialize_without_witness().hex()
self.log.info("Verify witness txs without witness data are invalid after the fork")
self.fail_accept(self.nodes[2], 'non-mandatory-script-verify-flag (Witness program hash mismatch) (code 64)', wit_ids[NODE_2][WIT_V0][2], sign=False)
self.fail_accept(self.nodes[2], 'non-mandatory-script-verify-flag (Witness program was passed an empty witness) (code 64)', wit_ids[NODE_2][WIT_V1][2], sign=False)
self.fail_accept(self.nodes[2], 'non-mandatory-script-verify-flag (Witness program hash mismatch) (code 64)', p2sh_ids[NODE_2][WIT_V0][2], sign=False, redeem_script=witness_script(False, self.pubkey[2]))
self.fail_accept(self.nodes[2], 'non-mandatory-script-verify-flag (Witness program was passed an empty witness) (code 64)', p2sh_ids[NODE_2][WIT_V1][2], sign=False, redeem_script=witness_script(True, self.pubkey[2]))
self.log.info("Verify default node can now use witness txs")
self.success_mine(self.nodes[0], wit_ids[NODE_0][WIT_V0][0], True) # block 432
self.success_mine(self.nodes[0], wit_ids[NODE_0][WIT_V1][0], True) # block 433
self.success_mine(self.nodes[0], p2sh_ids[NODE_0][WIT_V0][0], True) # block 434
self.success_mine(self.nodes[0], p2sh_ids[NODE_0][WIT_V1][0], True) # block 435
self.log.info("Verify sigops are counted in GBT with BIP141 rules after the fork")
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
tmpl = self.nodes[0].getblocktemplate({'rules': ['segwit']})
assert tmpl['sizelimit'] >= 390000 # actual maximum size is lower due to minimum mandatory non-witness data
assert tmpl['weightlimit'] == 400000
assert tmpl['sigoplimit'] == 8000
assert tmpl['transactions'][0]['txid'] == txid
assert tmpl['transactions'][0]['sigops'] == 8
self.nodes[0].generate(1) # Mine a block to clear the gbt cache
self.log.info("Non-segwit miners are able to use GBT response after activation.")
# Create a 3-tx chain: tx1 (non-segwit input, paying to a segwit output) ->
# tx2 (segwit input, paying to a non-segwit output) ->
# tx3 (non-segwit input, paying to a non-segwit output).
# tx1 is allowed to appear in the block, but no others.
txid1 = send_to_witness(1, self.nodes[0], find_spendable_utxo(self.nodes[0], 50), self.pubkey[0], False, Decimal("49.996"))
hex_tx = self.nodes[0].gettransaction(txid)['hex']
tx = FromHex(CTransaction(), hex_tx)
assert tx.wit.is_null() # This should not be a segwit input
assert txid1 in self.nodes[0].getrawmempool()
# Now create tx2, which will spend from txid1.
tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(int(txid1, 16), 0), b''))
tx.vout.append(CTxOut(int(49.99 * COIN), CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
tx2_hex = self.nodes[0].signrawtransactionwithwallet(ToHex(tx))['hex']
txid2 = self.nodes[0].sendrawtransaction(tx2_hex)
tx = FromHex(CTransaction(), tx2_hex)
assert not tx.wit.is_null()
# Now create tx3, which will spend from txid2
tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(int(txid2, 16), 0), b""))
tx.vout.append(CTxOut(int(49.95 * COIN), CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE]))) # Huge fee
tx.calc_sha256()
txid3 = self.nodes[0].sendrawtransaction(ToHex(tx))
assert tx.wit.is_null()
assert txid3 in self.nodes[0].getrawmempool()
# Check that getblocktemplate includes all transactions.
template = self.nodes[0].getblocktemplate({"rules": ["segwit"]})
template_txids = [t['txid'] for t in template['transactions']]
assert txid1 in template_txids
assert txid2 in template_txids
assert txid3 in template_txids
# Check that wtxid is properly reported in mempool entry
assert_equal(int(self.nodes[0].getmempoolentry(txid3)["wtxid"], 16), tx.calc_sha256(True))
# Mine a block to clear the gbt cache again.
self.nodes[0].generate(1)
self.log.info("Verify behaviour of importaddress and listunspent")
# Some public keys to be used later
pubkeys = [
"0363D44AABD0F1699138239DF2F042C3282C0671CC7A76826A55C8203D90E39242", # b4Vfz2Ly8GAubXRrhpSGF9ctmorBYVzdokEQcDrbV2EmnzB5LonH
"02D3E626B3E616FC8662B489C123349FECBFC611E778E5BE739B257EAE4721E5BF", # b4bVUqL7X7ZJpqzDnF6Ks32YM9GXbVdrEbmznQMRXcTixRM1AbGA
"04A47F2CBCEFFA7B9BCDA184E7D5668D3DA6F9079AD41E422FA5FD7B2D458F2538A62F5BD8EC85C2477F39650BD391EA6250207065B2A81DA8B009FC891E898F0E", # 8iW8cP2tV3YUkc8XrPz3v7CvFjV5VkhpzgKos82q1LWshZEooJo
"02A47F2CBCEFFA7B9BCDA184E7D5668D3DA6F9079AD41E422FA5FD7B2D458F2538", # b4BabAFLEnDwVU4FB2SosQPc42WvquuCqaa1rE34tV8rmhbQbjQv
"036722F784214129FEB9E8129D626324F3F6716555B603FFE8300BBCB882151228", # b54DUJnyPL6VQMoCd4sXtvCBvhM1vG2vSCwqShSRE8ryS7Cuu9H1
"0266A8396EE936BF6D99D17920DB21C6C7B1AB14C639D5CD72B300297E416FD2EC", # b8HQcxqFUhg4BsdjE21bisYRkwT4jvKhTUmcYh5ege5SQbLsmrAz
"0450A38BD7F0AC212FEBA77354A9B036A32E0F7C81FC4E0C5ADCA7C549C4505D2522458C2D9AE3CEFD684E039194B72C8A10F9CB9D4764AB26FCC2718D421D3B84", # 92h2XPssjBpsJN5CqSP7v9a7cf2kgDunBC6PDFwJHMACM1rrVBJ
]
# Import a compressed key and an uncompressed key, generate some multisig addresses
self.nodes[0].importprivkey("8j9PwFko4f5TjUAyE9ssZAQSNmbCHXdV6sBwuh2ouxyeg41E8Vu")
uncompressed_spendable_address = ["cg37jZdKe7YsxJMUVZNKD36EuaDpPdbZqe"]
self.nodes[0].importprivkey("b2yTVwqY6fX1PqXUEqWbUCYAaUo4YFQc8nRZavfUt9Ki77ewQaDr")
compressed_spendable_address = ["cWjYG6zbUdBfsULfCHD8xQF928QYxcy4ZZ"]
assert not self.nodes[0].getaddressinfo(uncompressed_spendable_address[0])['iscompressed']
assert self.nodes[0].getaddressinfo(compressed_spendable_address[0])['iscompressed']
self.nodes[0].importpubkey(pubkeys[0])
compressed_solvable_address = [key_to_p2pkh(pubkeys[0])]
self.nodes[0].importpubkey(pubkeys[1])
compressed_solvable_address.append(key_to_p2pkh(pubkeys[1]))
self.nodes[0].importpubkey(pubkeys[2])
uncompressed_solvable_address = [key_to_p2pkh(pubkeys[2])]
spendable_anytime = [] # These outputs should be seen anytime after importprivkey and addmultisigaddress
spendable_after_importaddress = [] # These outputs should be seen after importaddress
solvable_after_importaddress = [] # These outputs should be seen after importaddress but not spendable
unsolvable_after_importaddress = [] # These outputs should be unsolvable after importaddress
solvable_anytime = [] # These outputs should be solvable after importpubkey
unseen_anytime = [] # These outputs should never be seen
uncompressed_spendable_address.append(self.nodes[0].addmultisigaddress(2, [uncompressed_spendable_address[0], compressed_spendable_address[0]])['address'])
uncompressed_spendable_address.append(self.nodes[0].addmultisigaddress(2, [uncompressed_spendable_address[0], uncompressed_spendable_address[0]])['address'])
compressed_spendable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_spendable_address[0], compressed_spendable_address[0]])['address'])
uncompressed_solvable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_spendable_address[0], uncompressed_solvable_address[0]])['address'])
compressed_solvable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_spendable_address[0], compressed_solvable_address[0]])['address'])
compressed_solvable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_solvable_address[0], compressed_solvable_address[1]])['address'])
# Test multisig_without_privkey
# We have 2 public keys without private keys, use addmultisigaddress to add to wallet.
# Money sent to P2SH of multisig of this should only be seen after importaddress with the BASE58 P2SH address.
multisig_without_privkey_address = self.nodes[0].addmultisigaddress(2, [pubkeys[3], pubkeys[4]])['address']
script = CScript([OP_2, hex_str_to_bytes(pubkeys[3]), hex_str_to_bytes(pubkeys[4]), OP_2, OP_CHECKMULTISIG])
solvable_after_importaddress.append(CScript([OP_HASH160, hash160(script), OP_EQUAL]))
for i in compressed_spendable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
[bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
# p2sh multisig with compressed keys should always be spendable
spendable_anytime.extend([p2sh])
# bare multisig can be watched and signed, but is not treated as ours
solvable_after_importaddress.extend([bare])
# P2WSH and P2SH(P2WSH) multisig with compressed keys are spendable after direct importaddress
spendable_after_importaddress.extend([p2wsh, p2sh_p2wsh])
else:
[p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
# normal P2PKH and P2PK with compressed keys should always be spendable
spendable_anytime.extend([p2pkh, p2pk])
# P2SH_P2PK, P2SH_P2PKH with compressed keys are spendable after direct importaddress
spendable_after_importaddress.extend([p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh])
# P2WPKH and P2SH_P2WPKH with compressed keys should always be spendable
spendable_anytime.extend([p2wpkh, p2sh_p2wpkh])
for i in uncompressed_spendable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
[bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
# p2sh multisig with uncompressed keys should always be spendable
spendable_anytime.extend([p2sh])
# bare multisig can be watched and signed, but is not treated as ours
solvable_after_importaddress.extend([bare])
# P2WSH and P2SH(P2WSH) multisig with uncompressed keys are never seen
unseen_anytime.extend([p2wsh, p2sh_p2wsh])
else:
[p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
# normal P2PKH and P2PK with uncompressed keys should always be spendable
spendable_anytime.extend([p2pkh, p2pk])
# P2SH_P2PK and P2SH_P2PKH are spendable after direct importaddress
spendable_after_importaddress.extend([p2sh_p2pk, p2sh_p2pkh])
# Witness output types with uncompressed keys are never seen
unseen_anytime.extend([p2wpkh, p2sh_p2wpkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh])
for i in compressed_solvable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
# Multisig without private is not seen after addmultisigaddress, but seen after importaddress
[bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
solvable_after_importaddress.extend([bare, p2sh, p2wsh, p2sh_p2wsh])
else:
[p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
# normal P2PKH, P2PK, P2WPKH and P2SH_P2WPKH with compressed keys should always be seen
solvable_anytime.extend([p2pkh, p2pk, p2wpkh, p2sh_p2wpkh])
# P2SH_P2PK, P2SH_P2PKH with compressed keys are seen after direct importaddress
solvable_after_importaddress.extend([p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh])
for i in uncompressed_solvable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
[bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
# Base uncompressed multisig without private is not seen after addmultisigaddress, but seen after importaddress
solvable_after_importaddress.extend([bare, p2sh])
# P2WSH and P2SH(P2WSH) multisig with uncompressed keys are never seen
unseen_anytime.extend([p2wsh, p2sh_p2wsh])
else:
[p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
# normal P2PKH and P2PK with uncompressed keys should always be seen
solvable_anytime.extend([p2pkh, p2pk])
# P2SH_P2PK, P2SH_P2PKH with uncompressed keys are seen after direct importaddress
solvable_after_importaddress.extend([p2sh_p2pk, p2sh_p2pkh])
# Witness output types with uncompressed keys are never seen
unseen_anytime.extend([p2wpkh, p2sh_p2wpkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh])
op1 = CScript([OP_1])
op0 = CScript([OP_0])
# dTXLAVZMSwCLfWDF4us6U6F1FWbyWyBYwK is the P2SH(P2PKH) version of cV2MQNbEFyXpjGihDYNqf4s1RQGbS94jVC
unsolvable_address_key = hex_str_to_bytes("02341AEC7587A51CDE5279E0630A531AEA2615A9F80B17E8D9376327BAEAA59E3D")
unsolvablep2pkh = CScript([OP_DUP, OP_HASH160, hash160(unsolvable_address_key), OP_EQUALVERIFY, OP_CHECKSIG])
unsolvablep2wshp2pkh = CScript([OP_0, sha256(unsolvablep2pkh)])
p2shop0 = CScript([OP_HASH160, hash160(op0), OP_EQUAL])
p2wshop1 = CScript([OP_0, sha256(op1)])
unsolvable_after_importaddress.append(unsolvablep2pkh)
unsolvable_after_importaddress.append(unsolvablep2wshp2pkh)
unsolvable_after_importaddress.append(op1) # OP_1 will be imported as script
unsolvable_after_importaddress.append(p2wshop1)
unseen_anytime.append(op0) # OP_0 will be imported as P2SH address with no script provided
unsolvable_after_importaddress.append(p2shop0)
spendable_txid = []
solvable_txid = []
spendable_txid.append(self.mine_and_test_listunspent(spendable_anytime, 2))
solvable_txid.append(self.mine_and_test_listunspent(solvable_anytime, 1))
self.mine_and_test_listunspent(spendable_after_importaddress + solvable_after_importaddress + unseen_anytime + unsolvable_after_importaddress, 0)
importlist = []
for i in compressed_spendable_address + uncompressed_spendable_address + compressed_solvable_address + uncompressed_solvable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
bare = hex_str_to_bytes(v['hex'])
importlist.append(bare.hex())
importlist.append(CScript([OP_0, sha256(bare)]).hex())
else:
pubkey = hex_str_to_bytes(v['pubkey'])
p2pk = CScript([pubkey, OP_CHECKSIG])
p2pkh = CScript([OP_DUP, OP_HASH160, hash160(pubkey), OP_EQUALVERIFY, OP_CHECKSIG])
importlist.append(p2pk.hex())
importlist.append(p2pkh.hex())
importlist.append(CScript([OP_0, hash160(pubkey)]).hex())
importlist.append(CScript([OP_0, sha256(p2pk)]).hex())
importlist.append(CScript([OP_0, sha256(p2pkh)]).hex())
importlist.append(unsolvablep2pkh.hex())
importlist.append(unsolvablep2wshp2pkh.hex())
importlist.append(op1.hex())
importlist.append(p2wshop1.hex())
for i in importlist:
# import all generated addresses. The wallet already has the private keys for some of these, so catch JSON RPC
# exceptions and continue.
try_rpc(-4, "The wallet already contains the private key for this address or script", self.nodes[0].importaddress, i, "", False, True)
self.nodes[0].importaddress(script_to_p2sh(op0)) # import OP_0 as address only
self.nodes[0].importaddress(multisig_without_privkey_address) # Test multisig_without_privkey
spendable_txid.append(self.mine_and_test_listunspent(spendable_anytime + spendable_after_importaddress, 2))
solvable_txid.append(self.mine_and_test_listunspent(solvable_anytime + solvable_after_importaddress, 1))
self.mine_and_test_listunspent(unsolvable_after_importaddress, 1)
self.mine_and_test_listunspent(unseen_anytime, 0)
spendable_txid.append(self.mine_and_test_listunspent(spendable_anytime + spendable_after_importaddress, 2))
solvable_txid.append(self.mine_and_test_listunspent(solvable_anytime + solvable_after_importaddress, 1))
self.mine_and_test_listunspent(unsolvable_after_importaddress, 1)
self.mine_and_test_listunspent(unseen_anytime, 0)
# Repeat some tests. This time we don't add witness scripts with importaddress
# Import a compressed key and an uncompressed key, generate some multisig addresses
self.nodes[0].importprivkey("8id8M1PDTjZimEZBfxp2iYgp9xFZ865PHcVqdksDhja21H3kuZC")
uncompressed_spendable_address = ["cS8VPRWos5pYHt6ay9WAnenT6LeDpfdtVP"]
self.nodes[0].importprivkey("b2QBP8LNcftKZAW4zx7DdZYa3FvxMmuAAuCvkgmKcvEptAiiFsvU")
compressed_spendable_address = ["ckhW8KuyAKe1AvKYy5FXcP8JZrWA9n6u3g"]
self.nodes[0].importpubkey(pubkeys[5])
compressed_solvable_address = [key_to_p2pkh(pubkeys[5])]
self.nodes[0].importpubkey(pubkeys[6])
uncompressed_solvable_address = [key_to_p2pkh(pubkeys[6])]
unseen_anytime = [] # These outputs should never be seen
solvable_anytime = [] # These outputs should be solvable after importpubkey
unseen_anytime = [] # These outputs should never be seen
uncompressed_spendable_address.append(self.nodes[0].addmultisigaddress(2, [uncompressed_spendable_address[0], compressed_spendable_address[0]])['address'])
uncompressed_spendable_address.append(self.nodes[0].addmultisigaddress(2, [uncompressed_spendable_address[0], uncompressed_spendable_address[0]])['address'])
compressed_spendable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_spendable_address[0], compressed_spendable_address[0]])['address'])
uncompressed_solvable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_solvable_address[0], uncompressed_solvable_address[0]])['address'])
compressed_solvable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_spendable_address[0], compressed_solvable_address[0]])['address'])
premature_witaddress = []
for i in compressed_spendable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
[bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
premature_witaddress.append(script_to_p2sh(p2wsh))
else:
[p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
# P2WPKH, P2SH_P2WPKH are always spendable
spendable_anytime.extend([p2wpkh, p2sh_p2wpkh])
for i in uncompressed_spendable_address + uncompressed_solvable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
[bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
# P2WSH and P2SH(P2WSH) multisig with uncompressed keys are never seen
unseen_anytime.extend([p2wsh, p2sh_p2wsh])
else:
[p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
# P2WPKH, P2SH_P2WPKH with uncompressed keys are never seen
unseen_anytime.extend([p2wpkh, p2sh_p2wpkh])
for i in compressed_solvable_address:
v = self.nodes[0].getaddressinfo(i)
if (v['isscript']):
[bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
premature_witaddress.append(script_to_p2sh(p2wsh))
else:
[p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
# P2SH_P2PK, P2SH_P2PKH with compressed keys are always solvable
solvable_anytime.extend([p2wpkh, p2sh_p2wpkh])
self.mine_and_test_listunspent(spendable_anytime, 2)
self.mine_and_test_listunspent(solvable_anytime, 1)
self.mine_and_test_listunspent(unseen_anytime, 0)
# Check that createrawtransaction/decoderawtransaction with non-v0 Bech32 works
v1_addr = program_to_witness(1, [3, 5])
v1_tx = self.nodes[0].createrawtransaction([getutxo(spendable_txid[0])], {v1_addr: 1})
v1_decoded = self.nodes[1].decoderawtransaction(v1_tx)
assert_equal(v1_decoded['vout'][0]['scriptPubKey']['addresses'][0], v1_addr)
assert_equal(v1_decoded['vout'][0]['scriptPubKey']['hex'], "51020305")
# Check that spendable outputs are really spendable
self.create_and_mine_tx_from_txids(spendable_txid)
# import all the private keys so solvable addresses become spendable
self.nodes[0].importprivkey("b4Vfz2Ly8GAubXRrhpSGF9ctmorBYVzdokEQcDrbV2EmnzB5LonH")
self.nodes[0].importprivkey("b4bVUqL7X7ZJpqzDnF6Ks32YM9GXbVdrEbmznQMRXcTixRM1AbGA")
self.nodes[0].importprivkey("8iW8cP2tV3YUkc8XrPz3v7CvFjV5VkhpzgKos82q1LWshZEooJo")
self.nodes[0].importprivkey("b4BabAFLEnDwVU4FB2SosQPc42WvquuCqaa1rE34tV8rmhbQbjQv")
self.nodes[0].importprivkey("b54DUJnyPL6VQMoCd4sXtvCBvhM1vG2vSCwqShSRE8ryS7Cuu9H1")
self.nodes[0].importprivkey("b8HQcxqFUhg4BsdjE21bisYRkwT4jvKhTUmcYh5ege5SQbLsmrAz")
self.create_and_mine_tx_from_txids(solvable_txid)
# Test that importing native P2WPKH/P2WSH scripts works
for use_p2wsh in [False, True]:
if use_p2wsh:
scriptPubKey = "00203a59f3f56b713fdcf5d1a57357f02c44342cbf306ffe0c4741046837bf90561a"
transaction = "01000000000100e1f505000000002200203a59f3f56b713fdcf5d1a57357f02c44342cbf306ffe0c4741046837bf90561a00000000"
else:
scriptPubKey = "a9142f8c469c2f0084c48e11f998ffbe7efa7549f26d87"
transaction = "01000000000100e1f5050000000017a9142f8c469c2f0084c48e11f998ffbe7efa7549f26d8700000000"
self.nodes[1].importaddress(scriptPubKey, "", False)
rawtxfund = self.nodes[1].fundrawtransaction(transaction)['hex']
rawtxfund = self.nodes[1].signrawtransactionwithwallet(rawtxfund)["hex"]
txid = self.nodes[1].sendrawtransaction(rawtxfund)
assert_equal(self.nodes[1].gettransaction(txid, True)["txid"], txid)
assert_equal(self.nodes[1].listtransactions("*", 1, 0, True)[0]["txid"], txid)
# Assert it is properly saved
self.stop_node(1)
self.start_node(1)
assert_equal(self.nodes[1].gettransaction(txid, True)["txid"], txid)
assert_equal(self.nodes[1].listtransactions("*", 1, 0, True)[0]["txid"], txid)
def test_witness_block_size(self):
# TODO: Test that non-witness carrying blocks can't exceed 1MB
# Skipping this test for now; this is covered in p2p-fullblocktest.py
# Test that witness-bearing blocks are limited at ceil(base + wit/4) <= 1MB.
block = self.build_next_block()
assert len(self.utxo) > 0
# Create a P2WSH transaction.
# The witness program will be a bunch of OP_2DROP's, followed by OP_TRUE.
# This should give us plenty of room to tweak the spending tx's
# virtual size.
NUM_DROPS = 200 # 201 max ops per script!
NUM_OUTPUTS = 50
witness_program = CScript([OP_2DROP] * NUM_DROPS + [OP_TRUE])
witness_hash = uint256_from_str(sha256(witness_program))
script_pubkey = CScript([OP_0, ser_uint256(witness_hash)])
prevout = COutPoint(self.utxo[0].sha256, self.utxo[0].n)
value = self.utxo[0].nValue
parent_tx = CTransaction()
parent_tx.vin.append(CTxIn(prevout, b""))
child_value = int(value / NUM_OUTPUTS)
for i in range(NUM_OUTPUTS):
parent_tx.vout.append(CTxOut(child_value, script_pubkey))
parent_tx.vout[0].nValue -= 50000
assert parent_tx.vout[0].nValue > 0
parent_tx.rehash()
filler_size = 3150
child_tx = CTransaction()
for i in range(NUM_OUTPUTS):
child_tx.vin.append(CTxIn(COutPoint(parent_tx.sha256, i), b""))
child_tx.vout = [CTxOut(value - 100000, CScript([OP_TRUE]))]
for i in range(NUM_OUTPUTS):
child_tx.wit.vtxinwit.append(CTxInWitness())
child_tx.wit.vtxinwit[-1].scriptWitness.stack = [
b'a' * filler_size
] * (2 * NUM_DROPS) + [witness_program]
child_tx.rehash()
self.update_witness_block_with_transactions(block,
[parent_tx, child_tx])
vsize = get_virtual_size(block)
assert_greater_than(MAX_BLOCK_BASE_SIZE, vsize)
additional_bytes = (MAX_BLOCK_BASE_SIZE - vsize) * 4
i = 0
while additional_bytes > 0:
# Add some more bytes to each input until we hit MAX_BLOCK_BASE_SIZE+1
extra_bytes = min(additional_bytes + 1, 55)
block.vtx[-1].wit.vtxinwit[int(
i / (2 * NUM_DROPS))].scriptWitness.stack[
i % (2 * NUM_DROPS)] = b'a' * (filler_size + extra_bytes)
additional_bytes -= extra_bytes
i += 1
block.vtx[0].vout.pop() # Remove old commitment
add_witness_commitment(block)
block.solve()
vsize = get_virtual_size(block)
assert_equal(vsize, MAX_BLOCK_BASE_SIZE + 1)
# Make sure that our test case would exceed the old max-network-message
# limit
assert len(block.serialize()) > 2 * 1024 * 1024
test_witness_block(self.nodes[0],
self.test_node,
block,
accepted=False)
# Now resize the second transaction to make the block fit.
cur_length = len(block.vtx[-1].wit.vtxinwit[0].scriptWitness.stack[0])
block.vtx[-1].wit.vtxinwit[0].scriptWitness.stack[0] = b'a' * (
cur_length - 1)
block.vtx[0].vout.pop()
add_witness_commitment(block)
block.solve()
assert get_virtual_size(block) == MAX_BLOCK_BASE_SIZE
test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
# Update available utxo's
self.utxo.pop(0)
self.utxo.append(
UTXO(block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue))
def run_test(self):
node = self.nodes[0] # convenience reference to the node
self.bootstrap_p2p() # Add one p2p connection to the node
best_block = self.nodes[0].getbestblockhash()
tip = int(best_block, 16)
best_block_time = self.nodes[0].getblock(best_block)['time']
block_time = best_block_time + 1
self.log.info("Create a new block with an anyone-can-spend coinbase.")
height = 1
blocks = []
for _ in invalid_txs.iter_all_templates():
block = create_block(tip, create_coinbase(height), block_time)
block.nHeight = height
prepare_block(block)
block_time = block.nTime + 1
height += 1
# Save the coinbase for later
blocks.append(block)
tip = block.sha256
node.p2p.send_blocks_and_test([block], node, success=True)
self.log.info("Mature the blocks.")
self.nodes[0].generatetoaddress(
100, self.nodes[0].get_deterministic_priv_key().address)
# Iterate through a list of known invalid transaction types, ensuring each is
# rejected. Some are consensus invalid and some just violate policy.
setup_txs = []
for block, BadTxTemplate in zip(blocks,
invalid_txs.iter_all_templates()):
self.log.info("Testing invalid transaction: %s",
BadTxTemplate.__name__)
template = BadTxTemplate(spend_block=block)
setup_tx = template.get_setup_tx()
if setup_tx is not None:
node.p2p.send_txs_and_test([setup_tx], node)
setup_txs.append(setup_tx)
tx = template.get_tx(setup_tx)
else:
tx = template.get_tx()
node.p2p.send_txs_and_test(
[tx],
node,
success=False,
expect_disconnect=template.expect_disconnect,
reject_reason=template.reject_reason,
)
if template.expect_disconnect:
self.log.info("Reconnecting to peer")
self.reconnect_p2p()
# Make two p2p connections to provide the node with orphans
# * p2ps[0] will send valid orphan txs (one with low fee)
# * p2ps[1] will send an invalid orphan tx (and is later disconnected for that)
self.reconnect_p2p(num_connections=2)
self.log.info('Test orphan transaction handling ... ')
# Create a root transaction that we withold until all dependend transactions
# are sent out and in the orphan cache
SCRIPT_PUB_KEY_OP_TRUE = CScript([OP_TRUE])
tx_withhold = CTransaction()
tx_withhold.vin.append(
CTxIn(outpoint=COutPoint(blocks[0].vtx[0].txid, 1)))
tx_withhold.vout.append(
CTxOut(nValue=int(SUBSIDY * COIN) - 12000,
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
pad_tx(tx_withhold)
tx_withhold.calc_txid()
# Our first orphan tx with some outputs to create further orphan txs
tx_orphan_1 = CTransaction()
tx_orphan_1.vin.append(CTxIn(outpoint=COutPoint(tx_withhold.txid, 0)))
tx_orphan_1.vout = [
CTxOut(nValue=int(0.1 * COIN), scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE)
] * 3
pad_tx(tx_orphan_1)
tx_orphan_1.calc_txid()
# A valid transaction with low fee
tx_orphan_2_no_fee = CTransaction()
tx_orphan_2_no_fee.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.txid, 0)))
tx_orphan_2_no_fee.vout.append(
CTxOut(nValue=int(0.1 * COIN),
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
pad_tx(tx_orphan_2_no_fee)
# A valid transaction with sufficient fee
tx_orphan_2_valid = CTransaction()
tx_orphan_2_valid.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.txid, 1)))
tx_orphan_2_valid.vout.append(
CTxOut(nValue=int(0.1 * COIN) - 12000,
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
tx_orphan_2_valid.calc_txid()
pad_tx(tx_orphan_2_valid)
# An invalid transaction with negative fee
tx_orphan_2_invalid = CTransaction()
tx_orphan_2_invalid.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.txid, 2)))
tx_orphan_2_invalid.vout.append(
CTxOut(nValue=int(1.1 * COIN),
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
pad_tx(tx_orphan_2_invalid)
tx_orphan_2_invalid.calc_txid()
self.log.info('Send the orphans ... ')
# Send valid orphan txs from p2ps[0]
node.p2p.send_txs_and_test(
[tx_orphan_1, tx_orphan_2_no_fee, tx_orphan_2_valid],
node,
success=False)
# Send invalid tx from p2ps[1]
node.p2ps[1].send_txs_and_test([tx_orphan_2_invalid],
node,
success=False)
# Mempool should only have setup txs
assert_equal(len(setup_txs), node.getmempoolinfo()['size'])
# p2ps[1] is still connected
assert_equal(2, len(node.getpeerinfo()))
self.log.info('Send the withhold tx ... ')
with node.assert_debug_log(expected_msgs=["bad-txns-in-belowout"]):
node.p2p.send_txs_and_test([tx_withhold], node, success=True)
# Transactions that should end up in the mempool
expected_mempool = {
t.txid_hex
for t in [
tx_withhold, # The transaction that is the root for all orphans
tx_orphan_1, # The orphan transaction that splits the coins
# The valid transaction (with sufficient fee)
tx_orphan_2_valid,
] + setup_txs # The setup transactions we added in the beginning
}
# Transactions that do not end up in the mempool
# tx_orphan_no_fee, because it has too low fee (p2ps[0] is not disconnected for relaying that tx)
# tx_orphan_invaid, because it has negative fee (p2ps[1] is
# disconnected for relaying that tx)
# p2ps[1] is no longer connected
wait_until(lambda: 1 == len(node.getpeerinfo()), timeout=12)
assert_equal(expected_mempool, set(node.getrawmempool()))
self.log.info('Test orphan pool overflow')
orphan_tx_pool = [CTransaction() for _ in range(101)]
for i in range(len(orphan_tx_pool)):
orphan_tx_pool[i].vin.append(CTxIn(outpoint=COutPoint(i, 333)))
orphan_tx_pool[i].vout.append(
CTxOut(nValue=int(1.1 * COIN),
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
pad_tx(orphan_tx_pool[i])
with node.assert_debug_log(['mapOrphan overflow, removed 1 tx']):
node.p2p.send_txs_and_test(orphan_tx_pool, node, success=False)
rejected_parent = CTransaction()
rejected_parent.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_2_invalid.txid, 0)))
rejected_parent.vout.append(
CTxOut(nValue=int(1.1 * COIN),
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
pad_tx(rejected_parent)
rejected_parent.rehash()
with node.assert_debug_log([
'not keeping orphan with rejected parents {}'.format(
rejected_parent.txid_hex)
]):
node.p2p.send_txs_and_test([rejected_parent], node, success=False)
def run_test(self):
node = self.nodes[0]
node.add_p2p_connection(P2PDataStore())
# Allocate as many UTXOs as are needed
num_utxos = sum(
len(test_case['sig_hash_types']) for test_case in TESTCASES
if isinstance(test_case, dict))
value = int(SUBSIDY * 1_000_000)
fee = 10_000
max_utxo_value = (value - fee) // num_utxos
private_keys = []
public_keys = []
spendable_outputs = []
executed_scripts = []
utxo_idx = 0
# Prepare UTXOs for the tests below
for test_case in TESTCASES:
if test_case == 'ENABLE_REPLAY_PROTECTION':
continue
for _ in test_case['sig_hash_types']:
private_key = ECKey()
private_key.generate()
private_keys.append(private_key)
public_key = private_key.get_pubkey()
public_keys.append(public_key)
utxo_value = max_utxo_value - utxo_idx * 100 # deduct 100*i coins for unique amounts
if test_case.get('opcodes', False):
opcodes = test_case['opcodes']
redeem_script = CScript(
opcodes + [public_key.get_bytes(), OP_CHECKSIG])
executed_scripts.append(redeem_script)
utxo_script = CScript(
[OP_HASH160,
hash160(redeem_script), OP_EQUAL])
elif test_case.get('is_p2pk', False):
utxo_script = CScript(
[public_key.get_bytes(), OP_CHECKSIG])
executed_scripts.append(utxo_script)
else:
utxo_script = CScript([
OP_DUP, OP_HASH160,
hash160(public_key.get_bytes()), OP_EQUALVERIFY,
OP_CHECKSIG
])
executed_scripts.append(utxo_script)
spendable_outputs.append(CTxOut(utxo_value, utxo_script))
utxo_idx += 1
anyonecanspend_address = node.decodescript('51')['p2sh']
burn_address = node.decodescript('00')['p2sh']
p2sh_script = CScript([OP_HASH160, bytes(20), OP_EQUAL])
node.generatetoaddress(1, anyonecanspend_address)
node.generatetoaddress(100, burn_address)
# Build and send fan-out transaction creating all the UTXOs
block_hash = node.getblockhash(1)
coin = int(node.getblock(block_hash)['tx'][0], 16)
tx_fan_out = CTransaction()
tx_fan_out.vin.append(CTxIn(COutPoint(coin, 1), CScript([b'\x51'])))
tx_fan_out.vout = spendable_outputs
tx_fan_out.rehash()
node.p2p.send_txs_and_test([tx_fan_out], node)
utxo_idx = 0
key_idx = 0
for test_case in TESTCASES:
if test_case == 'ENABLE_REPLAY_PROTECTION':
node.setmocktime(ACTIVATION_TIME)
node.generatetoaddress(11, burn_address)
continue
# Build tx for this test, will broadcast later
tx = CTransaction()
num_inputs = len(test_case['sig_hash_types'])
spent_outputs = spendable_outputs[:num_inputs]
del spendable_outputs[:num_inputs]
assert len(spent_outputs) == num_inputs
total_input_amount = sum(output.nValue for output in spent_outputs)
max_output_amount = (total_input_amount -
fee) // test_case['outputs']
for i in range(test_case['outputs']):
output_amount = max_output_amount - i * 77
output_script = CScript(
[OP_HASH160, i.to_bytes(20, 'big'), OP_EQUAL])
tx.vout.append(CTxOut(output_amount, output_script))
for _ in test_case['sig_hash_types']:
tx.vin.append(
CTxIn(COutPoint(tx_fan_out.txid, utxo_idx), CScript()))
utxo_idx += 1
# Keep unsigned tx for signrawtransactionwithkey below
unsigned_tx = tx.serialize().hex()
private_keys_wif = []
sign_inputs = []
# Make list of inputs for signrawtransactionwithkey
for i, spent_output in enumerate(spent_outputs):
sign_inputs.append({
'txid':
tx_fan_out.txid_hex,
'vout':
key_idx + i,
'amount':
Decimal(spent_output.nValue) / COIN,
'scriptPubKey':
spent_output.scriptPubKey.hex(),
})
for i, sig_hash_type in enumerate(test_case['sig_hash_types']):
# Compute sighash for this input; we sign it manually using sign_ecdsa/sign_schnorr
# and then broadcast the complete transaction
sighash = SignatureHashLotus(
tx_to=tx,
spent_utxos=spent_outputs,
sig_hash_type=sig_hash_type,
input_index=i,
executed_script_hash=hash256(executed_scripts[key_idx]),
codeseparator_pos=test_case.get('codesep', 0xffff_ffff),
)
if test_case.get('schnorr', False):
signature = private_keys[key_idx].sign_schnorr(sighash)
else:
signature = private_keys[key_idx].sign_ecdsa(sighash)
signature += bytes(
[test_case.get('suffix', sig_hash_type & 0xff)])
# Build correct scriptSig
if test_case.get('opcodes'):
tx.vin[i].scriptSig = CScript(
[signature, executed_scripts[key_idx]])
elif test_case.get('is_p2pk'):
tx.vin[i].scriptSig = CScript([signature])
else:
tx.vin[i].scriptSig = CScript(
[signature, public_keys[key_idx].get_bytes()])
sig_hash_type_str = self.get_sig_hash_type_str(sig_hash_type)
if sig_hash_type_str is not None and 'opcodes' not in test_case and 'error' not in test_case:
# If we're a simple output type (P2PKH or P2KH) and aren't supposed to fail,
# we sign using signrawtransactionwithkey and verify the transaction signed
# the expected sighash. We won't broadcast it though.
# Note: signrawtransactionwithkey will not sign using replay-protection.
private_key_wif = bytes_to_wif(
private_keys[key_idx].get_bytes())
raw_tx_signed = self.nodes[0].signrawtransactionwithkey(
unsigned_tx, [private_key_wif], sign_inputs,
sig_hash_type_str)['hex']
# Extract signature from signed
signed_tx = CTransaction()
signed_tx.deserialize(
io.BytesIO(bytes.fromhex(raw_tx_signed)))
sig = list(CScript(signed_tx.vin[i].scriptSig))[0]
pubkey = private_keys[key_idx].get_pubkey()
sighash = SignatureHashLotus(
tx_to=tx,
spent_utxos=spent_outputs,
sig_hash_type=sig_hash_type & 0xff,
input_index=i,
executed_script_hash=hash256(
executed_scripts[key_idx]),
)
# Verify sig signs the above sighash and has the expected sighash type
assert pubkey.verify_ecdsa(sig[:-1], sighash)
assert sig[-1] == sig_hash_type & 0xff
key_idx += 1
# Broadcast transaction and check success/failure
tx.rehash()
if 'error' not in test_case:
node.p2p.send_txs_and_test([tx], node)
else:
node.p2p.send_txs_and_test([tx],
node,
success=False,
reject_reason=test_case['error'])
def run_test(self):
node = self.nodes[0] # convenience reference to the node
self.bootstrap_p2p() # Add one p2p connection to the node
best_block = self.nodes[0].getbestblockhash()
tip = int(best_block, 16)
best_block_time = self.nodes[0].getblock(best_block)['time']
block_time = best_block_time + 1
self.log.info("Create a new block with an anyone-can-spend coinbase.")
height = 1
block = create_block(tip, create_coinbase(height), block_time)
block.solve()
# Save the coinbase for later
block1 = block
tip = block.sha256
node.p2p.send_blocks_and_test([block], node, success=True)
self.log.info("Mature the block.")
self.nodes[0].generate(COINBASE_MATURITY)
# b'\x64' is OP_NOTIF
# Transaction will be rejected with code 16 (REJECT_INVALID)
# and we get disconnected immediately
self.log.info('Test a transaction that is rejected')
tx1 = create_tx_with_script(block1.vtx[0],
0,
script_sig=b'\x64' * 35,
amount=50 * COIN - 12000)
node.p2p.send_txs_and_test([tx1],
node,
success=False,
expect_disconnect=True)
# Make two p2p connections to provide the node with orphans
# * p2ps[0] will send valid orphan txs (one with low fee)
# * p2ps[1] will send an invalid orphan tx (and is later disconnected for that)
self.reconnect_p2p(num_connections=2)
self.log.info('Test orphan transaction handling ... ')
# Create a root transaction that we withhold until all dependend transactions
# are sent out and in the orphan cache
SCRIPT_PUB_KEY_OP_TRUE = b'\x51\x75' * 15 + b'\x51'
tx_withhold = CTransaction()
tx_withhold.vin.append(
CTxIn(outpoint=COutPoint(block1.vtx[0].sha256, 0)))
tx_withhold.vout.append(
CTxOut(nValue=50 * COIN - 12000,
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
tx_withhold.calc_sha256()
# Our first orphan tx with some outputs to create further orphan txs
tx_orphan_1 = CTransaction()
tx_orphan_1.vin.append(
CTxIn(outpoint=COutPoint(tx_withhold.sha256, 0)))
tx_orphan_1.vout = [
CTxOut(nValue=10 * COIN, scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE)
] * 3
tx_orphan_1.calc_sha256()
# A valid transaction with low fee
tx_orphan_2_no_fee = CTransaction()
tx_orphan_2_no_fee.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 0)))
tx_orphan_2_no_fee.vout.append(
CTxOut(nValue=10 * COIN, scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
# A valid transaction with sufficient fee
tx_orphan_2_valid = CTransaction()
tx_orphan_2_valid.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 1)))
tx_orphan_2_valid.vout.append(
CTxOut(nValue=10 * COIN - 1200000,
scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
tx_orphan_2_valid.calc_sha256()
# An invalid transaction with negative fee
tx_orphan_2_invalid = CTransaction()
tx_orphan_2_invalid.vin.append(
CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 2)))
tx_orphan_2_invalid.vout.append(
CTxOut(nValue=11 * COIN, scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
self.log.info('Send the orphans ... ')
# Send valid orphan txs from p2ps[0]
node.p2p.send_txs_and_test(
[tx_orphan_1, tx_orphan_2_no_fee, tx_orphan_2_valid],
node,
success=False)
# Send invalid tx from p2ps[1]
node.p2ps[1].send_txs_and_test([tx_orphan_2_invalid],
node,
success=False)
assert_equal(0,
node.getmempoolinfo()['size']) # Mempool should be empty
assert_equal(2, len(node.getpeerinfo())) # p2ps[1] is still connected
self.log.info('Send the withhold tx ... ')
node.p2p.send_txs_and_test([tx_withhold], node, success=True)
# Transactions that should end up in the mempool
expected_mempool = {
t.hash
for t in [
tx_withhold, # The transaction that is the root for all orphans
tx_orphan_1, # The orphan transaction that splits the coins
tx_orphan_2_valid, # The valid transaction (with sufficient fee)
]
}
# Transactions that do not end up in the mempool
# tx_orphan_no_fee, because it has too low fee (p2ps[0] is not disconnected for relaying that tx)
# tx_orphan_invaid, because it has negative fee (p2ps[1] is disconnected for relaying that tx)
wait_until(lambda: 1 == len(node.getpeerinfo()),
timeout=12) # p2ps[1] is no longer connected
assert_equal(expected_mempool, set(node.getrawmempool()))
# restart node with sending BIP61 messages disabled, check that it disconnects without sending the reject message
self.log.info(
'Test a transaction that is rejected, with BIP61 disabled')
self.restart_node(0, ['-enablebip61=0', '-persistmempool=0'])
self.reconnect_p2p(num_connections=1)
with node.assert_debug_log(expected_msgs=[
"{} from peer=0 was not accepted: mandatory-script-verify-flag-failed (Invalid OP_IF construction) (code 16)"
.format(tx1.hash),
"disconnecting peer=0",
]):
node.p2p.send_txs_and_test([tx1],
node,
success=False,
expect_disconnect=True)
# send_txs_and_test will have waited for disconnect, so we can safely check that no reject has been received
assert_equal(node.p2p.reject_code_received, None)
def _test_coin_stats_index(self):
node = self.nodes[0]
index_node = self.nodes[1]
# Both none and muhash options allow the usage of the index
index_hash_options = ['none', 'muhash']
# Generate a normal transaction and mine it
node.generate(COINBASE_MATURITY + 1)
address = self.nodes[0].get_deterministic_priv_key().address
node.sendtoaddress(address=address,
amount=10,
subtractfeefromamount=True)
node.generate(1)
self.sync_blocks(timeout=120)
self.log.info(
"Test that gettxoutsetinfo() output is consistent with or without coinstatsindex option"
)
self.wait_until(lambda: not try_rpc(-32603, "Unable to read UTXO set",
node.gettxoutsetinfo))
res0 = node.gettxoutsetinfo('none')
# The fields 'disk_size' and 'transactions' do not exist on the index
del res0['disk_size'], res0['transactions']
self.wait_until(
lambda: not try_rpc(-32603, "Unable to read UTXO set", index_node.
gettxoutsetinfo, 'muhash'))
for hash_option in index_hash_options:
res1 = index_node.gettxoutsetinfo(hash_option)
# The fields 'block_info' and 'total_unspendable_amount' only exist on the index
del res1['block_info'], res1['total_unspendable_amount']
res1.pop('muhash', None)
# Everything left should be the same
assert_equal(res1, res0)
self.log.info(
"Test that gettxoutsetinfo() can get fetch data on specific heights with index"
)
# Generate a new tip
node.generate(5)
self.wait_until(
lambda: not try_rpc(-32603, "Unable to read UTXO set", index_node.
gettxoutsetinfo, 'muhash'))
for hash_option in index_hash_options:
# Fetch old stats by height
res2 = index_node.gettxoutsetinfo(hash_option, 102)
del res2['block_info'], res2['total_unspendable_amount']
res2.pop('muhash', None)
assert_equal(res0, res2)
# Fetch old stats by hash
res3 = index_node.gettxoutsetinfo(hash_option, res0['bestblock'])
del res3['block_info'], res3['total_unspendable_amount']
res3.pop('muhash', None)
assert_equal(res0, res3)
# It does not work without coinstatsindex
assert_raises_rpc_error(
-8, "Querying specific block heights requires coinstatsindex",
node.gettxoutsetinfo, hash_option, 102)
self.log.info("Test gettxoutsetinfo() with index and verbose flag")
for hash_option in index_hash_options:
# Genesis block is unspendable
res4 = index_node.gettxoutsetinfo(hash_option, 0)
assert_equal(res4['total_unspendable_amount'], 50)
assert_equal(
res4['block_info'], {
'unspendable': 50,
'prevout_spent': 0,
'new_outputs_ex_coinbase': 0,
'coinbase': 0,
'unspendables': {
'genesis_block': 50,
'bip30': 0,
'scripts': 0,
'unclaimed_rewards': 0
}
})
self.block_sanity_check(res4['block_info'])
# Test an older block height that included a normal tx
res5 = index_node.gettxoutsetinfo(hash_option, 102)
assert_equal(res5['total_unspendable_amount'], 50)
assert_equal(
res5['block_info'], {
'unspendable': 0,
'prevout_spent': 50,
'new_outputs_ex_coinbase': Decimal('49.99995560'),
'coinbase': Decimal('50.00004440'),
'unspendables': {
'genesis_block': 0,
'bip30': 0,
'scripts': 0,
'unclaimed_rewards': 0
}
})
self.block_sanity_check(res5['block_info'])
# Generate and send a normal tx with two outputs
tx1_inputs = []
tx1_outputs = {
self.nodes[0].getnewaddress(): 21,
self.nodes[0].getnewaddress(): 42
}
raw_tx1 = self.nodes[0].createrawtransaction(tx1_inputs, tx1_outputs)
funded_tx1 = self.nodes[0].fundrawtransaction(raw_tx1)
signed_tx1 = self.nodes[0].signrawtransactionwithwallet(
funded_tx1['hex'])
tx1_txid = self.nodes[0].sendrawtransaction(signed_tx1['hex'])
# Find the right position of the 21 BTC output
tx1_final = self.nodes[0].gettransaction(tx1_txid)
for output in tx1_final['details']:
if output['amount'] == Decimal(
'21.00000000') and output['category'] == 'receive':
n = output['vout']
# Generate and send another tx with an OP_RETURN output (which is unspendable)
tx2 = CTransaction()
tx2.vin.append(CTxIn(COutPoint(int(tx1_txid, 16), n), b''))
tx2.vout.append(
CTxOut(int(20.99 * COIN), CScript([OP_RETURN] + [OP_FALSE] * 30)))
tx2_hex = self.nodes[0].signrawtransactionwithwallet(ToHex(tx2))['hex']
self.nodes[0].sendrawtransaction(tx2_hex)
# Include both txs in a block
self.nodes[0].generate(1)
self.sync_all()
self.wait_until(
lambda: not try_rpc(-32603, "Unable to read UTXO set", index_node.
gettxoutsetinfo, 'muhash'))
for hash_option in index_hash_options:
# Check all amounts were registered correctly
res6 = index_node.gettxoutsetinfo(hash_option, 108)
assert_equal(res6['total_unspendable_amount'],
Decimal('70.98999999'))
assert_equal(
res6['block_info'], {
'unspendable': Decimal('20.98999999'),
'prevout_spent': 111,
'new_outputs_ex_coinbase': Decimal('89.99993620'),
'coinbase': Decimal('50.01006381'),
'unspendables': {
'genesis_block': 0,
'bip30': 0,
'scripts': Decimal('20.98999999'),
'unclaimed_rewards': 0
}
})
self.block_sanity_check(res6['block_info'])
# Create a coinbase that does not claim full subsidy and also
# has two outputs
cb = create_coinbase(109, nValue=35)
cb.vout.append(CTxOut(5 * COIN, CScript([OP_FALSE])))
cb.rehash()
# Generate a block that includes previous coinbase
tip = self.nodes[0].getbestblockhash()
block_time = self.nodes[0].getblock(tip)['time'] + 1
block = create_block(int(tip, 16), cb, block_time)
block.solve()
self.nodes[0].submitblock(ToHex(block))
self.sync_all()
self.wait_until(
lambda: not try_rpc(-32603, "Unable to read UTXO set", index_node.
gettxoutsetinfo, 'muhash'))
for hash_option in index_hash_options:
res7 = index_node.gettxoutsetinfo(hash_option, 109)
assert_equal(res7['total_unspendable_amount'],
Decimal('80.98999999'))
assert_equal(
res7['block_info'], {
'unspendable': 10,
'prevout_spent': 0,
'new_outputs_ex_coinbase': 0,
'coinbase': 40,
'unspendables': {
'genesis_block': 0,
'bip30': 0,
'scripts': 0,
'unclaimed_rewards': 10
}
})
self.block_sanity_check(res7['block_info'])
self.log.info("Test that the index is robust across restarts")
res8 = index_node.gettxoutsetinfo('muhash')
self.restart_node(1, extra_args=self.extra_args[1])
res9 = index_node.gettxoutsetinfo('muhash')
assert_equal(res8, res9)
index_node.generate(1)
self.wait_until(
lambda: not try_rpc(-32603, "Unable to read UTXO set", index_node.
gettxoutsetinfo, 'muhash'))
res10 = index_node.gettxoutsetinfo('muhash')
assert (res8['txouts'] < res10['txouts'])
def run_test(self):
# Create a block with 2500 stakeable outputs
self.build_coins_to_stake()
# Propagate it to nodes 1 and 2 and stop them for now
self.sync_first_block()
# Key Management for node 0
keytool = KeyTool.for_node(self.nodes[0])
# Connect to node0
p2p0 = self.nodes[0].add_p2p_connection(BaseNode())
# Build the blockchain
self.tip = int(self.nodes[0].getbestblockhash(), 16)
self.block_time = self.nodes[0].getblock(
self.nodes[0].getbestblockhash())['time'] + 1
self.blocks = []
# Get a pubkey for the coinbase TXO
coinbase_key = keytool.make_privkey()
coinbase_pubkey = bytes(coinbase_key.get_pubkey())
keytool.upload_key(coinbase_key)
self.log.info(
"Create the first block with a coinbase output to our key")
height = 2
snapshot_meta = get_tip_snapshot_meta(self.nodes[0])
coin = self.get_coin_to_stake()
coinbase = sign_coinbase(
self.nodes[0],
create_coinbase(height, coin, snapshot_meta.hash, coinbase_pubkey))
block = create_block(self.tip, coinbase, self.block_time)
self.blocks.append(block)
self.block_time += 1
block.solve()
# Save the coinbase for later
self.block1 = block
self.tip = block.sha256
utxo1 = UTXO(height, TxType.COINBASE, COutPoint(coinbase.sha256, 0),
coinbase.vout[0])
snapshot_meta = update_snapshot_with_tx(self.nodes[0], snapshot_meta,
height, coinbase)
height += 1
self.log.info(
"Bury the block 100 deep so the coinbase output is spendable")
for i in range(100):
coin = self.get_coin_to_stake()
coinbase = sign_coinbase(
self.nodes[0],
create_coinbase(height, coin, snapshot_meta.hash,
coinbase_pubkey))
block = create_block(self.tip, coinbase, self.block_time)
block.solve()
self.blocks.append(block)
self.tip = block.sha256
self.block_time += 1
snapshot_meta = update_snapshot_with_tx(self.nodes[0],
snapshot_meta, height,
coinbase)
height += 1
self.log.info(
"Create a transaction spending the coinbase output with an invalid (null) signature"
)
tx = CTransaction()
tx.vin.append(
CTxIn(COutPoint(self.block1.vtx[0].sha256, 0), scriptSig=b""))
tx.vout.append(
CTxOut((PROPOSER_REWARD - 1) * 100000000, CScript([OP_TRUE])))
tx.calc_sha256()
coin = self.get_coin_to_stake()
coinbase = sign_coinbase(
self.nodes[0],
create_coinbase(height, coin, snapshot_meta.hash, coinbase_pubkey))
block102 = create_block(self.tip, coinbase, self.block_time)
self.block_time += 1
block102.vtx.extend([tx])
block102.compute_merkle_trees()
block102.rehash()
block102.solve()
self.blocks.append(block102)
self.tip = block102.sha256
self.block_time += 1
snapshot_meta = update_snapshot_with_tx(self.nodes[0], snapshot_meta,
height, coinbase)
utxo2 = UTXO(height, tx.get_type(), COutPoint(tx.sha256, 0),
tx.vout[0])
snapshot_meta = calc_snapshot_hash(self.nodes[0], snapshot_meta,
height, [utxo1], [utxo2])
height += 1
self.log.info("Bury the assumed valid block 2100 deep")
for i in range(2100):
coin = self.get_coin_to_stake()
coinbase = sign_coinbase(
self.nodes[0],
create_coinbase(height, coin, snapshot_meta.hash,
coinbase_pubkey))
block = create_block(self.tip, coinbase, self.block_time)
block.nVersion = 4
block.solve()
self.blocks.append(block)
self.tip = block.sha256
self.block_time += 1
snapshot_meta = update_snapshot_with_tx(self.nodes[0],
snapshot_meta, height,
coinbase)
height += 1
self.nodes[0].disconnect_p2ps()
self.log.info(
"Start node1 and node2 with assumevalid so they accept a block with a bad signature."
)
self.start_node(1,
extra_args=[
"-assumevalid=" + hex(block102.sha256),
ESPERANZA_CONFIG
])
self.start_node(2,
extra_args=[
"-assumevalid=" + hex(block102.sha256),
ESPERANZA_CONFIG
])
p2p0 = self.nodes[0].add_p2p_connection(BaseNode())
p2p1 = self.nodes[1].add_p2p_connection(BaseNode())
p2p2 = self.nodes[2].add_p2p_connection(BaseNode())
# send header lists to all three nodes
p2p0.send_header_for_blocks(self.blocks[0:2000])
p2p0.send_header_for_blocks(self.blocks[2000:])
p2p1.send_header_for_blocks(self.blocks[0:2000])
p2p1.send_header_for_blocks(self.blocks[2000:])
p2p2.send_header_for_blocks(self.blocks[0:200])
self.log.info("Send blocks to node0. Block 103 will be rejected.")
self.send_blocks_until_disconnected(p2p0)
self.assert_blockchain_height(self.nodes[0], 102)
self.log.info("Send all blocks to node1. All blocks will be accepted.")
for i in range(2202):
p2p1.send_message(msg_block(self.blocks[i]))
# Syncing 2200 blocks can take a while on slow systems. Give it plenty of time to sync.
p2p1.sync_with_ping(120)
assert_equal(
self.nodes[1].getblock(self.nodes[1].getbestblockhash())['height'],
2203)
self.log.info("Send blocks to node2. Block 102 will be rejected.")
self.send_blocks_until_disconnected(p2p2)
self.assert_blockchain_height(self.nodes[2], 102)
def run_test(self):
self.test_node = self.nodes[0].add_p2p_connection(P2PDataStore())
self.log.info("Running signed block tests")
assert_equal(self.nodes[0].getblockcount(), 0)
genesisblock_hash = int(self.nodes[0].getbestblockhash(), 16)
# create 1 spendable coinbase
height = 1
block_time = int(time())
block1 = create_block(genesisblock_hash, create_coinbase(height),
block_time)
block1.rehash()
block1.solve(self.secret)
self.nodes[0].p2p.send_blocks_and_test([block1],
self.nodes[0],
success=True)
self.nodes[0].generate(100, self.secret)
previousblock_hash = int(self.nodes[0].getbestblockhash(), 16)
# create a test block
height = 102
block_time = int(time())
block = create_block(previousblock_hash, create_coinbase(height),
block_time + 100)
block.rehash()
block_hex = ToHex(block)
block_hash = block.getsighash()
previousblock_hash = int(self.nodes[0].getbestblockhash(), 16)
self.log.info("Test block : %s" % bytes_to_hex_str(block_hash))
self.log.info("Testing RPC testproposedblock with valid block")
assert_equal(self.nodes[0].testproposedblock(block_hex), True)
self.log.info("Testing RPC combineblocksigs with 3 valid signatures")
sig0 = self.cKey[0].sign(block_hash)
sig1 = self.cKey[1].sign(block_hash)
sig2 = self.cKey[2].sign(block_hash)
signedBlock = self.nodes[0].combineblocksigs(block_hex, [
bytes_to_hex_str(sig0),
bytes_to_hex_str(sig1),
bytes_to_hex_str(sig2)
])
if (len(signedBlock["warning"])):
self.log.warning(
"%s : signatures:%s [%d, %d, %d]" %
(signedBlock["warning"], [sig0, sig1, sig2],
self.cKey[0].verify(block_hash, sig0), self.cKey[1].verify(
block_hash, sig1), self.cKey[2].verify(block_hash, sig2)))
block.solve(self.secret)
self.nodes[0].p2p.send_blocks_and_test([block],
self.nodes[0],
success=True)
# combineblocksigs only returns true when signatures are appended and enough
# are included to pass validation
assert_equal(signedBlock["complete"], True)
assert_equal(signedBlock["warning"], "")
assert_equal(
len(signedBlock["hex"]),
len(block_hex) + len(bytes_to_hex_str(sig0)) +
len(bytes_to_hex_str(sig1)) + len(bytes_to_hex_str(sig2)) + 6)
#6 is 2 bytes for 3 length of signatures
self.log.info("Testing RPC combineblocksigs with 1 invalid signature")
sig0 = bytearray(sig0)
sig0[2] = 30
signedBlock = self.nodes[0].combineblocksigs(block_hex, [
bytes_to_hex_str(sig0),
bytes_to_hex_str(sig1),
bytes_to_hex_str(sig2)
])
assert_equal(signedBlock["complete"], True) #True as threshold is 1
assert_equal(
signedBlock["warning"],
"invalid encoding in signature: Non-canonical DER signature %s One or more signatures were not added to block"
% (bytes_to_hex_str(sig0)))
assert_equal(
len(signedBlock["hex"]),
len(block_hex) + len(bytes_to_hex_str(sig1)) +
len(bytes_to_hex_str(sig2)) + 4)
self.log.info("Testing RPC combineblocksigs with 2 invalid signatures")
sig1 = bytearray(sig1)
sig1[2] = 30
signedBlock = self.nodes[0].combineblocksigs(block_hex, [
bytes_to_hex_str(sig0),
bytes_to_hex_str(sig1),
bytes_to_hex_str(sig2)
])
assert_equal(signedBlock["complete"], True) #True as threshold is 1
assert_equal(len(signedBlock["hex"]),
len(block_hex) + len(bytes_to_hex_str(sig2)) + 2)
self.log.info("Testing RPC combineblocksigs with 3 invalid signatures")
sig2 = bytearray(sig2)
sig2[2] = 30
signedBlock = self.nodes[0].combineblocksigs(block_hex, [
bytes_to_hex_str(sig0),
bytes_to_hex_str(sig1),
bytes_to_hex_str(sig2)
])
assert_equal(signedBlock["complete"], False)
assert_equal(len(signedBlock["hex"]), len(block_hex))
self.log.info("Testing RPC combineblocksigs with invalid blocks")
#invalid block hex
assert_raises_rpc_error(-22, "Block decode failed",
self.nodes[0].combineblocksigs, "0000", [])
#no signature
assert_raises_rpc_error(-32602, "Signature list was empty",
self.nodes[0].combineblocksigs, block_hex, [])
#too many signature
assert_raises_rpc_error(
-32602, "Too many signatures", self.nodes[0].combineblocksigs,
block_hex,
["00", "00", "00", "00", "00", "00", "00", "00", "00", "00"])
self.log.info("Testing RPC testproposedblock with old block")
#invalid block hex
assert_raises_rpc_error(-22, "Block decode failed",
self.nodes[0].testproposedblock, "0000")
# create invalid block
height = 103
invalid_block = create_block(previousblock_hash,
create_coinbase(height), block_time + 110)
invalid_block.solve(self.secret)
assert_raises_rpc_error(-25,
"proposal was not based on our best chain",
self.nodes[0].testproposedblock,
ToHex(invalid_block))
self.log.info("Testing RPC testproposedblock with non standard block")
# create block with non-standard transaction
previousblock_hash = int(self.nodes[0].getbestblockhash(), 16)
height = 103
nonstd_block = create_block(previousblock_hash,
create_coinbase(height), block_time + 120)
# 3 of 2 multisig is non standard
nonstd_script = CScript([
b'53' + self.pubkeys[0] + self.pubkeys[1] + self.pubkeys[2] +
b'52ea'
])
tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(block1.vtx[0].malfixsha256, 0), b""))
tx.vout.append(CTxOut(50, b'0x51'))
(sig_hash, err) = SignatureHash(nonstd_script, tx, 0, SIGHASH_ALL)
signature = self.cKey[0].sign(sig_hash) + b'\x01' # 0x1 is SIGHASH_ALL
tx.vin[0].scriptSig = CScript([signature, self.pubkeys[0]])
tx.rehash()
#add non-standard tx to block
nonstd_block.vtx.append(tx)
nonstd_block.solve(self.secret)
nonstd_block.hashMerkleRoot = nonstd_block.calc_merkle_root()
nonstd_block.hashImMerkleRoot = nonstd_block.calc_immutable_merkle_root(
)
assert (nonstd_block.is_valid())
#block is accepted when acceptnonstd flag is set
assert_equal(
self.nodes[0].testproposedblock(ToHex(nonstd_block), True), True)
#block is rejected when acceptnonstd flag is not set
assert_raises_rpc_error(
-25, "Block proposal included a non-standard transaction",
self.nodes[0].testproposedblock, ToHex(nonstd_block), False)
def test_opt_in(self):
"""Replacing should only work if orig tx opted in"""
tx0_outpoint = make_utxo(self.nodes[0], int(1.1 * COIN))
# Create a non-opting in transaction
tx1a = CTransaction()
tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0xffffffff)]
tx1a.vout = [CTxOut(1 * COIN, DUMMY_P2WPKH_SCRIPT)]
tx1a_hex = txToHex(tx1a)
tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, 0)
# This transaction isn't shown as replaceable
assert_equal(
self.nodes[0].getmempoolentry(tx1a_txid)['bip125-replaceable'],
False)
# Shouldn't be able to double-spend
tx1b = CTransaction()
tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)]
tx1b.vout = [CTxOut(int(0.9 * COIN), DUMMY_P2WPKH_SCRIPT)]
tx1b_hex = txToHex(tx1b)
# This will raise an exception
assert_raises_rpc_error(-26, "txn-mempool-conflict",
self.nodes[0].sendrawtransaction, tx1b_hex, 0)
tx1_outpoint = make_utxo(self.nodes[0], int(1.1 * COIN))
# Create a different non-opting in transaction
tx2a = CTransaction()
tx2a.vin = [CTxIn(tx1_outpoint, nSequence=0xfffffffe)]
tx2a.vout = [CTxOut(1 * COIN, DUMMY_P2WPKH_SCRIPT)]
tx2a_hex = txToHex(tx2a)
tx2a_txid = self.nodes[0].sendrawtransaction(tx2a_hex, 0)
# Still shouldn't be able to double-spend
tx2b = CTransaction()
tx2b.vin = [CTxIn(tx1_outpoint, nSequence=0)]
tx2b.vout = [CTxOut(int(0.9 * COIN), DUMMY_P2WPKH_SCRIPT)]
tx2b_hex = txToHex(tx2b)
# This will raise an exception
assert_raises_rpc_error(-26, "txn-mempool-conflict",
self.nodes[0].sendrawtransaction, tx2b_hex, 0)
# Now create a new transaction that spends from tx1a and tx2a
# opt-in on one of the inputs
# Transaction should be replaceable on either input
tx1a_txid = int(tx1a_txid, 16)
tx2a_txid = int(tx2a_txid, 16)
tx3a = CTransaction()
tx3a.vin = [
CTxIn(COutPoint(tx1a_txid, 0), nSequence=0xffffffff),
CTxIn(COutPoint(tx2a_txid, 0), nSequence=0xfffffffd)
]
tx3a.vout = [
CTxOut(int(0.9 * COIN), CScript([b'c'])),
CTxOut(int(0.9 * COIN), CScript([b'd']))
]
tx3a_hex = txToHex(tx3a)
tx3a_txid = self.nodes[0].sendrawtransaction(tx3a_hex, 0)
# This transaction is shown as replaceable
assert_equal(
self.nodes[0].getmempoolentry(tx3a_txid)['bip125-replaceable'],
True)
tx3b = CTransaction()
tx3b.vin = [CTxIn(COutPoint(tx1a_txid, 0), nSequence=0)]
tx3b.vout = [CTxOut(int(0.5 * COIN), DUMMY_P2WPKH_SCRIPT)]
tx3b_hex = txToHex(tx3b)
tx3c = CTransaction()
tx3c.vin = [CTxIn(COutPoint(tx2a_txid, 0), nSequence=0)]
tx3c.vout = [CTxOut(int(0.5 * COIN), DUMMY_P2WPKH_SCRIPT)]
tx3c_hex = txToHex(tx3c)
self.nodes[0].sendrawtransaction(tx3b_hex, 0)
# If tx3b was accepted, tx3c won't look like a replacement,
# but make sure it is accepted anyway
self.nodes[0].sendrawtransaction(tx3c_hex, 0)
def run_test(self):
self.log.info(
'prepare some coins for multiple *rawtransaction commands')
self.nodes[2].generate(1)
self.sync_all()
self.nodes[0].generate(101)
self.sync_all()
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.5)
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.0)
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 5.0)
self.sync_all()
self.nodes[0].generate(5)
self.sync_all()
self.log.info(
'Test getrawtransaction on genesis block coinbase returns an error'
)
block = self.nodes[0].getblock(self.nodes[0].getblockhash(0))
assert_raises_rpc_error(
-5,
"The genesis block coinbase is not considered an ordinary transaction",
self.nodes[0].getrawtransaction, block['merkleroot'])
self.log.info(
'Check parameter types and required parameters of createrawtransaction'
)
# Test `createrawtransaction` required parameters
assert_raises_rpc_error(-1, "createrawtransaction",
self.nodes[0].createrawtransaction)
assert_raises_rpc_error(-1, "createrawtransaction",
self.nodes[0].createrawtransaction, [])
# Test `createrawtransaction` invalid extra parameters
assert_raises_rpc_error(-1, "createrawtransaction",
self.nodes[0].createrawtransaction, [], {}, 0,
'foo')
# Test `createrawtransaction` invalid `inputs`
txid = '1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000'
assert_raises_rpc_error(-3, "Expected type array",
self.nodes[0].createrawtransaction, 'foo', {})
assert_raises_rpc_error(-1, "JSON value is not an object as expected",
self.nodes[0].createrawtransaction, ['foo'],
{})
assert_raises_rpc_error(-1, "JSON value is not a string as expected",
self.nodes[0].createrawtransaction, [{}], {})
assert_raises_rpc_error(
-8, "txid must be of length 64 (not 3, for 'foo')",
self.nodes[0].createrawtransaction, [{
'txid': 'foo'
}], {})
assert_raises_rpc_error(
-8,
"txid must be hexadecimal string (not 'ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844')",
self.nodes[0].createrawtransaction, [{
'txid':
'ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844'
}], {})
assert_raises_rpc_error(-8, "Invalid parameter, missing vout key",
self.nodes[0].createrawtransaction,
[{
'txid': txid
}], {})
assert_raises_rpc_error(-8, "Invalid parameter, vout must be a number",
self.nodes[0].createrawtransaction,
[{
'txid': txid,
'vout': 'foo'
}], {})
assert_raises_rpc_error(-8, "Invalid parameter, vout must be positive",
self.nodes[0].createrawtransaction, [{
'txid': txid,
'vout': -1
}], {})
assert_raises_rpc_error(
-8, "Invalid parameter, sequence number is out of range",
self.nodes[0].createrawtransaction, [{
'txid': txid,
'vout': 0,
'sequence': -1
}], {})
# Test `createrawtransaction` invalid `outputs`
address = self.nodes[0].getnewaddress()
address2 = self.nodes[0].getnewaddress()
assert_raises_rpc_error(-1, "JSON value is not an array as expected",
self.nodes[0].createrawtransaction, [], 'foo')
# Should not throw for backwards compatibility
self.nodes[0].createrawtransaction(inputs=[], outputs={})
self.nodes[0].createrawtransaction(inputs=[], outputs=[])
assert_raises_rpc_error(-8, "Data must be hexadecimal string",
self.nodes[0].createrawtransaction, [],
{'data': 'foo'})
assert_raises_rpc_error(-5, "Invalid Bitcoin address",
self.nodes[0].createrawtransaction, [],
{'foo': 0})
assert_raises_rpc_error(-3, "Invalid amount",
self.nodes[0].createrawtransaction, [],
{address: 'foo'})
assert_raises_rpc_error(-3, "Amount out of range",
self.nodes[0].createrawtransaction, [],
{address: -1})
assert_raises_rpc_error(
-8, "Invalid parameter, duplicated address: {}".format(address),
self.nodes[0].createrawtransaction, [],
multidict([(address, 1), (address, 1)]))
assert_raises_rpc_error(
-8, "Invalid parameter, duplicated address: {}".format(address),
self.nodes[0].createrawtransaction, [], [{
address: 1
}, {
address: 1
}])
assert_raises_rpc_error(-8, "Invalid parameter, duplicate key: data",
self.nodes[0].createrawtransaction, [],
[{
"data": 'aa'
}, {
"data": "bb"
}])
assert_raises_rpc_error(-8, "Invalid parameter, duplicate key: data",
self.nodes[0].createrawtransaction, [],
multidict([("data", 'aa'), ("data", "bb")]))
assert_raises_rpc_error(
-8,
"Invalid parameter, key-value pair must contain exactly one key",
self.nodes[0].createrawtransaction, [], [{
'a': 1,
'b': 2
}])
assert_raises_rpc_error(
-8, "Invalid parameter, key-value pair not an object as expected",
self.nodes[0].createrawtransaction, [],
[['key-value pair1'], ['2']])
# Test `createrawtransaction` invalid `locktime`
assert_raises_rpc_error(-3, "Expected type number",
self.nodes[0].createrawtransaction, [], {},
'foo')
assert_raises_rpc_error(-8, "Invalid parameter, locktime out of range",
self.nodes[0].createrawtransaction, [], {}, -1)
assert_raises_rpc_error(-8, "Invalid parameter, locktime out of range",
self.nodes[0].createrawtransaction, [], {},
4294967296)
self.log.info(
'Check that createrawtransaction accepts an array and object as outputs'
)
tx = CTransaction()
# One output
tx.deserialize(
BytesIO(
hex_str_to_bytes(self.nodes[2].createrawtransaction(
inputs=[{
'txid': txid,
'vout': 9
}], outputs={address: 99}))))
assert_equal(len(tx.vout), 1)
assert_equal(
tx.serialize().hex(),
self.nodes[2].createrawtransaction(inputs=[{
'txid': txid,
'vout': 9
}],
outputs=[{
address: 99
}]),
)
# Two outputs
tx.deserialize(
BytesIO(
hex_str_to_bytes(self.nodes[2].createrawtransaction(
inputs=[{
'txid': txid,
'vout': 9
}],
outputs=OrderedDict([(address, 99), (address2, 99)])))))
assert_equal(len(tx.vout), 2)
assert_equal(
tx.serialize().hex(),
self.nodes[2].createrawtransaction(inputs=[{
'txid': txid,
'vout': 9
}],
outputs=[{
address: 99
}, {
address2: 99
}]),
)
# Multiple mixed outputs
tx.deserialize(
BytesIO(
hex_str_to_bytes(self.nodes[2].createrawtransaction(
inputs=[{
'txid': txid,
'vout': 9
}],
outputs=multidict([(address, 99), (address2, 99),
('data', '99')])))))
assert_equal(len(tx.vout), 3)
assert_equal(
tx.serialize().hex(),
self.nodes[2].createrawtransaction(inputs=[{
'txid': txid,
'vout': 9
}],
outputs=[{
address: 99
}, {
address2: 99
}, {
'data': '99'
}]),
)
self.log.info('sendrawtransaction with missing input')
# won't exists
inputs = [{
'txid':
"1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000",
'vout': 1
}]
outputs = {self.nodes[0].getnewaddress(): 4.998}
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
rawtx = pad_raw_tx(rawtx)
rawtx = self.nodes[2].signrawtransactionwithwallet(rawtx)
# This will raise an exception since there are missing inputs
assert_raises_rpc_error(-25, "bad-txns-inputs-missingorspent",
self.nodes[2].sendrawtransaction, rawtx['hex'])
#####################################
# getrawtransaction with block hash #
#####################################
# make a tx by sending then generate 2 blocks; block1 has the tx in it
tx = self.nodes[2].sendtoaddress(self.nodes[1].getnewaddress(), 1)
block1, block2 = self.nodes[2].generate(2)
self.sync_all()
# We should be able to get the raw transaction by providing the correct
# block
gottx = self.nodes[0].getrawtransaction(tx, True, block1)
assert_equal(gottx['txid'], tx)
assert_equal(gottx['in_active_chain'], True)
# We should not have the 'in_active_chain' flag when we don't provide a
# block
gottx = self.nodes[0].getrawtransaction(tx, True)
assert_equal(gottx['txid'], tx)
assert 'in_active_chain' not in gottx
# We should not get the tx if we provide an unrelated block
assert_raises_rpc_error(-5, "No such transaction found",
self.nodes[0].getrawtransaction, tx, True,
block2)
# An invalid block hash should raise the correct errors
assert_raises_rpc_error(-1, "JSON value is not a string as expected",
self.nodes[0].getrawtransaction, tx, True,
True)
assert_raises_rpc_error(
-8, "parameter 3 must be of length 64 (not 6, for 'foobar')",
self.nodes[0].getrawtransaction, tx, True, "foobar")
assert_raises_rpc_error(
-8, "parameter 3 must be of length 64 (not 8, for 'abcd1234')",
self.nodes[0].getrawtransaction, tx, True, "abcd1234")
assert_raises_rpc_error(
-8,
"parameter 3 must be hexadecimal string (not 'ZZZ0000000000000000000000000000000000000000000000000000000000000')",
self.nodes[0].getrawtransaction, tx, True,
"ZZZ0000000000000000000000000000000000000000000000000000000000000")
assert_raises_rpc_error(
-5, "Block hash not found", self.nodes[0].getrawtransaction, tx,
True,
"0000000000000000000000000000000000000000000000000000000000000000")
# Undo the blocks and check in_active_chain
self.nodes[0].invalidateblock(block1)
gottx = self.nodes[0].getrawtransaction(txid=tx,
verbose=True,
blockhash=block1)
assert_equal(gottx['in_active_chain'], False)
self.nodes[0].reconsiderblock(block1)
assert_equal(self.nodes[0].getbestblockhash(), block2)
#
# RAW TX MULTISIG TESTS #
#
# 2of2 test
addr1 = self.nodes[2].getnewaddress()
addr2 = self.nodes[2].getnewaddress()
addr1Obj = self.nodes[2].getaddressinfo(addr1)
addr2Obj = self.nodes[2].getaddressinfo(addr2)
# Tests for createmultisig and addmultisigaddress
assert_raises_rpc_error(-5, "Invalid public key",
self.nodes[0].createmultisig, 1, ["01020304"])
# createmultisig can only take public keys
self.nodes[0].createmultisig(2,
[addr1Obj['pubkey'], addr2Obj['pubkey']])
# addmultisigaddress can take both pubkeys and addresses so long as
# they are in the wallet, which is tested here.
assert_raises_rpc_error(-5, "Invalid public key",
self.nodes[0].createmultisig, 2,
[addr1Obj['pubkey'], addr1])
mSigObj = self.nodes[2].addmultisigaddress(
2, [addr1Obj['pubkey'], addr1])['address']
# use balance deltas instead of absolute values
bal = self.nodes[2].getbalance()
# send 1.2 BCH to msig adr
txId = self.nodes[0].sendtoaddress(mSigObj, 1.2)
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
# node2 has both keys of the 2of2 ms addr., tx should affect the
# balance
assert_equal(self.nodes[2].getbalance(), bal + Decimal('1.20000000'))
# 2of3 test from different nodes
bal = self.nodes[2].getbalance()
addr1 = self.nodes[1].getnewaddress()
addr2 = self.nodes[2].getnewaddress()
addr3 = self.nodes[2].getnewaddress()
addr1Obj = self.nodes[1].getaddressinfo(addr1)
addr2Obj = self.nodes[2].getaddressinfo(addr2)
addr3Obj = self.nodes[2].getaddressinfo(addr3)
mSigObj = self.nodes[2].addmultisigaddress(
2, [addr1Obj['pubkey'], addr2Obj['pubkey'], addr3Obj['pubkey']
])['address']
txId = self.nodes[0].sendtoaddress(mSigObj, 2.2)
decTx = self.nodes[0].gettransaction(txId)
rawTx = self.nodes[0].decoderawtransaction(decTx['hex'])
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
# THIS IS AN INCOMPLETE FEATURE
# NODE2 HAS TWO OF THREE KEY AND THE FUNDS SHOULD BE SPENDABLE AND
# COUNT AT BALANCE CALCULATION
# for now, assume the funds of a 2of3 multisig tx are not marked as
# spendable
assert_equal(self.nodes[2].getbalance(), bal)
txDetails = self.nodes[0].gettransaction(txId, True)
rawTx = self.nodes[0].decoderawtransaction(txDetails['hex'])
vout = next(o for o in rawTx['vout']
if o['value'] == Decimal('2.20000000'))
bal = self.nodes[0].getbalance()
inputs = [{
"txid": txId,
"vout": vout['n'],
"scriptPubKey": vout['scriptPubKey']['hex'],
"amount": vout['value'],
}]
outputs = {self.nodes[0].getnewaddress(): 2.19}
rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
rawTxPartialSigned = self.nodes[1].signrawtransactionwithwallet(
rawTx, inputs)
# node1 only has one key, can't comp. sign the tx
assert_equal(rawTxPartialSigned['complete'], False)
rawTxSigned = self.nodes[2].signrawtransactionwithwallet(rawTx, inputs)
# node2 can sign the tx compl., own two of three keys
assert_equal(rawTxSigned['complete'], True)
self.nodes[2].sendrawtransaction(rawTxSigned['hex'])
rawTx = self.nodes[0].decoderawtransaction(rawTxSigned['hex'])
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
assert_equal(self.nodes[0].getbalance(), bal + Decimal('50.00000000') +
Decimal('2.19000000')) # block reward + tx
rawTxBlock = self.nodes[0].getblock(self.nodes[0].getbestblockhash())
# 2of2 test for combining transactions
bal = self.nodes[2].getbalance()
addr1 = self.nodes[1].getnewaddress()
addr2 = self.nodes[2].getnewaddress()
addr1Obj = self.nodes[1].getaddressinfo(addr1)
addr2Obj = self.nodes[2].getaddressinfo(addr2)
self.nodes[1].addmultisigaddress(
2, [addr1Obj['pubkey'], addr2Obj['pubkey']])['address']
mSigObj = self.nodes[2].addmultisigaddress(
2, [addr1Obj['pubkey'], addr2Obj['pubkey']])['address']
mSigObjValid = self.nodes[2].getaddressinfo(mSigObj)
txId = self.nodes[0].sendtoaddress(mSigObj, 2.2)
decTx = self.nodes[0].gettransaction(txId)
rawTx2 = self.nodes[0].decoderawtransaction(decTx['hex'])
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
# the funds of a 2of2 multisig tx should not be marked as spendable
assert_equal(self.nodes[2].getbalance(), bal)
txDetails = self.nodes[0].gettransaction(txId, True)
rawTx2 = self.nodes[0].decoderawtransaction(txDetails['hex'])
vout = next(o for o in rawTx2['vout']
if o['value'] == Decimal('2.20000000'))
bal = self.nodes[0].getbalance()
inputs = [{
"txid": txId,
"vout": vout['n'],
"scriptPubKey": vout['scriptPubKey']['hex'],
"redeemScript": mSigObjValid['hex'],
"amount": vout['value']
}]
outputs = {self.nodes[0].getnewaddress(): 2.19}
rawTx2 = self.nodes[2].createrawtransaction(inputs, outputs)
rawTxPartialSigned1 = self.nodes[1].signrawtransactionwithwallet(
rawTx2, inputs)
self.log.debug(rawTxPartialSigned1)
# node1 only has one key, can't comp. sign the tx
assert_equal(rawTxPartialSigned1['complete'], False)
rawTxPartialSigned2 = self.nodes[2].signrawtransactionwithwallet(
rawTx2, inputs)
self.log.debug(rawTxPartialSigned2)
# node2 only has one key, can't comp. sign the tx
assert_equal(rawTxPartialSigned2['complete'], False)
rawTxComb = self.nodes[2].combinerawtransaction(
[rawTxPartialSigned1['hex'], rawTxPartialSigned2['hex']])
self.log.debug(rawTxComb)
self.nodes[2].sendrawtransaction(rawTxComb)
rawTx2 = self.nodes[0].decoderawtransaction(rawTxComb)
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
assert_equal(self.nodes[0].getbalance(), bal + Decimal('50.00000000') +
Decimal('2.19000000')) # block reward + tx
# getrawtransaction tests
# 1. valid parameters - only supply txid
txHash = rawTx["hash"]
assert_equal(self.nodes[0].getrawtransaction(txHash),
rawTxSigned['hex'])
# 2. valid parameters - supply txid and 0 for non-verbose
assert_equal(self.nodes[0].getrawtransaction(txHash, 0),
rawTxSigned['hex'])
# 3. valid parameters - supply txid and False for non-verbose
assert_equal(self.nodes[0].getrawtransaction(txHash, False),
rawTxSigned['hex'])
# 4. valid parameters - supply txid and 1 for verbose.
# We only check the "hex" field of the output so we don't need to
# update this test every time the output format changes.
assert_equal(self.nodes[0].getrawtransaction(txHash, 1)["hex"],
rawTxSigned['hex'])
# 5. valid parameters - supply txid and True for non-verbose
assert_equal(self.nodes[0].getrawtransaction(txHash, True)["hex"],
rawTxSigned['hex'])
# 6. invalid parameters - supply txid and string "Flase"
assert_raises_rpc_error(-1, "not a boolean",
self.nodes[0].getrawtransaction, txHash,
"False")
# 7. invalid parameters - supply txid and empty array
assert_raises_rpc_error(-1, "not a boolean",
self.nodes[0].getrawtransaction, txHash, [])
# 8. invalid parameters - supply txid and empty dict
assert_raises_rpc_error(-1, "not a boolean",
self.nodes[0].getrawtransaction, txHash, {})
# Sanity checks on verbose getrawtransaction output
rawTxOutput = self.nodes[0].getrawtransaction(txHash, True)
assert_equal(rawTxOutput["hex"], rawTxSigned["hex"])
assert_equal(rawTxOutput["txid"], txHash)
assert_equal(rawTxOutput["hash"], txHash)
assert_greater_than(rawTxOutput["size"], 300)
assert_equal(rawTxOutput["version"], 0x02)
assert_equal(rawTxOutput["locktime"], 0)
assert_equal(len(rawTxOutput["vin"]), 1)
assert_equal(len(rawTxOutput["vout"]), 1)
assert_equal(rawTxOutput["blockhash"], rawTxBlock["hash"])
assert_equal(rawTxOutput["confirmations"], 3)
assert_equal(rawTxOutput["time"], rawTxBlock["time"])
assert_equal(rawTxOutput["blocktime"], rawTxBlock["time"])
inputs = [{
'txid':
"1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000",
'sequence': 1000
}]
outputs = {self.nodes[0].getnewaddress(): 1}
assert_raises_rpc_error(-8, 'Invalid parameter, missing vout key',
self.nodes[0].createrawtransaction, inputs,
outputs)
inputs[0]['vout'] = "1"
assert_raises_rpc_error(-8, 'Invalid parameter, vout must be a number',
self.nodes[0].createrawtransaction, inputs,
outputs)
inputs[0]['vout'] = -1
assert_raises_rpc_error(-8, 'Invalid parameter, vout must be positive',
self.nodes[0].createrawtransaction, inputs,
outputs)
inputs[0]['vout'] = 1
rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
decrawtx = self.nodes[0].decoderawtransaction(rawtx)
assert_equal(decrawtx['vin'][0]['sequence'], 1000)
# 9. invalid parameters - sequence number out of range
inputs[0]['sequence'] = -1
assert_raises_rpc_error(
-8, 'Invalid parameter, sequence number is out of range',
self.nodes[0].createrawtransaction, inputs, outputs)
# 10. invalid parameters - sequence number out of range
inputs[0]['sequence'] = 4294967296
assert_raises_rpc_error(
-8, 'Invalid parameter, sequence number is out of range',
self.nodes[0].createrawtransaction, inputs, outputs)
inputs[0]['sequence'] = 4294967294
rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
decrawtx = self.nodes[0].decoderawtransaction(rawtx)
assert_equal(decrawtx['vin'][0]['sequence'], 4294967294)
####################################
# TRANSACTION VERSION NUMBER TESTS #
####################################
# Test the minimum transaction version number that fits in a signed
# 32-bit integer.
tx = CTransaction()
tx.nVersion = -0x80000000
rawtx = ToHex(tx)
decrawtx = self.nodes[0].decoderawtransaction(rawtx)
assert_equal(decrawtx['version'], -0x80000000)
# Test the maximum transaction version number that fits in a signed
# 32-bit integer.
tx = CTransaction()
tx.nVersion = 0x7fffffff
rawtx = ToHex(tx)
decrawtx = self.nodes[0].decoderawtransaction(rawtx)
assert_equal(decrawtx['version'], 0x7fffffff)
self.log.info('sendrawtransaction/testmempoolaccept with maxfeerate')
txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.0)
rawTx = self.nodes[0].getrawtransaction(txId, True)
vout = next(o for o in rawTx['vout']
if o['value'] == Decimal('1.00000000'))
self.sync_all()
inputs = [{"txid": txId, "vout": vout['n']}]
# 1000 sat fee
outputs = {self.nodes[0].getnewaddress(): Decimal("0.99999000")}
rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
rawTxSigned = self.nodes[2].signrawtransactionwithwallet(rawTx)
assert_equal(rawTxSigned['complete'], True)
# 1000 sat fee, ~200 b transaction, fee rate should land around 5 sat/b = 0.00005000 BTC/kB
# Thus, testmempoolaccept should reject
testres = self.nodes[2].testmempoolaccept([rawTxSigned['hex']],
0.00001000)[0]
assert_equal(testres['allowed'], False)
assert_equal(testres['reject-reason'], '256: absurdly-high-fee')
# and sendrawtransaction should throw
assert_raises_rpc_error(-26, "absurdly-high-fee",
self.nodes[2].sendrawtransaction,
rawTxSigned['hex'], 0.00001000)
# And below calls should both succeed
testres = self.nodes[2].testmempoolaccept(rawtxs=[rawTxSigned['hex']],
maxfeerate='0.00007000')[0]
assert_equal(testres['allowed'], True)
self.nodes[2].sendrawtransaction(hexstring=rawTxSigned['hex'],
maxfeerate='0.00007000')
##########################################
# Decoding weird scripts in transactions #
##########################################
self.log.info('Decode correctly-formatted but weird transactions')
tx = CTransaction()
# empty
self.nodes[0].decoderawtransaction(ToHex(tx))
# truncated push
tx.vin.append(CTxIn(COutPoint(42, 0), b'\x4e\x00\x00'))
tx.vin.append(CTxIn(COutPoint(42, 0), b'\x4c\x10TRUNC'))
tx.vout.append(CTxOut(0, b'\x4e\x00\x00'))
tx.vout.append(CTxOut(0, b'\x4c\x10TRUNC'))
self.nodes[0].decoderawtransaction(ToHex(tx))
# giant pushes and long scripts
tx.vin.append(CTxIn(COutPoint(42, 0),
CScript([b'giant push' * 10000])))
tx.vout.append(CTxOut(0, CScript([b'giant push' * 10000])))
self.nodes[0].decoderawtransaction(ToHex(tx))
self.log.info('Refuse garbage after transaction')
assert_raises_rpc_error(-22, 'TX decode failed',
self.nodes[0].decoderawtransaction,
ToHex(tx) + '00')
def __init__(self, *, spend_tx=None, spend_block=None):
self.spend_tx = spend_block.vtx[0] if spend_block else spend_tx
self.spend_avail = sum(o.nValue for o in self.spend_tx.vout)
self.valid_txin = CTxIn(COutPoint(self.spend_tx.sha256, 0), b"",
0xffffffff)
def run_test(self):
node = self.nodes[0]
self.log.info('Start with empty mempool and 101 blocks')
# The last 100 coinbase transactions are premature
blockhash = self.generate(node, 101)[0]
txid = node.getblock(blockhash=blockhash, verbosity=2)["tx"][0]["txid"]
assert_equal(node.getmempoolinfo()['size'], 0)
self.log.info("Submit parent with multiple script branches to mempool")
hashlock = hash160(b'Preimage')
witness_script = CScript([
OP_IF, OP_HASH160, hashlock, OP_EQUAL, OP_ELSE, OP_TRUE, OP_ENDIF
])
witness_program = sha256(witness_script)
script_pubkey = CScript([OP_0, witness_program])
parent = CTransaction()
parent.vin.append(CTxIn(COutPoint(int(txid, 16), 0), b""))
parent.vout.append(CTxOut(int(9.99998 * COIN), script_pubkey))
parent.rehash()
privkeys = [node.get_deterministic_priv_key().key]
raw_parent = node.signrawtransactionwithkey(
hexstring=parent.serialize().hex(), privkeys=privkeys)['hex']
parent_txid = node.sendrawtransaction(hexstring=raw_parent,
maxfeerate=0)
self.generate(node, 1)
peer_wtxid_relay = node.add_p2p_connection(P2PTxInvStore())
# Create a new transaction with witness solving first branch
child_witness_script = CScript([OP_TRUE])
child_witness_program = sha256(child_witness_script)
child_script_pubkey = CScript([OP_0, child_witness_program])
child_one = CTransaction()
child_one.vin.append(CTxIn(COutPoint(int(parent_txid, 16), 0), b""))
child_one.vout.append(CTxOut(int(9.99996 * COIN), child_script_pubkey))
child_one.wit.vtxinwit.append(CTxInWitness())
child_one.wit.vtxinwit[0].scriptWitness.stack = [
b'Preimage', b'\x01', witness_script
]
child_one_wtxid = child_one.getwtxid()
child_one_txid = child_one.rehash()
# Create another identical transaction with witness solving second branch
child_two = deepcopy(child_one)
child_two.wit.vtxinwit[0].scriptWitness.stack = [b'', witness_script]
child_two_wtxid = child_two.getwtxid()
child_two_txid = child_two.rehash()
assert_equal(child_one_txid, child_two_txid)
assert child_one_wtxid != child_two_wtxid
self.log.info("Submit child_one to the mempool")
txid_submitted = node.sendrawtransaction(child_one.serialize().hex())
assert_equal(
node.getmempoolentry(txid_submitted)['wtxid'], child_one_wtxid)
peer_wtxid_relay.wait_for_broadcast([child_one_wtxid])
assert_equal(node.getmempoolinfo()["unbroadcastcount"], 0)
# testmempoolaccept reports the "already in mempool" error
assert_equal(node.testmempoolaccept([child_one.serialize().hex()]),
[{
"txid": child_one_txid,
"wtxid": child_one_wtxid,
"allowed": False,
"reject-reason": "txn-already-in-mempool"
}])
assert_equal(
node.testmempoolaccept([child_two.serialize().hex()])[0], {
"txid": child_two_txid,
"wtxid": child_two_wtxid,
"allowed": False,
"reject-reason": "txn-same-nonwitness-data-in-mempool"
})
# sendrawtransaction will not throw but quits early when the exact same transaction is already in mempool
node.sendrawtransaction(child_one.serialize().hex())
self.log.info("Connect another peer that hasn't seen child_one before")
peer_wtxid_relay_2 = node.add_p2p_connection(P2PTxInvStore())
self.log.info("Submit child_two to the mempool")
# sendrawtransaction will not throw but quits early when a transaction with the same non-witness data is already in mempool
node.sendrawtransaction(child_two.serialize().hex())
# The node should rebroadcast the transaction using the wtxid of the correct transaction
# (child_one, which is in its mempool).
peer_wtxid_relay_2.wait_for_broadcast([child_one_wtxid])
assert_equal(node.getmempoolinfo()["unbroadcastcount"], 0)
def test_sequence_lock_confirmed_inputs(self):
# Create lots of confirmed utxos, and use them to generate lots of random
# transactions.
max_outputs = 50
addresses = []
while len(addresses) < max_outputs:
addresses.append(self.nodes[0].getnewaddress())
while len(self.nodes[0].listunspent()) < 200:
import random
random.shuffle(addresses)
num_outputs = random.randint(1, max_outputs)
outputs = {}
for i in range(num_outputs):
outputs[addresses[i]] = random.randint(1, 20) * 0.01
self.nodes[0].sendmany("", outputs)
self.nodes[0].generate(1)
utxos = self.nodes[0].listunspent()
# Try creating a lot of random transactions.
# Each time, choose a random number of inputs, and randomly set
# some of those inputs to be sequence locked (and randomly choose
# between height/time locking). Small random chance of making the locks
# all pass.
for i in range(400):
# Randomly choose up to 10 inputs
num_inputs = random.randint(1, 10)
random.shuffle(utxos)
# Track whether any sequence locks used should fail
should_pass = True
# Track whether this transaction was built with sequence locks
using_sequence_locks = False
tx = CTransaction()
tx.nVersion = 2
value = 0
for j in range(num_inputs):
sequence_value = 0xfffffffe # this disables sequence locks
# 50% chance we enable sequence locks
if random.randint(0, 1):
using_sequence_locks = True
# 10% of the time, make the input sequence value pass
input_will_pass = (random.randint(1, 10) == 1)
sequence_value = utxos[j]["confirmations"]
if not input_will_pass:
sequence_value += 1
should_pass = False
# Figure out what the median-time-past was for the confirmed input
# Note that if an input has N confirmations, we're going back N blocks
# from the tip so that we're looking up MTP of the block
# PRIOR to the one the input appears in, as per the BIP68 spec.
orig_time = self.get_median_time_past(
utxos[j]["confirmations"])
cur_time = self.get_median_time_past(0) # MTP of the tip
# can only timelock this input if it's not too old -- otherwise use height
can_time_lock = True
if ((cur_time - orig_time) >> SEQUENCE_LOCKTIME_GRANULARITY
) >= SEQUENCE_LOCKTIME_MASK:
can_time_lock = False
# if time-lockable, then 50% chance we make this a time lock
if random.randint(0, 1) and can_time_lock:
# Find first time-lock value that fails, or latest one that succeeds
time_delta = sequence_value << SEQUENCE_LOCKTIME_GRANULARITY
if input_will_pass and time_delta > cur_time - orig_time:
sequence_value = ((cur_time - orig_time) >>
SEQUENCE_LOCKTIME_GRANULARITY)
elif (not input_will_pass
and time_delta <= cur_time - orig_time):
sequence_value = (
(cur_time - orig_time) >>
SEQUENCE_LOCKTIME_GRANULARITY) + 1
sequence_value |= SEQUENCE_LOCKTIME_TYPE_FLAG
tx.vin.append(
CTxIn(COutPoint(int(utxos[j]["txid"], 16),
utxos[j]["vout"]),
nSequence=sequence_value))
value += utxos[j]["amount"] * COIN
# Overestimate the size of the tx - signatures should be less than 120 bytes, and leave 50 for the output
tx_size = len(ToHex(tx)) // 2 + 120 * num_inputs + 50
tx.vout.append(
CTxOut(int(value - self.relayfee * tx_size * COIN / 1000),
CScript([b'a'])))
rawtx = self.nodes[0].signrawtransactionwithwallet(
ToHex(tx))["hex"]
if (using_sequence_locks and not should_pass):
# This transaction should be rejected
assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
self.nodes[0].sendrawtransaction,
rawtx)
else:
# This raw transaction should be accepted
self.nodes[0].sendrawtransaction(rawtx)
utxos = self.nodes[0].listunspent()
def run_test(self):
self.nodes[0].add_p2p_connection(P2PDataStore())
self.nodeaddress = self.nodes[0].getnewaddress()
self.pubkey = self.nodes[0].getaddressinfo(self.nodeaddress)["pubkey"]
self.log.info("Mining %d blocks", CHAIN_HEIGHT)
self.coinbase_txids = [
self.nodes[0].getblock(b)['tx'][0] for b in self.nodes[0].generate(
CHAIN_HEIGHT, self.signblockprivkeys)
]
## P2PKH transaction
########################
self.log.info("Test using a P2PKH transaction")
spendtx = create_transaction(self.nodes[0],
self.coinbase_txids[0],
self.nodeaddress,
amount=10)
spendtx.rehash()
copy_spendTx = CTransaction(spendtx)
#cache hashes
hash = spendtx.hash
hashMalFix = spendtx.hashMalFix
#malleate
unDERify(spendtx)
spendtx.rehash()
# verify that hashMalFix remains the same even when signature is malleated and hash changes
assert_not_equal(hash, spendtx.hash)
assert_equal(hashMalFix, spendtx.hashMalFix)
# verify that hash is spendtx.serialize()
hash = encode(hash256(spendtx.serialize())[::-1],
'hex_codec').decode('ascii')
assert_equal(hash, spendtx.hash)
# verify that hashMalFix is spendtx.serialize(with_scriptsig=False)
hashMalFix = encode(
hash256(spendtx.serialize(with_scriptsig=False))[::-1],
'hex_codec').decode('ascii')
assert_equal(hashMalFix, spendtx.hashMalFix)
assert_not_equal(hash, hashMalFix)
#as this transaction does not have witness data the following is true
assert_equal(spendtx.serialize(),
spendtx.serialize(with_witness=True, with_scriptsig=True))
assert_equal(spendtx.serialize(with_witness=False),
spendtx.serialize(with_witness=True, with_scriptsig=True))
assert_not_equal(
spendtx.serialize(with_witness=False),
spendtx.serialize(with_witness=True, with_scriptsig=False))
assert_equal(spendtx.serialize(with_witness=False),
spendtx.serialize_without_witness(with_scriptsig=True))
assert_equal(spendtx.serialize_with_witness(with_scriptsig=True),
spendtx.serialize_without_witness(with_scriptsig=True))
assert_equal(spendtx.serialize_with_witness(with_scriptsig=False),
spendtx.serialize_without_witness(with_scriptsig=False))
#Create block with only non-DER signature P2PKH transaction
tip = self.nodes[0].getbestblockhash()
block_time = self.nodes[0].getblockheader(tip)['mediantime'] + 1
block = create_block(int(tip, 16), create_coinbase(CHAIN_HEIGHT + 1),
block_time)
block.vtx.append(spendtx)
block.hashMerkleRoot = block.calc_merkle_root()
block.hashImMerkleRoot = block.calc_immutable_merkle_root()
block.rehash()
block.solve(self.signblockprivkeys)
# serialize with and without witness block remains the same
assert_equal(block.serialize(with_witness=True), block.serialize())
assert_equal(block.serialize(with_witness=True),
block.serialize(with_witness=False))
assert_equal(block.serialize(with_witness=True),
block.serialize(with_witness=False, with_scriptsig=True))
self.log.info("Reject block with non-DER signature")
self.nodes[0].p2p.send_and_ping(msg_block(block))
assert_equal(self.nodes[0].getbestblockhash(), tip)
wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(),
lock=mininode_lock)
with mininode_lock:
assert_equal(self.nodes[0].p2p.last_message["reject"].code,
REJECT_INVALID)
assert_equal(self.nodes[0].p2p.last_message["reject"].data,
block.sha256)
assert_equal(self.nodes[0].p2p.last_message["reject"].reason,
b'block-validation-failed')
self.log.info("Accept block with DER signature")
#recreate block with DER sig transaction
block = create_block(int(tip, 16), create_coinbase(CHAIN_HEIGHT + 1),
block_time)
block.vtx.append(copy_spendTx)
block.hashMerkleRoot = block.calc_merkle_root()
block.hashImMerkleRoot = block.calc_immutable_merkle_root()
block.rehash()
block.solve(self.signblockprivkeys)
self.nodes[0].p2p.send_and_ping(msg_block(block))
assert_equal(self.nodes[0].getbestblockhash(), block.hash)
## P2SH transaction
########################
self.log.info("Test using P2SH transaction ")
REDEEM_SCRIPT_1 = CScript([OP_1, OP_DROP])
P2SH_1 = CScript([OP_HASH160, hash160(REDEEM_SCRIPT_1), OP_EQUAL])
tx = CTransaction()
tx.vin.append(
CTxIn(COutPoint(int(self.coinbase_txids[1], 16), 0), b"",
0xffffffff))
tx.vout.append(CTxOut(10, P2SH_1))
tx.rehash()
spendtx_raw = self.nodes[0].signrawtransactionwithwallet(
ToHex(tx), [], "ALL", self.options.scheme)["hex"]
spendtx = FromHex(spendtx, spendtx_raw)
spendtx.rehash()
copy_spendTx = CTransaction(spendtx)
#cache hashes
hash = spendtx.hash
hashMalFix = spendtx.hashMalFix
#malleate
spendtxcopy = spendtx
unDERify(spendtxcopy)
spendtxcopy.rehash()
# verify that hashMalFix remains the same even when signature is malleated and hash changes
assert_not_equal(hash, spendtxcopy.hash)
assert_equal(hashMalFix, spendtxcopy.hashMalFix)
# verify that hash is spendtx.serialize()
hash = encode(
hash256(spendtx.serialize(with_witness=False))[::-1],
'hex_codec').decode('ascii')
assert_equal(hash, spendtx.hash)
# verify that hashMalFix is spendtx.serialize(with_scriptsig=False)
hashMalFix = encode(
hash256(spendtx.serialize(with_witness=False,
with_scriptsig=False))[::-1],
'hex_codec').decode('ascii')
assert_equal(hashMalFix, spendtx.hashMalFix)
assert_not_equal(hash, hashMalFix)
#as this transaction does not have witness data the following is true
assert_equal(spendtx.serialize(),
spendtx.serialize(with_witness=True, with_scriptsig=True))
assert_equal(spendtx.serialize(with_witness=False),
spendtx.serialize(with_witness=True, with_scriptsig=True))
assert_not_equal(
spendtx.serialize(with_witness=False),
spendtx.serialize(with_witness=True, with_scriptsig=False))
assert_equal(spendtx.serialize(with_witness=False),
spendtx.serialize_without_witness(with_scriptsig=True))
assert_equal(spendtx.serialize_with_witness(with_scriptsig=True),
spendtx.serialize_without_witness(with_scriptsig=True))
assert_equal(spendtx.serialize_with_witness(with_scriptsig=False),
spendtx.serialize_without_witness(with_scriptsig=False))
#Create block with only non-DER signature P2SH transaction
tip = self.nodes[0].getbestblockhash()
block_time = self.nodes[0].getblockheader(tip)['mediantime'] + 1
block = create_block(int(tip, 16), create_coinbase(CHAIN_HEIGHT + 2),
block_time)
block.vtx.append(spendtx)
block.hashMerkleRoot = block.calc_merkle_root()
block.hashImMerkleRoot = block.calc_immutable_merkle_root()
block.rehash()
block.solve(self.signblockprivkeys)
# serialize with and without witness block remains the same
assert_equal(block.serialize(with_witness=True), block.serialize())
assert_equal(block.serialize(with_witness=True),
block.serialize(with_witness=False))
assert_equal(block.serialize(with_witness=True),
block.serialize(with_witness=True, with_scriptsig=True))
self.log.info("Reject block with non-DER signature")
self.nodes[0].p2p.send_and_ping(msg_block(block))
assert_equal(self.nodes[0].getbestblockhash(), tip)
wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(),
lock=mininode_lock)
with mininode_lock:
assert_equal(self.nodes[0].p2p.last_message["reject"].code,
REJECT_INVALID)
assert_equal(self.nodes[0].p2p.last_message["reject"].data,
block.sha256)
assert_equal(self.nodes[0].p2p.last_message["reject"].reason,
b'block-validation-failed')
self.log.info("Accept block with DER signature")
#recreate block with DER sig transaction
block = create_block(int(tip, 16), create_coinbase(CHAIN_HEIGHT + 2),
block_time)
block.vtx.append(copy_spendTx)
block.hashMerkleRoot = block.calc_merkle_root()
block.hashImMerkleRoot = block.calc_immutable_merkle_root()
block.rehash()
block.solve(self.signblockprivkeys)
self.nodes[0].p2p.send_and_ping(msg_block(block))
assert_equal(self.nodes[0].getbestblockhash(), block.hash)
## redeem previous P2SH
#########################
self.log.info("Test using P2SH redeem transaction ")
tx = CTransaction()
tx.vout.append(CTxOut(1, CScript([OP_TRUE])))
tx.vin.append(CTxIn(COutPoint(block.vtx[1].malfixsha256, 0), b''))
(sighash, err) = SignatureHash(REDEEM_SCRIPT_1, tx, 1, SIGHASH_ALL)
signKey = CECKey()
signKey.set_secretbytes(b"horsebattery")
sig = signKey.sign(sighash) + bytes(bytearray([SIGHASH_ALL]))
scriptSig = CScript([sig, REDEEM_SCRIPT_1])
tx.vin[0].scriptSig = scriptSig
tx.rehash()
spendtx_raw = self.nodes[0].signrawtransactionwithwallet(
ToHex(tx), [], "ALL", self.options.scheme)["hex"]
spendtx = FromHex(spendtx, spendtx_raw)
spendtx.rehash()
#cache hashes
hash = spendtx.hash
hashMalFix = spendtx.hashMalFix
#malleate
spendtxcopy = spendtx
unDERify(spendtxcopy)
spendtxcopy.rehash()
# verify that hashMalFix remains the same even when signature is malleated and hash changes
assert_not_equal(hash, spendtxcopy.hash)
assert_equal(hashMalFix, spendtxcopy.hashMalFix)
# verify that hash is spendtx.serialize()
hash = encode(
hash256(spendtx.serialize(with_witness=False))[::-1],
'hex_codec').decode('ascii')
assert_equal(hash, spendtx.hash)
# verify that hashMalFix is spendtx.serialize(with_scriptsig=False)
hashMalFix = encode(
hash256(spendtx.serialize(with_witness=False,
with_scriptsig=False))[::-1],
'hex_codec').decode('ascii')
assert_equal(hashMalFix, spendtx.hashMalFix)
assert_not_equal(hash, hashMalFix)
#as this transaction does not have witness data the following is true
assert_equal(spendtx.serialize(),
spendtx.serialize(with_witness=True, with_scriptsig=True))
assert_equal(spendtx.serialize(with_witness=False),
spendtx.serialize(with_witness=True, with_scriptsig=True))
assert_not_equal(
spendtx.serialize(with_witness=False),
spendtx.serialize(with_witness=True, with_scriptsig=False))
assert_equal(spendtx.serialize(with_witness=False),
spendtx.serialize_without_witness(with_scriptsig=True))
assert_equal(spendtx.serialize_with_witness(with_scriptsig=True),
spendtx.serialize_without_witness(with_scriptsig=True))
assert_equal(spendtx.serialize_with_witness(with_scriptsig=False),
spendtx.serialize_without_witness(with_scriptsig=False))
#Create block with only non-DER signature P2SH redeem transaction
tip = self.nodes[0].getbestblockhash()
block_time = self.nodes[0].getblockheader(tip)['mediantime'] + 1
block = create_block(int(tip, 16), create_coinbase(CHAIN_HEIGHT + 3),
block_time)
block.vtx.append(spendtx)
block.hashMerkleRoot = block.calc_merkle_root()
block.hashImMerkleRoot = block.calc_immutable_merkle_root()
block.rehash()
block.solve(self.signblockprivkeys)
# serialize with and without witness block remains the same
assert_equal(block.serialize(with_witness=True), block.serialize())
assert_equal(block.serialize(with_witness=True),
block.serialize(with_witness=False))
assert_equal(block.serialize(with_witness=True),
block.serialize(with_witness=True, with_scriptsig=True))
self.log.info("Accept block with P2SH redeem transaction")
self.nodes[0].p2p.send_and_ping(msg_block(block))
assert_equal(self.nodes[0].getbestblockhash(), block.hash)
## p2sh_p2wpkh transaction
##############################
self.log.info("Test using p2sh_p2wpkh transaction ")
spendtxStr = create_witness_tx(self.nodes[0],
True,
getInput(self.coinbase_txids[4]),
self.pubkey,
amount=1.0)
#get CTRansaction object from above hex
spendtx = CTransaction()
spendtx.deserialize(BytesIO(hex_str_to_bytes(spendtxStr)))
spendtx.rehash()
#cache hashes
spendtx.rehash()
hash = spendtx.hash
hashMalFix = spendtx.hashMalFix
withash = spendtx.calc_sha256(True)
# malleate
unDERify(spendtx)
spendtx.rehash()
withash2 = spendtx.calc_sha256(True)
# verify that hashMalFix remains the same even when signature is malleated and hash changes
assert_equal(withash, withash2)
assert_equal(hash, spendtx.hash)
assert_equal(hashMalFix, spendtx.hashMalFix)
# verify that hash is spendtx.serialize()
hash = encode(hash256(spendtx.serialize())[::-1],
'hex_codec').decode('ascii')
assert_equal(hash, spendtx.hash)
# verify that hashMalFix is spendtx.serialize(with_scriptsig=False)
hashMalFix = encode(
hash256(spendtx.serialize(with_scriptsig=False))[::-1],
'hex_codec').decode('ascii')
assert_equal(hashMalFix, spendtx.hashMalFix)
assert_not_equal(hash, hashMalFix)
#as this transaction does not have witness data the following is true
assert_equal(spendtx.serialize(),
spendtx.serialize(with_witness=True, with_scriptsig=True))
assert_equal(spendtx.serialize(with_witness=False),
spendtx.serialize(with_witness=True, with_scriptsig=True))
assert_not_equal(
spendtx.serialize(with_witness=False),
spendtx.serialize(with_witness=True, with_scriptsig=False))
assert_equal(spendtx.serialize(with_witness=False),
spendtx.serialize_without_witness(with_scriptsig=True))
assert_equal(spendtx.serialize_with_witness(with_scriptsig=True),
spendtx.serialize_without_witness(with_scriptsig=True))
assert_equal(spendtx.serialize_with_witness(with_scriptsig=False),
spendtx.serialize_without_witness(with_scriptsig=False))
#Create block with only non-DER signature p2sh_p2wpkh transaction
spendtxStr = self.nodes[0].signrawtransactionwithwallet(
spendtxStr, [], "ALL", self.options.scheme)
assert ("errors" not in spendtxStr or len(["errors"]) == 0)
spendtxStr = spendtxStr["hex"]
spendtx = CTransaction()
spendtx.deserialize(BytesIO(hex_str_to_bytes(spendtxStr)))
spendtx.rehash()
tip = self.nodes[0].getbestblockhash()
block_time = self.nodes[0].getblockheader(tip)['mediantime'] + 1
block = create_block(int(tip, 16), create_coinbase(CHAIN_HEIGHT + 4),
block_time)
block.vtx.append(spendtx)
add_witness_commitment(block)
block.hashMerkleRoot = block.calc_merkle_root()
block.hashImMerkleRoot = block.calc_immutable_merkle_root()
block.rehash()
block.solve(self.signblockprivkeys)
# serialize with and without witness
assert_equal(block.serialize(with_witness=False), block.serialize())
assert_not_equal(block.serialize(with_witness=True),
block.serialize(with_witness=False))
assert_not_equal(
block.serialize(with_witness=True),
block.serialize(with_witness=False, with_scriptsig=True))
self.log.info(
"Reject block with p2sh_p2wpkh transaction and witness commitment")
assert_raises_rpc_error(
-22, "Block does not start with a coinbase",
self.nodes[0].submitblock,
bytes_to_hex_str(block.serialize(with_witness=True)))
assert_equal(self.nodes[0].getbestblockhash(), tip)
block = create_block(int(tip, 16), create_coinbase(CHAIN_HEIGHT + 4),
block_time)
block.vtx.append(spendtx)
block.hashMerkleRoot = block.calc_merkle_root()
block.hashImMerkleRoot = block.calc_immutable_merkle_root()
block.rehash()
block.solve(self.signblockprivkeys)
self.log.info("Accept block with p2sh_p2wpkh transaction")
self.nodes[0].submitblock(
bytes_to_hex_str(block.serialize(with_witness=True)))
assert_equal(self.nodes[0].getbestblockhash(), block.hash)
## p2sh_p2wsh transaction
##############################
self.log.info("Test using p2sh_p2wsh transaction")
spendtxStr = create_witness_tx(self.nodes[0],
True,
getInput(self.coinbase_txids[5]),
self.pubkey,
amount=1.0)
#get CTRansaction object from above hex
spendtx = CTransaction()
spendtx.deserialize(BytesIO(hex_str_to_bytes(spendtxStr)))
spendtx.rehash()
#cache hashes
spendtx.rehash()
hash = spendtx.hash
hashMalFix = spendtx.hashMalFix
withash = spendtx.calc_sha256(True)
# malleate
unDERify(spendtx)
spendtx.rehash()
withash2 = spendtx.calc_sha256(True)
# verify that hashMalFix remains the same even when signature is malleated and hash changes
assert_equal(withash, withash2)
assert_equal(hash, spendtx.hash)
assert_equal(hashMalFix, spendtx.hashMalFix)
# verify that hash is spendtx.serialize()
hash = encode(hash256(spendtx.serialize())[::-1],
'hex_codec').decode('ascii')
assert_equal(hash, spendtx.hash)
# verify that hashMalFix is spendtx.serialize(with_scriptsig=False)
hashMalFix = encode(
hash256(spendtx.serialize(with_scriptsig=False))[::-1],
'hex_codec').decode('ascii')
assert_equal(hashMalFix, spendtx.hashMalFix)
assert_not_equal(hash, hashMalFix)
#as this transaction does not have witness data the following is true
assert_equal(spendtx.serialize(),
spendtx.serialize(with_witness=True, with_scriptsig=True))
assert_equal(spendtx.serialize(with_witness=False),
spendtx.serialize(with_witness=True, with_scriptsig=True))
assert_not_equal(
spendtx.serialize(with_witness=False),
spendtx.serialize(with_witness=True, with_scriptsig=False))
assert_equal(spendtx.serialize(with_witness=False),
spendtx.serialize_without_witness(with_scriptsig=True))
assert_equal(spendtx.serialize_with_witness(with_scriptsig=True),
spendtx.serialize_without_witness(with_scriptsig=True))
assert_equal(spendtx.serialize_with_witness(with_scriptsig=False),
spendtx.serialize_without_witness(with_scriptsig=False))
#Create block with only non-DER signature p2sh_p2wsh transaction
spendtxStr = self.nodes[0].signrawtransactionwithwallet(
spendtxStr, [], "ALL", self.options.scheme)
assert ("errors" not in spendtxStr or len(["errors"]) == 0)
spendtxStr = spendtxStr["hex"]
spendtx = CTransaction()
spendtx.deserialize(BytesIO(hex_str_to_bytes(spendtxStr)))
spendtx.rehash()
tip = self.nodes[0].getbestblockhash()
block_time = self.nodes[0].getblockheader(tip)['mediantime'] + 1
block = create_block(int(tip, 16), create_coinbase(CHAIN_HEIGHT + 5),
block_time)
block.vtx.append(spendtx)
add_witness_commitment(block)
block.hashMerkleRoot = block.calc_merkle_root()
block.hashImMerkleRoot = block.calc_immutable_merkle_root()
block.rehash()
block.solve(self.signblockprivkeys)
# serialize with and without witness
assert_equal(block.serialize(with_witness=False), block.serialize())
assert_not_equal(block.serialize(with_witness=True),
block.serialize(with_witness=False))
assert_not_equal(
block.serialize(with_witness=True),
block.serialize(with_witness=False, with_scriptsig=True))
self.log.info(
"Reject block with p2sh_p2wsh transaction and witness commitment")
assert_raises_rpc_error(
-22, "Block does not start with a coinbase",
self.nodes[0].submitblock,
bytes_to_hex_str(block.serialize(with_witness=True)))
assert_equal(self.nodes[0].getbestblockhash(), tip)
block = create_block(int(tip, 16), create_coinbase(CHAIN_HEIGHT + 5),
block_time)
block.vtx.append(spendtx)
block.hashMerkleRoot = block.calc_merkle_root()
block.hashImMerkleRoot = block.calc_immutable_merkle_root()
block.rehash()
block.solve(self.signblockprivkeys)
self.log.info("Accept block with p2sh_p2wsh transaction")
self.nodes[0].submitblock(
bytes_to_hex_str(block.serialize(with_witness=True)))
assert_equal(self.nodes[0].getbestblockhash(), block.hash)
def run_test(self):
p2p0 = self.nodes[0].add_p2p_connection(BaseNode())
# Build the blockchain
self.tip = int(self.nodes[0].getbestblockhash(), 16)
self.block_time = self.nodes[0].getblock(
self.nodes[0].getbestblockhash())['time'] + 1
self.blocks = []
# Get a pubkey for the coinbase TXO
coinbase_key = ECKey()
coinbase_key.generate()
coinbase_pubkey = coinbase_key.get_pubkey().get_bytes()
# Create the first block with a coinbase output to our key
height = 1
block = create_block(self.tip, create_coinbase(height,
coinbase_pubkey),
self.block_time)
self.blocks.append(block)
self.block_time += 1
block.solve()
# Save the coinbase for later
self.block1 = block
self.tip = block.sha256
height += 1
# Bury the block 100 deep so the coinbase output is spendable
for i in range(COINBASE_MATURITY):
block = create_block(self.tip, create_coinbase(height),
self.block_time)
block.solve()
self.blocks.append(block)
self.tip = block.sha256
self.block_time += 1
height += 1
# Create a transaction spending the coinbase output with an invalid (null) signature
tx = CTransaction()
tx.vin.append(
CTxIn(COutPoint(self.block1.vtx[0].sha256, 0), scriptSig=b""))
tx.vout.append(CTxOut(49 * 100000000, CScript([OP_TRUE])))
tx.calc_sha256()
block102 = create_block(self.tip, create_coinbase(height),
self.block_time)
self.block_time += 1
block102.vtx.extend([tx])
block102.hashMerkleRoot = block102.calc_merkle_root()
block102.rehash()
block102.solve()
self.blocks.append(block102)
self.tip = block102.sha256
self.block_time += 1
height += 1
# Bury the assumed valid block 2100 deep
for i in range(10000):
block = create_block(self.tip, create_coinbase(height),
self.block_time)
block.nVersion = 4
block.solve()
self.blocks.append(block)
self.tip = block.sha256
self.block_time += 1
height += 1
self.nodes[0].disconnect_p2ps()
# Start node1 and node2 with assumevalid so they accept a block with a bad signature.
self.start_node(
1, extra_args=["-assumevalid=" + hex(block102.sha256)[2:]])
self.start_node(
2, extra_args=["-assumevalid=" + hex(block102.sha256)[2:]])
p2p0 = self.nodes[0].add_p2p_connection(BaseNode())
p2p1 = self.nodes[1].add_p2p_connection(BaseNode())
p2p2 = self.nodes[2].add_p2p_connection(BaseNode())
# send header lists to all three nodes
p2p0.send_header_for_blocks(self.blocks[0:2000])
p2p0.send_header_for_blocks(self.blocks[2000:4000])
p2p0.send_header_for_blocks(self.blocks[4000:6000])
p2p0.send_header_for_blocks(self.blocks[6000:8000])
p2p0.send_header_for_blocks(self.blocks[8000:10000])
p2p0.send_header_for_blocks(self.blocks[10000:])
p2p1.send_header_for_blocks(self.blocks[0:2000])
p2p1.send_header_for_blocks(self.blocks[2000:4000])
p2p1.send_header_for_blocks(self.blocks[4000:6000])
p2p1.send_header_for_blocks(self.blocks[6000:8000])
p2p1.send_header_for_blocks(self.blocks[8000:10000])
p2p1.send_header_for_blocks(self.blocks[10000:])
p2p2.send_header_for_blocks(self.blocks[0:600])
# Send blocks to node0. Block 102 will be rejected.
self.send_blocks_until_disconnected(p2p0)
self.assert_blockchain_height(self.nodes[0], COINBASE_MATURITY + 1)
# Send all blocks to node1. All blocks will be accepted.
# Send only a subset to speed this up
p2p1 = self.nodes[1].add_p2p_connection(BaseNode())
for i in range(1000):
p2p1.send_message(msg_block(self.blocks[i]))
# Syncing 2200 blocks can take a while on slow systems. Give it plenty of time to sync.
timeout = time.time() + 200
while time.time() < timeout:
if self.nodes[1].getblock(
self.nodes[1].getbestblockhash())['height'] == 1000:
break
assert_equal(
self.nodes[1].getblock(self.nodes[1].getbestblockhash())['height'],
1000)
# Send blocks to node2. Block 102 will be rejected.
p2p2 = self.nodes[2].add_p2p_connection(BaseNode())
self.send_blocks_until_disconnected(p2p2)
self.assert_blockchain_height(self.nodes[2], COINBASE_MATURITY + 1)
def run_test(self):
node = self.nodes[0] # convenience reference to the node
self.address = node.getnewaddress()
node.add_p2p_connection(P2PDataStore())
node.p2p.wait_for_getheaders(timeout=5)
self.address = self.nodes[0].getnewaddress()
self.log.info("Test starting...")
#generate 10 blocks for coinbase outputs
coinbase_txs = []
for i in range(1, 10):
height = node.getblockcount() + 1
coinbase_tx = create_coinbase(height, self.coinbase_pubkey)
coinbase_txs.append(coinbase_tx)
tip = node.getbestblockhash()
block_time = node.getblockheader(tip)["mediantime"] + 1
block = create_block(int(tip, 16), coinbase_tx, block_time)
block.solve(self.signblockprivkey)
tip = block.hash
node.p2p.send_and_ping(msg_block(block))
assert_equal(node.getbestblockhash(), tip)
change_script = CScript([self.coinbase_pubkey, OP_CHECKSIG])
burn_script = CScript([hex_str_to_bytes(self.pubkeys[1]), OP_CHECKSIG])
#TxSuccess1 - coinbaseTx1 - issue 100 REISSUABLE + 30 (UTXO-1,2)
colorId_reissuable = colorIdReissuable(coinbase_txs[0].vout[0].scriptPubKey)
script_reissuable = CP2PHK_script(colorId = colorId_reissuable, pubkey = self.pubkeys[0])
script_transfer_reissuable = CP2PHK_script(colorId = colorId_reissuable, pubkey = self.pubkeys[1])
txSuccess1 = CTransaction()
txSuccess1.vin.append(CTxIn(COutPoint(coinbase_txs[0].malfixsha256, 0), b""))
txSuccess1.vout.append(CTxOut(100, script_reissuable))
txSuccess1.vout.append(CTxOut(30 * COIN, CScript([self.coinbase_pubkey, OP_CHECKSIG])))
sig_hash, err = SignatureHash(coinbase_txs[0].vout[0].scriptPubKey, txSuccess1, 0, SIGHASH_ALL)
signature = self.coinbase_key.sign(sig_hash) + b'\x01' # 0x1 is SIGHASH_ALL
txSuccess1.vin[0].scriptSig = CScript([signature])
txSuccess1.rehash()
test_transaction_acceptance(node, txSuccess1, accepted=True)
tx_info = node.getrawtransaction(txSuccess1.hashMalFix, 1)
assert_equal(tx_info['vout'][0]['token'], bytes_to_hex_str(colorId_reissuable))
assert_equal(tx_info['vout'][0]['value'], 100)
#TxSuccess2 - (UTXO-2) - issue 100 NON-REISSUABLE (UTXO-3)
colorId_nonreissuable = colorIdNonReissuable(COutPoint(txSuccess1.malfixsha256, 1).serialize())
script_nonreissuable = CP2PHK_script(colorId = colorId_nonreissuable, pubkey = self.pubkeys[0])
script_transfer_nonreissuable = CP2PHK_script(colorId = colorId_nonreissuable, pubkey = self.pubkeys[1])
txSuccess2 = CTransaction()
txSuccess2.vin.append(CTxIn(COutPoint(txSuccess1.malfixsha256, 1), b""))
txSuccess2.vout.append(CTxOut(100, script_nonreissuable))
sig_hash, err = SignatureHash(txSuccess1.vout[1].scriptPubKey, txSuccess2, 0, SIGHASH_ALL)
signature = self.coinbase_key.sign(sig_hash) + b'\x01'
txSuccess2.vin[0].scriptSig = CScript([signature])
txSuccess2.rehash()
test_transaction_acceptance(node, txSuccess2, accepted=True)
tx_info = node.getrawtransaction(txSuccess2.hashMalFix, 1)
assert_equal(tx_info['vout'][0]['token'], bytes_to_hex_str(colorId_nonreissuable))
assert_equal(tx_info['vout'][0]['value'], 100)
#TxSuccess3 - coinbaseTx2 - issue 1 NFT (UTXO-4)
colorId_nft = colorIdNFT(COutPoint(coinbase_txs[1].malfixsha256, 0).serialize())
script_nft = CP2PHK_script(colorId = colorId_nft, pubkey = self.pubkeys[0])
script_transfer_nft = CP2PHK_script(colorId = colorId_nft, pubkey = self.pubkeys[0])
txSuccess3 = CTransaction()
txSuccess3.vin.append(CTxIn(COutPoint(coinbase_txs[1].malfixsha256, 0), b""))
txSuccess3.vout.append(CTxOut(1, script_nft))
sig_hash, err = SignatureHash(coinbase_txs[1].vout[0].scriptPubKey, txSuccess3, 0, SIGHASH_ALL)
signature = self.coinbase_key.sign(sig_hash) + b'\x01'
txSuccess3.vin[0].scriptSig = CScript([signature])
txSuccess3.rehash()
test_transaction_acceptance(node, txSuccess3, accepted=True)
tx_info = node.getrawtransaction(txSuccess3.hashMalFix, 1)
assert_equal(tx_info['vout'][0]['token'], bytes_to_hex_str(colorId_nft))
assert_equal(tx_info['vout'][0]['value'], 1)
#TxFailure4 - (UTXO-1) - split REISSUABLE - 25 + 75 (UTXO-5,6)
# - (UTXO-3) - split NON-REISSUABLE - 40 + 60 (UTXO-7,8)
# - coinbaseTx3 - issue 100 REISSUABLE (UTXO-9)
TxFailure4 = CTransaction()
TxFailure4.vin.append(CTxIn(COutPoint(txSuccess1.malfixsha256, 0), b""))
TxFailure4.vin.append(CTxIn(COutPoint(txSuccess2.malfixsha256, 0), b""))
TxFailure4.vin.append(CTxIn(COutPoint(coinbase_txs[2].malfixsha256, 0), b""))
TxFailure4.vout.append(CTxOut(25, script_reissuable))
TxFailure4.vout.append(CTxOut(75, script_reissuable))
TxFailure4.vout.append(CTxOut(40, script_nonreissuable))
TxFailure4.vout.append(CTxOut(60, script_nonreissuable))
TxFailure4.vout.append(CTxOut(100, script_reissuable))
sig_hash, err = SignatureHash(txSuccess1.vout[0].scriptPubKey, TxFailure4, 0, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
TxFailure4.vin[0].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(txSuccess2.vout[0].scriptPubKey, TxFailure4, 1, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
TxFailure4.vin[1].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(coinbase_txs[2].vout[0].scriptPubKey, TxFailure4, 2, SIGHASH_ALL)
signature = self.coinbase_key.sign(sig_hash) + b'\x01'
TxFailure4.vin[2].scriptSig = CScript([signature])
TxFailure4.rehash()
test_transaction_acceptance(node, TxFailure4, accepted=False, reason=b"bad-txns-token-balance")
#TxSuccess4 - (UTXO-1) - split REISSUABLE - 25 + 75 (UTXO-5,6)
# - (UTXO-3) - split NON-REISSUABLE - 40 + 60 (UTXO-7,8)
txSuccess4 = CTransaction()
txSuccess4.vin.append(CTxIn(COutPoint(txSuccess1.malfixsha256, 0), b""))
txSuccess4.vin.append(CTxIn(COutPoint(txSuccess2.malfixsha256, 0), b""))
txSuccess4.vin.append(CTxIn(COutPoint(coinbase_txs[2].malfixsha256, 0), b""))
txSuccess4.vout.append(CTxOut(25, script_reissuable))
txSuccess4.vout.append(CTxOut(75, script_reissuable))
txSuccess4.vout.append(CTxOut(40, script_nonreissuable))
txSuccess4.vout.append(CTxOut(60, script_nonreissuable))
sig_hash, err = SignatureHash(txSuccess1.vout[0].scriptPubKey, txSuccess4, 0, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
txSuccess4.vin[0].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(txSuccess2.vout[0].scriptPubKey, txSuccess4, 1, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
txSuccess4.vin[1].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(coinbase_txs[2].vout[0].scriptPubKey, txSuccess4, 2, SIGHASH_ALL)
signature = self.coinbase_key.sign(sig_hash) + b'\x01'
txSuccess4.vin[2].scriptSig = CScript([signature])
txSuccess4.rehash()
test_transaction_acceptance(node, txSuccess4, accepted=True)
#TxFailure5 - (UTXO-6) - split REISSUABLE(75) (UTXO-10,11)
# - (UTXO-7) - split NON-REISSUABLE(40) (UTXO-12)
# - (UTXO-4) - split NFT (UTXO-13)
# - coinbaseTx4
TxFailure5 = CTransaction()
TxFailure5.vin.append(CTxIn(COutPoint(txSuccess4.malfixsha256, 1), b""))
TxFailure5.vin.append(CTxIn(COutPoint(txSuccess4.malfixsha256, 2), b""))
TxFailure5.vin.append(CTxIn(COutPoint(txSuccess3.malfixsha256, 0), b""))
TxFailure5.vin.append(CTxIn(COutPoint(coinbase_txs[3].malfixsha256, 0), b""))
TxFailure5.vout.append(CTxOut(35, script_reissuable))
TxFailure5.vout.append(CTxOut(40, script_reissuable))
TxFailure5.vout.append(CTxOut(20, script_nonreissuable))
TxFailure5.vout.append(CTxOut(20, script_nonreissuable))
TxFailure5.vout.append(CTxOut(1, script_nft))
TxFailure5.vout.append(CTxOut(1, script_nft))
sig_hash, err = SignatureHash(txSuccess4.vout[1].scriptPubKey, TxFailure5, 0, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
TxFailure5.vin[0].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(txSuccess4.vout[2].scriptPubKey, TxFailure5, 1, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
TxFailure5.vin[1].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(txSuccess3.vout[0].scriptPubKey, TxFailure5, 2, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
TxFailure5.vin[2].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(coinbase_txs[3].vout[0].scriptPubKey, TxFailure5, 3, SIGHASH_ALL)
signature = self.coinbase_key.sign(sig_hash) + b'\x01'
TxFailure5.vin[3].scriptSig = CScript([signature])
TxFailure5.rehash()
test_transaction_acceptance(node, TxFailure5, accepted=False, reason=b"bad-txns-token-balance")
#txSuccess5 - (UTXO-6) - split REISSUABLE(75) (UTXO-10,11)
# - (UTXO-7) - split NON-REISSUABLE(40) (UTXO-12)
# - (UTXO-4) - transfer NFT (UTXO-13)
# - coinbaseTx4
txSuccess5 = CTransaction()
txSuccess5.vin.append(CTxIn(COutPoint(txSuccess4.malfixsha256, 1), b""))
txSuccess5.vin.append(CTxIn(COutPoint(txSuccess4.malfixsha256, 2), b""))
txSuccess5.vin.append(CTxIn(COutPoint(txSuccess3.malfixsha256, 0), b""))
txSuccess5.vin.append(CTxIn(COutPoint(coinbase_txs[3].malfixsha256, 0), b""))
txSuccess5.vout.append(CTxOut(35, script_reissuable))
txSuccess5.vout.append(CTxOut(40, script_reissuable))
txSuccess5.vout.append(CTxOut(20, script_nonreissuable))
txSuccess5.vout.append(CTxOut(20, script_nonreissuable))
txSuccess5.vout.append(CTxOut(1, script_nft))
sig_hash, err = SignatureHash(txSuccess4.vout[1].scriptPubKey, txSuccess5, 0, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
txSuccess5.vin[0].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(txSuccess4.vout[2].scriptPubKey, txSuccess5, 1, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
txSuccess5.vin[1].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(txSuccess3.vout[0].scriptPubKey, txSuccess5, 2, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
txSuccess5.vin[2].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(coinbase_txs[3].vout[0].scriptPubKey, txSuccess5, 3, SIGHASH_ALL)
signature = self.coinbase_key.sign(sig_hash) + b'\x01'
txSuccess5.vin[3].scriptSig = CScript([signature])
txSuccess5.rehash()
test_transaction_acceptance(node, txSuccess5, accepted=True)
#TxFailure6 - (UTXO-11) - transfer REISSUABLE(40) (UTXO-14)
# - (UTXO-8) - burn NON-REISSUABLE(60) (UTXO-15)*
# - (UTXO-13) - transfer NFT (UTXO-16)
# - coinbaseTx5 - issue 1000 REISSUABLE1, change (UTXO-17)
colorId_reissuable1 = colorIdReissuable(coinbase_txs[6].vout[0].scriptPubKey)
script_reissuable1 = CP2PHK_script(colorId = colorId_reissuable, pubkey = self.pubkeys[0])
TxFailure6 = CTransaction()
TxFailure6.vin.append(CTxIn(COutPoint(txSuccess5.malfixsha256, 1), b""))
TxFailure6.vin.append(CTxIn(COutPoint(txSuccess4.malfixsha256, 3), b""))
TxFailure6.vin.append(CTxIn(COutPoint(txSuccess5.malfixsha256, 4), b""))
TxFailure6.vin.append(CTxIn(COutPoint(coinbase_txs[4].malfixsha256, 0), b""))
TxFailure6.vout.append(CTxOut(40, script_transfer_reissuable))
TxFailure6.vout.append(CTxOut(30, script_transfer_nonreissuable))
TxFailure6.vout.append(CTxOut(1, script_transfer_nft))
TxFailure6.vout.append(CTxOut(1000, script_reissuable1))
TxFailure6.vout.append(CTxOut(1*COIN, change_script))
sig_hash, err = SignatureHash(txSuccess5.vout[1].scriptPubKey, TxFailure6, 0, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
TxFailure6.vin[0].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(txSuccess4.vout[3].scriptPubKey, TxFailure6, 1, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
TxFailure6.vin[1].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(txSuccess5.vout[4].scriptPubKey, TxFailure6, 2, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
TxFailure6.vin[2].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(coinbase_txs[4].vout[0].scriptPubKey, TxFailure6, 3, SIGHASH_ALL)
signature = self.coinbase_key.sign(sig_hash) + b'\x01'
TxFailure6.vin[3].scriptSig = CScript([signature])
TxFailure6.rehash()
test_transaction_acceptance(node, TxFailure6, accepted=False, reason=b"bad-txns-token-balance")
#TxSuccess6 - (UTXO-11) - transfer REISSUABLE(40) (UTXO-14)
# - (UTXO-8) - burn NON-REISSUABLE(60) (UTXO-15)*
# - (UTXO-13) - transfer NFT (UTXO-16)
# - coinbaseTx5 - change
txSuccess6 = CTransaction()
txSuccess6.vin.append(CTxIn(COutPoint(txSuccess5.malfixsha256, 1), b""))
txSuccess6.vin.append(CTxIn(COutPoint(txSuccess4.malfixsha256, 3), b""))
txSuccess6.vin.append(CTxIn(COutPoint(txSuccess5.malfixsha256, 4), b""))
txSuccess6.vin.append(CTxIn(COutPoint(coinbase_txs[4].malfixsha256, 0), b""))
txSuccess6.vout.append(CTxOut(40, script_transfer_reissuable))
txSuccess6.vout.append(CTxOut(30, script_transfer_nonreissuable))
txSuccess6.vout.append(CTxOut(1, script_transfer_nft))
txSuccess6.vout.append(CTxOut(1*COIN, change_script))
sig_hash, err = SignatureHash(txSuccess5.vout[1].scriptPubKey, txSuccess6, 0, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
txSuccess6.vin[0].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(txSuccess4.vout[3].scriptPubKey, txSuccess6, 1, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
txSuccess6.vin[1].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(txSuccess5.vout[4].scriptPubKey, txSuccess6, 2, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
txSuccess6.vin[2].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(coinbase_txs[4].vout[0].scriptPubKey, txSuccess6, 3, SIGHASH_ALL)
signature = self.coinbase_key.sign(sig_hash) + b'\x01'
txSuccess6.vin[3].scriptSig = CScript([signature])
txSuccess6.rehash()
test_transaction_acceptance(node, txSuccess6, accepted=True)
#TxSuccess7 - coinbaseTx5 - issue 1000 REISSUABLE1, change (UTXO-17)
txSuccess7 = CTransaction()
txSuccess7.vin.append(CTxIn(COutPoint(coinbase_txs[5].malfixsha256, 0), b""))
txSuccess7.vout.append(CTxOut(1000, script_reissuable1))
sig_hash, err = SignatureHash(coinbase_txs[5].vout[0].scriptPubKey, txSuccess7, 0, SIGHASH_ALL)
signature = self.coinbase_key.sign(sig_hash) + b'\x01'
txSuccess7.vin[0].scriptSig = CScript([signature])
txSuccess7.rehash()
test_transaction_acceptance(node, txSuccess7, accepted=True)
#TxFailure7 - (UTXO-9,14) - aggregate REISSUABLE(25 + 40) x
# - (UTXO-12) - burn NON-REISSUABLE(20) *
TxFailure7 = CTransaction()
TxFailure7.vin.append(CTxIn(COutPoint(txSuccess4.malfixsha256, 0), b""))
TxFailure7.vin.append(CTxIn(COutPoint(txSuccess6.malfixsha256, 0), b""))
TxFailure7.vin.append(CTxIn(COutPoint(txSuccess5.malfixsha256, 2), b""))
TxFailure7.vout.append(CTxOut(65, script_transfer_reissuable))
sig_hash, err = SignatureHash(txSuccess4.vout[0].scriptPubKey, TxFailure7, 0, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
TxFailure7.vin[0].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(txSuccess6.vout[0].scriptPubKey, TxFailure7, 1, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
TxFailure7.vin[1].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(txSuccess5.vout[2].scriptPubKey, TxFailure7, 2, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
TxFailure7.vin[2].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
TxFailure7.rehash()
test_transaction_acceptance(node, TxFailure7, accepted=False, reason=b'min relay fee not met')
#txSuccess8 - (UTXO-9,14) - aggregate REISSUABLE(25 + 40) x
# - (UTXO-12) - burn NON-REISSUABLE(20) *
# - coinbase[6]
txSuccess8 = CTransaction()
txSuccess8.vin.append(CTxIn(COutPoint(txSuccess4.malfixsha256, 0), b""))
txSuccess8.vin.append(CTxIn(COutPoint(txSuccess6.malfixsha256, 0), b""))
txSuccess8.vin.append(CTxIn(COutPoint(txSuccess5.malfixsha256, 2), b""))
txSuccess8.vin.append(CTxIn(COutPoint(coinbase_txs[6].malfixsha256, 0), b""))
txSuccess8.vout.append(CTxOut(65, script_transfer_reissuable))
sig_hash, err = SignatureHash(txSuccess4.vout[0].scriptPubKey, txSuccess8, 0, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
txSuccess8.vin[0].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(txSuccess6.vout[0].scriptPubKey, txSuccess8, 1, SIGHASH_ALL)
signature = self.privkeys[1].sign(sig_hash) + b'\x01'
txSuccess8.vin[1].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[1])])
sig_hash, err = SignatureHash(txSuccess5.vout[2].scriptPubKey, txSuccess8, 2, SIGHASH_ALL)
signature = self.privkeys[0].sign(sig_hash) + b'\x01'
txSuccess8.vin[2].scriptSig = CScript([signature, hex_str_to_bytes(self.pubkeys[0])])
sig_hash, err = SignatureHash(coinbase_txs[6].vout[0].scriptPubKey, txSuccess8, 3, SIGHASH_ALL)
signature = self.coinbase_key.sign(sig_hash) + b'\x01'
txSuccess8.vin[3].scriptSig = CScript([signature])
txSuccess8.rehash()
test_transaction_acceptance(node, txSuccess8, accepted=True)
#TxFailure8 - (UTXO-17) - convert REISSUABLE to NON-REISSUABLE
TxFailure8 = CTransaction()
TxFailure8.vin.append(CTxIn(COutPoint(txSuccess7.malfixsha256, 0), b""))
TxFailure8.vout.append(CTxOut(60, script_transfer_nonreissuable))
sig_hash, err = SignatureHash(txSuccess7.vout[0].scriptPubKey, TxFailure8, 0, SIGHASH_ALL)
signature = self.coinbase_key.sign(sig_hash) + b'\x01'
TxFailure8.vin[0].scriptSig = CScript([signature])
TxFailure8.rehash()
test_transaction_acceptance(node, TxFailure8, accepted=False, reason=b'invalid-colorid')
def run_test(self):
node = self.nodes[0]
self.log.info('Start with empty mempool, and 200 blocks')
self.mempool_size = 0
assert_equal(node.getblockcount(), 200)
assert_equal(node.getmempoolinfo()['size'], self.mempool_size)
coins = node.listunspent()
self.log.info('Should not accept garbage to testmempoolaccept')
assert_raises_rpc_error(-3, 'Expected type array, got string', lambda: node.testmempoolaccept(rawtxs='ff00baar'))
assert_raises_rpc_error(-8, 'Array must contain exactly one raw transaction for now', lambda: node.testmempoolaccept(rawtxs=['ff00baar', 'ff22']))
assert_raises_rpc_error(-22, 'TX decode failed', lambda: node.testmempoolaccept(rawtxs=['ff00baar']))
self.log.info('A transaction already in the blockchain')
coin = coins.pop() # Pick a random coin(base) to spend
raw_tx_in_block = node.signrawtransactionwithwallet(node.createrawtransaction(
inputs=[{'txid': coin['txid'], 'vout': coin['vout']}],
outputs=[{node.getnewaddress(): 0.3}, {node.getnewaddress(): 49}],
))['hex']
txid_in_block = node.sendrawtransaction(hexstring=raw_tx_in_block, maxfeerate=0)
node.generate(1)
self.mempool_size = 0
self.check_mempool_result(
result_expected=[{'txid': txid_in_block, 'allowed': False, 'reject-reason': '18: txn-already-known'}],
rawtxs=[raw_tx_in_block],
)
self.log.info('A transaction not in the mempool')
fee = 0.00000700
raw_tx_0 = node.signrawtransactionwithwallet(node.createrawtransaction(
inputs=[{"txid": txid_in_block, "vout": 0, "sequence": BIP125_SEQUENCE_NUMBER}], # RBF is used later
outputs=[{node.getnewaddress(): 0.3 - fee}],
))['hex']
tx = CTransaction()
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
txid_0 = tx.rehash()
self.check_mempool_result(
result_expected=[{'txid': txid_0, 'allowed': True}],
rawtxs=[raw_tx_0],
)
self.log.info('A final transaction not in the mempool')
coin = coins.pop() # Pick a random coin(base) to spend
raw_tx_final = node.signrawtransactionwithwallet(node.createrawtransaction(
inputs=[{'txid': coin['txid'], 'vout': coin['vout'], "sequence": 0xffffffff}], # SEQUENCE_FINAL
outputs=[{node.getnewaddress(): 0.025}],
locktime=node.getblockcount() + 2000, # Can be anything
))['hex']
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_final)))
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': True}],
rawtxs=[tx.serialize().hex()],
maxfeerate=0,
)
node.sendrawtransaction(hexstring=raw_tx_final, maxfeerate=0)
self.mempool_size += 1
self.log.info('A transaction in the mempool')
node.sendrawtransaction(hexstring=raw_tx_0)
self.mempool_size += 1
self.check_mempool_result(
result_expected=[{'txid': txid_0, 'allowed': False, 'reject-reason': '18: txn-already-in-mempool'}],
rawtxs=[raw_tx_0],
)
self.log.info('A transaction that replaces a mempool transaction')
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
tx.vout[0].nValue -= int(fee * COIN) # Double the fee
tx.vin[0].nSequence = BIP125_SEQUENCE_NUMBER + 1 # Now, opt out of RBF
raw_tx_0 = node.signrawtransactionwithwallet(tx.serialize().hex())['hex']
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
txid_0 = tx.rehash()
self.check_mempool_result(
result_expected=[{'txid': txid_0, 'allowed': True}],
rawtxs=[raw_tx_0],
)
self.log.info('A transaction that conflicts with an unconfirmed tx')
# Send the transaction that replaces the mempool transaction and opts out of replaceability
node.sendrawtransaction(hexstring=tx.serialize().hex(), maxfeerate=0)
# take original raw_tx_0
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
tx.vout[0].nValue -= int(4 * fee * COIN) # Set more fee
# skip re-signing the tx
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '18: txn-mempool-conflict'}],
rawtxs=[tx.serialize().hex()],
maxfeerate=0,
)
self.log.info('A transaction with missing inputs, that never existed')
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
tx.vin[0].prevout = COutPoint(hash=int('ff' * 32, 16), n=14)
# skip re-signing the tx
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'missing-inputs'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A transaction with missing inputs, that existed once in the past')
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
tx.vin[0].prevout.n = 1 # Set vout to 1, to spend the other outpoint (49 coins) of the in-chain-tx we want to double spend
raw_tx_1 = node.signrawtransactionwithwallet(tx.serialize().hex())['hex']
txid_1 = node.sendrawtransaction(hexstring=raw_tx_1, maxfeerate=0)
# Now spend both to "clearly hide" the outputs, ie. remove the coins from the utxo set by spending them
raw_tx_spend_both = node.signrawtransactionwithwallet(node.createrawtransaction(
inputs=[
{'txid': txid_0, 'vout': 0},
{'txid': txid_1, 'vout': 0},
],
outputs=[{node.getnewaddress(): 0.1}]
))['hex']
txid_spend_both = node.sendrawtransaction(hexstring=raw_tx_spend_both, maxfeerate=0)
node.generate(1)
self.mempool_size = 0
# Now see if we can add the coins back to the utxo set by sending the exact txs again
self.check_mempool_result(
result_expected=[{'txid': txid_0, 'allowed': False, 'reject-reason': 'missing-inputs'}],
rawtxs=[raw_tx_0],
)
self.check_mempool_result(
result_expected=[{'txid': txid_1, 'allowed': False, 'reject-reason': 'missing-inputs'}],
rawtxs=[raw_tx_1],
)
self.log.info('Create a signed "reference" tx for later use')
raw_tx_reference = node.signrawtransactionwithwallet(node.createrawtransaction(
inputs=[{'txid': txid_spend_both, 'vout': 0}],
outputs=[{node.getnewaddress(): 0.05}],
))['hex']
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
# Reference tx should be valid on itself
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': True}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A transaction with no outputs')
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vout = []
# Skip re-signing the transaction for context independent checks from now on
# tx.deserialize(BytesIO(hex_str_to_bytes(node.signrawtransactionwithwallet(tx.serialize().hex())['hex'])))
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-vout-empty'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A really large transaction')
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vin = [tx.vin[0]] * math.ceil(MAX_BLOCK_BASE_SIZE / len(tx.vin[0].serialize()))
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-oversize'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A transaction with negative output value')
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vout[0].nValue *= -1
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-vout-negative'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A transaction with too large output value')
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vout[0].nValue = 21000000 * COIN + 1
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-vout-toolarge'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A transaction with too large sum of output values')
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vout = [tx.vout[0]] * 2
tx.vout[0].nValue = 21000000 * COIN
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-txouttotal-toolarge'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A transaction with duplicate inputs')
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vin = [tx.vin[0]] * 2
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-inputs-duplicate'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A coinbase transaction')
# Pick the input of the first tx we signed, so it has to be a coinbase tx
raw_tx_coinbase_spent = node.getrawtransaction(txid=node.decoderawtransaction(hexstring=raw_tx_in_block)['vin'][0]['txid'])
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_coinbase_spent)))
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: coinbase'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('Some nonstandard transactions')
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.nVersion = 3 # A version currently non-standard
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: version'}],
rawtxs=[tx.serialize().hex()],
)
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vout[0].scriptPubKey = CScript([OP_0]) # Some non-standard script
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: scriptpubkey'}],
rawtxs=[tx.serialize().hex()],
)
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vin[0].scriptSig = CScript([OP_HASH160]) # Some not-pushonly scriptSig
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: scriptsig-not-pushonly'}],
rawtxs=[tx.serialize().hex()],
)
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
output_p2sh_burn = CTxOut(nValue=540, scriptPubKey=CScript([OP_HASH160, hash160(b'burn'), OP_EQUAL]))
num_scripts = 100000 // len(output_p2sh_burn.serialize()) # Use enough outputs to make the tx too large for our policy
tx.vout = [output_p2sh_burn] * num_scripts
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: tx-size'}],
rawtxs=[tx.serialize().hex()],
)
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vout[0] = output_p2sh_burn
tx.vout[0].nValue -= 1 # Make output smaller, such that it is dust for our policy
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: dust'}],
rawtxs=[tx.serialize().hex()],
)
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vout[0].scriptPubKey = CScript([OP_RETURN, b'\xff'])
tx.vout = [tx.vout[0]] * 2
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: multi-op-return'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A timelocked transaction')
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vin[0].nSequence -= 1 # Should be non-max, so locktime is not ignored
tx.nLockTime = node.getblockcount() + 1
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: non-final'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A transaction that is locked by BIP68 sequence logic')
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vin[0].nSequence = 2 # We could include it in the second block mined from now, but not the very next one
# Can skip re-signing the tx because of early rejection
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: non-BIP68-final'}],
rawtxs=[tx.serialize().hex()],
maxfeerate=0,
)
def run_test(self):
self.enable_mocktime()
self.setup_3_masternodes_network()
txHashSet = set([
self.mnOneCollateral.hash, self.mnTwoCollateral.hash,
self.proRegTx1
])
# check mn list from miner
self.check_mn_list(self.miner, txHashSet)
# check status of masternodes
self.check_mns_status_legacy(self.remoteOne, self.mnOneCollateral.hash)
self.log.info("MN1 active")
self.check_mns_status_legacy(self.remoteTwo, self.mnTwoCollateral.hash)
self.log.info("MN2 active")
self.check_mns_status(self.remoteDMN1, self.proRegTx1)
self.log.info("DMN1 active")
# Prepare the proposal
self.log.info("preparing budget proposal..")
firstProposalName = "super-cool"
firstProposalLink = "https://forum.pivx.org/t/test-proposal"
firstProposalCycles = 2
firstProposalAddress = self.miner.getnewaddress()
firstProposalAmountPerCycle = 300
nextSuperBlockHeight = self.miner.getnextsuperblock()
proposalFeeTxId = self.miner.preparebudget(
firstProposalName, firstProposalLink, firstProposalCycles,
nextSuperBlockHeight, firstProposalAddress,
firstProposalAmountPerCycle)
# generate 3 blocks to confirm the tx (and update the mnping)
self.stake(3, [self.remoteOne, self.remoteTwo])
# activate sporks
self.activate_spork(self.minerPos,
"SPORK_8_MASTERNODE_PAYMENT_ENFORCEMENT")
self.activate_spork(self.minerPos,
"SPORK_9_MASTERNODE_BUDGET_ENFORCEMENT")
self.activate_spork(self.minerPos, "SPORK_13_ENABLE_SUPERBLOCKS")
txinfo = self.miner.gettransaction(proposalFeeTxId)
assert_equal(txinfo['amount'], -50.00)
self.log.info("submitting the budget proposal..")
proposalHash = self.miner.submitbudget(
firstProposalName, firstProposalLink, firstProposalCycles,
nextSuperBlockHeight, firstProposalAddress,
firstProposalAmountPerCycle, proposalFeeTxId)
# let's wait a little bit and see if all nodes are sync
time.sleep(1)
self.check_proposal_existence(firstProposalName, proposalHash)
self.log.info("proposal broadcast successful!")
# Proposal is established after 5 minutes. Mine 7 blocks
# Proposal needs to be on the chain > 5 min.
self.stake(7, [self.remoteOne, self.remoteTwo])
# now let's vote for the proposal with the first MN
self.log.info("Voting with MN1...")
voteResult = self.ownerOne.mnbudgetvote("alias", proposalHash, "yes",
self.masternodeOneAlias, True)
assert_equal(voteResult["detail"][0]["result"], "success")
# check that the vote was accepted everywhere
self.stake(1, [self.remoteOne, self.remoteTwo])
self.check_vote_existence(firstProposalName, self.mnOneCollateral.hash,
"YES", True)
self.log.info("all good, MN1 vote accepted everywhere!")
# now let's vote for the proposal with the second MN
self.log.info("Voting with MN2...")
voteResult = self.ownerTwo.mnbudgetvote("alias", proposalHash, "yes",
self.masternodeTwoAlias, True)
assert_equal(voteResult["detail"][0]["result"], "success")
# check that the vote was accepted everywhere
self.stake(1, [self.remoteOne, self.remoteTwo])
self.check_vote_existence(firstProposalName, self.mnTwoCollateral.hash,
"YES", True)
self.log.info("all good, MN2 vote accepted everywhere!")
# now let's vote for the proposal with the first DMN
self.log.info("Voting with DMN1...")
voteResult = self.ownerOne.mnbudgetvote("alias", proposalHash, "yes",
self.proRegTx1)
assert_equal(voteResult["detail"][0]["result"], "success")
# check that the vote was accepted everywhere
self.stake(1, [self.remoteOne, self.remoteTwo])
self.check_vote_existence(firstProposalName, self.proRegTx1, "YES",
True)
self.log.info("all good, DMN1 vote accepted everywhere!")
# Now check the budget
blockStart = nextSuperBlockHeight
blockEnd = blockStart + firstProposalCycles * 145
TotalPayment = firstProposalAmountPerCycle * firstProposalCycles
Allotted = firstProposalAmountPerCycle
RemainingPaymentCount = firstProposalCycles
expected_budget = [
self.get_proposal_obj(firstProposalName, firstProposalLink,
proposalHash, proposalFeeTxId, blockStart,
blockEnd, firstProposalCycles,
RemainingPaymentCount, firstProposalAddress,
1, 3, 0, 0, satoshi_round(TotalPayment),
satoshi_round(firstProposalAmountPerCycle),
True, True, satoshi_round(Allotted),
satoshi_round(Allotted))
]
self.check_budgetprojection(expected_budget)
# Quick block count check.
assert_equal(self.ownerOne.getblockcount(), 276)
self.log.info("starting budget finalization sync test..")
self.stake(5, [self.remoteOne, self.remoteTwo])
# assert that there is no budget finalization first.
assert_true(len(self.ownerOne.mnfinalbudget("show")) == 0)
# suggest the budget finalization and confirm the tx (+4 blocks).
budgetFinHash = self.broadcastbudgetfinalization(
self.miner, with_ping_mns=[self.remoteOne, self.remoteTwo])
assert (budgetFinHash != "")
time.sleep(1)
self.log.info("checking budget finalization sync..")
self.check_budget_finalization_sync(0, "OK")
self.log.info(
"budget finalization synced!, now voting for the budget finalization.."
)
voteResult = self.ownerOne.mnfinalbudget("vote-many", budgetFinHash,
True)
assert_equal(voteResult["detail"][0]["result"], "success")
self.log.info("Remote One voted successfully.")
voteResult = self.ownerTwo.mnfinalbudget("vote-many", budgetFinHash,
True)
assert_equal(voteResult["detail"][0]["result"], "success")
self.log.info("Remote Two voted successfully.")
voteResult = self.remoteDMN1.mnfinalbudget("vote", budgetFinHash)
assert_equal(voteResult["detail"][0]["result"], "success")
self.log.info("DMN voted successfully.")
self.stake(2, [self.remoteOne, self.remoteTwo])
self.log.info("checking finalization votes..")
self.check_budget_finalization_sync(3, "OK")
self.stake(8, [self.remoteOne, self.remoteTwo])
addrInfo = self.miner.listreceivedbyaddress(0, False, False,
firstProposalAddress)
assert_equal(addrInfo[0]["amount"], firstProposalAmountPerCycle)
self.log.info("budget proposal paid!, all good")
# Check that the proposal info returns updated payment count
expected_budget[0]["RemainingPaymentCount"] -= 1
self.check_budgetprojection(expected_budget)
self.stake(1, [self.remoteOne, self.remoteTwo])
# now let's verify that votes expire properly.
# Drop one MN and one DMN
self.log.info("expiring MN1..")
self.spend_collateral(self.ownerOne, self.mnOneCollateral, self.miner)
self.wait_until_mn_vinspent(self.mnOneCollateral.hash, 30,
[self.remoteTwo])
self.stake(15,
[self.remoteTwo]) # create blocks to remove staled votes
time.sleep(2) # wait a little bit
self.check_vote_existence(firstProposalName, self.mnOneCollateral.hash,
"YES", False)
self.log.info("MN1 vote expired after collateral spend, all good")
self.log.info("expiring DMN1..")
lm = self.ownerOne.listmasternodes(self.proRegTx1)[0]
self.spend_collateral(
self.ownerOne,
COutPoint(lm["collateralHash"], lm["collateralIndex"]), self.miner)
self.wait_until_mn_vinspent(self.proRegTx1, 30, [self.remoteTwo])
self.stake(15,
[self.remoteTwo]) # create blocks to remove staled votes
time.sleep(2) # wait a little bit
self.check_vote_existence(firstProposalName, self.proRegTx1, "YES",
False)
self.log.info("DMN vote expired after collateral spend, all good")
def def_utxo(height):
hex_id = hex_str_to_bytes('0' * 64)
uint256 = uint256_from_str(hex_id)
return UTXO(height, TxType.REGULAR, COutPoint(uint256, 0),
CTxOut(0, b""))
def test_governance_publishers(self):
governance_publishers = [
ZMQPublisher.hash_governance_object,
ZMQPublisher.raw_governance_object,
ZMQPublisher.hash_governance_vote,
ZMQPublisher.raw_governance_vote
]
self.log.info("Testing %d governance publishers" % len(governance_publishers))
# Subscribe to governance messages
self.subscribe(governance_publishers)
# Create a proposal and submit it to the network
proposal_rev = 1
proposal_time = int(time.time())
proposal_data = {
"type": 1, # GOVERNANCE_OBJECT_PROPOSAL
"name": "Test",
"start_epoch": proposal_time,
"end_epoch": proposal_time + 60,
"payment_amount": 5,
"payment_address": self.nodes[0].getnewaddress(),
"url": "https://grana.org"
}
proposal_hex = ''.join(format(x, '02x') for x in json.dumps(proposal_data).encode())
collateral = self.nodes[0].gobject("prepare", "0", proposal_rev, proposal_time, proposal_hex)
self.wait_for_instantlock(collateral, self.nodes[0])
self.nodes[0].generate(6)
self.sync_blocks()
rpc_proposal_hash = self.nodes[0].gobject("submit", "0", proposal_rev, proposal_time, proposal_hex, collateral)
# Validate hashgovernanceobject
zmq_governance_object_hash = bytes_to_hex_str(self.receive(ZMQPublisher.hash_governance_object).read(32))
assert_equal(zmq_governance_object_hash, rpc_proposal_hash)
zmq_governance_object_raw = CGovernanceObject()
zmq_governance_object_raw.deserialize(self.receive(ZMQPublisher.raw_governance_object))
assert_equal(zmq_governance_object_raw.nHashParent, 0)
assert_equal(zmq_governance_object_raw.nRevision, proposal_rev)
assert_equal(zmq_governance_object_raw.nTime, proposal_time)
assert_equal(json.loads(zmq_governance_object_raw.vchData.decode()), proposal_data)
assert_equal(zmq_governance_object_raw.nObjectType, proposal_data["type"])
assert_equal(zmq_governance_object_raw.masternodeOutpoint.hash, COutPoint().hash)
assert_equal(zmq_governance_object_raw.masternodeOutpoint.n, COutPoint().n)
# Vote for the proposal and validate the governance vote message
map_vote_outcomes = {
0: "none",
1: "yes",
2: "no",
3: "abstain"
}
map_vote_signals = {
0: "none",
1: "funding",
2: "valid",
3: "delete",
4: "endorsed"
}
self.nodes[0].gobject("vote-many", rpc_proposal_hash, map_vote_signals[1], map_vote_outcomes[1])
rpc_proposal_votes = self.nodes[0].gobject('getcurrentvotes', rpc_proposal_hash)
# Validate hashgovernancevote
zmq_governance_vote_hash = bytes_to_hex_str(self.receive(ZMQPublisher.hash_governance_vote).read(32))
assert(zmq_governance_vote_hash in rpc_proposal_votes)
# Validate rawgovernancevote
zmq_governance_vote_raw = CGovernanceVote()
zmq_governance_vote_raw.deserialize(self.receive(ZMQPublisher.raw_governance_vote))
assert_equal(uint256_to_string(zmq_governance_vote_raw.nParentHash), rpc_proposal_hash)
rpc_vote_parts = rpc_proposal_votes[zmq_governance_vote_hash].split(':')
rpc_outpoint_parts = rpc_vote_parts[0].split('-')
assert_equal(uint256_to_string(zmq_governance_vote_raw.masternodeOutpoint.hash), rpc_outpoint_parts[0])
assert_equal(zmq_governance_vote_raw.masternodeOutpoint.n, int(rpc_outpoint_parts[1]))
assert_equal(zmq_governance_vote_raw.nTime, int(rpc_vote_parts[1]))
assert_equal(map_vote_outcomes[zmq_governance_vote_raw.nVoteOutcome], rpc_vote_parts[2])
assert_equal(map_vote_signals[zmq_governance_vote_raw.nVoteSignal], rpc_vote_parts[3])
# Unsubscribe from governance messages
self.unsubscribe(governance_publishers)
