def run_test(self):
node = self.nodes[0]
addrkey0 = node.get_deterministic_priv_key()
blockhashes = node.generatetoaddress(100, addrkey0.address)
self.log.info(
"Make build a valid proof and restart the node to use it")
privkey = ECKey()
privkey.set(
bytes.fromhex(
"12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747"
), True)
def get_hex_pubkey(privkey):
return privkey.get_pubkey().get_bytes().hex()
proof_master = get_hex_pubkey(privkey)
proof_sequence = 11
proof_expiration = 12
proof = node.buildavalancheproof(
proof_sequence, proof_expiration, proof_master,
get_stakes(node, [blockhashes[0]], addrkey0.key))
# Restart the node, making sure it is initially in IBD mode
minchainwork = int(node.getblockchaininfo()["chainwork"], 16) + 1
self.restart_node(
0, self.extra_args[0] + [
"-avaproof={}".format(proof),
"-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
"-minimumchainwork=0x{:x}".format(minchainwork),
])
self.log.info(
"The proof verification should be delayed until IBD is complete")
assert node.getblockchaininfo()["initialblockdownload"] is True
# Our proof cannot be verified during IBD, so we should have no peer
assert not node.getavalanchepeerinfo()
# Mining a few more blocks should cause us to leave IBD
node.generate(2)
# Our proof is now verified and our node is added as a peer
assert node.getblockchaininfo()["initialblockdownload"] is False
wait_until(lambda: len(node.getavalanchepeerinfo()) == 1, timeout=5)
self.log.info(
"A proof using the maximum number of stakes is accepted...")
blockhashes = node.generatetoaddress(AVALANCHE_MAX_PROOF_STAKES + 1,
addrkey0.address)
too_many_stakes = get_stakes(node, blockhashes, addrkey0.key)
maximum_stakes = get_stakes(node, blockhashes[:-1], addrkey0.key)
good_proof = node.buildavalancheproof(proof_sequence, proof_expiration,
proof_master, maximum_stakes)
peerid1 = add_interface_node(node)
assert node.addavalanchenode(peerid1, proof_master, good_proof)
self.log.info("A proof using too many stakes should be rejected...")
too_many_utxos = node.buildavalancheproof(proof_sequence,
proof_expiration,
proof_master,
too_many_stakes)
peerid2 = add_interface_node(node)
assert not node.addavalanchenode(peerid2, proof_master, too_many_utxos)
self.log.info("Generate delegations for the proof")
# Stack up a few delegation levels
def gen_privkey():
pk = ECKey()
pk.generate()
return pk
delegator_privkey = privkey
delegation = None
for _ in range(10):
delegated_privkey = gen_privkey()
delegation = node.delegateavalancheproof(
proof,
bytes_to_wif(delegator_privkey.get_bytes()),
get_hex_pubkey(delegated_privkey),
delegation,
)
delegator_privkey = delegated_privkey
random_privkey = gen_privkey()
random_pubkey = get_hex_pubkey(random_privkey)
# Invalid proof
assert_raises_rpc_error(
-8,
"The proof is invalid",
node.delegateavalancheproof,
too_many_utxos,
bytes_to_wif(privkey.get_bytes()),
random_pubkey,
)
# Invalid privkey
assert_raises_rpc_error(
-5,
"The private key is invalid",
node.delegateavalancheproof,
proof,
bytes_to_wif(bytes(32)),
random_pubkey,
)
# Invalid delegation
bad_dg = AvalancheDelegation()
assert_raises_rpc_error(
-8,
"The supplied delegation is not valid",
node.delegateavalancheproof,
proof,
bytes_to_wif(privkey.get_bytes()),
random_pubkey,
bad_dg.serialize().hex(),
)
# Wrong privkey, does not match the proof
assert_raises_rpc_error(
-8,
"The private key does not match the proof or the delegation",
node.delegateavalancheproof,
proof,
bytes_to_wif(random_privkey.get_bytes()),
random_pubkey,
)
# Wrong privkey, match the proof but does not match the delegation
assert_raises_rpc_error(
-8,
"The private key does not match the proof or the delegation",
node.delegateavalancheproof,
proof,
bytes_to_wif(privkey.get_bytes()),
random_pubkey,
delegation,
)
# Test invalid proofs
self.log.info("Bad proof should be rejected at startup")
no_stake = node.buildavalancheproof(proof_sequence, proof_expiration,
proof_master, [])
dust = node.buildavalancheproof(
proof_sequence, proof_expiration, proof_master,
get_stakes(node, [blockhashes[0]], addrkey0.key, amount="0"))
duplicate_stake = node.buildavalancheproof(
proof_sequence, proof_expiration, proof_master,
get_stakes(node, [blockhashes[0]] * 2, addrkey0.key))
bad_sig = (
"0b000000000000000c0000000000000021030b4c866585dd868a9d62348"
"a9cd008d6a312937048fff31670e7e920cfc7a7440105c5f72f5d6da3085"
"583e75ee79340eb4eff208c89988e7ed0efb30b87298fa30000000000f20"
"52a0100000003000000210227d85ba011276cf25b51df6a188b75e604b3"
"8770a462b2d0e9fb2fc839ef5d3faf07f001dd38e9b4a43d07d5d449cc0"
"f7d2888d96b82962b3ce516d1083c0e031773487fc3c4f2e38acd1db974"
"1321b91a79b82d1c2cfd47793261e4ba003cf5")
self.stop_node(0)
node.assert_start_raises_init_error(
self.extra_args[0] + [
"-avasessionkey=0",
],
expected_msg="Error: the avalanche session key is invalid",
)
node.assert_start_raises_init_error(
self.extra_args[0] + [
"-avaproof={}".format(proof),
],
expected_msg=
"Error: the avalanche master key is missing for the avalanche proof",
)
node.assert_start_raises_init_error(
self.extra_args[0] + [
"-avaproof={}".format(proof),
"-avamasterkey=0",
],
expected_msg="Error: the avalanche master key is invalid",
)
def check_proof_init_error(proof, message):
node.assert_start_raises_init_error(
self.extra_args[0] + [
"-avaproof={}".format(proof),
"-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
],
expected_msg="Error: " + message,
)
check_proof_init_error(no_stake, "the avalanche proof has no stake")
check_proof_init_error(dust, "the avalanche proof stake is too low")
check_proof_init_error(duplicate_stake,
"the avalanche proof has duplicated stake")
check_proof_init_error(
bad_sig, "the avalanche proof has invalid stake signatures")
# The too many utxos case creates a proof which is that large that it
# cannot fit on the command line
append_config(node.datadir, ["avaproof={}".format(too_many_utxos)])
node.assert_start_raises_init_error(
self.extra_args[0] + [
"-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
],
expected_msg="Error: the avalanche proof has too many utxos",
match=ErrorMatch.PARTIAL_REGEX,
)
def test_double_spend(self):
'''
This tests the case where the same UTXO is spent twice on two separate
blocks as part of a reorg.
ab0
/ \
aa1 [tx1] bb1 [tx2]
| |
aa2 bb2
| |
aa3 bb3
|
bb4
Problematic case:
1. User 1 receives BTC in tx1 from utxo1 in block aa1.
2. User 2 receives BTC in tx2 from utxo1 (same) in block bb1
3. User 1 sees 2 confirmations at block aa3.
4. Reorg into bb chain.
5. User 1 asks `listsinceblock aa3` and does not see that tx1 is now
invalidated.
Currently the solution to this is to detect that a reorg'd block is
asked for in listsinceblock, and to iterate back over existing blocks up
until the fork point, and to include all transactions that relate to the
node wallet.
'''
self.log.info("Test double spend")
self.sync_all()
# share utxo between nodes[1] and nodes[2]
eckey = ECKey()
eckey.generate()
privkey = bytes_to_wif(eckey.get_bytes())
address = key_to_p2wpkh(eckey.get_pubkey().get_bytes())
self.nodes[2].sendtoaddress(address, 10)
self.generate(self.nodes[2], 6)
self.nodes[2].importprivkey(privkey)
utxos = self.nodes[2].listunspent()
utxo = [u for u in utxos if u["address"] == address][0]
self.nodes[1].importprivkey(privkey)
# Split network into two
self.split_network()
# send from nodes[1] using utxo to nodes[0]
change = '%.8f' % (float(utxo['amount']) - 1.0003)
recipient_dict = {
self.nodes[0].getnewaddress(): 1,
self.nodes[1].getnewaddress(): change,
}
utxo_dicts = [{
'txid': utxo['txid'],
'vout': utxo['vout'],
}]
txid1 = self.nodes[1].sendrawtransaction(
self.nodes[1].signrawtransactionwithwallet(
self.nodes[1].createrawtransaction(utxo_dicts,
recipient_dict))['hex'])
# send from nodes[2] using utxo to nodes[3]
recipient_dict2 = {
self.nodes[3].getnewaddress(): 1,
self.nodes[2].getnewaddress(): change,
}
self.nodes[2].sendrawtransaction(
self.nodes[2].signrawtransactionwithwallet(
self.nodes[2].createrawtransaction(utxo_dicts,
recipient_dict2))['hex'])
# generate on both sides
lastblockhash = self.generate(self.nodes[1], 3, sync_fun=self.no_op)[2]
self.generate(self.nodes[2], 4, sync_fun=self.no_op)
self.join_network()
self.sync_all()
# gettransaction should work for txid1
assert self.nodes[0].gettransaction(
txid1)['txid'] == txid1, "gettransaction failed to find txid1"
# listsinceblock(lastblockhash) should now include txid1, as seen from nodes[0]
lsbres = self.nodes[0].listsinceblock(lastblockhash)
assert any(tx['txid'] == txid1 for tx in lsbres['removed'])
# but it should not include 'removed' if include_removed=false
lsbres2 = self.nodes[0].listsinceblock(blockhash=lastblockhash,
include_removed=False)
assert 'removed' not in lsbres2
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(100):
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(2100):
block = create_block(self.tip, create_coinbase(height),
self.block_time)
block.set_base_version(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)])
self.start_node(2, extra_args=["-assumevalid=" + hex(block102.sha256)])
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])
# Send blocks to node0. Block 102 will be rejected.
self.send_blocks_until_disconnected(p2p0)
self.assert_blockchain_height(self.nodes[0], 101)
# 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(200)
assert_equal(
self.nodes[1].getblock(self.nodes[1].getbestblockhash())['height'],
2202)
# Send blocks to node2. Block 102 will be rejected.
self.send_blocks_until_disconnected(p2p2)
self.assert_blockchain_height(self.nodes[2], 101)
def random_p2wpkh():
"""Generate a random P2WPKH scriptPubKey. Can be used when a random destination is needed,
but no compiled wallet is available (e.g. as replacement to the getnewaddress RPC)."""
key = ECKey()
key.generate()
return key_to_p2wpkh_script(key.get_pubkey().get_bytes())
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': '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': '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': '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()],
maxfeerate=0,
)
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': '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': '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': 'bad-txns-vout-negative'
}],
rawtxs=[tx.serialize().hex()],
)
# The following two validations prevent overflow of the output amounts (see CVE-2010-5139).
self.log.info('A transaction with too large output value')
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vout[0].nValue = MAX_MONEY + 1
self.check_mempool_result(
result_expected=[{
'txid': tx.rehash(),
'allowed': False,
'reject-reason': '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 = MAX_MONEY
self.check_mempool_result(
result_expected=[{
'txid': tx.rehash(),
'allowed': False,
'reject-reason': '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': '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': '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': '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': 'scriptpubkey'
}],
rawtxs=[tx.serialize().hex()],
)
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
key = ECKey()
key.generate()
pubkey = key.get_pubkey().get_bytes()
tx.vout[0].scriptPubKey = CScript(
[OP_2, pubkey, pubkey, pubkey, OP_3,
OP_CHECKMULTISIG]) # Some bare multisig script (2-of-3)
self.check_mempool_result(
result_expected=[{
'txid': tx.rehash(),
'allowed': False,
'reject-reason': 'bare-multisig'
}],
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': 'scriptsig-not-pushonly'
}],
rawtxs=[tx.serialize().hex()],
)
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
tx.vin[0].scriptSig = CScript(
[b'a' * 1648]) # Some too large scriptSig (>1650 bytes)
self.check_mempool_result(
result_expected=[{
'txid': tx.rehash(),
'allowed': False,
'reject-reason': 'scriptsig-size'
}],
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': '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': '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': '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': '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': 'non-BIP68-final'
}],
rawtxs=[tx.serialize().hex()],
maxfeerate=0,
)
def run_test(self):
node = self.nodes[0]
self.wallet = MiniWallet(node)
self.wallet.rescan_utxos()
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)
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 between 1 and 25 transactions.', lambda: node.testmempoolaccept(rawtxs=['ff22']*26))
assert_raises_rpc_error(-8, 'Array must contain between 1 and 25 transactions.', lambda: node.testmempoolaccept(rawtxs=[]))
assert_raises_rpc_error(-22, 'TX decode failed', lambda: node.testmempoolaccept(rawtxs=['ff00baar']))
self.log.info('A transaction already in the blockchain')
tx = self.wallet.create_self_transfer()['tx'] # Pick a random coin(base) to spend
tx.vout.append(deepcopy(tx.vout[0]))
tx.vout[0].nValue = int(0.3 * COIN)
tx.vout[1].nValue = int(49 * COIN)
raw_tx_in_block = tx.serialize().hex()
txid_in_block = self.wallet.sendrawtransaction(from_node=node, tx_hex=raw_tx_in_block, maxfeerate=0)
self.generate(node, 1)
self.mempool_size = 0
self.check_mempool_result(
result_expected=[{'txid': txid_in_block, 'allowed': False, 'reject-reason': 'txn-already-known'}],
rawtxs=[raw_tx_in_block],
)
self.log.info('A transaction not in the mempool')
fee = Decimal('0.000007')
utxo_to_spend = self.wallet.get_utxo(txid=txid_in_block) # use 0.3 UMK UTXO
tx = self.wallet.create_self_transfer(utxo_to_spend=utxo_to_spend, sequence=BIP125_SEQUENCE_NUMBER)['tx']
tx.vout[0].nValue = int((Decimal('0.3') - fee) * COIN)
raw_tx_0 = tx.serialize().hex()
txid_0 = tx.rehash()
self.check_mempool_result(
result_expected=[{'txid': txid_0, 'allowed': True, 'vsize': tx.get_vsize(), 'fees': {'base': fee}}],
rawtxs=[raw_tx_0],
)
self.log.info('A final transaction not in the mempool')
output_amount = Decimal('0.025')
tx = self.wallet.create_self_transfer(
sequence=SEQUENCE_FINAL,
locktime=node.getblockcount() + 2000, # Can be anything
)['tx']
tx.vout[0].nValue = int(output_amount * COIN)
raw_tx_final = tx.serialize().hex()
tx = tx_from_hex(raw_tx_final)
fee_expected = Decimal('50.0') - output_amount
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': True, 'vsize': tx.get_vsize(), 'fees': {'base': fee_expected}}],
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': 'txn-already-in-mempool'}],
rawtxs=[raw_tx_0],
)
self.log.info('A transaction that replaces a mempool transaction')
tx = tx_from_hex(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 = tx.serialize().hex()
txid_0 = tx.rehash()
self.check_mempool_result(
result_expected=[{'txid': txid_0, 'allowed': True, 'vsize': tx.get_vsize(), 'fees': {'base': (2 * fee)}}],
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 = tx_from_hex(raw_tx_0)
tx.vout[0].nValue -= int(4 * fee * COIN) # Set more fee
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'txn-mempool-conflict'}],
rawtxs=[tx.serialize().hex()],
maxfeerate=0,
)
self.log.info('A transaction with missing inputs, that never existed')
tx = tx_from_hex(raw_tx_0)
tx.vin[0].prevout = COutPoint(hash=int('ff' * 32, 16), n=14)
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 = tx_from_hex(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 = tx.serialize().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
tx = self.wallet.create_self_transfer()['tx']
tx.vin.append(deepcopy(tx.vin[0]))
tx.wit.vtxinwit.append(deepcopy(tx.wit.vtxinwit[0]))
tx.vin[0].prevout = COutPoint(hash=int(txid_0, 16), n=0)
tx.vin[1].prevout = COutPoint(hash=int(txid_1, 16), n=0)
tx.vout[0].nValue = int(0.1 * COIN)
raw_tx_spend_both = tx.serialize().hex()
txid_spend_both = self.wallet.sendrawtransaction(from_node=node, tx_hex=raw_tx_spend_both, maxfeerate=0)
self.generate(node, 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 "reference" tx for later use')
utxo_to_spend = self.wallet.get_utxo(txid=txid_spend_both)
tx = self.wallet.create_self_transfer(utxo_to_spend=utxo_to_spend, sequence=SEQUENCE_FINAL)['tx']
tx.vout[0].nValue = int(0.05 * COIN)
raw_tx_reference = tx.serialize().hex()
# Reference tx should be valid on itself
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': True, 'vsize': tx.get_vsize(), 'fees': { 'base': Decimal('0.1') - Decimal('0.05')}}],
rawtxs=[tx.serialize().hex()],
maxfeerate=0,
)
self.log.info('A transaction with no outputs')
tx = tx_from_hex(raw_tx_reference)
tx.vout = []
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'bad-txns-vout-empty'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A really large transaction')
tx = tx_from_hex(raw_tx_reference)
tx.vin = [tx.vin[0]] * math.ceil(MAX_BLOCK_WEIGHT // 4 / len(tx.vin[0].serialize()))
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'bad-txns-oversize'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A transaction with negative output value')
tx = tx_from_hex(raw_tx_reference)
tx.vout[0].nValue *= -1
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'bad-txns-vout-negative'}],
rawtxs=[tx.serialize().hex()],
)
# The following two validations prevent overflow of the output amounts (see CVE-2010-5139).
self.log.info('A transaction with too large output value')
tx = tx_from_hex(raw_tx_reference)
tx.vout[0].nValue = MAX_MONEY + 1
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'bad-txns-vout-toolarge'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A transaction with too large sum of output values')
tx = tx_from_hex(raw_tx_reference)
tx.vout = [tx.vout[0]] * 2
tx.vout[0].nValue = MAX_MONEY
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'bad-txns-txouttotal-toolarge'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A transaction with duplicate inputs')
tx = tx_from_hex(raw_tx_reference)
tx.vin = [tx.vin[0]] * 2
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'bad-txns-inputs-duplicate'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A non-coinbase transaction with coinbase-like outpoint')
tx = tx_from_hex(raw_tx_reference)
tx.vin.append(CTxIn(COutPoint(hash=0, n=0xffffffff)))
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'bad-txns-prevout-null'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A coinbase transaction')
# Pick the input of the first tx we created, 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 = tx_from_hex(raw_tx_coinbase_spent)
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'coinbase'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('Some nonstandard transactions')
tx = tx_from_hex(raw_tx_reference)
tx.nVersion = 3 # A version currently non-standard
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'version'}],
rawtxs=[tx.serialize().hex()],
)
tx = tx_from_hex(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': 'scriptpubkey'}],
rawtxs=[tx.serialize().hex()],
)
tx = tx_from_hex(raw_tx_reference)
key = ECKey()
key.generate()
pubkey = key.get_pubkey().get_bytes()
tx.vout[0].scriptPubKey = keys_to_multisig_script([pubkey] * 3, k=2) # Some bare multisig script (2-of-3)
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'bare-multisig'}],
rawtxs=[tx.serialize().hex()],
)
tx = tx_from_hex(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': 'scriptsig-not-pushonly'}],
rawtxs=[tx.serialize().hex()],
)
tx = tx_from_hex(raw_tx_reference)
tx.vin[0].scriptSig = CScript([b'a' * 1648]) # Some too large scriptSig (>1650 bytes)
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'scriptsig-size'}],
rawtxs=[tx.serialize().hex()],
)
tx = tx_from_hex(raw_tx_reference)
output_p2sh_burn = CTxOut(nValue=540, scriptPubKey=script_to_p2sh_script(b'burn'))
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': 'tx-size'}],
rawtxs=[tx.serialize().hex()],
)
tx = tx_from_hex(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': 'dust'}],
rawtxs=[tx.serialize().hex()],
)
tx = tx_from_hex(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': 'multi-op-return'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A timelocked transaction')
tx = tx_from_hex(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': 'non-final'}],
rawtxs=[tx.serialize().hex()],
)
self.log.info('A transaction that is locked by BIP68 sequence logic')
tx = tx_from_hex(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
self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'non-BIP68-final'}],
rawtxs=[tx.serialize().hex()],
maxfeerate=0,
)
def run_test(self):
node = self.nodes[0]
node.add_p2p_connection(P2PDataStore())
# Allocate as many UTXOs as are needed
num_utxos = sum(test_case['inputs'] 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 range(test_case['inputs']):
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
utxo_script = CScript(
[OP_SCRIPTTYPE, OP_1,
public_key.get_bytes()])
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()
# Broadcast fan-out tx
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 = test_case['inputs']
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 range(test_case['inputs']):
tx.vin.append(
CTxIn(COutPoint(tx_fan_out.txid, utxo_idx), CScript()))
utxo_idx += 1
if test_case.get('sigs', None) is not None:
for i, sig in enumerate(test_case['sigs']):
tx.vin[i].scriptSig = CScript([sig])
key_idx += 1
else:
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,
)
if test_case.get('sig', None) is not None:
signature = test_case['sig']
if test_case.get('ecdsa', False):
signature = private_keys[key_idx].sign_ecdsa(sighash)
else:
signature = private_keys[key_idx].sign_schnorr(sighash)
signature += bytes(
[test_case.get('suffix', sig_hash_type & 0xff)])
# Build correct scriptSig
tx.vin[i].scriptSig = CScript([signature])
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]
node.add_p2p_connection(P2PDataStore())
# Allocate as many UTXOs as are needed
num_utxos = sum(
len(tx_case['inputs']) for tx_case in TX_CASES
if isinstance(tx_case, dict))
value = int(SUBSIDY * 1_000_000)
fee = 10_000
pubkey_bytes = bytes.fromhex(
'020000000000000000000000000000000000000000000000000000000000000001'
)
pubkey = ECPubKey()
pubkey.set(pubkey_bytes)
max_utxo_value = (value - fee) // num_utxos
spendable_outputs = []
utxo_idx = 0
# Prepare UTXOs for the tests below
for tx_case in TX_CASES:
if tx_case == 'ENABLE_REPLAY_PROTECTION':
continue
for tree, leaf_idx, _ in tx_case['inputs']:
utxo_value = max_utxo_value - utxo_idx * 100 # deduct 100*i coins for unique amounts
tree_result = taproot_tree_helper(tree)
merkle_root = tree_result['hash']
tweak_hash = TaggedHash("TapTweak", pubkey_bytes + merkle_root)
commitment = pubkey.add(tweak_hash)
ops = [OP_SCRIPTTYPE, OP_1, commitment.get_bytes()]
script_case = tree_result['items'][leaf_idx]['leaf'][
'script_case']
if script_case.get('state', False):
ops.append(script_case['state'])
utxo_script = CScript(ops)
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
for tx_case in TX_CASES:
if tx_case == 'ENABLE_REPLAY_PROTECTION':
node.setmocktime(ACTIVATION_TIME)
node.generatetoaddress(11, burn_address)
continue
num_inputs = len(tx_case['inputs'])
num_outputs = tx_case['outputs']
# Build tx for this test, will broadcast later
tx = CTransaction()
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) // num_outputs
for i in range(num_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 range(num_inputs):
tx.vin.append(
CTxIn(COutPoint(tx_fan_out.txid, utxo_idx), CScript()))
utxo_idx += 1
for input_idx, input_case in enumerate(tx_case['inputs']):
tree, leaf_idx, sig_hash_types = input_case
tree_result = taproot_tree_helper(tree)
result_item = tree_result['items'][leaf_idx]
leaf = result_item['leaf']
script_case = leaf['script_case']
exec_script = CScript(script_case['script'])
keys = script_case.get('keys', [])
assert len(sig_hash_types) == len(keys)
sigs = []
for sig_hash_type, key in zip(sig_hash_types, keys):
if sig_hash_type & SIGHASH_LOTUS == SIGHASH_LOTUS:
sighash = SignatureHashLotus(
tx_to=tx,
spent_utxos=spent_outputs,
sig_hash_type=sig_hash_type,
input_index=input_idx,
executed_script_hash=leaf['tapleaf_hash'],
codeseparator_pos=script_case.get(
'codesep', 0xffff_ffff),
)
elif sig_hash_type & SIGHASH_FORKID:
sighash = SignatureHashForkId(
exec_script,
tx,
input_idx,
sig_hash_type,
spent_outputs[input_idx].nValue,
)
else:
raise NotImplemented
private_key = ECKey()
private_key.set(key, True)
if script_case.get('schnorr', False):
signature = private_key.sign_schnorr(sighash)
else:
signature = private_key.sign_ecdsa(sighash)
signature += bytes(
[tx_case.get('suffix', sig_hash_type & 0xff)])
sigs.append(signature)
control_block = bytearray(pubkey_bytes)
control_block[0] = 0xc0
control_block[0] |= int(pubkey_bytes[0] == 0x03)
control_block += result_item['path']
tx.vin[input_idx].scriptSig = CScript(
script_case['script_inputs'] + sigs +
[exec_script, control_block])
# Broadcast transaction and check success/failure
tx.rehash()
if 'error' not in tx_case:
node.p2p.send_txs_and_test([tx], node)
else:
node.p2p.send_txs_and_test([tx],
node,
success=False,
reject_reason=tx_case['error'])
def run_test(self):
node = self.nodes[0]
self.log.info("Check the node is signalling the avalanche service.")
assert_equal(
int(node.getnetworkinfo()['localservices'], 16) & NODE_AVALANCHE,
NODE_AVALANCHE)
# Build a fake quorum of nodes.
def get_quorum():
def get_node():
n = TestNode()
node.add_p2p_connection(
n, services=NODE_NETWORK | NODE_AVALANCHE)
n.wait_for_verack()
# Get our own node id so we can use it later.
n.nodeid = node.getpeerinfo()[-1]['id']
return n
return [get_node() for _ in range(0, QUORUM_NODE_COUNT)]
# Pick on node from the quorum for polling.
quorum = get_quorum()
poll_node = quorum[0]
# Generate many block and poll for them.
address = node.get_deterministic_priv_key().address
blocks = node.generatetoaddress(100, address)
def get_coinbase(h):
b = node.getblock(h, 2)
return {
'height': b['height'],
'txid': b['tx'][0]['txid'],
'n': 0,
'value': b['tx'][0]['vout'][0]['value'],
}
coinbases = [get_coinbase(h) for h in blocks]
fork_node = self.nodes[1]
# Make sure the fork node has synced the blocks
self.sync_blocks([node, fork_node])
# Get the key so we can verify signatures.
avakey = ECPubKey()
avakey.set(bytes.fromhex(node.getavalanchekey()))
self.log.info("Poll for the chain tip...")
best_block_hash = int(node.getbestblockhash(), 16)
poll_node.send_poll([best_block_hash])
def assert_response(expected):
response = poll_node.wait_for_avaresponse()
r = response.response
assert_equal(r.cooldown, 0)
# Verify signature.
assert avakey.verify_schnorr(response.sig, r.get_hash())
votes = r.votes
assert_equal(len(votes), len(expected))
for i in range(0, len(votes)):
assert_equal(repr(votes[i]), repr(expected[i]))
assert_response([AvalancheVote(BLOCK_ACCEPTED, best_block_hash)])
self.log.info("Poll for a selection of blocks...")
various_block_hashes = [
int(node.getblockhash(0), 16),
int(node.getblockhash(1), 16),
int(node.getblockhash(10), 16),
int(node.getblockhash(25), 16),
int(node.getblockhash(42), 16),
int(node.getblockhash(96), 16),
int(node.getblockhash(99), 16),
int(node.getblockhash(100), 16),
]
poll_node.send_poll(various_block_hashes)
assert_response([AvalancheVote(BLOCK_ACCEPTED, h)
for h in various_block_hashes])
self.log.info(
"Poll for a selection of blocks, but some are now invalid...")
invalidated_block = node.getblockhash(76)
node.invalidateblock(invalidated_block)
# We need to send the coin to a new address in order to make sure we do
# not regenerate the same block.
node.generatetoaddress(
26, 'bchreg:pqv2r67sgz3qumufap3h2uuj0zfmnzuv8v7ej0fffv')
node.reconsiderblock(invalidated_block)
poll_node.send_poll(various_block_hashes)
assert_response([AvalancheVote(BLOCK_ACCEPTED, h) for h in various_block_hashes[:5]] +
[AvalancheVote(BLOCK_FORK, h) for h in various_block_hashes[-3:]])
self.log.info("Poll for unknown blocks...")
various_block_hashes = [
int(node.getblockhash(0), 16),
int(node.getblockhash(25), 16),
int(node.getblockhash(42), 16),
various_block_hashes[5],
various_block_hashes[6],
various_block_hashes[7],
random.randrange(1 << 255, (1 << 256) - 1),
random.randrange(1 << 255, (1 << 256) - 1),
random.randrange(1 << 255, (1 << 256) - 1),
]
poll_node.send_poll(various_block_hashes)
assert_response([AvalancheVote(BLOCK_ACCEPTED, h) for h in various_block_hashes[:3]] +
[AvalancheVote(BLOCK_FORK, h) for h in various_block_hashes[3:6]] +
[AvalancheVote(BLOCK_UNKNOWN, h) for h in various_block_hashes[-3:]])
self.log.info("Trigger polling from the node...")
# duplicate the deterministic sig test from src/test/key_tests.cpp
privkey = ECKey()
privkey.set(bytes.fromhex(
"12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747"), True)
pubkey = privkey.get_pubkey()
privatekey = node.get_deterministic_priv_key().key
proof_sequence = 11
proof_expiration = 12
proof = node.buildavalancheproof(
proof_sequence, proof_expiration, pubkey.get_bytes().hex(),
[{
'txid': coinbases[0]['txid'],
'vout': coinbases[0]['n'],
'amount': coinbases[0]['value'],
'height': coinbases[0]['height'],
'iscoinbase': True,
'privatekey': privatekey,
}])
# Activate the quorum.
for n in quorum:
success = node.addavalanchenode(
n.nodeid, pubkey.get_bytes().hex(), proof)
assert success is True
self.log.info("Testing getavalanchepeerinfo...")
avapeerinfo = node.getavalanchepeerinfo()
# There is a single peer because all nodes share the same proof.
assert_equal(len(avapeerinfo), 1)
assert_equal(avapeerinfo[0]["peerid"], 0)
assert_equal(avapeerinfo[0]["nodecount"], len(quorum))
# The first avalanche node index is 1, because 0 is self.nodes[1].
assert_equal(sorted(avapeerinfo[0]["nodes"]),
list(range(1, QUORUM_NODE_COUNT + 1)))
assert_equal(avapeerinfo[0]["sequence"], proof_sequence)
assert_equal(avapeerinfo[0]["expiration"], proof_expiration)
assert_equal(avapeerinfo[0]["master"], pubkey.get_bytes().hex())
assert_equal(avapeerinfo[0]["proof"], proof)
assert_equal(len(avapeerinfo[0]["stakes"]), 1)
assert_equal(avapeerinfo[0]["stakes"][0]["txid"], coinbases[0]['txid'])
def can_find_block_in_poll(hash, resp=BLOCK_ACCEPTED):
found_hash = False
for n in quorum:
poll = n.get_avapoll_if_available()
# That node has not received a poll
if poll is None:
continue
# We got a poll, check for the hash and repond
votes = []
for inv in poll.invs:
# Vote yes to everything
r = BLOCK_ACCEPTED
# Look for what we expect
if inv.hash == hash:
r = resp
found_hash = True
votes.append(AvalancheVote(r, inv.hash))
n.send_avaresponse(poll.round, votes, privkey)
return found_hash
# Now that we have a peer, we should start polling for the tip.
hash_tip = int(node.getbestblockhash(), 16)
wait_until(lambda: can_find_block_in_poll(hash_tip), timeout=5)
# Make sure the fork node has synced the blocks
self.sync_blocks([node, fork_node])
# Create a fork 2 blocks deep. This should trigger polling.
fork_node.invalidateblock(fork_node.getblockhash(100))
fork_address = fork_node.get_deterministic_priv_key().address
fork_node.generatetoaddress(2, fork_address)
# Because the new tip is a deep reorg, the node will not accept it
# right away, but poll for it.
def parked_block(blockhash):
for tip in node.getchaintips():
if tip["hash"] == blockhash:
assert tip["status"] != "active"
return tip["status"] == "parked"
return False
fork_tip = fork_node.getbestblockhash()
wait_until(lambda: parked_block(fork_tip))
self.log.info("Answer all polls to finalize...")
hash_to_find = int(fork_tip, 16)
def has_accepted_new_tip():
can_find_block_in_poll(hash_to_find)
return node.getbestblockhash() == fork_tip
# Because everybody answers yes, the node will accept that block.
wait_until(has_accepted_new_tip, timeout=15)
assert_equal(node.getbestblockhash(), fork_tip)
self.log.info("Answer all polls to park...")
node.generate(1)
tip_to_park = node.getbestblockhash()
hash_to_find = int(tip_to_park, 16)
assert(tip_to_park != fork_tip)
def has_parked_new_tip():
can_find_block_in_poll(hash_to_find, BLOCK_PARKED)
return node.getbestblockhash() == fork_tip
# Because everybody answers no, the node will park that block.
wait_until(has_parked_new_tip, timeout=15)
assert_equal(node.getbestblockhash(), fork_tip)
# Restart the node and rebuild the quorum
self.restart_node(0, self.extra_args[0] + [
"-avaproof={}".format(proof),
"-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
])
quorum = get_quorum()
poll_node = quorum[0]
# Check the avahello is consistent
avahello = poll_node.wait_for_avahello().hello
avakey.set(bytes.fromhex(node.getavalanchekey()))
assert avakey.verify_schnorr(
avahello.sig, avahello.get_sighash(poll_node))
def run_test(self):
node = self.nodes[0]
# Build a fake quorum of nodes.
quorum = []
for i in range(0, 16):
n = TestNode()
quorum.append(n)
node.add_p2p_connection(n)
n.wait_for_verack()
# Get our own node id so we can use it later.
n.nodeid = node.getpeerinfo()[-1]['id']
# Pick on node from the quorum for polling.
poll_node = quorum[0]
# Generate many block and poll for them.
address = node.get_deterministic_priv_key().address
node.generatetoaddress(100, address)
fork_node = self.nodes[1]
# Make sure the fork node has synced the blocks
self.sync_blocks([node, fork_node])
# Get the key so we can verify signatures.
avakey = ECPubKey()
avakey.set(bytes.fromhex(node.getavalanchekey()))
self.log.info("Poll for the chain tip...")
best_block_hash = int(node.getbestblockhash(), 16)
poll_node.send_poll([best_block_hash])
def assert_response(expected):
response = poll_node.wait_for_avaresponse()
r = response.response
assert_equal(r.cooldown, 0)
# Verify signature.
assert avakey.verify_schnorr(response.sig, r.get_hash())
votes = r.votes
assert_equal(len(votes), len(expected))
for i in range(0, len(votes)):
assert_equal(repr(votes[i]), repr(expected[i]))
assert_response([AvalancheVote(BLOCK_ACCEPTED, best_block_hash)])
self.log.info("Poll for a selection of blocks...")
various_block_hashes = [
int(node.getblockhash(0), 16),
int(node.getblockhash(1), 16),
int(node.getblockhash(10), 16),
int(node.getblockhash(25), 16),
int(node.getblockhash(42), 16),
int(node.getblockhash(96), 16),
int(node.getblockhash(99), 16),
int(node.getblockhash(100), 16),
]
poll_node.send_poll(various_block_hashes)
assert_response([AvalancheVote(BLOCK_ACCEPTED, h)
for h in various_block_hashes])
self.log.info(
"Poll for a selection of blocks, but some are now invalid...")
invalidated_block = node.getblockhash(76)
node.invalidateblock(invalidated_block)
# We need to send the coin to a new address in order to make sure we do
# not regenerate the same block.
node.generatetoaddress(
26, 'bchreg:pqv2r67sgz3qumufap3h2uuj0zfmnzuv8v7ej0fffv')
node.reconsiderblock(invalidated_block)
poll_node.send_poll(various_block_hashes)
assert_response([AvalancheVote(BLOCK_ACCEPTED, h) for h in various_block_hashes[:5]] +
[AvalancheVote(BLOCK_REJECTED, h) for h in various_block_hashes[-3:]])
self.log.info("Poll for unknown blocks...")
various_block_hashes = [
int(node.getblockhash(0), 16),
int(node.getblockhash(25), 16),
int(node.getblockhash(42), 16),
various_block_hashes[5],
various_block_hashes[6],
various_block_hashes[7],
random.randrange(1 << 255, (1 << 256) - 1),
random.randrange(1 << 255, (1 << 256) - 1),
random.randrange(1 << 255, (1 << 256) - 1),
]
poll_node.send_poll(various_block_hashes)
assert_response([AvalancheVote(BLOCK_ACCEPTED, h) for h in various_block_hashes[:3]] +
[AvalancheVote(BLOCK_REJECTED, h) for h in various_block_hashes[3:6]] +
[AvalancheVote(BLOCK_UNKNOWN, h) for h in various_block_hashes[-3:]])
self.log.info("Trigger polling from the node...")
# duplicate the deterministic sig test from src/test/key_tests.cpp
privkey = ECKey()
privkey.set(bytes.fromhex(
"12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747"), True)
pubkey = privkey.get_pubkey()
privatekey = node.get_deterministic_priv_key().key
proof = node.buildavalancheproof(11, 12, pubkey.get_bytes().hex(), [{
'txid': "12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747",
'vout': 0,
'amount': 10,
'height': 100,
'privatekey': privatekey,
}])
# Activate the quorum.
for n in quorum:
success = node.addavalanchenode(
n.nodeid, pubkey.get_bytes().hex(), proof)
assert success is True
def can_find_block_in_poll(hash, resp=BLOCK_ACCEPTED):
found_hash = False
for n in quorum:
poll = n.get_avapoll_if_available()
# That node has not received a poll
if poll is None:
continue
# We got a poll, check for the hash and repond
votes = []
for inv in poll.invs:
# Vote yes to everything
r = BLOCK_ACCEPTED
# Look for what we expect
if inv.hash == hash:
r = resp
found_hash = True
votes.append(AvalancheVote(r, inv.hash))
n.send_avaresponse(poll.round, votes, privkey)
return found_hash
# Now that we have a peer, we should start polling for the tip.
hash_tip = int(node.getbestblockhash(), 16)
wait_until(lambda: can_find_block_in_poll(hash_tip), timeout=5)
# Make sure the fork node has synced the blocks
self.sync_blocks([node, fork_node])
# Create a fork 2 blocks deep. This should trigger polling.
fork_node.invalidateblock(fork_node.getblockhash(100))
fork_address = fork_node.get_deterministic_priv_key().address
fork_node.generatetoaddress(2, fork_address)
# Because the new tip is a deep reorg, the node will not accept it
# right away, but poll for it.
def parked_block(blockhash):
for tip in node.getchaintips():
if tip["hash"] == blockhash:
assert tip["status"] != "active"
return tip["status"] == "parked"
return False
fork_tip = fork_node.getbestblockhash()
wait_until(lambda: parked_block(fork_tip))
self.log.info("Answer all polls to finalize...")
hash_to_find = int(fork_tip, 16)
def has_accepted_new_tip():
can_find_block_in_poll(hash_to_find)
return node.getbestblockhash() == fork_tip
# Because everybody answers yes, the node will accept that block.
wait_until(has_accepted_new_tip, timeout=15)
assert_equal(node.getbestblockhash(), fork_tip)
self.log.info("Answer all polls to park...")
node.generate(1)
tip_to_park = node.getbestblockhash()
self.log.info(tip_to_park)
hash_to_find = int(tip_to_park, 16)
assert(tip_to_park != fork_tip)
def has_parked_new_tip():
can_find_block_in_poll(hash_to_find, BLOCK_REJECTED)
return node.getbestblockhash() == fork_tip
# Because everybody answers no, the node will park that block.
wait_until(has_parked_new_tip, timeout=15)
assert_equal(node.getbestblockhash(), fork_tip)
SIGHASH_ALL,
SIGHASH_ANYONECANPAY,
SIGHASH_LOTUS,
SIGHASH_NONE,
SIGHASH_SINGLE,
SIGHASH_FORKID,
SignatureHashLotus,
SignatureHashForkId,
TaggedHash,
)
from test_framework.test_framework import BitcoinTestFramework
PRIVATE_KEYS = []
PUBLIC_KEYS = []
for _ in range(18):
private_key = ECKey()
private_key.generate()
PRIVATE_KEYS.append(private_key.get_bytes())
PUBLIC_KEYS.append(private_key.get_pubkey().get_bytes())
script_checksig = dict(script_inputs=[],
script=[PUBLIC_KEYS[0], OP_CHECKSIG],
keys=[PRIVATE_KEYS[0]])
script_checksig_state = dict(
script_inputs=[],
script=[PUBLIC_KEYS[0][0], OP_SWAP, OP_CAT, OP_CHECKSIG],
keys=[PRIVATE_KEYS[0]],
state=PUBLIC_KEYS[0][1:])
def nth_script(n):
def run_test(self):
node = self.nodes[0] # convenience reference to the node
self.bootstrap_p2p() # Add one p2p connection to the node
self.block_heights = {}
self.coinbase_key = ECKey()
self.coinbase_key.generate()
self.coinbase_pubkey = self.coinbase_key.get_pubkey().get_bytes()
self.tip = None
self.blocks = {}
self.genesis_hash = int(self.nodes[0].getbestblockhash(), 16)
self.block_heights[self.genesis_hash] = 0
self.spendable_outputs = []
# Create a new block
b0 = self.next_block(0)
self.save_spendable_output()
self.send_blocks([b0])
# Allow the block to mature
blocks = []
for i in range(99):
blocks.append(self.next_block(5000 + i))
self.save_spendable_output()
self.send_blocks(blocks)
# collect spendable outputs now to avoid cluttering the code later on
out = []
for i in range(33):
out.append(self.get_spendable_output())
# Start by building a couple of blocks on top (which output is spent is
# in parentheses):
# genesis -> b1 (0) -> b2 (1)
b1 = self.next_block(1, spend=out[0])
self.save_spendable_output()
b2 = self.next_block(2, spend=out[1])
self.save_spendable_output()
self.send_blocks([b1, b2])
# Fork like this:
#
# genesis -> b1 (0) -> b2 (1)
# \-> b3 (1)
#
# Nothing should happen at this point. We saw b2 first so it takes
# priority.
self.log.info("Don't reorg to a chain of the same length")
self.move_tip(1)
b3 = self.next_block(3, spend=out[1])
txout_b3 = b3.vtx[1]
self.send_blocks([b3], False)
# Now we add another block to make the alternative chain longer.
#
# genesis -> b1 (0) -> b2 (1)
# \-> b3 (1) -> b4 (2)
self.log.info("Reorg to a longer chain")
b4 = self.next_block(4, spend=out[2])
self.send_blocks([b4])
# ... and back to the first chain.
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b3 (1) -> b4 (2)
self.move_tip(2)
b5 = self.next_block(5, spend=out[2])
self.save_spendable_output()
self.send_blocks([b5], False)
self.log.info("Reorg back to the original chain")
b6 = self.next_block(6, spend=out[3])
self.send_blocks([b6], True)
# Try to create a fork that double-spends
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b7 (2) -> b8 (4)
# \-> b3 (1) -> b4 (2)
self.log.info(
"Reject a chain with a double spend, even if it is longer")
self.move_tip(5)
b7 = self.next_block(7, spend=out[2])
self.send_blocks([b7], False)
b8 = self.next_block(8, spend=out[4])
self.send_blocks([b8], False, reconnect=True)
# Try to create a block that has too much fee
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b9 (4)
# \-> b3 (1) -> b4 (2)
self.log.info(
"Reject a block where the miner creates too much coinbase reward")
self.move_tip(6)
b9 = self.next_block(9, spend=out[4], additional_coinbase_value=1)
self.send_blocks([b9], success=False,
reject_reason='bad-cb-amount', reconnect=True)
# Create a fork that ends in a block with too much fee (the one that causes the reorg)
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b10 (3) -> b11 (4)
# \-> b3 (1) -> b4 (2)
self.log.info(
"Reject a chain where the miner creates too much coinbase reward, even if the chain is longer")
self.move_tip(5)
b10 = self.next_block(10, spend=out[3])
self.send_blocks([b10], False)
b11 = self.next_block(11, spend=out[4], additional_coinbase_value=1)
self.send_blocks([b11], success=False,
reject_reason='bad-cb-amount', reconnect=True)
# Try again, but with a valid fork first
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b14 (5)
# \-> b3 (1) -> b4 (2)
self.log.info(
"Reject a chain where the miner creates too much coinbase reward, even if the chain is longer (on a forked chain)")
self.move_tip(5)
b12 = self.next_block(12, spend=out[3])
self.save_spendable_output()
b13 = self.next_block(13, spend=out[4])
self.save_spendable_output()
b14 = self.next_block(14, spend=out[5], additional_coinbase_value=1)
self.send_blocks([b12, b13, b14], success=False,
reject_reason='bad-cb-amount', reconnect=True)
# New tip should be b13.
assert_equal(node.getbestblockhash(), b13.hash)
self.log.info("Skipped sigops tests")
# tests were moved to feature_block_sigops.py
self.move_tip(13)
b15 = self.next_block(15)
self.save_spendable_output()
self.send_blocks([b15], True)
# Attempt to spend a transaction created on a different fork
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b15 (5) -> b17 (b3.vtx[1])
# \-> b3 (1) -> b4 (2)
self.log.info("Reject a block with a spend from a re-org'ed out tx")
self.move_tip(15)
b17 = self.next_block(17, spend=txout_b3)
self.send_blocks([b17], success=False,
reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# Attempt to spend a transaction created on a different fork (on a fork this time)
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b15 (5)
# \-> b18 (b3.vtx[1]) -> b19 (6)
# \-> b3 (1) -> b4 (2)
self.log.info(
"Reject a block with a spend from a re-org'ed out tx (on a forked chain)")
self.move_tip(13)
b18 = self.next_block(18, spend=txout_b3)
self.send_blocks([b18], False)
b19 = self.next_block(19, spend=out[6])
self.send_blocks([b19], success=False,
reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# Attempt to spend a coinbase at depth too low
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b15 (5) -> b20 (7)
# \-> b3 (1) -> b4 (2)
self.log.info("Reject a block spending an immature coinbase.")
self.move_tip(15)
b20 = self.next_block(20, spend=out[7])
self.send_blocks([b20], success=False,
reject_reason='bad-txns-premature-spend-of-coinbase')
# Attempt to spend a coinbase at depth too low (on a fork this time)
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b15 (5)
# \-> b21 (6) -> b22 (5)
# \-> b3 (1) -> b4 (2)
self.log.info(
"Reject a block spending an immature coinbase (on a forked chain)")
self.move_tip(13)
b21 = self.next_block(21, spend=out[6])
self.send_blocks([b21], False)
b22 = self.next_block(22, spend=out[5])
self.send_blocks([b22], success=False,
reject_reason='bad-txns-premature-spend-of-coinbase')
# Create a block on either side of LEGACY_MAX_BLOCK_SIZE and make sure its accepted/rejected
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6)
# \-> b24 (6) -> b25 (7)
# \-> b3 (1) -> b4 (2)
self.log.info("Accept a block of size LEGACY_MAX_BLOCK_SIZE")
self.move_tip(15)
b23 = self.next_block(23, spend=out[6])
tx = CTransaction()
script_length = LEGACY_MAX_BLOCK_SIZE - len(b23.serialize()) - 69
script_output = CScript([b'\x00' * script_length])
tx.vout.append(CTxOut(0, script_output))
tx.vin.append(CTxIn(COutPoint(b23.vtx[1].sha256, 0)))
b23 = self.update_block(23, [tx])
# Make sure the math above worked out to produce a max-sized block
assert_equal(len(b23.serialize()), LEGACY_MAX_BLOCK_SIZE)
self.send_blocks([b23], True)
self.save_spendable_output()
# Create blocks with a coinbase input script size out of range
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6) -> b30 (7)
# \-> ... (6) -> ... (7)
# \-> b3 (1) -> b4 (2)
self.log.info(
"Reject a block with coinbase input script size out of range")
self.move_tip(15)
b26 = self.next_block(26, spend=out[6])
b26.vtx[0].vin[0].scriptSig = b'\x00'
b26.vtx[0].rehash()
# update_block causes the merkle root to get updated, even with no new
# transactions, and updates the required state.
b26 = self.update_block(26, [])
self.send_blocks([b26], success=False,
reject_reason='bad-cb-length', reconnect=True)
# Extend the b26 chain to make sure bitcoind isn't accepting b26
b27 = self.next_block(27, spend=out[7])
self.send_blocks([b27], False)
# Now try a too-large-coinbase script
self.move_tip(15)
b28 = self.next_block(28, spend=out[6])
b28.vtx[0].vin[0].scriptSig = b'\x00' * 101
b28.vtx[0].rehash()
b28 = self.update_block(28, [])
self.send_blocks([b28], success=False,
reject_reason='bad-cb-length', reconnect=True)
# Extend the b28 chain to make sure bitcoind isn't accepting b28
b29 = self.next_block(29, spend=out[7])
self.send_blocks([b29], False)
# b30 has a max-sized coinbase scriptSig.
self.move_tip(23)
b30 = self.next_block(30)
b30.vtx[0].vin[0].scriptSig = b'\x00' * 100
b30.vtx[0].rehash()
b30 = self.update_block(30, [])
self.send_blocks([b30], True)
self.save_spendable_output()
self.log.info("Skipped sigops tests")
# tests were moved to feature_block_sigops.py
b31 = self.next_block(31)
self.save_spendable_output()
b33 = self.next_block(33)
self.save_spendable_output()
b35 = self.next_block(35)
self.save_spendable_output()
self.send_blocks([b31, b33, b35], True)
# Check spending of a transaction in a block which failed to connect
#
# b6 (3)
# b12 (3) -> b13 (4) -> b15 (5) -> b23 (6) -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10)
# \-> b37 (11)
# \-> b38 (11/37)
#
# save 37's spendable output, but then double-spend out11 to invalidate
# the block
self.log.info(
"Reject a block spending transaction from a block which failed to connect")
self.move_tip(35)
b37 = self.next_block(37, spend=out[11])
txout_b37 = b37.vtx[1]
tx = self.create_and_sign_transaction(out[11], 0)
b37 = self.update_block(37, [tx])
self.send_blocks([b37], success=False,
reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# attempt to spend b37's first non-coinbase tx, at which point b37 was
# still considered valid
self.move_tip(35)
b38 = self.next_block(38, spend=txout_b37)
self.send_blocks([b38], success=False,
reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
self.log.info("Skipped sigops tests")
# tests were moved to feature_block_sigops.py
self.move_tip(35)
b39 = self.next_block(39)
self.save_spendable_output()
b41 = self.next_block(41)
self.send_blocks([b39, b41], True)
# Fork off of b39 to create a constant base again
#
# b23 (6) -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13)
# \-> b41 (12)
#
self.move_tip(39)
b42 = self.next_block(42, spend=out[12])
self.save_spendable_output()
b43 = self.next_block(43, spend=out[13])
self.save_spendable_output()
self.send_blocks([b42, b43], True)
# Test a number of really invalid scenarios
#
# -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b44 (14)
# \-> ??? (15)
# The next few blocks are going to be created "by hand" since they'll do funky things, such as having
# the first transaction be non-coinbase, etc. The purpose of b44 is to
# make sure this works.
self.log.info("Build block 44 manually")
height = self.block_heights[self.tip.sha256] + 1
coinbase = create_coinbase(height, self.coinbase_pubkey)
b44 = CBlock()
b44.nTime = self.tip.nTime + 1
b44.hashPrevBlock = self.tip.sha256
b44.nBits = 0x207fffff
b44.vtx.append(coinbase)
b44.hashMerkleRoot = b44.calc_merkle_root()
b44.solve()
self.tip = b44
self.block_heights[b44.sha256] = height
self.blocks[44] = b44
self.send_blocks([b44], True)
self.log.info("Reject a block with a non-coinbase as the first tx")
non_coinbase = self.create_tx(out[15], 0, 1)
b45 = CBlock()
b45.nTime = self.tip.nTime + 1
b45.hashPrevBlock = self.tip.sha256
b45.nBits = 0x207fffff
b45.vtx.append(non_coinbase)
b45.hashMerkleRoot = b45.calc_merkle_root()
b45.calc_sha256()
b45.solve()
self.block_heights[b45.sha256] = self.block_heights[
self.tip.sha256] + 1
self.tip = b45
self.blocks[45] = b45
self.send_blocks([b45], success=False,
reject_reason='bad-cb-missing', reconnect=True)
self.log.info("Reject a block with no transactions")
self.move_tip(44)
b46 = CBlock()
b46.nTime = b44.nTime + 1
b46.hashPrevBlock = b44.sha256
b46.nBits = 0x207fffff
b46.vtx = []
b46.hashMerkleRoot = 0
b46.solve()
self.block_heights[b46.sha256] = self.block_heights[b44.sha256] + 1
self.tip = b46
assert 46 not in self.blocks
self.blocks[46] = b46
self.send_blocks([b46], success=False,
reject_reason='bad-cb-missing', reconnect=True)
self.log.info("Reject a block with invalid work")
self.move_tip(44)
b47 = self.next_block(47, solve=False)
target = uint256_from_compact(b47.nBits)
while b47.sha256 < target:
b47.nNonce += 1
b47.rehash()
self.send_blocks([b47], False, request_block=False)
self.log.info("Reject a block with a timestamp >2 hours in the future")
self.move_tip(44)
b48 = self.next_block(48, solve=False)
b48.nTime = int(time.time()) + 60 * 60 * 3
b48.solve()
self.send_blocks([b48], False, request_block=False)
self.log.info("Reject a block with invalid merkle hash")
self.move_tip(44)
b49 = self.next_block(49)
b49.hashMerkleRoot += 1
b49.solve()
self.send_blocks([b49], success=False,
reject_reason='bad-txnmrklroot', reconnect=True)
self.log.info("Reject a block with incorrect POW limit")
self.move_tip(44)
b50 = self.next_block(50)
b50.nBits = b50.nBits - 1
b50.solve()
self.send_blocks([b50], False, request_block=False, reconnect=True)
self.log.info("Reject a block with two coinbase transactions")
self.move_tip(44)
b51 = self.next_block(51)
cb2 = create_coinbase(51, self.coinbase_pubkey)
b51 = self.update_block(51, [cb2])
self.send_blocks([b51], success=False,
reject_reason='bad-tx-coinbase', reconnect=True)
self.log.info("Reject a block with duplicate transactions")
self.move_tip(44)
b52 = self.next_block(52, spend=out[15])
b52 = self.update_block(52, [b52.vtx[1]])
self.send_blocks([b52], success=False,
reject_reason='tx-duplicate', reconnect=True)
# Test block timestamps
# -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15)
# \-> b54 (15)
#
self.move_tip(43)
b53 = self.next_block(53, spend=out[14])
self.send_blocks([b53], False)
self.save_spendable_output()
self.log.info("Reject a block with timestamp before MedianTimePast")
b54 = self.next_block(54, spend=out[15])
b54.nTime = b35.nTime - 1
b54.solve()
self.send_blocks([b54], False, request_block=False)
# valid timestamp
self.move_tip(53)
b55 = self.next_block(55, spend=out[15])
b55.nTime = b35.nTime
self.update_block(55, [])
self.send_blocks([b55], True)
self.save_spendable_output()
# Test Merkle tree malleability
#
# -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57p2 (16)
# \-> b57 (16)
# \-> b56p2 (16)
# \-> b56 (16)
#
# Merkle tree malleability (CVE-2012-2459): repeating sequences of transactions in a block without
# affecting the merkle root of a block, while still invalidating it.
# See: src/consensus/merkle.h
#
# b57 has three txns: coinbase, tx, tx1. The merkle root computation will duplicate tx.
# Result: OK
#
# b56 copies b57 but duplicates tx1 and does not recalculate the block hash. So it has a valid merkle
# root but duplicate transactions.
# Result: Fails
#
# b57p2 has six transactions in its merkle tree:
# - coinbase, tx, tx1, tx2, tx3, tx4
# Merkle root calculation will duplicate as necessary.
# Result: OK.
#
# b56p2 copies b57p2 but adds both tx3 and tx4. The purpose of the test is to make sure the code catches
# duplicate txns that are not next to one another with the "bad-txns-duplicate" error (which indicates
# that the error was caught early, avoiding a DOS vulnerability.)
# b57 - a good block with 2 txs, don't submit until end
self.move_tip(55)
b57 = self.next_block(57)
tx = self.create_and_sign_transaction(out[16], 1)
tx1 = self.create_tx(tx, 0, 1)
b57 = self.update_block(57, [tx, tx1])
# b56 - copy b57, add a duplicate tx
self.log.info(
"Reject a block with a duplicate transaction in the Merkle Tree (but with a valid Merkle Root)")
self.move_tip(55)
b56 = copy.deepcopy(b57)
self.blocks[56] = b56
assert_equal(len(b56.vtx), 3)
b56 = self.update_block(56, [b57.vtx[2]])
assert_equal(b56.hash, b57.hash)
self.send_blocks([b56], success=False,
reject_reason='bad-txns-duplicate', reconnect=True)
# b57p2 - a good block with 6 tx'es, don't submit until end
self.move_tip(55)
b57p2 = self.next_block("57p2")
tx = self.create_and_sign_transaction(out[16], 1)
tx1 = self.create_tx(tx, 0, 1)
tx2 = self.create_tx(tx1, 0, 1)
tx3 = self.create_tx(tx2, 0, 1)
tx4 = self.create_tx(tx3, 0, 1)
b57p2 = self.update_block("57p2", [tx, tx1, tx2, tx3, tx4])
# b56p2 - copy b57p2, duplicate two non-consecutive tx's
self.log.info(
"Reject a block with two duplicate transactions in the Merkle Tree (but with a valid Merkle Root)")
self.move_tip(55)
b56p2 = copy.deepcopy(b57p2)
self.blocks["b56p2"] = b56p2
assert_equal(len(b56p2.vtx), 6)
b56p2 = self.update_block("b56p2", b56p2.vtx[4:6], reorder=False)
assert_equal(b56p2.hash, b57p2.hash)
self.send_blocks([b56p2], success=False,
reject_reason='bad-txns-duplicate', reconnect=True)
self.move_tip("57p2")
self.send_blocks([b57p2], True)
self.move_tip(57)
# The tip is not updated because 57p2 seen first
self.send_blocks([b57], False)
self.save_spendable_output()
# Test a few invalid tx types
#
# -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
# \-> ??? (17)
#
# tx with prevout.n out of range
self.log.info(
"Reject a block with a transaction with prevout.n out of range")
self.move_tip(57)
b58 = self.next_block(58, spend=out[17])
tx = CTransaction()
assert(len(out[17].vout) < 42)
tx.vin.append(
CTxIn(COutPoint(out[17].sha256, 42), CScript([OP_TRUE]), 0xffffffff))
tx.vout.append(CTxOut(0, b""))
pad_tx(tx)
tx.calc_sha256()
b58 = self.update_block(58, [tx])
self.send_blocks([b58], success=False,
reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# tx with output value > input value
self.log.info(
"Reject a block with a transaction with outputs > inputs")
self.move_tip(57)
b59 = self.next_block(59)
tx = self.create_and_sign_transaction(out[17], 51 * COIN)
b59 = self.update_block(59, [tx])
self.send_blocks([b59], success=False,
reject_reason='bad-txns-in-belowout', reconnect=True)
# reset to good chain
self.move_tip(57)
b60 = self.next_block(60, spend=out[17])
self.send_blocks([b60], True)
self.save_spendable_output()
# Test BIP30
#
# -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
# \-> b61 (18)
#
# Blocks are not allowed to contain a transaction whose id matches that of an earlier,
# not-fully-spent transaction in the same chain. To test, make identical coinbases;
# the second one should be rejected.
#
self.log.info(
"Reject a block with a transaction with a duplicate hash of a previous transaction (BIP30)")
self.move_tip(60)
b61 = self.next_block(61, spend=out[18])
# Equalize the coinbases
b61.vtx[0].vin[0].scriptSig = b60.vtx[0].vin[0].scriptSig
b61.vtx[0].rehash()
b61 = self.update_block(61, [])
assert_equal(b60.vtx[0].serialize(), b61.vtx[0].serialize())
self.send_blocks([b61], success=False,
reject_reason='bad-txns-BIP30', reconnect=True)
# Test tx.isFinal is properly rejected (not an exhaustive tx.isFinal test, that should be in data-driven transaction tests)
#
# -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
# \-> b62 (18)
#
self.log.info(
"Reject a block with a transaction with a nonfinal locktime")
self.move_tip(60)
b62 = self.next_block(62)
tx = CTransaction()
tx.nLockTime = 0xffffffff # this locktime is non-final
# don't set nSequence
tx.vin.append(CTxIn(COutPoint(out[18].sha256, 0)))
tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
assert tx.vin[0].nSequence < 0xffffffff
tx.calc_sha256()
b62 = self.update_block(62, [tx])
self.send_blocks([b62], success=False,
reject_reason='bad-txns-nonfinal')
# Test a non-final coinbase is also rejected
#
# -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
# \-> b63 (-)
#
self.log.info(
"Reject a block with a coinbase transaction with a nonfinal locktime")
self.move_tip(60)
b63 = self.next_block(63)
b63.vtx[0].nLockTime = 0xffffffff
b63.vtx[0].vin[0].nSequence = 0xDEADBEEF
b63.vtx[0].rehash()
b63 = self.update_block(63, [])
self.send_blocks([b63], success=False,
reject_reason='bad-txns-nonfinal')
# This checks that a block with a bloated VARINT between the block_header and the array of tx such that
# the block is > LEGACY_MAX_BLOCK_SIZE with the bloated varint, but <= LEGACY_MAX_BLOCK_SIZE without the bloated varint,
# does not cause a subsequent, identical block with canonical encoding to be rejected. The test does not
# care whether the bloated block is accepted or rejected; it only cares that the second block is accepted.
#
# What matters is that the receiving node should not reject the bloated block, and then reject the canonical
# block on the basis that it's the same as an already-rejected block (which would be a consensus failure.)
#
# -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18)
# \
# b64a (18)
# b64a is a bloated block (non-canonical varint)
# b64 is a good block (same as b64 but w/ canonical varint)
#
self.log.info(
"Accept a valid block even if a bloated version of the block has previously been sent")
self.move_tip(60)
regular_block = self.next_block("64a", spend=out[18])
# make it a "broken_block," with non-canonical serialization
b64a = CBrokenBlock(regular_block)
b64a.initialize(regular_block)
self.blocks["64a"] = b64a
self.tip = b64a
tx = CTransaction()
# use canonical serialization to calculate size
script_length = LEGACY_MAX_BLOCK_SIZE - \
len(b64a.normal_serialize()) - 69
script_output = CScript([b'\x00' * script_length])
tx.vout.append(CTxOut(0, script_output))
tx.vin.append(CTxIn(COutPoint(b64a.vtx[1].sha256, 0)))
b64a = self.update_block("64a", [tx])
assert_equal(len(b64a.serialize()), LEGACY_MAX_BLOCK_SIZE + 8)
self.send_blocks([b64a], success=False,
reject_reason='non-canonical ReadCompactSize():')
# bitcoind doesn't disconnect us for sending a bloated block, but if we subsequently
# resend the header message, it won't send us the getdata message again. Just
# disconnect and reconnect and then call sync_blocks.
# TODO: improve this test to be less dependent on P2P DOS behaviour.
node.disconnect_p2ps()
self.reconnect_p2p()
self.move_tip(60)
b64 = CBlock(b64a)
b64.vtx = copy.deepcopy(b64a.vtx)
assert_equal(b64.hash, b64a.hash)
assert_equal(len(b64.serialize()), LEGACY_MAX_BLOCK_SIZE)
self.blocks[64] = b64
b64 = self.update_block(64, [])
self.send_blocks([b64], True)
self.save_spendable_output()
# Spend an output created in the block itself
#
# -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19)
#
self.log.info(
"Accept a block with a transaction spending an output created in the same block")
self.move_tip(64)
b65 = self.next_block(65)
tx1 = self.create_and_sign_transaction(out[19], out[19].vout[0].nValue)
tx2 = self.create_and_sign_transaction(tx1, 0)
b65 = self.update_block(65, [tx1, tx2])
self.send_blocks([b65], True)
self.save_spendable_output()
# Attempt to double-spend a transaction created in a block
#
# -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19)
# \-> b67 (20)
#
#
self.log.info(
"Reject a block with a transaction double spending a transaction created in the same block")
self.move_tip(65)
b67 = self.next_block(67)
tx1 = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue)
tx2 = self.create_and_sign_transaction(tx1, 1)
tx3 = self.create_and_sign_transaction(tx1, 2)
b67 = self.update_block(67, [tx1, tx2, tx3])
self.send_blocks([b67], success=False,
reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# More tests of block subsidy
#
# -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20)
# \-> b68 (20)
#
# b68 - coinbase with an extra 10 satoshis,
# creates a tx that has 9 satoshis from out[20] go to fees
# this fails because the coinbase is trying to claim 1 satoshi too much in fees
#
# b69 - coinbase with extra 10 satoshis, and a tx that gives a 10 satoshi fee
# this succeeds
#
self.log.info(
"Reject a block trying to claim too much subsidy in the coinbase transaction")
self.move_tip(65)
b68 = self.next_block(68, additional_coinbase_value=10)
tx = self.create_and_sign_transaction(
out[20], out[20].vout[0].nValue - 9)
b68 = self.update_block(68, [tx])
self.send_blocks([b68], success=False,
reject_reason='bad-cb-amount', reconnect=True)
self.log.info(
"Accept a block claiming the correct subsidy in the coinbase transaction")
self.move_tip(65)
b69 = self.next_block(69, additional_coinbase_value=10)
tx = self.create_and_sign_transaction(
out[20], out[20].vout[0].nValue - 10)
self.update_block(69, [tx])
self.send_blocks([b69], True)
self.save_spendable_output()
# Test spending the outpoint of a non-existent transaction
#
# -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20)
# \-> b70 (21)
#
self.log.info(
"Reject a block containing a transaction spending from a non-existent input")
self.move_tip(69)
b70 = self.next_block(70, spend=out[21])
bogus_tx = CTransaction()
bogus_tx.sha256 = uint256_from_str(
b"23c70ed7c0506e9178fc1a987f40a33946d4ad4c962b5ae3a52546da53af0c5c")
tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(bogus_tx.sha256, 0), b"", 0xffffffff))
tx.vout.append(CTxOut(1, b""))
pad_tx(tx)
b70 = self.update_block(70, [tx])
self.send_blocks([b70], success=False,
reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# Test accepting an invalid block which has the same hash as a valid one (via merkle tree tricks)
#
# -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20) -> b72 (21)
# \-> b71 (21)
#
# b72 is a good block.
# b71 is a copy of 72, but re-adds one of its transactions. However,
# it has the same hash as b72.
self.log.info(
"Reject a block containing a duplicate transaction but with the same Merkle root (Merkle tree malleability")
self.move_tip(69)
b72 = self.next_block(72)
tx1 = self.create_and_sign_transaction(out[21], 2)
tx2 = self.create_and_sign_transaction(tx1, 1)
b72 = self.update_block(72, [tx1, tx2]) # now tip is 72
b71 = copy.deepcopy(b72)
# add duplicate last transaction
b71.vtx.append(b72.vtx[-1])
# b71 builds off b69
self.block_heights[b71.sha256] = self.block_heights[b69.sha256] + 1
self.blocks[71] = b71
assert_equal(len(b71.vtx), 4)
assert_equal(len(b72.vtx), 3)
assert_equal(b72.sha256, b71.sha256)
self.move_tip(71)
self.send_blocks([b71], success=False,
reject_reason='bad-txns-duplicate', reconnect=True)
self.move_tip(72)
self.send_blocks([b72], True)
self.save_spendable_output()
self.log.info("Skipped sigops tests")
# tests were moved to feature_block_sigops.py
b75 = self.next_block(75)
self.save_spendable_output()
b76 = self.next_block(76)
self.save_spendable_output()
self.send_blocks([b75, b76], True)
# Test transaction resurrection
#
# -> b77 (24) -> b78 (25) -> b79 (26)
# \-> b80 (25) -> b81 (26) -> b82 (27)
#
# b78 creates a tx, which is spent in b79. After b82, both should be in mempool
#
# The tx'es must be unsigned and pass the node's mempool policy. It is unsigned for the
# rather obscure reason that the Python signature code does not distinguish between
# Low-S and High-S values (whereas the bitcoin code has custom code which does so);
# as a result of which, the odds are 50% that the python code will use the right
# value and the transaction will be accepted into the mempool. Until we modify the
# test framework to support low-S signing, we are out of luck.
#
# To get around this issue, we construct transactions which are not signed and which
# spend to OP_TRUE. If the standard-ness rules change, this test would need to be
# updated. (Perhaps to spend to a P2SH OP_TRUE script)
self.log.info("Test transaction resurrection during a re-org")
self.move_tip(76)
b77 = self.next_block(77)
tx77 = self.create_and_sign_transaction(out[24], 10 * COIN)
b77 = self.update_block(77, [tx77])
self.send_blocks([b77], True)
self.save_spendable_output()
b78 = self.next_block(78)
tx78 = self.create_tx(tx77, 0, 9 * COIN)
b78 = self.update_block(78, [tx78])
self.send_blocks([b78], True)
b79 = self.next_block(79)
tx79 = self.create_tx(tx78, 0, 8 * COIN)
b79 = self.update_block(79, [tx79])
self.send_blocks([b79], True)
# mempool should be empty
assert_equal(len(self.nodes[0].getrawmempool()), 0)
self.move_tip(77)
b80 = self.next_block(80, spend=out[25])
self.send_blocks([b80], False, request_block=False)
self.save_spendable_output()
b81 = self.next_block(81, spend=out[26])
# other chain is same length
self.send_blocks([b81], False, request_block=False)
self.save_spendable_output()
b82 = self.next_block(82, spend=out[27])
# now this chain is longer, triggers re-org
self.send_blocks([b82], True)
self.save_spendable_output()
# now check that tx78 and tx79 have been put back into the peer's
# mempool
mempool = self.nodes[0].getrawmempool()
assert_equal(len(mempool), 2)
assert tx78.hash in mempool
assert tx79.hash in mempool
# Test invalid opcodes in dead execution paths.
#
# -> b81 (26) -> b82 (27) -> b83 (28)
#
self.log.info(
"Accept a block with invalid opcodes in dead execution paths")
b83 = self.next_block(83)
op_codes = [OP_IF, OP_INVALIDOPCODE, OP_ELSE, OP_TRUE, OP_ENDIF]
script = CScript(op_codes)
tx1 = self.create_and_sign_transaction(
out[28], out[28].vout[0].nValue, script)
tx2 = self.create_and_sign_transaction(tx1, 0, CScript([OP_TRUE]))
tx2.vin[0].scriptSig = CScript([OP_FALSE])
tx2.rehash()
b83 = self.update_block(83, [tx1, tx2])
self.send_blocks([b83], True)
self.save_spendable_output()
# Reorg on/off blocks that have OP_RETURN in them (and try to spend them)
#
# -> b81 (26) -> b82 (27) -> b83 (28) -> b84 (29) -> b87 (30) -> b88 (31)
# \-> b85 (29) -> b86 (30) \-> b89a (32)
#
self.log.info("Test re-orging blocks with OP_RETURN in them")
b84 = self.next_block(84)
tx1 = self.create_tx(out[29], 0, 0, CScript([OP_RETURN]))
vout_offset = len(tx1.vout)
tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
tx1.calc_sha256()
self.sign_tx(tx1, out[29])
tx1.rehash()
tx2 = self.create_tx(tx1, vout_offset, 0, CScript([OP_RETURN]))
tx2.vout.append(CTxOut(0, CScript([OP_RETURN])))
tx3 = self.create_tx(tx1, vout_offset + 1, 0, CScript([OP_RETURN]))
tx3.vout.append(CTxOut(0, CScript([OP_TRUE])))
tx4 = self.create_tx(tx1, vout_offset + 2, 0, CScript([OP_TRUE]))
tx4.vout.append(CTxOut(0, CScript([OP_RETURN])))
tx5 = self.create_tx(tx1, vout_offset + 3, 0, CScript([OP_RETURN]))
b84 = self.update_block(84, [tx1, tx2, tx3, tx4, tx5])
self.send_blocks([b84], True)
self.save_spendable_output()
self.move_tip(83)
b85 = self.next_block(85, spend=out[29])
self.send_blocks([b85], False) # other chain is same length
b86 = self.next_block(86, spend=out[30])
self.send_blocks([b86], True)
self.move_tip(84)
b87 = self.next_block(87, spend=out[30])
self.send_blocks([b87], False) # other chain is same length
self.save_spendable_output()
b88 = self.next_block(88, spend=out[31])
self.send_blocks([b88], True)
self.save_spendable_output()
# trying to spend the OP_RETURN output is rejected
b89a = self.next_block("89a", spend=out[32])
tx = self.create_tx(tx1, 0, 0, CScript([OP_TRUE]))
b89a = self.update_block("89a", [tx])
self.send_blocks([b89a], success=False,
reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
self.log.info(
"Test a re-org of one week's worth of blocks (1088 blocks)")
self.move_tip(88)
LARGE_REORG_SIZE = 1088
blocks = []
spend = out[32]
for i in range(89, LARGE_REORG_SIZE + 89):
b = self.next_block(i, spend)
tx = CTransaction()
script_length = LEGACY_MAX_BLOCK_SIZE - len(b.serialize()) - 69
script_output = CScript([b'\x00' * script_length])
tx.vout.append(CTxOut(0, script_output))
tx.vin.append(CTxIn(COutPoint(b.vtx[1].sha256, 0)))
b = self.update_block(i, [tx])
assert_equal(len(b.serialize()), LEGACY_MAX_BLOCK_SIZE)
blocks.append(b)
self.save_spendable_output()
spend = self.get_spendable_output()
self.send_blocks(blocks, True, timeout=960)
chain1_tip = i
# now create alt chain of same length
self.move_tip(88)
blocks2 = []
for i in range(89, LARGE_REORG_SIZE + 89):
blocks2.append(self.next_block("alt" + str(i)))
self.send_blocks(blocks2, False, request_block=False)
# extend alt chain to trigger re-org
block = self.next_block("alt" + str(chain1_tip + 1))
self.send_blocks([block], True, timeout=960)
# ... and re-org back to the first chain
self.move_tip(chain1_tip)
block = self.next_block(chain1_tip + 1)
self.send_blocks([block], False, request_block=False)
block = self.next_block(chain1_tip + 2)
self.send_blocks([block], True, timeout=960)
# node2.generatetoaddress(250, node2_addr)
# node3.generate(2)
balance1 = node1.getbalance()
print('Balance node 1:', balance1)
# balance2 = node2.getbalance()
# print('Balance node 2:', balance2)
node1_priv = node1.dumpprivkey(node1_addr)
print("Node1 key base58: {}".format(node1_priv))
node1_key_bytes = base58.b58decode_check(node1_priv)[1:-1]
print("Node1 key: {}".format(node1_key_bytes.hex()))
node1_key = ECKey()
node1_key.set(node1_key_bytes, True)
# Spending key
key0 = ECKey()
key0.generate(compressed=True)
key0_bytes = b'\xef' + key0.get_bytes() + b'\x01'
key0_wif = str(base58.b58encode_check(key0_bytes), "ascii")
addr0 = key_to_p2pkh(key0.get_pubkey().get_bytes())
print("key0 bytes: {}".format(key0_bytes.hex()))
print("key0 WIF: {}".format(key0_wif))
print("addr0: {}".format(addr0))
def prepare_tx_signed_with_sighash(self, address_type,
sighash_rangeproof_aware,
attach_issuance):
# Create a tx that is signed with a specific version of the sighash
# method.
# If `sighash_rangeproof_aware` is
# true, the sighash will contain the rangeproofs if SIGHASH_RANGEPROOF is set
# false, the sighash will NOT contain the rangeproofs if SIGHASH_RANGEPROOF is set
addr = self.nodes[1].getnewaddress("", address_type)
assert len(self.nodes[1].getaddressinfo(addr)["confidential_key"]) > 0
self.nodes[0].sendtoaddress(addr, 1.0)
self.nodes[0].generate(1)
self.sync_all()
utxo = self.nodes[1].listunspent(1, 1, [addr])[0]
utxo_tx = FromHex(CTransaction(),
self.nodes[1].getrawtransaction(utxo["txid"]))
utxo_spk = CScript(hex_str_to_bytes(utxo["scriptPubKey"]))
utxo_value = utxo_tx.vout[utxo["vout"]].nValue
assert len(utxo["amountblinder"]) > 0
sink_addr = self.nodes[2].getnewaddress()
unsigned_hex = self.nodes[1].createrawtransaction([{
"txid": utxo["txid"],
"vout": utxo["vout"]
}], [{
sink_addr: 0.9
}, {
"fee": 0.1
}])
if attach_issuance:
# Attach a blinded issuance
unsigned_hex = self.nodes[1].rawissueasset(
unsigned_hex,
[{
"asset_amount": 100,
"asset_address": self.nodes[1].getnewaddress(),
"token_amount": 100,
"token_address": self.nodes[1].getnewaddress(),
"blind":
True, # FIXME: if blind=False, `blindrawtranaction` fails. Should fix this in a future PR
}])[0]["hex"]
blinded_hex = self.nodes[1].blindrawtransaction(unsigned_hex)
blinded_tx = FromHex(CTransaction(), blinded_hex)
signed_hex = self.nodes[1].signrawtransactionwithwallet(
blinded_hex)["hex"]
signed_tx = FromHex(CTransaction(), signed_hex)
# Make sure that the tx the node produced is always valid.
test_accept = self.nodes[0].testmempoolaccept([signed_hex])[0]
assert test_accept["allowed"], "not accepted: {}".format(
test_accept["reject-reason"])
# Prepare the keypair we need to re-sign the tx.
wif = self.nodes[1].dumpprivkey(addr)
(b, v) = base58_to_byte(wif)
privkey = ECKey()
privkey.set(b[0:32], len(b) == 33)
pubkey = privkey.get_pubkey()
# Now we need to replace the signature with an equivalent one with the new sighash set,
# which we do using the Python logic to detect any forking changes in the sighash format.
hashtype = SIGHASH_ALL | SIGHASH_RANGEPROOF
if address_type == "legacy":
if sighash_rangeproof_aware:
(sighash, _) = LegacySignatureHash(utxo_spk, blinded_tx, 0,
hashtype)
else:
(sighash,
_) = LegacySignatureHash(utxo_spk,
blinded_tx,
0,
hashtype,
enable_sighash_rangeproof=False)
signature = privkey.sign_ecdsa(sighash) + chr(hashtype).encode(
'latin-1')
assert len(signature) <= 0xfc
assert len(pubkey.get_bytes()) <= 0xfc
signed_tx.vin[0].scriptSig = CScript(
struct.pack("<B", len(signature)) + signature +
struct.pack("<B", len(pubkey.get_bytes())) +
pubkey.get_bytes())
elif address_type == "bech32" or address_type == "p2sh-segwit":
assert signed_tx.wit.vtxinwit[0].scriptWitness.stack[
1] == pubkey.get_bytes()
pubkeyhash = hash160(pubkey.get_bytes())
script = get_p2pkh_script(pubkeyhash)
if sighash_rangeproof_aware:
sighash = SegwitV0SignatureHash(script, blinded_tx, 0,
hashtype, utxo_value)
else:
sighash = SegwitV0SignatureHash(
script,
blinded_tx,
0,
hashtype,
utxo_value,
enable_sighash_rangeproof=False)
signature = privkey.sign_ecdsa(sighash) + chr(hashtype).encode(
'latin-1')
signed_tx.wit.vtxinwit[0].scriptWitness.stack[0] = signature
else:
assert False
# Make sure that the tx we manually signed is valid
signed_hex = signed_tx.serialize_with_witness().hex()
test_accept = self.nodes[0].testmempoolaccept([signed_hex])[0]
if sighash_rangeproof_aware:
assert test_accept["allowed"], "not accepted: {}".format(
test_accept["reject-reason"])
else:
assert not test_accept["allowed"], "tx was accepted"
if sighash_rangeproof_aware:
signed_hex = self.nodes[1].signrawtransactionwithwallet(
blinded_hex, [], "ALL|RANGEPROOF")["hex"]
signed_tx = FromHex(CTransaction(), signed_hex)
# Make sure that the tx that the node signed is valid
test_accept = self.nodes[0].testmempoolaccept([signed_hex])[0]
assert test_accept["allowed"], "not accepted: {}".format(
test_accept["reject-reason"])
# Try re-signing with node 0, which should have no effect since the transaction was already complete
signed_hex = self.nodes[0].signrawtransactionwithwallet(
signed_hex)["hex"]
test_accept = self.nodes[0].testmempoolaccept([signed_hex])[0]
assert test_accept["allowed"], "not accepted: {}".format(
test_accept["reject-reason"])
# Try signing using the PSBT interface
psbt_hex = self.nodes[0].converttopsbt(unsigned_hex)
signed_psbt = self.nodes[1].walletprocesspsbt(
psbt_hex, True, "ALL|RANGEPROOF")
extracted_tx = self.nodes[0].finalizepsbt(signed_psbt["psbt"])
assert extracted_tx["complete"]
test_accept = self.nodes[0].testmempoolaccept(
[extracted_tx["hex"]])[0]
assert test_accept["allowed"], "not accepted: {}".format(
test_accept["reject-reason"])
else:
signed_tx.rehash()
return signed_tx
def create_unsigned_pos_block(self,
staking_prevouts,
nTime=None,
outNValue=10002,
signStakeTx=True,
bestBlockHash=None,
coinStakePrevout=None):
if not nTime:
current_time = int(time.time()) + 15
nTime = current_time & 0xfffffff0
if not bestBlockHash:
bestBlockHash = self.node.getbestblockhash()
block_height = self.node.getblockcount()
else:
block_height = self.node.getblock(bestBlockHash)['height']
parent_block_stake_modifier = int(
self.node.getblock(bestBlockHash)['modifier'], 16)
parent_block_raw_hex = self.node.getblock(bestBlockHash, False)
f = io.BytesIO(hex_str_to_bytes(parent_block_raw_hex))
parent_block = CBlock()
parent_block.deserialize(f)
coinbase = create_coinbase(block_height + 1)
coinbase.vout[0].nValue = 0
coinbase.vout[0].scriptPubKey = b""
coinbase.rehash()
block = create_block(int(bestBlockHash, 16), coinbase, nTime)
block.hashPrevBlock = int(bestBlockHash, 16)
if not block.solve_stake(parent_block_stake_modifier,
staking_prevouts):
return None
# create a new private key used for block signing.
block_sig_key = ECKey()
block_sig_key.set(hash256(struct.pack('<I', 0)), False)
pubkey = block_sig_key.get_pubkey().get_bytes()
scriptPubKey = CScript([pubkey, OP_CHECKSIG])
stake_tx_unsigned = CTransaction()
if not coinStakePrevout:
coinStakePrevout = block.prevoutStake
stake_tx_unsigned.vin.append(CTxIn(coinStakePrevout))
stake_tx_unsigned.vout.append(CTxOut())
stake_tx_unsigned.vout.append(
CTxOut(int(outNValue * COIN), scriptPubKey))
stake_tx_unsigned.vout.append(
CTxOut(int(outNValue * COIN), scriptPubKey))
if signStakeTx:
stake_tx_signed_raw_hex = self.node.signrawtransactionwithwallet(
bytes_to_hex_str(stake_tx_unsigned.serialize()))['hex']
f = io.BytesIO(hex_str_to_bytes(stake_tx_signed_raw_hex))
stake_tx_signed = CTransaction()
stake_tx_signed.deserialize(f)
block.vtx.append(stake_tx_signed)
else:
block.vtx.append(stake_tx_unsigned)
block.hashMerkleRoot = block.calc_merkle_root()
return (block, block_sig_key)
def run_test(self):
# peers that we expect to be protected from eviction
protected_peers = set()
current_peer = -1
node = self.nodes[0]
blocks = node.generatetoaddress(
101,
node.get_deterministic_priv_key().address)
self.log.info(
"Create 4 peers and protect them from eviction by sending us a block"
)
for _ in range(4):
block_peer = node.add_p2p_connection(SlowP2PDataStore())
current_peer += 1
block_peer.sync_with_ping()
best_block = node.getbestblockhash()
tip = int(best_block, 16)
best_block_time = node.getblock(best_block)['time']
block = create_block(tip,
create_coinbase(node.getblockcount() + 1),
best_block_time + 1)
block.solve()
block_peer.send_blocks_and_test([block], node, success=True)
protected_peers.add(current_peer)
self.log.info(
"Create 4 peers and protect them from eviction by sending us a proof"
)
privkey = ECKey()
privkey.generate()
wif_privkey = bytes_to_wif(privkey.get_bytes())
pubkey = privkey.get_pubkey()
stakes = create_coinbase_stakes(node, blocks,
node.get_deterministic_priv_key().key)
for i in range(4):
proof_peer = node.add_p2p_connection(SlowP2PDataStore())
current_peer += 1
proof_peer.sync_with_ping()
proof = node.buildavalancheproof(42, 2000000000, wif_privkey,
[stakes[i]])
avaproof_msg = msg_avaproof()
avaproof_msg.proof = FromHex(LegacyAvalancheProof(), proof)
proof_peer.send_message(avaproof_msg)
protected_peers.add(current_peer)
self.log.info(
"Create 5 slow-pinging peers, making them eviction candidates")
for _ in range(5):
node.add_p2p_connection(SlowP2PInterface())
current_peer += 1
self.log.info(
"Create 4 peers and protect them from eviction by sending us a tx")
for i in range(4):
txpeer = node.add_p2p_connection(SlowP2PInterface())
current_peer += 1
txpeer.sync_with_ping()
prevtx = node.getblock(node.getblockhash(i + 1), 2)['tx'][0]
rawtx = node.createrawtransaction(
inputs=[{
'txid': prevtx['txid'],
'vout': 0
}],
outputs=[{
node.get_deterministic_priv_key().address:
50000000 - 1250.00
}],
)
sigtx = node.signrawtransactionwithkey(
hexstring=rawtx,
privkeys=[node.get_deterministic_priv_key().key],
prevtxs=[{
'txid':
prevtx['txid'],
'vout':
0,
'amount':
prevtx['vout'][0]['value'],
'scriptPubKey':
prevtx['vout'][0]['scriptPubKey']['hex'],
}],
)['hex']
txpeer.send_message(msg_tx(FromHex(CTransaction(), sigtx)))
protected_peers.add(current_peer)
self.log.info(
"Create 8 peers and protect them from eviction by having faster pings"
)
for _ in range(8):
fastpeer = node.add_p2p_connection(P2PInterface())
current_peer += 1
self.wait_until(lambda: "ping" in fastpeer.last_message,
timeout=10)
self.log.info(
"Create 128 peers and protect them from eviction by sending an avahello message"
)
proof = node.buildavalancheproof(42, 2000000000, wif_privkey,
[stakes[0]])
proof_obj = FromHex(LegacyAvalancheProof(), proof)
delegation = node.delegateavalancheproof(
f"{proof_obj.limited_proofid:064x}",
bytes_to_wif(privkey.get_bytes()),
pubkey.get_bytes().hex(),
)
for _ in range(128):
avapeer = node.add_p2p_connection(SlowAvaP2PInterface())
current_peer += 1
avapeer.sync_with_ping()
avapeer.send_avahello(delegation, privkey)
# Make sure by asking the node what the actual min pings are
peerinfo = node.getpeerinfo()
pings = {}
for i in range(len(peerinfo)):
pings[i] = peerinfo[i]['minping'] if 'minping' in peerinfo[
i] else 1000000
sorted_pings = sorted(pings.items(), key=lambda x: x[1])
# Usually the 8 fast peers are protected. In rare case of unreliable pings,
# one of the slower peers might have a faster min ping though.
for i in range(8):
protected_peers.add(sorted_pings[i][0])
self.log.info("Create peer that triggers the eviction mechanism")
node.add_p2p_connection(SlowP2PInterface())
# One of the non-protected peers must be evicted. We can't be sure which one because
# 4 peers are protected via netgroup, which is identical for all peers,
# and the eviction mechanism doesn't preserve the order of identical
# elements.
evicted_peers = []
for i in range(len(node.p2ps)):
if not node.p2ps[i].is_connected:
evicted_peers.append(i)
self.log.info("Test that one peer was evicted")
self.log.debug("{} evicted peer: {}".format(len(evicted_peers),
set(evicted_peers)))
assert_equal(len(evicted_peers), 1)
self.log.info("Test that no peer expected to be protected was evicted")
self.log.debug("{} protected peers: {}".format(len(protected_peers),
protected_peers))
assert evicted_peers[0] not in protected_peers
def run_test(self):
self.node = self.nodes[0]
privkey = byte_to_base58(hash256(struct.pack('<I', 0)), 239)
self.node.importprivkey(privkey)
self.bootstrap_p2p()
# returns a test case that asserts that the current tip was accepted
# First generate some blocks so we have some spendable coins
block_hashes = self.node.generatetoaddress(
100, "qSrM9K6FMhZ29Vkp8Rdk8Jp66bbfpjFETq")
for i in range(COINBASE_MATURITY):
self.tip = create_block(
int(self.node.getbestblockhash(), 16),
create_coinbase(self.node.getblockcount() + 1),
int(time.time()))
self.tip.solve()
self.sync_blocks([self.tip], success=True)
for _ in range(10):
self.node.sendtoaddress("qSrM9K6FMhZ29Vkp8Rdk8Jp66bbfpjFETq", 1000)
block_hashes += self.node.generatetoaddress(
1, "qSrM9K6FMhZ29Vkp8Rdk8Jp66bbfpjFETq")
blocks = []
for block_hash in block_hashes:
blocks.append(self.node.getblock(block_hash))
# These are our staking txs
self.staking_prevouts = []
self.bad_vout_staking_prevouts = []
self.bad_txid_staking_prevouts = []
self.unconfirmed_staking_prevouts = []
for unspent in self.node.listunspent():
for block in blocks:
if unspent['txid'] in block['tx']:
tx_block_time = block['time']
break
else:
assert (False)
if unspent['confirmations'] > COINBASE_MATURITY:
self.staking_prevouts.append(
(COutPoint(int(unspent['txid'], 16), unspent['vout']),
int(unspent['amount']) * COIN, tx_block_time))
self.bad_vout_staking_prevouts.append(
(COutPoint(int(unspent['txid'], 16), 0xff),
int(unspent['amount']) * COIN, tx_block_time))
self.bad_txid_staking_prevouts.append(
(COutPoint(int(unspent['txid'], 16) + 1, unspent['vout']),
int(unspent['amount']) * COIN, tx_block_time))
if unspent['confirmations'] < COINBASE_MATURITY:
self.unconfirmed_staking_prevouts.append(
(COutPoint(int(unspent['txid'], 16), unspent['vout']),
int(unspent['amount']) * COIN, tx_block_time))
# First let 25 seconds pass so that we do not submit blocks directly after the last one
#time.sleep(100)
block_count = self.node.getblockcount()
# 1 A block that does not have the correct timestamp mask
t = int(time.time()) | 1
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts,
nTime=t)
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip],
success=False,
force_send=True,
reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 2 A block that with a too high reward
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts,
outNValue=30006)
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 3 A block with an incorrect block sig
bad_key = ECKey()
bad_key.set(hash256(b'horse staple battery'), False)
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
self.tip.sign_block(bad_key)
self.tip.rehash()
self.sync_blocks([self.tip],
success=False,
reconnect=False,
force_send=True)
self._remove_from_staking_prevouts(self.tip)
# 4 A block that stakes with txs with too few confirmations
(self.tip, block_sig_key) = self.create_unsigned_pos_block(
self.unconfirmed_staking_prevouts)
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip],
success=False,
reconnect=True,
force_send=True)
self._remove_from_staking_prevouts(self.tip)
# 5 A block that with a coinbase reward
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
self.tip.vtx[0].vout[0].nValue = 1
self.tip.hashMerkleRoot = self.tip.calc_merkle_root()
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 6 A block that with no vout in the coinbase
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
self.tip.vtx[0].vout = []
self.tip.hashMerkleRoot = self.tip.calc_merkle_root()
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 7 A block way into the future
t = (int(time.time()) + 100) & 0xfffffff0
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts,
nTime=t)
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, force_send=True)
self._remove_from_staking_prevouts(self.tip)
# 8 No vout in the staking tx
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
self.tip.vtx[1].vout = []
self.tip.hashMerkleRoot = self.tip.calc_merkle_root()
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 9 Unsigned coinstake.
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts,
signStakeTx=False)
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False)
self._remove_from_staking_prevouts(self.tip)
# 10 A block without a coinstake tx.
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
self.tip.vtx.pop(-1)
self.tip.hashMerkleRoot = self.tip.calc_merkle_root()
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 11 A block without a coinbase.
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
self.tip.vtx.pop(0)
self.tip.hashMerkleRoot = self.tip.calc_merkle_root()
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 12 A block where the coinbase has no outputs
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
self.tip.vtx[0].vout = []
self.tip.hashMerkleRoot = self.tip.calc_merkle_root()
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 13 A block where the coinstake has no outputs
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
self.tip.vtx[1].vout.pop(-1)
self.tip.vtx[1].vout.pop(-1)
stake_tx_signed_raw_hex = self.node.signrawtransactionwithwallet(
bytes_to_hex_str(self.tip.vtx[1].serialize()))['hex']
f = io.BytesIO(hex_str_to_bytes(stake_tx_signed_raw_hex))
self.tip.vtx[1] = CTransaction()
self.tip.vtx[1].deserialize(f)
self.tip.hashMerkleRoot = self.tip.calc_merkle_root()
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 14 A block with an incorrect hashStateRoot
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
self.tip.hashStateRoot = 0xe
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 15 A block with an incorrect hashUTXORoot
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
self.tip.hashUTXORoot = 0xe
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 16 A block with an a signature on wrong header data
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
self.tip.sign_block(block_sig_key)
self.tip.nNonce = 0xfffe
self.tip.rehash()
self.sync_blocks([self.tip], success=False, force_send=True)
self._remove_from_staking_prevouts(self.tip)
# 17 A block with where the pubkey of the second output of the coinstake has been modified after block signing
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
scriptPubKey = self.tip.vtx[1].vout[1].scriptPubKey
# Modify a byte of the pubkey
self.tip.vtx[1].vout[
1].scriptPubKey = scriptPubKey[0:20] + bytes.fromhex(
hex(ord(scriptPubKey[20:21]) + 1)[2:4]) + scriptPubKey[21:]
assert_equal(len(scriptPubKey),
len(self.tip.vtx[1].vout[1].scriptPubKey))
stake_tx_signed_raw_hex = self.node.signrawtransactionwithwallet(
bytes_to_hex_str(self.tip.vtx[1].serialize()))['hex']
f = io.BytesIO(hex_str_to_bytes(stake_tx_signed_raw_hex))
self.tip.vtx[1] = CTransaction()
self.tip.vtx[1].deserialize(f)
self.tip.hashMerkleRoot = self.tip.calc_merkle_root()
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 18. A block in the past
t = (int(time.time()) - 700) & 0xfffffff0
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts,
nTime=t)
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, force_send=True)
self._remove_from_staking_prevouts(self.tip)
# 19. A block with too many coinbase vouts
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
self.tip.vtx[0].vout.append(CTxOut(0, CScript([OP_TRUE])))
self.tip.vtx[0].rehash()
self.tip.hashMerkleRoot = self.tip.calc_merkle_root()
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 20. A block where the coinstake's vin is not the prevout specified in the block
(self.tip, block_sig_key) = self.create_unsigned_pos_block(
self.staking_prevouts,
coinStakePrevout=self.staking_prevouts[-1][0])
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=False, reconnect=True)
self._remove_from_staking_prevouts(self.tip)
# 21. A block that stakes with valid txs but invalid vouts
(self.tip, block_sig_key) = self.create_unsigned_pos_block(
self.bad_vout_staking_prevouts)
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip],
success=False,
reconnect=False,
force_send=True)
self._remove_from_staking_prevouts(self.tip)
# 22. A block that stakes with txs that do not exist
(self.tip, block_sig_key) = self.create_unsigned_pos_block(
self.bad_txid_staking_prevouts)
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip],
success=False,
reconnect=True,
force_send=True)
self._remove_from_staking_prevouts(self.tip)
# Make sure for certain that no blocks were accepted. (This is also to make sure that no segfaults ocurred)
assert_equal(self.node.getblockcount(), block_count)
# And at last, make sure that a valid pos block is accepted
(self.tip,
block_sig_key) = self.create_unsigned_pos_block(self.staking_prevouts)
self.tip.sign_block(block_sig_key)
self.tip.rehash()
self.sync_blocks([self.tip], success=True)
assert_equal(self.node.getblockcount(), block_count + 1)
def run_test(self):
# Create and fund a raw tx for sending 10 BTC
psbtx1 = self.nodes[0].walletcreatefundedpsbt([], {self.nodes[2].getnewaddress():10})['psbt']
# If inputs are specified, do not automatically add more:
utxo1 = self.nodes[0].listunspent()[0]
assert_raises_rpc_error(-4, "Insufficient funds", self.nodes[0].walletcreatefundedpsbt, [{"txid": utxo1['txid'], "vout": utxo1['vout']}], {self.nodes[2].getnewaddress():90})
psbtx1 = self.nodes[0].walletcreatefundedpsbt([{"txid": utxo1['txid'], "vout": utxo1['vout']}], {self.nodes[2].getnewaddress():90}, 0, {"add_inputs": True})['psbt']
assert_equal(len(self.nodes[0].decodepsbt(psbtx1)['tx']['vin']), 2)
# Inputs argument can be null
self.nodes[0].walletcreatefundedpsbt(None, {self.nodes[2].getnewaddress():10})
# Node 1 should not be able to add anything to it but still return the psbtx same as before
psbtx = self.nodes[1].walletprocesspsbt(psbtx1)['psbt']
assert_equal(psbtx1, psbtx)
# Node 0 should not be able to sign the transaction with the wallet is locked
self.nodes[0].encryptwallet("password")
assert_raises_rpc_error(-13, "Please enter the wallet passphrase with walletpassphrase first", self.nodes[0].walletprocesspsbt, psbtx)
# Node 0 should be able to process without signing though
unsigned_tx = self.nodes[0].walletprocesspsbt(psbtx, False)
assert_equal(unsigned_tx['complete'], False)
self.nodes[0].walletpassphrase(passphrase="password", timeout=1000000)
# Sign the transaction and send
signed_tx = self.nodes[0].walletprocesspsbt(psbt=psbtx, finalize=False)['psbt']
finalized_tx = self.nodes[0].walletprocesspsbt(psbt=psbtx, finalize=True)['psbt']
assert signed_tx != finalized_tx
final_tx = self.nodes[0].finalizepsbt(signed_tx)['hex']
self.nodes[0].sendrawtransaction(final_tx)
# Manually selected inputs can be locked:
assert_equal(len(self.nodes[0].listlockunspent()), 0)
utxo1 = self.nodes[0].listunspent()[0]
psbtx1 = self.nodes[0].walletcreatefundedpsbt([{"txid": utxo1['txid'], "vout": utxo1['vout']}], {self.nodes[2].getnewaddress():1}, 0,{"lockUnspents": True})["psbt"]
assert_equal(len(self.nodes[0].listlockunspent()), 1)
# Locks are ignored for manually selected inputs
self.nodes[0].walletcreatefundedpsbt([{"txid": utxo1['txid'], "vout": utxo1['vout']}], {self.nodes[2].getnewaddress():1}, 0)
# Create p2sh, p2wpkh, and p2wsh addresses
pubkey0 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress())['pubkey']
pubkey1 = self.nodes[1].getaddressinfo(self.nodes[1].getnewaddress())['pubkey']
pubkey2 = self.nodes[2].getaddressinfo(self.nodes[2].getnewaddress())['pubkey']
# Setup watchonly wallets
self.nodes[2].createwallet(wallet_name='wmulti', disable_private_keys=True)
wmulti = self.nodes[2].get_wallet_rpc('wmulti')
# Create all the addresses
p2sh = wmulti.addmultisigaddress(2, [pubkey0, pubkey1, pubkey2], "", "legacy")['address']
p2wsh = wmulti.addmultisigaddress(2, [pubkey0, pubkey1, pubkey2], "", "bech32")['address']
p2sh_p2wsh = wmulti.addmultisigaddress(2, [pubkey0, pubkey1, pubkey2], "", "p2sh-segwit")['address']
if not self.options.descriptors:
wmulti.importaddress(p2sh)
wmulti.importaddress(p2wsh)
wmulti.importaddress(p2sh_p2wsh)
p2wpkh = self.nodes[1].getnewaddress("", "bech32")
p2pkh = self.nodes[1].getnewaddress("", "legacy")
p2sh_p2wpkh = self.nodes[1].getnewaddress("", "p2sh-segwit")
# fund those addresses
rawtx = self.nodes[0].createrawtransaction([], {p2sh:10, p2wsh:10, p2wpkh:10, p2sh_p2wsh:10, p2sh_p2wpkh:10, p2pkh:10})
rawtx = self.nodes[0].fundrawtransaction(rawtx, {"changePosition":3})
signed_tx = self.nodes[0].signrawtransactionwithwallet(rawtx['hex'])['hex']
txid = self.nodes[0].sendrawtransaction(signed_tx)
self.generate(self.nodes[0], 6)
# Find the output pos
p2sh_pos = -1
p2wsh_pos = -1
p2wpkh_pos = -1
p2pkh_pos = -1
p2sh_p2wsh_pos = -1
p2sh_p2wpkh_pos = -1
decoded = self.nodes[0].decoderawtransaction(signed_tx)
for out in decoded['vout']:
if out['scriptPubKey']['address'] == p2sh:
p2sh_pos = out['n']
elif out['scriptPubKey']['address'] == p2wsh:
p2wsh_pos = out['n']
elif out['scriptPubKey']['address'] == p2wpkh:
p2wpkh_pos = out['n']
elif out['scriptPubKey']['address'] == p2sh_p2wsh:
p2sh_p2wsh_pos = out['n']
elif out['scriptPubKey']['address'] == p2sh_p2wpkh:
p2sh_p2wpkh_pos = out['n']
elif out['scriptPubKey']['address'] == p2pkh:
p2pkh_pos = out['n']
inputs = [{"txid": txid, "vout": p2wpkh_pos}, {"txid": txid, "vout": p2sh_p2wpkh_pos}, {"txid": txid, "vout": p2pkh_pos}]
outputs = [{self.nodes[1].getnewaddress(): 29.99}]
# spend single key from node 1
created_psbt = self.nodes[1].walletcreatefundedpsbt(inputs, outputs)
walletprocesspsbt_out = self.nodes[1].walletprocesspsbt(created_psbt['psbt'])
# Make sure it has both types of UTXOs
decoded = self.nodes[1].decodepsbt(walletprocesspsbt_out['psbt'])
assert 'non_witness_utxo' in decoded['inputs'][0]
assert 'witness_utxo' in decoded['inputs'][0]
# Check decodepsbt fee calculation (input values shall only be counted once per UTXO)
assert_equal(decoded['fee'], created_psbt['fee'])
assert_equal(walletprocesspsbt_out['complete'], True)
self.nodes[1].sendrawtransaction(self.nodes[1].finalizepsbt(walletprocesspsbt_out['psbt'])['hex'])
self.log.info("Test walletcreatefundedpsbt fee rate of 10000 sat/vB and 0.1 BTC/kvB produces a total fee at or slightly below -maxtxfee (~0.05290000)")
res1 = self.nodes[1].walletcreatefundedpsbt(inputs, outputs, 0, {"fee_rate": 10000, "add_inputs": True})
assert_approx(res1["fee"], 0.055, 0.005)
res2 = self.nodes[1].walletcreatefundedpsbt(inputs, outputs, 0, {"feeRate": "0.1", "add_inputs": True})
assert_approx(res2["fee"], 0.055, 0.005)
self.log.info("Test min fee rate checks with walletcreatefundedpsbt are bypassed, e.g. a fee_rate under 1 sat/vB is allowed")
res3 = self.nodes[1].walletcreatefundedpsbt(inputs, outputs, 0, {"fee_rate": "0.999", "add_inputs": True})
assert_approx(res3["fee"], 0.00000381, 0.0000001)
res4 = self.nodes[1].walletcreatefundedpsbt(inputs, outputs, 0, {"feeRate": 0.00000999, "add_inputs": True})
assert_approx(res4["fee"], 0.00000381, 0.0000001)
self.log.info("Test min fee rate checks with walletcreatefundedpsbt are bypassed and that funding non-standard 'zero-fee' transactions is valid")
for param, zero_value in product(["fee_rate", "feeRate"], [0, 0.000, 0.00000000, "0", "0.000", "0.00000000"]):
assert_equal(0, self.nodes[1].walletcreatefundedpsbt(inputs, outputs, 0, {param: zero_value, "add_inputs": True})["fee"])
self.log.info("Test invalid fee rate settings")
for param, value in {("fee_rate", 100000), ("feeRate", 1)}:
assert_raises_rpc_error(-4, "Fee exceeds maximum configured by user (e.g. -maxtxfee, maxfeerate)",
self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {param: value, "add_inputs": True})
assert_raises_rpc_error(-3, "Amount out of range",
self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {param: -1, "add_inputs": True})
assert_raises_rpc_error(-3, "Amount is not a number or string",
self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {param: {"foo": "bar"}, "add_inputs": True})
# Test fee rate values that don't pass fixed-point parsing checks.
for invalid_value in ["", 0.000000001, 1e-09, 1.111111111, 1111111111111111, "31.999999999999999999999"]:
assert_raises_rpc_error(-3, "Invalid amount",
self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {param: invalid_value, "add_inputs": True})
# Test fee_rate values that cannot be represented in sat/vB.
for invalid_value in [0.0001, 0.00000001, 0.00099999, 31.99999999, "0.0001", "0.00000001", "0.00099999", "31.99999999"]:
assert_raises_rpc_error(-3, "Invalid amount",
self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"fee_rate": invalid_value, "add_inputs": True})
self.log.info("- raises RPC error if both feeRate and fee_rate are passed")
assert_raises_rpc_error(-8, "Cannot specify both fee_rate (sat/vB) and feeRate (BTC/kvB)",
self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"fee_rate": 0.1, "feeRate": 0.1, "add_inputs": True})
self.log.info("- raises RPC error if both feeRate and estimate_mode passed")
assert_raises_rpc_error(-8, "Cannot specify both estimate_mode and feeRate",
self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"estimate_mode": "economical", "feeRate": 0.1, "add_inputs": True})
for param in ["feeRate", "fee_rate"]:
self.log.info("- raises RPC error if both {} and conf_target are passed".format(param))
assert_raises_rpc_error(-8, "Cannot specify both conf_target and {}. Please provide either a confirmation "
"target in blocks for automatic fee estimation, or an explicit fee rate.".format(param),
self.nodes[1].walletcreatefundedpsbt ,inputs, outputs, 0, {param: 1, "conf_target": 1, "add_inputs": True})
self.log.info("- raises RPC error if both fee_rate and estimate_mode are passed")
assert_raises_rpc_error(-8, "Cannot specify both estimate_mode and fee_rate",
self.nodes[1].walletcreatefundedpsbt ,inputs, outputs, 0, {"fee_rate": 1, "estimate_mode": "economical", "add_inputs": True})
self.log.info("- raises RPC error with invalid estimate_mode settings")
for k, v in {"number": 42, "object": {"foo": "bar"}}.items():
assert_raises_rpc_error(-3, "Expected type string for estimate_mode, got {}".format(k),
self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"estimate_mode": v, "conf_target": 0.1, "add_inputs": True})
for mode in ["", "foo", Decimal("3.141592")]:
assert_raises_rpc_error(-8, 'Invalid estimate_mode parameter, must be one of: "unset", "economical", "conservative"',
self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"estimate_mode": mode, "conf_target": 0.1, "add_inputs": True})
self.log.info("- raises RPC error with invalid conf_target settings")
for mode in ["unset", "economical", "conservative"]:
self.log.debug("{}".format(mode))
for k, v in {"string": "", "object": {"foo": "bar"}}.items():
assert_raises_rpc_error(-3, "Expected type number for conf_target, got {}".format(k),
self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"estimate_mode": mode, "conf_target": v, "add_inputs": True})
for n in [-1, 0, 1009]:
assert_raises_rpc_error(-8, "Invalid conf_target, must be between 1 and 1008", # max value of 1008 per src/policy/fees.h
self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"estimate_mode": mode, "conf_target": n, "add_inputs": True})
self.log.info("Test walletcreatefundedpsbt with too-high fee rate produces total fee well above -maxtxfee and raises RPC error")
# previously this was silently capped at -maxtxfee
for bool_add, outputs_array in {True: outputs, False: [{self.nodes[1].getnewaddress(): 1}]}.items():
msg = "Fee exceeds maximum configured by user (e.g. -maxtxfee, maxfeerate)"
assert_raises_rpc_error(-4, msg, self.nodes[1].walletcreatefundedpsbt, inputs, outputs_array, 0, {"fee_rate": 1000000, "add_inputs": bool_add})
assert_raises_rpc_error(-4, msg, self.nodes[1].walletcreatefundedpsbt, inputs, outputs_array, 0, {"feeRate": 1, "add_inputs": bool_add})
self.log.info("Test various PSBT operations")
# partially sign multisig things with node 1
psbtx = wmulti.walletcreatefundedpsbt(inputs=[{"txid":txid,"vout":p2wsh_pos},{"txid":txid,"vout":p2sh_pos},{"txid":txid,"vout":p2sh_p2wsh_pos}], outputs={self.nodes[1].getnewaddress():29.99}, options={'changeAddress': self.nodes[1].getrawchangeaddress()})['psbt']
walletprocesspsbt_out = self.nodes[1].walletprocesspsbt(psbtx)
psbtx = walletprocesspsbt_out['psbt']
assert_equal(walletprocesspsbt_out['complete'], False)
# Unload wmulti, we don't need it anymore
wmulti.unloadwallet()
# partially sign with node 2. This should be complete and sendable
walletprocesspsbt_out = self.nodes[2].walletprocesspsbt(psbtx)
assert_equal(walletprocesspsbt_out['complete'], True)
self.nodes[2].sendrawtransaction(self.nodes[2].finalizepsbt(walletprocesspsbt_out['psbt'])['hex'])
# check that walletprocesspsbt fails to decode a non-psbt
rawtx = self.nodes[1].createrawtransaction([{"txid":txid,"vout":p2wpkh_pos}], {self.nodes[1].getnewaddress():9.99})
assert_raises_rpc_error(-22, "TX decode failed", self.nodes[1].walletprocesspsbt, rawtx)
# Convert a non-psbt to psbt and make sure we can decode it
rawtx = self.nodes[0].createrawtransaction([], {self.nodes[1].getnewaddress():10})
rawtx = self.nodes[0].fundrawtransaction(rawtx)
new_psbt = self.nodes[0].converttopsbt(rawtx['hex'])
self.nodes[0].decodepsbt(new_psbt)
# Make sure that a non-psbt with signatures cannot be converted
# Error could be either "TX decode failed" (segwit inputs causes parsing to fail) or "Inputs must not have scriptSigs and scriptWitnesses"
# We must set iswitness=True because the serialized transaction has inputs and is therefore a witness transaction
signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx['hex'])
assert_raises_rpc_error(-22, "", self.nodes[0].converttopsbt, hexstring=signedtx['hex'], iswitness=True)
assert_raises_rpc_error(-22, "", self.nodes[0].converttopsbt, hexstring=signedtx['hex'], permitsigdata=False, iswitness=True)
# Unless we allow it to convert and strip signatures
self.nodes[0].converttopsbt(signedtx['hex'], True)
# Explicitly allow converting non-empty txs
new_psbt = self.nodes[0].converttopsbt(rawtx['hex'])
self.nodes[0].decodepsbt(new_psbt)
# Create outputs to nodes 1 and 2
node1_addr = self.nodes[1].getnewaddress()
node2_addr = self.nodes[2].getnewaddress()
txid1 = self.nodes[0].sendtoaddress(node1_addr, 13)
txid2 = self.nodes[0].sendtoaddress(node2_addr, 13)
blockhash = self.generate(self.nodes[0], 6)[0]
vout1 = find_output(self.nodes[1], txid1, 13, blockhash=blockhash)
vout2 = find_output(self.nodes[2], txid2, 13, blockhash=blockhash)
# Create a psbt spending outputs from nodes 1 and 2
psbt_orig = self.nodes[0].createpsbt([{"txid":txid1, "vout":vout1}, {"txid":txid2, "vout":vout2}], {self.nodes[0].getnewaddress():25.999})
# Update psbts, should only have data for one input and not the other
psbt1 = self.nodes[1].walletprocesspsbt(psbt_orig, False, "ALL")['psbt']
psbt1_decoded = self.nodes[0].decodepsbt(psbt1)
assert psbt1_decoded['inputs'][0] and not psbt1_decoded['inputs'][1]
# Check that BIP32 path was added
assert "bip32_derivs" in psbt1_decoded['inputs'][0]
psbt2 = self.nodes[2].walletprocesspsbt(psbt_orig, False, "ALL", False)['psbt']
psbt2_decoded = self.nodes[0].decodepsbt(psbt2)
assert not psbt2_decoded['inputs'][0] and psbt2_decoded['inputs'][1]
# Check that BIP32 paths were not added
assert "bip32_derivs" not in psbt2_decoded['inputs'][1]
# Sign PSBTs (workaround issue #18039)
psbt1 = self.nodes[1].walletprocesspsbt(psbt_orig)['psbt']
psbt2 = self.nodes[2].walletprocesspsbt(psbt_orig)['psbt']
# Combine, finalize, and send the psbts
combined = self.nodes[0].combinepsbt([psbt1, psbt2])
finalized = self.nodes[0].finalizepsbt(combined)['hex']
self.nodes[0].sendrawtransaction(finalized)
self.generate(self.nodes[0], 6)
# Test additional args in walletcreatepsbt
# Make sure both pre-included and funded inputs
# have the correct sequence numbers based on
# replaceable arg
block_height = self.nodes[0].getblockcount()
unspent = self.nodes[0].listunspent()[0]
psbtx_info = self.nodes[0].walletcreatefundedpsbt([{"txid":unspent["txid"], "vout":unspent["vout"]}], [{self.nodes[2].getnewaddress():unspent["amount"]+1}], block_height+2, {"replaceable": False, "add_inputs": True}, False)
decoded_psbt = self.nodes[0].decodepsbt(psbtx_info["psbt"])
for tx_in, psbt_in in zip(decoded_psbt["tx"]["vin"], decoded_psbt["inputs"]):
assert_greater_than(tx_in["sequence"], MAX_BIP125_RBF_SEQUENCE)
assert "bip32_derivs" not in psbt_in
assert_equal(decoded_psbt["tx"]["locktime"], block_height+2)
# Same construction with only locktime set and RBF explicitly enabled
psbtx_info = self.nodes[0].walletcreatefundedpsbt([{"txid":unspent["txid"], "vout":unspent["vout"]}], [{self.nodes[2].getnewaddress():unspent["amount"]+1}], block_height, {"replaceable": True, "add_inputs": True}, True)
decoded_psbt = self.nodes[0].decodepsbt(psbtx_info["psbt"])
for tx_in, psbt_in in zip(decoded_psbt["tx"]["vin"], decoded_psbt["inputs"]):
assert_equal(tx_in["sequence"], MAX_BIP125_RBF_SEQUENCE)
assert "bip32_derivs" in psbt_in
assert_equal(decoded_psbt["tx"]["locktime"], block_height)
# Same construction without optional arguments
psbtx_info = self.nodes[0].walletcreatefundedpsbt([], [{self.nodes[2].getnewaddress():unspent["amount"]+1}])
decoded_psbt = self.nodes[0].decodepsbt(psbtx_info["psbt"])
for tx_in, psbt_in in zip(decoded_psbt["tx"]["vin"], decoded_psbt["inputs"]):
assert_equal(tx_in["sequence"], MAX_BIP125_RBF_SEQUENCE)
assert "bip32_derivs" in psbt_in
assert_equal(decoded_psbt["tx"]["locktime"], 0)
# Same construction without optional arguments, for a node with -walletrbf=0
unspent1 = self.nodes[1].listunspent()[0]
psbtx_info = self.nodes[1].walletcreatefundedpsbt([{"txid":unspent1["txid"], "vout":unspent1["vout"]}], [{self.nodes[2].getnewaddress():unspent1["amount"]+1}], block_height, {"add_inputs": True})
decoded_psbt = self.nodes[1].decodepsbt(psbtx_info["psbt"])
for tx_in, psbt_in in zip(decoded_psbt["tx"]["vin"], decoded_psbt["inputs"]):
assert_greater_than(tx_in["sequence"], MAX_BIP125_RBF_SEQUENCE)
assert "bip32_derivs" in psbt_in
# Make sure change address wallet does not have P2SH innerscript access to results in success
# when attempting BnB coin selection
self.nodes[0].walletcreatefundedpsbt([], [{self.nodes[2].getnewaddress():unspent["amount"]+1}], block_height+2, {"changeAddress":self.nodes[1].getnewaddress()}, False)
# Make sure the wallet's change type is respected by default
small_output = {self.nodes[0].getnewaddress():0.1}
psbtx_native = self.nodes[0].walletcreatefundedpsbt([], [small_output])
self.assert_change_type(psbtx_native, "witness_v0_keyhash")
psbtx_legacy = self.nodes[1].walletcreatefundedpsbt([], [small_output])
self.assert_change_type(psbtx_legacy, "pubkeyhash")
# Make sure the change type of the wallet can also be overwritten
psbtx_np2wkh = self.nodes[1].walletcreatefundedpsbt([], [small_output], 0, {"change_type":"p2sh-segwit"})
self.assert_change_type(psbtx_np2wkh, "scripthash")
# Make sure the change type cannot be specified if a change address is given
invalid_options = {"change_type":"legacy","changeAddress":self.nodes[0].getnewaddress()}
assert_raises_rpc_error(-8, "both change address and address type options", self.nodes[0].walletcreatefundedpsbt, [], [small_output], 0, invalid_options)
# Regression test for 14473 (mishandling of already-signed witness transaction):
psbtx_info = self.nodes[0].walletcreatefundedpsbt([{"txid":unspent["txid"], "vout":unspent["vout"]}], [{self.nodes[2].getnewaddress():unspent["amount"]+1}], 0, {"add_inputs": True})
complete_psbt = self.nodes[0].walletprocesspsbt(psbtx_info["psbt"])
double_processed_psbt = self.nodes[0].walletprocesspsbt(complete_psbt["psbt"])
assert_equal(complete_psbt, double_processed_psbt)
# We don't care about the decode result, but decoding must succeed.
self.nodes[0].decodepsbt(double_processed_psbt["psbt"])
# Make sure unsafe inputs are included if specified
self.nodes[2].createwallet(wallet_name="unsafe")
wunsafe = self.nodes[2].get_wallet_rpc("unsafe")
self.nodes[0].sendtoaddress(wunsafe.getnewaddress(), 2)
self.sync_mempools()
assert_raises_rpc_error(-4, "Insufficient funds", wunsafe.walletcreatefundedpsbt, [], [{self.nodes[0].getnewaddress(): 1}])
wunsafe.walletcreatefundedpsbt([], [{self.nodes[0].getnewaddress(): 1}], 0, {"include_unsafe": True})
# BIP 174 Test Vectors
# Check that unknown values are just passed through
unknown_psbt = "cHNidP8BAD8CAAAAAf//////////////////////////////////////////AAAAAAD/////AQAAAAAAAAAAA2oBAAAAAAAACg8BAgMEBQYHCAkPAQIDBAUGBwgJCgsMDQ4PAAA="
unknown_out = self.nodes[0].walletprocesspsbt(unknown_psbt)['psbt']
assert_equal(unknown_psbt, unknown_out)
# Open the data file
with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'data/rpc_psbt.json'), encoding='utf-8') as f:
d = json.load(f)
invalids = d['invalid']
valids = d['valid']
creators = d['creator']
signers = d['signer']
combiners = d['combiner']
finalizers = d['finalizer']
extractors = d['extractor']
# Invalid PSBTs
for invalid in invalids:
assert_raises_rpc_error(-22, "TX decode failed", self.nodes[0].decodepsbt, invalid)
# Valid PSBTs
for valid in valids:
self.nodes[0].decodepsbt(valid)
# Creator Tests
for creator in creators:
created_tx = self.nodes[0].createpsbt(creator['inputs'], creator['outputs'])
assert_equal(created_tx, creator['result'])
# Signer tests
for i, signer in enumerate(signers):
self.nodes[2].createwallet(wallet_name="wallet{}".format(i))
wrpc = self.nodes[2].get_wallet_rpc("wallet{}".format(i))
for key in signer['privkeys']:
wrpc.importprivkey(key)
signed_tx = wrpc.walletprocesspsbt(signer['psbt'], True, "ALL")['psbt']
assert_equal(signed_tx, signer['result'])
# Combiner test
for combiner in combiners:
combined = self.nodes[2].combinepsbt(combiner['combine'])
assert_equal(combined, combiner['result'])
# Empty combiner test
assert_raises_rpc_error(-8, "Parameter 'txs' cannot be empty", self.nodes[0].combinepsbt, [])
# Finalizer test
for finalizer in finalizers:
finalized = self.nodes[2].finalizepsbt(finalizer['finalize'], False)['psbt']
assert_equal(finalized, finalizer['result'])
# Extractor test
for extractor in extractors:
extracted = self.nodes[2].finalizepsbt(extractor['extract'], True)['hex']
assert_equal(extracted, extractor['result'])
# Unload extra wallets
for i, signer in enumerate(signers):
self.nodes[2].unloadwallet("wallet{}".format(i))
# TODO: Re-enable this for segwit v1
# self.test_utxo_conversion()
# Test that psbts with p2pkh outputs are created properly
p2pkh = self.nodes[0].getnewaddress(address_type='legacy')
psbt = self.nodes[1].walletcreatefundedpsbt([], [{p2pkh : 1}], 0, {"includeWatching" : True}, True)
self.nodes[0].decodepsbt(psbt['psbt'])
# Test decoding error: invalid base64
assert_raises_rpc_error(-22, "TX decode failed invalid base64", self.nodes[0].decodepsbt, ";definitely not base64;")
# Send to all types of addresses
addr1 = self.nodes[1].getnewaddress("", "bech32")
txid1 = self.nodes[0].sendtoaddress(addr1, 11)
vout1 = find_output(self.nodes[0], txid1, 11)
addr2 = self.nodes[1].getnewaddress("", "legacy")
txid2 = self.nodes[0].sendtoaddress(addr2, 11)
vout2 = find_output(self.nodes[0], txid2, 11)
addr3 = self.nodes[1].getnewaddress("", "p2sh-segwit")
txid3 = self.nodes[0].sendtoaddress(addr3, 11)
vout3 = find_output(self.nodes[0], txid3, 11)
self.sync_all()
def test_psbt_input_keys(psbt_input, keys):
"""Check that the psbt input has only the expected keys."""
assert_equal(set(keys), set(psbt_input.keys()))
# Create a PSBT. None of the inputs are filled initially
psbt = self.nodes[1].createpsbt([{"txid":txid1, "vout":vout1},{"txid":txid2, "vout":vout2},{"txid":txid3, "vout":vout3}], {self.nodes[0].getnewaddress():32.999})
decoded = self.nodes[1].decodepsbt(psbt)
test_psbt_input_keys(decoded['inputs'][0], [])
test_psbt_input_keys(decoded['inputs'][1], [])
test_psbt_input_keys(decoded['inputs'][2], [])
# Update a PSBT with UTXOs from the node
# Bech32 inputs should be filled with witness UTXO. Other inputs should not be filled because they are non-witness
updated = self.nodes[1].utxoupdatepsbt(psbt)
decoded = self.nodes[1].decodepsbt(updated)
test_psbt_input_keys(decoded['inputs'][0], ['witness_utxo'])
test_psbt_input_keys(decoded['inputs'][1], [])
test_psbt_input_keys(decoded['inputs'][2], [])
# Try again, now while providing descriptors, making P2SH-segwit work, and causing bip32_derivs and redeem_script to be filled in
descs = [self.nodes[1].getaddressinfo(addr)['desc'] for addr in [addr1,addr2,addr3]]
updated = self.nodes[1].utxoupdatepsbt(psbt=psbt, descriptors=descs)
decoded = self.nodes[1].decodepsbt(updated)
test_psbt_input_keys(decoded['inputs'][0], ['witness_utxo', 'bip32_derivs'])
test_psbt_input_keys(decoded['inputs'][1], [])
test_psbt_input_keys(decoded['inputs'][2], ['witness_utxo', 'bip32_derivs', 'redeem_script'])
# Two PSBTs with a common input should not be joinable
psbt1 = self.nodes[1].createpsbt([{"txid":txid1, "vout":vout1}], {self.nodes[0].getnewaddress():Decimal('10.999')})
assert_raises_rpc_error(-8, "exists in multiple PSBTs", self.nodes[1].joinpsbts, [psbt1, updated])
# Join two distinct PSBTs
addr4 = self.nodes[1].getnewaddress("", "p2sh-segwit")
txid4 = self.nodes[0].sendtoaddress(addr4, 5)
vout4 = find_output(self.nodes[0], txid4, 5)
self.generate(self.nodes[0], 6)
psbt2 = self.nodes[1].createpsbt([{"txid":txid4, "vout":vout4}], {self.nodes[0].getnewaddress():Decimal('4.999')})
psbt2 = self.nodes[1].walletprocesspsbt(psbt2)['psbt']
psbt2_decoded = self.nodes[0].decodepsbt(psbt2)
assert "final_scriptwitness" in psbt2_decoded['inputs'][0] and "final_scriptSig" in psbt2_decoded['inputs'][0]
joined = self.nodes[0].joinpsbts([psbt, psbt2])
joined_decoded = self.nodes[0].decodepsbt(joined)
assert len(joined_decoded['inputs']) == 4 and len(joined_decoded['outputs']) == 2 and "final_scriptwitness" not in joined_decoded['inputs'][3] and "final_scriptSig" not in joined_decoded['inputs'][3]
# Check that joining shuffles the inputs and outputs
# 10 attempts should be enough to get a shuffled join
shuffled = False
for _ in range(10):
shuffled_joined = self.nodes[0].joinpsbts([psbt, psbt2])
shuffled |= joined != shuffled_joined
if shuffled:
break
assert shuffled
# Newly created PSBT needs UTXOs and updating
addr = self.nodes[1].getnewaddress("", "p2sh-segwit")
txid = self.nodes[0].sendtoaddress(addr, 7)
addrinfo = self.nodes[1].getaddressinfo(addr)
blockhash = self.generate(self.nodes[0], 6)[0]
vout = find_output(self.nodes[0], txid, 7, blockhash=blockhash)
psbt = self.nodes[1].createpsbt([{"txid":txid, "vout":vout}], {self.nodes[0].getnewaddress("", "p2sh-segwit"):Decimal('6.999')})
analyzed = self.nodes[0].analyzepsbt(psbt)
assert not analyzed['inputs'][0]['has_utxo'] and not analyzed['inputs'][0]['is_final'] and analyzed['inputs'][0]['next'] == 'updater' and analyzed['next'] == 'updater'
# After update with wallet, only needs signing
updated = self.nodes[1].walletprocesspsbt(psbt, False, 'ALL', True)['psbt']
analyzed = self.nodes[0].analyzepsbt(updated)
assert analyzed['inputs'][0]['has_utxo'] and not analyzed['inputs'][0]['is_final'] and analyzed['inputs'][0]['next'] == 'signer' and analyzed['next'] == 'signer' and analyzed['inputs'][0]['missing']['signatures'][0] == addrinfo['embedded']['witness_program']
# Check fee and size things
assert analyzed['fee'] == Decimal('0.001') and analyzed['estimated_vsize'] == 134 and analyzed['estimated_feerate'] == Decimal('0.00746268')
# After signing and finalizing, needs extracting
signed = self.nodes[1].walletprocesspsbt(updated)['psbt']
analyzed = self.nodes[0].analyzepsbt(signed)
assert analyzed['inputs'][0]['has_utxo'] and analyzed['inputs'][0]['is_final'] and analyzed['next'] == 'extractor'
self.log.info("PSBT spending unspendable outputs should have error message and Creator as next")
analysis = self.nodes[0].analyzepsbt('cHNidP8BAJoCAAAAAljoeiG1ba8MI76OcHBFbDNvfLqlyHV5JPVFiHuyq911AAAAAAD/////g40EJ9DsZQpoqka7CwmK6kQiwHGyyng1Kgd5WdB86h0BAAAAAP////8CcKrwCAAAAAAWAEHYXCtx0AYLCcmIauuBXlCZHdoSTQDh9QUAAAAAFv8/wADXYP/7//////8JxOh0LR2HAI8AAAAAAAEBIADC6wsAAAAAF2oUt/X69ELjeX2nTof+fZ10l+OyAokDAQcJAwEHEAABAACAAAEBIADC6wsAAAAAF2oUt/X69ELjeX2nTof+fZ10l+OyAokDAQcJAwEHENkMak8AAAAA')
assert_equal(analysis['next'], 'creator')
assert_equal(analysis['error'], 'PSBT is not valid. Input 0 spends unspendable output')
self.log.info("PSBT with invalid values should have error message and Creator as next")
analysis = self.nodes[0].analyzepsbt('cHNidP8BAHECAAAAAfA00BFgAm6tp86RowwH6BMImQNL5zXUcTT97XoLGz0BAAAAAAD/////AgD5ApUAAAAAFgAUKNw0x8HRctAgmvoevm4u1SbN7XL87QKVAAAAABYAFPck4gF7iL4NL4wtfRAKgQbghiTUAAAAAAABAR8AgIFq49AHABYAFJUDtxf2PHo641HEOBOAIvFMNTr2AAAA')
assert_equal(analysis['next'], 'creator')
assert_equal(analysis['error'], 'PSBT is not valid. Input 0 has invalid value')
self.log.info("PSBT with signed, but not finalized, inputs should have Finalizer as next")
analysis = self.nodes[0].analyzepsbt('cHNidP8BAHECAAAAAZYezcxdnbXoQCmrD79t/LzDgtUo9ERqixk8wgioAobrAAAAAAD9////AlDDAAAAAAAAFgAUy/UxxZuzZswcmFnN/E9DGSiHLUsuGPUFAAAAABYAFLsH5o0R38wXx+X2cCosTMCZnQ4baAAAAAABAR8A4fUFAAAAABYAFOBI2h5thf3+Lflb2LGCsVSZwsltIgIC/i4dtVARCRWtROG0HHoGcaVklzJUcwo5homgGkSNAnJHMEQCIGx7zKcMIGr7cEES9BR4Kdt/pzPTK3fKWcGyCJXb7MVnAiALOBgqlMH4GbC1HDh/HmylmO54fyEy4lKde7/BT/PWxwEBAwQBAAAAIgYC/i4dtVARCRWtROG0HHoGcaVklzJUcwo5homgGkSNAnIYDwVpQ1QAAIABAACAAAAAgAAAAAAAAAAAAAAiAgL+CIiB59NSCssOJRGiMYQK1chahgAaaJpIXE41Cyir+xgPBWlDVAAAgAEAAIAAAACAAQAAAAAAAAAA')
assert_equal(analysis['next'], 'finalizer')
analysis = self.nodes[0].analyzepsbt('cHNidP8BAHECAAAAAfA00BFgAm6tp86RowwH6BMImQNL5zXUcTT97XoLGz0BAAAAAAD/////AgCAgWrj0AcAFgAUKNw0x8HRctAgmvoevm4u1SbN7XL87QKVAAAAABYAFPck4gF7iL4NL4wtfRAKgQbghiTUAAAAAAABAR8A8gUqAQAAABYAFJUDtxf2PHo641HEOBOAIvFMNTr2AAAA')
assert_equal(analysis['next'], 'creator')
assert_equal(analysis['error'], 'PSBT is not valid. Output amount invalid')
analysis = self.nodes[0].analyzepsbt('cHNidP8BAJoCAAAAAkvEW8NnDtdNtDpsmze+Ht2LH35IJcKv00jKAlUs21RrAwAAAAD/////S8Rbw2cO1020OmybN74e3Ysffkglwq/TSMoCVSzbVGsBAAAAAP7///8CwLYClQAAAAAWABSNJKzjaUb3uOxixsvh1GGE3fW7zQD5ApUAAAAAFgAUKNw0x8HRctAgmvoevm4u1SbN7XIAAAAAAAEAnQIAAAACczMa321tVHuN4GKWKRncycI22aX3uXgwSFUKM2orjRsBAAAAAP7///9zMxrfbW1Ue43gYpYpGdzJwjbZpfe5eDBIVQozaiuNGwAAAAAA/v///wIA+QKVAAAAABl2qRT9zXUVA8Ls5iVqynLHe5/vSe1XyYisQM0ClQAAAAAWABRmWQUcjSjghQ8/uH4Bn/zkakwLtAAAAAAAAQEfQM0ClQAAAAAWABRmWQUcjSjghQ8/uH4Bn/zkakwLtAAAAA==')
assert_equal(analysis['next'], 'creator')
assert_equal(analysis['error'], 'PSBT is not valid. Input 0 specifies invalid prevout')
assert_raises_rpc_error(-25, 'Inputs missing or spent', self.nodes[0].walletprocesspsbt, 'cHNidP8BAJoCAAAAAkvEW8NnDtdNtDpsmze+Ht2LH35IJcKv00jKAlUs21RrAwAAAAD/////S8Rbw2cO1020OmybN74e3Ysffkglwq/TSMoCVSzbVGsBAAAAAP7///8CwLYClQAAAAAWABSNJKzjaUb3uOxixsvh1GGE3fW7zQD5ApUAAAAAFgAUKNw0x8HRctAgmvoevm4u1SbN7XIAAAAAAAEAnQIAAAACczMa321tVHuN4GKWKRncycI22aX3uXgwSFUKM2orjRsBAAAAAP7///9zMxrfbW1Ue43gYpYpGdzJwjbZpfe5eDBIVQozaiuNGwAAAAAA/v///wIA+QKVAAAAABl2qRT9zXUVA8Ls5iVqynLHe5/vSe1XyYisQM0ClQAAAAAWABRmWQUcjSjghQ8/uH4Bn/zkakwLtAAAAAAAAQEfQM0ClQAAAAAWABRmWQUcjSjghQ8/uH4Bn/zkakwLtAAAAA==')
self.log.info("Test that we can fund psbts with external inputs specified")
eckey = ECKey()
eckey.generate()
privkey = bytes_to_wif(eckey.get_bytes())
self.nodes[1].createwallet("extfund")
wallet = self.nodes[1].get_wallet_rpc("extfund")
# Make a weird but signable script. sh(wsh(pkh())) descriptor accomplishes this
desc = descsum_create("sh(wsh(pkh({})))".format(privkey))
if self.options.descriptors:
res = self.nodes[0].importdescriptors([{"desc": desc, "timestamp": "now"}])
else:
res = self.nodes[0].importmulti([{"desc": desc, "timestamp": "now"}])
assert res[0]["success"]
addr = self.nodes[0].deriveaddresses(desc)[0]
addr_info = self.nodes[0].getaddressinfo(addr)
self.nodes[0].sendtoaddress(addr, 10)
self.nodes[0].sendtoaddress(wallet.getnewaddress(), 10)
self.generate(self.nodes[0], 6)
ext_utxo = self.nodes[0].listunspent(addresses=[addr])[0]
# An external input without solving data should result in an error
assert_raises_rpc_error(-4, "Insufficient funds", wallet.walletcreatefundedpsbt, [ext_utxo], {self.nodes[0].getnewaddress(): 15})
# But funding should work when the solving data is provided
psbt = wallet.walletcreatefundedpsbt([ext_utxo], {self.nodes[0].getnewaddress(): 15}, 0, {"add_inputs": True, "solving_data": {"pubkeys": [addr_info['pubkey']], "scripts": [addr_info["embedded"]["scriptPubKey"], addr_info["embedded"]["embedded"]["scriptPubKey"]]}})
signed = wallet.walletprocesspsbt(psbt['psbt'])
assert not signed['complete']
signed = self.nodes[0].walletprocesspsbt(signed['psbt'])
assert signed['complete']
self.nodes[0].finalizepsbt(signed['psbt'])
psbt = wallet.walletcreatefundedpsbt([ext_utxo], {self.nodes[0].getnewaddress(): 15}, 0, {"add_inputs": True, "solving_data":{"descriptors": [desc]}})
signed = wallet.walletprocesspsbt(psbt['psbt'])
assert not signed['complete']
signed = self.nodes[0].walletprocesspsbt(signed['psbt'])
assert signed['complete']
final = self.nodes[0].finalizepsbt(signed['psbt'], False)
dec = self.nodes[0].decodepsbt(signed["psbt"])
for i, txin in enumerate(dec["tx"]["vin"]):
if txin["txid"] == ext_utxo["txid"] and txin["vout"] == ext_utxo["vout"]:
input_idx = i
break
psbt_in = dec["inputs"][input_idx]
# Calculate the input weight
# (prevout + sequence + length of scriptSig + scriptsig + 1 byte buffer) * WITNESS_SCALE_FACTOR + num scriptWitness stack items + (length of stack item + stack item) * N stack items + 1 byte buffer
len_scriptsig = len(psbt_in["final_scriptSig"]["hex"]) // 2 if "final_scriptSig" in psbt_in else 0
len_scriptsig += len(ser_compact_size(len_scriptsig)) + 1
len_scriptwitness = (sum([(len(x) // 2) + len(ser_compact_size(len(x) // 2)) for x in psbt_in["final_scriptwitness"]]) + len(psbt_in["final_scriptwitness"]) + 1) if "final_scriptwitness" in psbt_in else 0
input_weight = ((40 + len_scriptsig) * WITNESS_SCALE_FACTOR) + len_scriptwitness
low_input_weight = input_weight // 2
high_input_weight = input_weight * 2
# Input weight error conditions
assert_raises_rpc_error(
-8,
"Input weights should be specified in inputs rather than in options.",
wallet.walletcreatefundedpsbt,
inputs=[ext_utxo],
outputs={self.nodes[0].getnewaddress(): 15},
options={"input_weights": [{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": 1000}]}
)
# Funding should also work if the input weight is provided
psbt = wallet.walletcreatefundedpsbt(
inputs=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": input_weight}],
outputs={self.nodes[0].getnewaddress(): 15},
options={"add_inputs": True}
)
signed = wallet.walletprocesspsbt(psbt["psbt"])
signed = self.nodes[0].walletprocesspsbt(signed["psbt"])
final = self.nodes[0].finalizepsbt(signed["psbt"])
assert self.nodes[0].testmempoolaccept([final["hex"]])[0]["allowed"]
# Reducing the weight should have a lower fee
psbt2 = wallet.walletcreatefundedpsbt(
inputs=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": low_input_weight}],
outputs={self.nodes[0].getnewaddress(): 15},
options={"add_inputs": True}
)
assert_greater_than(psbt["fee"], psbt2["fee"])
# Increasing the weight should have a higher fee
psbt2 = wallet.walletcreatefundedpsbt(
inputs=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": high_input_weight}],
outputs={self.nodes[0].getnewaddress(): 15},
options={"add_inputs": True}
)
assert_greater_than(psbt2["fee"], psbt["fee"])
# The provided weight should override the calculated weight when solving data is provided
psbt3 = wallet.walletcreatefundedpsbt(
inputs=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": high_input_weight}],
outputs={self.nodes[0].getnewaddress(): 15},
options={'add_inputs': True, "solving_data":{"descriptors": [desc]}}
)
assert_equal(psbt2["fee"], psbt3["fee"])
# Import the external utxo descriptor so that we can sign for it from the test wallet
if self.options.descriptors:
res = wallet.importdescriptors([{"desc": desc, "timestamp": "now"}])
else:
res = wallet.importmulti([{"desc": desc, "timestamp": "now"}])
assert res[0]["success"]
# The provided weight should override the calculated weight for a wallet input
psbt3 = wallet.walletcreatefundedpsbt(
inputs=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": high_input_weight}],
outputs={self.nodes[0].getnewaddress(): 15},
options={"add_inputs": True}
)
assert_equal(psbt2["fee"], psbt3["fee"])
self.log.info("Test signing inputs that the wallet has keys for but is not watching the scripts")
self.nodes[1].createwallet(wallet_name="scriptwatchonly", disable_private_keys=True)
watchonly = self.nodes[1].get_wallet_rpc("scriptwatchonly")
eckey = ECKey()
eckey.generate()
privkey = bytes_to_wif(eckey.get_bytes())
desc = descsum_create("wsh(pkh({}))".format(eckey.get_pubkey().get_bytes().hex()))
if self.options.descriptors:
res = watchonly.importdescriptors([{"desc": desc, "timestamp": "now"}])
else:
res = watchonly.importmulti([{"desc": desc, "timestamp": "now"}])
assert res[0]["success"]
addr = self.nodes[0].deriveaddresses(desc)[0]
self.nodes[0].sendtoaddress(addr, 10)
self.generate(self.nodes[0], 1)
self.nodes[0].importprivkey(privkey)
psbt = watchonly.sendall([wallet.getnewaddress()])["psbt"]
psbt = self.nodes[0].walletprocesspsbt(psbt)["psbt"]
self.nodes[0].sendrawtransaction(self.nodes[0].finalizepsbt(psbt)["hex"])
# Same test but for taproot
if self.options.descriptors:
eckey = ECKey()
eckey.generate()
privkey = bytes_to_wif(eckey.get_bytes())
desc = descsum_create("tr({},pk({}))".format(H_POINT, eckey.get_pubkey().get_bytes().hex()))
res = watchonly.importdescriptors([{"desc": desc, "timestamp": "now"}])
assert res[0]["success"]
addr = self.nodes[0].deriveaddresses(desc)[0]
self.nodes[0].sendtoaddress(addr, 10)
self.generate(self.nodes[0], 1)
self.nodes[0].importdescriptors([{"desc": descsum_create("tr({})".format(privkey)), "timestamp":"now"}])
psbt = watchonly.sendall([wallet.getnewaddress()])["psbt"]
psbt = self.nodes[0].walletprocesspsbt(psbt)["psbt"]
self.nodes[0].sendrawtransaction(self.nodes[0].finalizepsbt(psbt)["hex"])
self.log.info("Test that walletprocesspsbt both updates and signs a non-updated psbt containing Taproot inputs")
addr = self.nodes[0].getnewaddress("", "bech32m")
txid = self.nodes[0].sendtoaddress(addr, 1)
vout = find_vout_for_address(self.nodes[0], txid, addr)
psbt = self.nodes[0].createpsbt([{"txid": txid, "vout": vout}], [{self.nodes[0].getnewaddress(): 0.9999}])
signed = self.nodes[0].walletprocesspsbt(psbt)
rawtx = self.nodes[0].finalizepsbt(signed["psbt"])["hex"]
self.nodes[0].sendrawtransaction(rawtx)
self.generate(self.nodes[0], 1)
self.log.info("Test decoding PSBT with per-input preimage types")
# note that the decodepsbt RPC doesn't check whether preimages and hashes match
hash_ripemd160, preimage_ripemd160 = random_bytes(20), random_bytes(50)
hash_sha256, preimage_sha256 = random_bytes(32), random_bytes(50)
hash_hash160, preimage_hash160 = random_bytes(20), random_bytes(50)
hash_hash256, preimage_hash256 = random_bytes(32), random_bytes(50)
tx = CTransaction()
tx.vin = [CTxIn(outpoint=COutPoint(hash=int('aa' * 32, 16), n=0), scriptSig=b""),
CTxIn(outpoint=COutPoint(hash=int('bb' * 32, 16), n=0), scriptSig=b""),
CTxIn(outpoint=COutPoint(hash=int('cc' * 32, 16), n=0), scriptSig=b""),
CTxIn(outpoint=COutPoint(hash=int('dd' * 32, 16), n=0), scriptSig=b"")]
tx.vout = [CTxOut(nValue=0, scriptPubKey=b"")]
psbt = PSBT()
psbt.g = PSBTMap({PSBT_GLOBAL_UNSIGNED_TX: tx.serialize()})
psbt.i = [PSBTMap({bytes([PSBT_IN_RIPEMD160]) + hash_ripemd160: preimage_ripemd160}),
PSBTMap({bytes([PSBT_IN_SHA256]) + hash_sha256: preimage_sha256}),
PSBTMap({bytes([PSBT_IN_HASH160]) + hash_hash160: preimage_hash160}),
PSBTMap({bytes([PSBT_IN_HASH256]) + hash_hash256: preimage_hash256})]
psbt.o = [PSBTMap()]
res_inputs = self.nodes[0].decodepsbt(psbt.to_base64())["inputs"]
assert_equal(len(res_inputs), 4)
preimage_keys = ["ripemd160_preimages", "sha256_preimages", "hash160_preimages", "hash256_preimages"]
expected_hashes = [hash_ripemd160, hash_sha256, hash_hash160, hash_hash256]
expected_preimages = [preimage_ripemd160, preimage_sha256, preimage_hash160, preimage_hash256]
for res_input, preimage_key, hash, preimage in zip(res_inputs, preimage_keys, expected_hashes, expected_preimages):
assert preimage_key in res_input
assert_equal(len(res_input[preimage_key]), 1)
assert hash.hex() in res_input[preimage_key]
assert_equal(res_input[preimage_key][hash.hex()], preimage.hex())
def run_test(self):
self.log.info("Setup wallets...")
# w0 is a wallet with coinbase rewards
w0 = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
# w1 is a regular wallet
self.nodes[1].createwallet(wallet_name="w1")
w1 = self.nodes[1].get_wallet_rpc("w1")
# w2 contains the private keys for w3
self.nodes[1].createwallet(wallet_name="w2", blank=True)
w2 = self.nodes[1].get_wallet_rpc("w2")
xpriv = "tprv8ZgxMBicQKsPfHCsTwkiM1KT56RXbGGTqvc2hgqzycpwbHqqpcajQeMRZoBD35kW4RtyCemu6j34Ku5DEspmgjKdt2qe4SvRch5Kk8B8A2v"
xpub = "tpubD6NzVbkrYhZ4YkEfMbRJkQyZe7wTkbTNRECozCtJPtdLRn6cT1QKb8yHjwAPcAr26eHBFYs5iLiFFnCbwPRsncCKUKCfubHDMGKzMVcN1Jg"
if self.options.descriptors:
w2.importdescriptors([{
"desc":
descsum_create("wpkh(" + xpriv + "/0/0/*)"),
"timestamp":
"now",
"range": [0, 100],
"active":
True
}, {
"desc":
descsum_create("wpkh(" + xpriv + "/0/1/*)"),
"timestamp":
"now",
"range": [0, 100],
"active":
True,
"internal":
True
}])
else:
w2.sethdseed(True)
# w3 is a watch-only wallet, based on w2
self.nodes[1].createwallet(wallet_name="w3", disable_private_keys=True)
w3 = self.nodes[1].get_wallet_rpc("w3")
if self.options.descriptors:
# Match the privkeys in w2 for descriptors
res = w3.importdescriptors([{
"desc":
descsum_create("wpkh(" + xpub + "/0/0/*)"),
"timestamp":
"now",
"range": [0, 100],
"keypool":
True,
"active":
True,
"watchonly":
True
}, {
"desc":
descsum_create("wpkh(" + xpub + "/0/1/*)"),
"timestamp":
"now",
"range": [0, 100],
"keypool":
True,
"active":
True,
"internal":
True,
"watchonly":
True
}])
assert_equal(res, [{"success": True}, {"success": True}])
for _ in range(3):
a2_receive = w2.getnewaddress()
if not self.options.descriptors:
# Because legacy wallets use exclusively hardened derivation, we can't do a ranged import like we do for descriptors
a2_change = w2.getrawchangeaddress(
) # doesn't actually use change derivation
res = w3.importmulti([{
"desc":
w2.getaddressinfo(a2_receive)["desc"],
"timestamp":
"now",
"keypool":
True,
"watchonly":
True
}, {
"desc":
w2.getaddressinfo(a2_change)["desc"],
"timestamp":
"now",
"keypool":
True,
"internal":
True,
"watchonly":
True
}])
assert_equal(res, [{"success": True}, {"success": True}])
w0.sendtoaddress(a2_receive, 10) # fund w3
self.generate(self.nodes[0], 1)
if not self.options.descriptors:
# w4 has private keys enabled, but only contains watch-only keys (from w2)
# This is legacy wallet behavior only as descriptor wallets don't allow watchonly and non-watchonly things in the same wallet.
self.nodes[1].createwallet(wallet_name="w4",
disable_private_keys=False)
w4 = self.nodes[1].get_wallet_rpc("w4")
for _ in range(3):
a2_receive = w2.getnewaddress()
res = w4.importmulti([{
"desc":
w2.getaddressinfo(a2_receive)["desc"],
"timestamp":
"now",
"keypool":
False,
"watchonly":
True
}])
assert_equal(res, [{"success": True}])
w0.sendtoaddress(a2_receive, 10) # fund w4
self.generate(self.nodes[0], 1)
self.log.info("Send to address...")
self.test_send(from_wallet=w0, to_wallet=w1, amount=1)
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
add_to_wallet=True)
self.log.info("Don't broadcast...")
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
add_to_wallet=False)
assert (res["hex"])
self.log.info("Return PSBT...")
res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, psbt=True)
assert (res["psbt"])
self.log.info(
"Create transaction that spends to address, but don't broadcast..."
)
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
add_to_wallet=False)
# conf_target & estimate_mode can be set as argument or option
res1 = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
arg_conf_target=1,
arg_estimate_mode="economical",
add_to_wallet=False)
res2 = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
conf_target=1,
estimate_mode="economical",
add_to_wallet=False)
assert_equal(self.nodes[1].decodepsbt(res1["psbt"])["fee"],
self.nodes[1].decodepsbt(res2["psbt"])["fee"])
# but not at the same time
for mode in ["unset", "economical", "conservative"]:
self.test_send(
from_wallet=w0,
to_wallet=w1,
amount=1,
arg_conf_target=1,
arg_estimate_mode="economical",
conf_target=1,
estimate_mode=mode,
add_to_wallet=False,
expect_error=
(-8,
"Pass conf_target and estimate_mode either as arguments or in the options object, but not both"
))
self.log.info("Create PSBT from watch-only wallet w3, sign with w2...")
res = self.test_send(from_wallet=w3, to_wallet=w1, amount=1)
res = w2.walletprocesspsbt(res["psbt"])
assert res["complete"]
if not self.options.descriptors:
# Descriptor wallets do not allow mixed watch-only and non-watch-only things in the same wallet.
# This is specifically testing that w4 ignores its own private keys and creates a psbt with send
# which is not something that needs to be tested in descriptor wallets.
self.log.info(
"Create PSBT from wallet w4 with watch-only keys, sign with w2..."
)
self.test_send(from_wallet=w4,
to_wallet=w1,
amount=1,
expect_error=(-4, "Insufficient funds"))
res = self.test_send(from_wallet=w4,
to_wallet=w1,
amount=1,
include_watching=True,
add_to_wallet=False)
res = w2.walletprocesspsbt(res["psbt"])
assert res["complete"]
self.log.info("Create OP_RETURN...")
self.test_send(from_wallet=w0, to_wallet=w1, amount=1)
self.test_send(
from_wallet=w0,
data="Hello World",
expect_error=(
-8, "Data must be hexadecimal string (not 'Hello World')"))
self.test_send(from_wallet=w0, data="23")
res = self.test_send(from_wallet=w3, data="23")
res = w2.walletprocesspsbt(res["psbt"])
assert res["complete"]
self.log.info("Test setting explicit fee rate")
res1 = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
arg_fee_rate="1",
add_to_wallet=False)
res2 = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
fee_rate="1",
add_to_wallet=False)
assert_equal(self.nodes[1].decodepsbt(res1["psbt"])["fee"],
self.nodes[1].decodepsbt(res2["psbt"])["fee"])
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
fee_rate=7,
add_to_wallet=False)
fee = self.nodes[1].decodepsbt(res["psbt"])["fee"]
assert_fee_amount(fee, Decimal(len(res["hex"]) / 2),
Decimal("0.00007"))
# "unset" and None are treated the same for estimate_mode
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
fee_rate=2,
estimate_mode="unset",
add_to_wallet=False)
fee = self.nodes[1].decodepsbt(res["psbt"])["fee"]
assert_fee_amount(fee, Decimal(len(res["hex"]) / 2),
Decimal("0.00002"))
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
arg_fee_rate=4.531,
add_to_wallet=False)
fee = self.nodes[1].decodepsbt(res["psbt"])["fee"]
assert_fee_amount(fee, Decimal(len(res["hex"]) / 2),
Decimal("0.00004531"))
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
arg_fee_rate=3,
add_to_wallet=False)
fee = self.nodes[1].decodepsbt(res["psbt"])["fee"]
assert_fee_amount(fee, Decimal(len(res["hex"]) / 2),
Decimal("0.00003"))
# Test that passing fee_rate as both an argument and an option raises.
self.test_send(
from_wallet=w0,
to_wallet=w1,
amount=1,
arg_fee_rate=1,
fee_rate=1,
add_to_wallet=False,
expect_error=
(-8,
"Pass the fee_rate either as an argument, or in the options object, but not both"
))
assert_raises_rpc_error(-8, "Use fee_rate (sat/vB) instead of feeRate",
w0.send, {w1.getnewaddress(): 1}, 6,
"conservative", 1, {"feeRate": 0.01})
assert_raises_rpc_error(-3, "Unexpected key totalFee", w0.send,
{w1.getnewaddress(): 1}, 6, "conservative", 1,
{"totalFee": 0.01})
for target, mode in product([-1, 0, 1009],
["economical", "conservative"]):
self.test_send(
from_wallet=w0,
to_wallet=w1,
amount=1,
conf_target=target,
estimate_mode=mode,
expect_error=(-8,
"Invalid conf_target, must be between 1 and 1008"
)) # max value of 1008 per src/policy/fees.h
msg = 'Invalid estimate_mode parameter, must be one of: "unset", "economical", "conservative"'
for target, mode in product([-1, 0], ["btc/kb", "sat/b"]):
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
conf_target=target,
estimate_mode=mode,
expect_error=(-8, msg))
for mode in ["", "foo", Decimal("3.141592")]:
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
conf_target=0.1,
estimate_mode=mode,
expect_error=(-8, msg))
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
arg_conf_target=0.1,
arg_estimate_mode=mode,
expect_error=(-8, msg))
assert_raises_rpc_error(-8, msg, w0.send, {w1.getnewaddress(): 1},
0.1, mode)
for mode in ["economical", "conservative"]:
for k, v in {
"string": "true",
"bool": True,
"object": {
"foo": "bar"
}
}.items():
self.test_send(
from_wallet=w0,
to_wallet=w1,
amount=1,
conf_target=v,
estimate_mode=mode,
expect_error=(
-3, f"Expected type number for conf_target, got {k}"))
# Test setting explicit fee rate just below the minimum of 1 sat/vB.
self.log.info(
"Explicit fee rate raises RPC error 'fee rate too low' if fee_rate of 0.99999999 is passed"
)
msg = "Fee rate (0.999 sat/vB) is lower than the minimum fee rate setting (1.000 sat/vB)"
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
fee_rate=0.999,
expect_error=(-4, msg))
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
arg_fee_rate=0.999,
expect_error=(-4, msg))
self.log.info("Explicit fee rate raises if invalid fee_rate is passed")
# Test fee_rate with zero values.
msg = "Fee rate (0.000 sat/vB) is lower than the minimum fee rate setting (1.000 sat/vB)"
for zero_value in [0, 0.000, 0.00000000, "0", "0.000", "0.00000000"]:
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
fee_rate=zero_value,
expect_error=(-4, msg))
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
arg_fee_rate=zero_value,
expect_error=(-4, msg))
msg = "Invalid amount"
# Test fee_rate values that don't pass fixed-point parsing checks.
for invalid_value in [
"", 0.000000001, 1e-09, 1.111111111, 1111111111111111,
"31.999999999999999999999"
]:
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
fee_rate=invalid_value,
expect_error=(-3, msg))
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
arg_fee_rate=invalid_value,
expect_error=(-3, msg))
# Test fee_rate values that cannot be represented in sat/vB.
for invalid_value in [
0.0001, 0.00000001, 0.00099999, 31.99999999, "0.0001",
"0.00000001", "0.00099999", "31.99999999"
]:
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
fee_rate=invalid_value,
expect_error=(-3, msg))
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
arg_fee_rate=invalid_value,
expect_error=(-3, msg))
# Test fee_rate out of range (negative number).
msg = "Amount out of range"
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
fee_rate=-1,
expect_error=(-3, msg))
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
arg_fee_rate=-1,
expect_error=(-3, msg))
# Test type error.
msg = "Amount is not a number or string"
for invalid_value in [True, {"foo": "bar"}]:
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
fee_rate=invalid_value,
expect_error=(-3, msg))
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
arg_fee_rate=invalid_value,
expect_error=(-3, msg))
# TODO: Return hex if fee rate is below -maxmempool
# res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, conf_target=0.1, estimate_mode="sat/b", add_to_wallet=False)
# assert res["hex"]
# hex = res["hex"]
# res = self.nodes[0].testmempoolaccept([hex])
# assert not res[0]["allowed"]
# assert_equal(res[0]["reject-reason"], "...") # low fee
# assert_fee_amount(fee, Decimal(len(res["hex"]) / 2), Decimal("0.000001"))
self.log.info(
"If inputs are specified, do not automatically add more...")
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=51,
inputs=[],
add_to_wallet=False)
assert res["complete"]
utxo1 = w0.listunspent()[0]
assert_equal(utxo1["amount"], 50)
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=51,
inputs=[utxo1],
expect_error=(-4, "Insufficient funds"))
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=51,
inputs=[utxo1],
add_inputs=False,
expect_error=(-4, "Insufficient funds"))
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=51,
inputs=[utxo1],
add_inputs=True,
add_to_wallet=False)
assert res["complete"]
self.log.info("Manual change address and position...")
self.test_send(
from_wallet=w0,
to_wallet=w1,
amount=1,
change_address="not an address",
expect_error=(-5,
"Change address must be a valid bitcoin address"))
change_address = w0.getnewaddress()
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
add_to_wallet=False,
change_address=change_address)
assert res["complete"]
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
add_to_wallet=False,
change_address=change_address,
change_position=0)
assert res["complete"]
assert_equal(
self.nodes[0].decodepsbt(
res["psbt"])["tx"]["vout"][0]["scriptPubKey"]["address"],
change_address)
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
add_to_wallet=False,
change_type="legacy",
change_position=0)
assert res["complete"]
change_address = self.nodes[0].decodepsbt(
res["psbt"])["tx"]["vout"][0]["scriptPubKey"]["address"]
assert change_address[0] == "m" or change_address[0] == "n"
self.log.info("Set lock time...")
height = self.nodes[0].getblockchaininfo()["blocks"]
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
locktime=height + 1)
assert res["complete"]
assert res["txid"]
txid = res["txid"]
# Although the wallet finishes the transaction, it can't be added to the mempool yet:
hex = self.nodes[0].gettransaction(res["txid"])["hex"]
res = self.nodes[0].testmempoolaccept([hex])
assert not res[0]["allowed"]
assert_equal(res[0]["reject-reason"], "non-final")
# It shouldn't be confirmed in the next block
self.generate(self.nodes[0], 1)
assert_equal(self.nodes[0].gettransaction(txid)["confirmations"], 0)
# The mempool should allow it now:
res = self.nodes[0].testmempoolaccept([hex])
assert res[0]["allowed"]
# Don't wait for wallet to add it to the mempool:
res = self.nodes[0].sendrawtransaction(hex)
self.generate(self.nodes[0], 1)
assert_equal(self.nodes[0].gettransaction(txid)["confirmations"], 1)
self.log.info("Lock unspents...")
utxo1 = w0.listunspent()[0]
assert_greater_than(utxo1["amount"], 1)
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
inputs=[utxo1],
add_to_wallet=False,
lock_unspents=True)
assert res["complete"]
locked_coins = w0.listlockunspent()
assert_equal(len(locked_coins), 1)
# Locked coins are automatically unlocked when manually selected
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
inputs=[utxo1],
add_to_wallet=False)
assert res["complete"]
self.log.info("Replaceable...")
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
add_to_wallet=True,
replaceable=True)
assert res["complete"]
assert_equal(
self.nodes[0].gettransaction(res["txid"])["bip125-replaceable"],
"yes")
res = self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
add_to_wallet=True,
replaceable=False)
assert res["complete"]
assert_equal(
self.nodes[0].gettransaction(res["txid"])["bip125-replaceable"],
"no")
self.log.info("Subtract fee from output")
self.test_send(from_wallet=w0,
to_wallet=w1,
amount=1,
subtract_fee_from_outputs=[0])
self.log.info("Include unsafe inputs")
self.nodes[1].createwallet(wallet_name="w5")
w5 = self.nodes[1].get_wallet_rpc("w5")
self.test_send(from_wallet=w0, to_wallet=w5, amount=2)
self.test_send(from_wallet=w5,
to_wallet=w0,
amount=1,
expect_error=(-4, "Insufficient funds"))
res = self.test_send(from_wallet=w5,
to_wallet=w0,
amount=1,
include_unsafe=True)
assert res["complete"]
self.log.info("External outputs")
eckey = ECKey()
eckey.generate()
privkey = bytes_to_wif(eckey.get_bytes())
self.nodes[1].createwallet("extsend")
ext_wallet = self.nodes[1].get_wallet_rpc("extsend")
self.nodes[1].createwallet("extfund")
ext_fund = self.nodes[1].get_wallet_rpc("extfund")
# Make a weird but signable script. sh(pkh()) descriptor accomplishes this
desc = descsum_create("sh(pkh({}))".format(privkey))
if self.options.descriptors:
res = ext_fund.importdescriptors([{
"desc": desc,
"timestamp": "now"
}])
else:
res = ext_fund.importmulti([{"desc": desc, "timestamp": "now"}])
assert res[0]["success"]
addr = self.nodes[0].deriveaddresses(desc)[0]
addr_info = ext_fund.getaddressinfo(addr)
self.nodes[0].sendtoaddress(addr, 10)
self.nodes[0].sendtoaddress(ext_wallet.getnewaddress(), 10)
self.generate(self.nodes[0], 6)
ext_utxo = ext_fund.listunspent(addresses=[addr])[0]
# An external input without solving data should result in an error
self.test_send(from_wallet=ext_wallet,
to_wallet=self.nodes[0],
amount=15,
inputs=[ext_utxo],
add_inputs=True,
psbt=True,
include_watching=True,
expect_error=(-4, "Insufficient funds"))
# But funding should work when the solving data is provided
res = self.test_send(from_wallet=ext_wallet,
to_wallet=self.nodes[0],
amount=15,
inputs=[ext_utxo],
add_inputs=True,
psbt=True,
include_watching=True,
solving_data={
"pubkeys": [addr_info['pubkey']],
"scripts":
[addr_info["embedded"]["scriptPubKey"]]
})
signed = ext_wallet.walletprocesspsbt(res["psbt"])
signed = ext_fund.walletprocesspsbt(res["psbt"])
assert signed["complete"]
self.nodes[0].finalizepsbt(signed["psbt"])
res = self.test_send(from_wallet=ext_wallet,
to_wallet=self.nodes[0],
amount=15,
inputs=[ext_utxo],
add_inputs=True,
psbt=True,
include_watching=True,
solving_data={"descriptors": [desc]})
signed = ext_wallet.walletprocesspsbt(res["psbt"])
signed = ext_fund.walletprocesspsbt(res["psbt"])
assert signed["complete"]
self.nodes[0].finalizepsbt(signed["psbt"])
dec = self.nodes[0].decodepsbt(signed["psbt"])
for i, txin in enumerate(dec["tx"]["vin"]):
if txin["txid"] == ext_utxo["txid"] and txin["vout"] == ext_utxo[
"vout"]:
input_idx = i
break
psbt_in = dec["inputs"][input_idx]
# Calculate the input weight
# (prevout + sequence + length of scriptSig + 2 bytes buffer) * 4 + len of scriptwitness
len_scriptsig = len(psbt_in["final_scriptSig"]["hex"]
) // 2 if "final_scriptSig" in psbt_in else 0
len_scriptwitness = len(
psbt_in["final_scriptwitness"]
["hex"]) // 2 if "final_scriptwitness" in psbt_in else 0
input_weight = ((41 + len_scriptsig + 2) * 4) + len_scriptwitness
# Input weight error conditions
assert_raises_rpc_error(
-8,
"Input weights should be specified in inputs rather than in options.",
ext_wallet.send,
outputs={self.nodes[0].getnewaddress(): 15},
options={
"inputs": [ext_utxo],
"input_weights": [{
"txid": ext_utxo["txid"],
"vout": ext_utxo["vout"],
"weight": 1000
}]
})
# Funding should also work when input weights are provided
res = self.test_send(from_wallet=ext_wallet,
to_wallet=self.nodes[0],
amount=15,
inputs=[{
"txid": ext_utxo["txid"],
"vout": ext_utxo["vout"],
"weight": input_weight
}],
add_inputs=True,
psbt=True,
include_watching=True,
fee_rate=10)
signed = ext_wallet.walletprocesspsbt(res["psbt"])
signed = ext_fund.walletprocesspsbt(res["psbt"])
assert signed["complete"]
tx = self.nodes[0].finalizepsbt(signed["psbt"])
testres = self.nodes[0].testmempoolaccept([tx["hex"]])[0]
assert_equal(testres["allowed"], True)
assert_fee_amount(testres["fees"]["base"], testres["vsize"],
Decimal(0.0001))
def tapscript_satisfy_test(self,
script,
inputs=[],
add_issuance=False,
add_pegin=False,
fail=None,
add_prevout=False,
add_asset=False,
add_value=False,
add_spk=False,
seq=0,
add_out_spk=None,
add_out_asset=None,
add_out_value=None,
add_out_nonce=None,
ver=2,
locktime=0,
add_num_outputs=False,
add_weight=False,
blind=False):
# Create a taproot utxo
scripts = [("s0", script)]
prev_tx, prev_vout, spk, sec, pub, tap = self.create_taproot_utxo(
scripts)
if add_pegin:
fund_info = self.nodes[0].getpeginaddress()
peg_id = self.nodes[0].sendtoaddress(
fund_info["mainchain_address"], 1)
raw_peg_tx = self.nodes[0].gettransaction(peg_id)["hex"]
peg_txid = self.nodes[0].sendrawtransaction(raw_peg_tx)
self.nodes[0].generate(101)
peg_prf = self.nodes[0].gettxoutproof([peg_txid])
claim_script = fund_info["claim_script"]
raw_claim = self.nodes[0].createrawpegin(raw_peg_tx, peg_prf,
claim_script)
tx = FromHex(CTransaction(), raw_claim['hex'])
else:
tx = CTransaction()
tx.nVersion = ver
tx.nLockTime = locktime
# Spend the pegin and taproot tx together
in_total = prev_tx.vout[prev_vout].nValue.getAmount()
fees = 1000
tap_in_pos = 0
if blind:
# Add an unrelated output
key = ECKey()
key.generate()
tx.vout.append(
CTxOut(nValue=CTxOutValue(10000),
scriptPubKey=spk,
nNonce=CTxOutNonce(key.get_pubkey().get_bytes())))
tx_hex = self.nodes[0].fundrawtransaction(tx.serialize().hex())
tx = FromHex(CTransaction(), tx_hex['hex'])
tx.vin.append(
CTxIn(COutPoint(prev_tx.sha256, prev_vout), nSequence=seq))
tx.vout.append(
CTxOut(nValue=CTxOutValue(in_total - fees),
scriptPubKey=spk)) # send back to self
tx.vout.append(CTxOut(CTxOutValue(fees)))
if add_issuance:
blind_addr = self.nodes[0].getnewaddress()
issue_addr = self.nodes[0].validateaddress(
blind_addr)['unconfidential']
# Issuances only require one fee output and that output must the last
# one. However the way, the current code is structured, it is not possible
# to this in a super clean without special casing.
if add_pegin:
tx.vout.pop()
tx.vout.pop()
tx.vout.insert(0,
CTxOut(nValue=CTxOutValue(in_total),
scriptPubKey=spk)) # send back to self)
issued_tx = self.nodes[0].rawissueasset(
tx.serialize().hex(), [{
"asset_amount": 2,
"asset_address": issue_addr,
"blind": False
}])[0]["hex"]
tx = FromHex(CTransaction(), issued_tx)
# Sign inputs
if add_pegin:
signed = self.nodes[0].signrawtransactionwithwallet(
tx.serialize().hex())
tx = FromHex(CTransaction(), signed['hex'])
tap_in_pos += 1
else:
# Need to create empty witness when not deserializing from rpc
tx.wit.vtxinwit.append(CTxInWitness())
if blind:
tx.vin[0], tx.vin[1] = tx.vin[1], tx.vin[0]
utxo = self.get_utxo(tx, 1)
zero_str = "0" * 64
blinded_raw = self.nodes[0].rawblindrawtransaction(
tx.serialize().hex(), [zero_str, utxo["amountblinder"]],
[1.2, utxo['amount']], [utxo['asset'], utxo['asset']],
[zero_str, utxo['assetblinder']])
tx = FromHex(CTransaction(), blinded_raw)
signed_raw_tx = self.nodes[0].signrawtransactionwithwallet(
tx.serialize().hex())
tx = FromHex(CTransaction(), signed_raw_tx['hex'])
suffix_annex = []
control_block = bytes([
tap.leaves["s0"].version + tap.negflag
]) + tap.inner_pubkey + tap.leaves["s0"].merklebranch
# Add the prevout to the top of inputs. The witness script will check for equality.
if add_prevout:
inputs = [
prev_vout.to_bytes(4, 'little'),
ser_uint256(prev_tx.sha256)
]
if add_asset:
assert blind # only used with blinding in testing
utxo = self.nodes[0].gettxout(
ser_uint256(tx.vin[1].prevout.hash)[::-1].hex(),
tx.vin[1].prevout.n)
if "assetcommitment" in utxo:
asset = bytes.fromhex(utxo["assetcommitment"])
else:
asset = b"\x01" + bytes.fromhex(utxo["asset"])[::-1]
inputs = [asset[0:1], asset[1:33]]
if add_value:
utxo = self.nodes[0].gettxout(
ser_uint256(tx.vin[1].prevout.hash)[::-1].hex(),
tx.vin[1].prevout.n)
if "valuecommitment" in utxo:
value = bytes.fromhex(utxo["valuecommitment"])
inputs = [value[0:1], value[1:33]]
else:
value = b"\x01" + int(
satoshi_round(utxo["value"]) * COIN).to_bytes(8, 'little')
inputs = [value[0:1], value[1:9]]
if add_spk:
ver = CScriptOp.decode_op_n(int.from_bytes(spk[0:1], 'little'))
inputs = [CScriptNum.encode(CScriptNum(ver))[1:],
spk[2:len(spk)]] # always segwit
# Add witness for outputs
if add_out_asset is not None:
asset = tx.vout[add_out_asset].nAsset.vchCommitment
inputs = [asset[0:1], asset[1:33]]
if add_out_value is not None:
value = tx.vout[add_out_value].nValue.vchCommitment
if len(value) == 9:
inputs = [value[0:1], value[1:9][::-1]]
else:
inputs = [value[0:1], value[1:33]]
if add_out_nonce is not None:
nonce = tx.vout[add_out_nonce].nNonce.vchCommitment
if len(nonce) == 1:
inputs = [b'']
else:
inputs = [nonce]
if add_out_spk is not None:
out_spk = tx.vout[add_out_spk].scriptPubKey
if len(out_spk) == 0:
# Python upstream encoding CScriptNum interesting behaviour where it also encodes the length
# This assumes the implicit wallet behaviour of using segwit outputs.
# This is useful while sending scripts, but not while using CScriptNums in constructing scripts
inputs = [
CScriptNum.encode(CScriptNum(-1))[1:],
sha256(out_spk)
]
else:
ver = CScriptOp.decode_op_n(
int.from_bytes(out_spk[0:1], 'little'))
inputs = [
CScriptNum.encode(CScriptNum(ver))[1:],
out_spk[2:len(out_spk)]
] # always segwit
if add_num_outputs:
num_outs = len(tx.vout)
inputs = [CScriptNum.encode(CScriptNum(num_outs))[1:]]
if add_weight:
# Add a dummy input and check the overall weight
inputs = [int(5).to_bytes(8, 'little')]
wit = inputs + [bytes(tap.leaves["s0"].script), control_block
] + suffix_annex
tx.wit.vtxinwit[tap_in_pos].scriptWitness.stack = wit
exp_weight = self.nodes[0].decoderawtransaction(
tx.serialize().hex())["weight"]
inputs = [exp_weight.to_bytes(8, 'little')]
wit = inputs + [bytes(tap.leaves["s0"].script), control_block
] + suffix_annex
tx.wit.vtxinwit[tap_in_pos].scriptWitness.stack = wit
if fail:
assert_raises_rpc_error(-26, fail,
self.nodes[0].sendrawtransaction,
tx.serialize().hex())
return
self.nodes[0].sendrawtransaction(hexstring=tx.serialize().hex())
self.nodes[0].generate(1)
last_blk = self.nodes[0].getblock(self.nodes[0].getbestblockhash())
tx.rehash()
assert (tx.hash in last_blk['tx'])
def generate_wif_key():
# Makes a WIF privkey for imports
k = ECKey()
k.generate()
return bytes_to_wif(k.get_bytes(), k.is_compressed)
def run_test(self):
# Connect to node0
node0 = BaseNode()
connections = [
NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0)
]
node0.add_connection(connections[0])
NetworkThread().start() # Start up network handling in another thread
node0.wait_for_verack()
# 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.x16r
height += 1
# Bury the block 100 deep so the coinbase output is spendable
for i in range(100):
block = create_block(self.tip, create_coinbase(height),
self.block_time)
block.solve()
self.blocks.append(block)
self.tip = block.x16r
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].x16r, 0), script_sig=b""))
tx.vout.append(CTxOut(49 * 100000000, CScript([OP_TRUE])))
tx.calc_x16r()
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.x16r
self.block_time += 1
height += 1
# Bury the assumed valid block 2100 deep
for i in range(2100):
block = create_block(self.tip, create_coinbase(height),
self.block_time)
block.nVersion = 4
block.solve()
self.blocks.append(block)
self.tip = block.x16r
self.block_time += 1
height += 1
# Start node1 and node2 with assumevalid so they accept a block with a bad signature.
self.start_node(1, extra_args=["-assumevalid=" + hex(block102.x16r)])
node1 = BaseNode() # connects to node1
connections.append(
NodeConn('127.0.0.1', p2p_port(1), self.nodes[1], node1))
node1.add_connection(connections[1])
node1.wait_for_verack()
self.start_node(2, extra_args=["-assumevalid=" + hex(block102.x16r)])
node2 = BaseNode() # connects to node2
connections.append(
NodeConn('127.0.0.1', p2p_port(2), self.nodes[2], node2))
node2.add_connection(connections[2])
node2.wait_for_verack()
# send header lists to all three nodes
node0.send_header_for_blocks(self.blocks[0:2000])
node0.send_header_for_blocks(self.blocks[2000:])
node1.send_header_for_blocks(self.blocks[0:2000])
node1.send_header_for_blocks(self.blocks[2000:])
node2.send_header_for_blocks(self.blocks[0:200])
# Send blocks to node0. Block 102 will be rejected.
self.send_blocks_until_disconnected(node0)
self.assert_blockchain_height(self.nodes[0], 101)
# Send all blocks to node1. All blocks will be accepted.
for i in range(2202):
node1.send_message(MsgBlock(self.blocks[i]))
# Syncing 2200 blocks can take a while on slow systems. Give it plenty of time to sync.
node1.sync_with_ping(120)
assert_equal(
self.nodes[1].getblock(self.nodes[1].getbestblockhash())['height'],
2202)
# Send blocks to node2. Block 102 will be rejected.
self.send_blocks_until_disconnected(node2)
self.assert_blockchain_height(self.nodes[2], 101)
def run_test(self):
node, = self.nodes
self.bootstrap_p2p()
tip = self.getbestblock(node)
self.log.info("Create some blocks with OP_1 coinbase for spending.")
blocks = []
for _ in range(10):
tip = self.build_block(tip)
blocks.append(tip)
node.p2p.send_blocks_and_test(blocks, node, success=True)
spendable_outputs = [block.vtx[0] for block in blocks]
self.log.info("Mature the blocks and get out of IBD.")
node.generatetoaddress(100, node.get_deterministic_priv_key().address)
tip = self.getbestblock(node)
self.log.info("Setting up spends to test and mining the fundings.")
fundings = []
# Generate a key pair
private_key = ECKey()
private_key.set(b"Schnorr!" * 4, True)
# get uncompressed public key serialization
public_key = private_key.get_pubkey().get_bytes()
def create_fund_and_spend_tx(multi=False, sig='schnorr'):
spendfrom = spendable_outputs.pop()
vout = 1
if multi:
script = CScript([OP_1, public_key, OP_1, OP_CHECKMULTISIG])
else:
script = CScript([public_key, OP_CHECKSIG])
value = spendfrom.vout[vout].nValue
# Fund transaction
txfund = create_tx_with_script(spendfrom,
vout,
b'',
amount=value,
script_pub_key=script)
txfund.rehash()
fundings.append(txfund)
# Spend transaction
txspend = CTransaction()
txspend.vout.append(CTxOut(value - 1000, CScript([OP_TRUE])))
txspend.vin.append(CTxIn(COutPoint(txfund.txid, 0), b''))
# Sign the transaction
sighashtype = SIGHASH_ALL | SIGHASH_FORKID
hashbyte = bytes([sighashtype & 0xff])
sighash = SignatureHashForkId(script, txspend, 0, sighashtype,
value)
if sig == 'schnorr':
txsig = private_key.sign_schnorr(sighash) + hashbyte
elif sig == 'ecdsa':
txsig = private_key.sign_ecdsa(sighash) + hashbyte
elif isinstance(sig, bytes):
txsig = sig + hashbyte
if multi:
txspend.vin[0].scriptSig = CScript([b'', txsig])
else:
txspend.vin[0].scriptSig = CScript([txsig])
txspend.rehash()
return txspend
schnorrchecksigtx = create_fund_and_spend_tx()
schnorrmultisigtx = create_fund_and_spend_tx(multi=True)
ecdsachecksigtx = create_fund_and_spend_tx(sig='ecdsa')
sig64checksigtx = create_fund_and_spend_tx(sig=sig64)
sig64multisigtx = create_fund_and_spend_tx(multi=True, sig=sig64)
tip = self.build_block(tip, fundings)
node.p2p.send_blocks_and_test([tip], node)
self.log.info("Typical ECDSA and Schnorr CHECKSIG are valid.")
node.p2p.send_txs_and_test([schnorrchecksigtx, ecdsachecksigtx], node)
# They get mined as usual.
node.generatetoaddress(1, node.get_deterministic_priv_key().address)
tip = self.getbestblock(node)
# Make sure they are in the block, and mempool is now empty.
txids = set([schnorrchecksigtx.txid_hex, ecdsachecksigtx.txid_hex])
for tx in tip.vtx:
tx.calc_txid()
assert txids.issubset(tx.txid_hex for tx in tip.vtx)
assert not node.getrawmempool()
self.log.info("Schnorr in multisig is rejected with mandatory error.")
assert_raises_rpc_error(-26, SCHNORR_MULTISIG_ERROR,
node.sendrawtransaction,
ToHex(schnorrmultisigtx))
# And it is banworthy.
self.check_for_ban_on_rejected_tx(schnorrmultisigtx,
SCHNORR_MULTISIG_ERROR)
# And it can't be mined
self.check_for_ban_on_rejected_block(
self.build_block(tip, [schnorrmultisigtx]), BADINPUTS_ERROR)
self.log.info("Bad 64-byte sig is rejected with mandatory error.")
# In CHECKSIG it's invalid Schnorr and hence NULLFAIL.
assert_raises_rpc_error(-26, NULLFAIL_ERROR, node.sendrawtransaction,
ToHex(sig64checksigtx))
# In CHECKMULTISIG it's invalid length and hence BAD_LENGTH.
assert_raises_rpc_error(-26, SCHNORR_MULTISIG_ERROR,
node.sendrawtransaction,
ToHex(sig64multisigtx))
# Sending these transactions is banworthy.
self.check_for_ban_on_rejected_tx(sig64checksigtx, NULLFAIL_ERROR)
self.check_for_ban_on_rejected_tx(sig64multisigtx,
SCHNORR_MULTISIG_ERROR)
# And they can't be mined either...
self.check_for_ban_on_rejected_block(
self.build_block(tip, [sig64checksigtx]), BADINPUTS_ERROR)
self.check_for_ban_on_rejected_block(
self.build_block(tip, [sig64multisigtx]), BADINPUTS_ERROR)
def run_test(self):
node = self.nodes[0]
self.bootstrap_p2p()
self.log.info("Create some blocks with OP_1 coinbase for spending.")
tip = self.getbestblock(node)
blocks = []
for _ in range(10):
tip = self.build_block(tip)
blocks.append(tip)
node.p2p.send_blocks_and_test(blocks, node, success=True)
spendable_txns = [block.vtx[0] for block in blocks]
self.log.info("Mature the blocks and get out of IBD.")
self.generatetoaddress(node, 100, node.get_deterministic_priv_key().address)
self.log.info("Setting up spends to test and mining the fundings")
# Generate a key pair
privkeybytes = b"INT64!!!" * 4
private_key = ECKey()
private_key.set(privkeybytes, True)
# get uncompressed public key serialization
public_key = private_key.get_pubkey().get_bytes()
def create_fund_and_spend_tx(scriptsigextra, redeemextra) -> Tuple[CTransaction, CTransaction]:
spendfrom = spendable_txns.pop()
redeem_script = CScript(redeemextra + [OP_1, public_key, OP_1, OP_CHECKMULTISIG])
script_pubkey = CScript([OP_HASH160, hash160(redeem_script), OP_EQUAL])
value = spendfrom.vout[0].nValue
value1 = value - 500
# Fund transaction
txfund = create_tx_with_script(spendfrom, 0, b'', value1, script_pubkey)
txfund.rehash()
p2sh = script_to_p2sh(redeem_script)
self.log.info(f"scriptPubKey {script_pubkey!r}")
self.log.info(f"redeemScript {redeem_script!r} -> p2sh address {p2sh}")
# Spend transaction
value2 = value1 - 500
txspend = CTransaction()
txspend.vout.append(
CTxOut(value2, CScript([OP_TRUE])))
txspend.vin.append(
CTxIn(COutPoint(txfund.sha256, 0), b''))
# Sign the transaction
sighashtype = SIGHASH_ALL | SIGHASH_FORKID
hashbyte = bytes([sighashtype & 0xff])
sighash = SignatureHashForkId(
redeem_script, txspend, 0, sighashtype, value1)
txsig = schnorr.sign(privkeybytes, sighash) + hashbyte
dummy = OP_1 # Required for 1-of-1 schnorr sig
txspend.vin[0].scriptSig = ss = CScript([dummy, txsig] + scriptsigextra + [redeem_script])
self.log.info(f"scriptSig: {ss!r}")
txspend.rehash()
return txfund, txspend
mempool = []
# Basic test of OP_MUL 2 * 3 = 6
tx0, tx = create_fund_and_spend_tx([OP_2, OP_3], [OP_MUL, OP_6, OP_EQUALVERIFY])
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle the output from this tx
assert_equal(node.getrawmempool(), mempool)
# Basic test of OP_DIV 6 / 3 = 2
tx0, tx = create_fund_and_spend_tx([OP_6, OP_3], [OP_DIV, OP_2, OP_EQUALVERIFY])
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Divide 2^63-1 by 1 -- This should be 100% ok
ssextra = [CScriptNum(int(2**63 - 1)), OP_1]
rsextra = [OP_DIV, CScriptNum(int(2**63 - 1) // 1), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Divide -2^63-1 / -2^63-1 -- This should be 100% ok
ssextra = [CScriptNum(-int(2**63 - 1)), CScriptNum(-int(2**63 - 1))]
rsextra = [OP_DIV, OP_1, OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Divide -2^63-1 / 2^63-1 -- This should be 100% ok
ssextra = [CScriptNum(-int(2**63 - 1)), CScriptNum(int(2**63 - 1))]
rsextra = [OP_DIV, OP_1NEGATE, OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Divide 2^63-1 / -2^63-1 -- This should be 100% ok
ssextra = [CScriptNum(int(2**63 - 1)), CScriptNum(-int(2**63 - 1))]
rsextra = [OP_DIV, OP_1NEGATE, OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Divide 2^63-1 / 2^63-1 -- This should be 100% ok
ssextra = [CScriptNum(int(2**63 - 1)), CScriptNum(int(2**63 - 1))]
rsextra = [OP_DIV, OP_1, OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Multiply past 2^32 -- should work
ssextra = [CScriptNum(int(2**31)), CScriptNum(int(2**31))]
rsextra = [OP_MUL, CScriptNum(int(2**62)), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Add past (2^31 - 1) -- should work
ssextra = [CScriptNum(int(2**31)), CScriptNum(int(2**31))]
rsextra = [OP_ADD, CScriptNum(int(2**32)), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Sub below -(2^31 - 1) -- should work
ssextra = [CScriptNum(-int(2**31 - 1)), CScriptNum(int(2**31 - 1))]
rsextra = [OP_SUB, CScriptNum(-int(2**32 - 2)), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Divide/multiply mixed: -2^60 * 3 / 6 == -2^59
ssextra = [CScriptNum(-int(2**60)), OP_3]
rsextra = [OP_MUL, OP_6, OP_DIV, CScriptNum(-int(2**59)), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Divide: -2^31 * 3 / -6 == 2^30 (intermediate value outside of 32-bit range)
ssextra = [CScriptNum(-int(2**31)), OP_3]
rsextra = [OP_MUL, CScriptNum(-6), OP_DIV, CScriptNum(int(2**30)), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Divide: -2^32 * 3 / -6 == 2^31 (1 operand & intermediate value > 2^31 - 1)
ssextra = [CScriptNum(-int(2**32)), OP_3]
rsextra = [OP_MUL, CScriptNum(-6), OP_DIV, CScriptNum(int(2**31)), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Multiply past 2^63 - 1 -- funding tx is ok, spending should not be accepted due to out-of-range operand
ssextra = [CScriptNum(int((2**63) - 1)), OP_3]
rsextra = [OP_MUL, OP_DROP, OP_1, OP_1, OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0], node)
node.p2p.send_txs_and_test([tx], node, success=False, expect_disconnect=True,
reject_reason=OVERFLOW_ERROR_BAD_OPERAND)
mempool += [tx0.hash]
assert_equal(node.getrawmempool(), mempool)
self.reconnect_p2p() # we lost the connection from above bad tx, reconnect
# Add past 2^63 - 1 -- funding tx is ok, spending should not be accepted due to bad operand
ssextra = [CScriptNum(int((2**63) - 1)), OP_1]
rsextra = [OP_ADD, OP_DROP, OP_1, OP_1, OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0], node)
node.p2p.send_txs_and_test([tx], node, success=False, expect_disconnect=True,
reject_reason=OVERFLOW_ERROR_BAD_OPERAND)
mempool += [tx0.hash]
assert_equal(node.getrawmempool(), mempool)
self.reconnect_p2p() # we lost the connection from above bad tx, reconnect
# Sub below -2^63 - 1 -- funding tx is ok, spending should not be accepted due to bad operand
ssextra = [CScriptNum(-int((2**63) - 1)), OP_10]
rsextra = [OP_SUB, OP_DROP, OP_1, OP_1, OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0], node)
node.p2p.send_txs_and_test([tx], node, success=False, expect_disconnect=True,
reject_reason=OVERFLOW_ERROR_BAD_OPERAND)
mempool += [tx0.hash]
assert_equal(node.getrawmempool(), mempool)
self.reconnect_p2p() # we lost the connection from above bad tx, reconnect
# Modulo: -(2^63 - 1) % -1. Should not overflow, but yield 0
ssextra = [CScriptNum(-int((2**63) - 1)), OP_1NEGATE]
rsextra = [OP_MOD, OP_0, OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Modulo: -(2^63 - 1) % -(2^63 - 1). Should not overflow, but yield 0
ssextra = [CScriptNum(-int((2**63) - 1)), CScriptNum(-int((2**63) - 1))]
rsextra = [OP_MOD, OP_0, OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Attempt to create the forbidden: -(2^63), but don't use it as a number
ssextra = [bytes((0x80,)) + bytes((0x7f,)) + bytes((0xff,) * 7)]
rsextra = [bytes((0x80,)) + bytes((0x7f,)) + bytes((0xff,) * 7), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# Attempt to create the forbidden: -(2^63), use it as a number
# Note: This generates an overflow exception when deserializing, hence the "unknown error" -- known issue
# with the interpreter.
ssextra = [bytes((0x80,)) + bytes((0x7f,)) + bytes((0xff,) * 7)]
rsextra = [bytes((0x80,)) + bytes((0x7f,)) + bytes((0xff,) * 7), OP_SUB, OP_0, OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0], node)
node.p2p.send_txs_and_test([tx], node, success=False, expect_disconnect=True,
reject_reason=OVERFLOW_ERROR_UNK)
mempool += [tx0.hash]
assert_equal(node.getrawmempool(), mempool)
self.reconnect_p2p() # we lost the connection from above bad tx, reconnect
# OP_NUM2BIN - {2^63 - 1} -> 8-byte BIN should succeed
ssextra = [CScriptNum(int(2**63 - 1)), OP_8]
rsextra = [OP_NUM2BIN, bytes.fromhex('ffffffffffffff7f'), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# OP_NUM2BIN - {2^63 - 1} -> 16-byte BIN should succeed
ssextra = [CScriptNum(int(2**63 - 1)), OP_16]
rsextra = [OP_NUM2BIN, bytes.fromhex('ffffffffffffff7f0000000000000000'), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# OP_NUM2BIN - {-2^63 + 1} -> 8-byte BIN should succeed
ssextra = [CScriptNum(int(-2**63 + 1)), OP_8]
rsextra = [OP_NUM2BIN, bytes.fromhex('ffffffffffffffff'), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# OP_NUM2BIN - {2^63 - 1} -> 7-byte BIN should fail because it won't fit within requested size
ssextra = [CScriptNum(int(2**63 - 1)), OP_7]
rsextra = [OP_NUM2BIN, OP_DROP]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0], node)
node.p2p.send_txs_and_test([tx], node, success=False, expect_disconnect=True,
reject_reason=IMPOSSIBLE_ENCODING_ERROR)
mempool += [tx0.hash]
assert_equal(node.getrawmempool(), mempool)
self.reconnect_p2p() # we lost the connection from above bad tx, reconnect
# OP_NUM2BIN - {2^31 - 1} -> 8-byte BIN should succeed (check that old functionality still works)
ssextra = [CScriptNum(int(2**31 - 1)), OP_8]
rsextra = [OP_NUM2BIN, bytes.fromhex('ffffff7f00000000'), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# OP_NUM2BIN - {2^31 - 1} -> 4-byte BIN should succeed (check that old functionality still works)
ssextra = [CScriptNum(int(2**31 - 1)), OP_4]
rsextra = [OP_NUM2BIN, bytes.fromhex('ffffff7f'), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# OP_BIN2NUM - {BIN 2^63 - 1} should succeed
ssextra = [CScriptNum(int(2**63 - 1))]
rsextra = [OP_BIN2NUM, bytes.fromhex('ffffffffffffff7f'), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# OP_BIN2NUM - {BIN 2^63-1 padded with 8 extra bytes of zeroes} should succeed
ssextra = [CScriptNum.encode(CScriptNum(int(2**63 - 1)))[1:] + bytes.fromhex('00') * 8]
rsextra = [OP_BIN2NUM, bytes.fromhex('ffffffffffffff7f'), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# OP_BIN2NUM - {BIN -2^63+1} should succeed
ssextra = [CScriptNum(int(-2**63 + 1))]
rsextra = [OP_BIN2NUM, bytes.fromhex('ffffffffffffffff'), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# OP_BIN2NUM - {BIN 2^63} when crammed into 8 bytes will be treated as '-0'.. which, oddly, ends up as
# 0 when using BIN2NUM. This is the same quirky behavior as before this feature was added,
# e.g.: 0x80 BIN2NUM -> 0
ssextra = [bytes.fromhex('0000000000000080')]
rsextra = [OP_BIN2NUM, OP_0, OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
assert_equal(node.getrawmempool(), mempool)
# OP_BIN2NUM - {2^63} -> When encoding as not '-0', but what 2^63 would encode as (9-byte value), it should fail
# because it's out of range.
ssextra = [bytes.fromhex('000000000000008000')]
rsextra = [OP_BIN2NUM, OP_DROP]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0], node)
node.p2p.send_txs_and_test([tx], node, success=False, expect_disconnect=True,
reject_reason=OVERFLOW_ERROR_BAD_OPERAND)
mempool += [tx0.hash]
assert_equal(node.getrawmempool(), mempool)
self.reconnect_p2p() # we lost the connection from above bad tx, reconnect
# OP_BIN2NUM - {BIN 2^31-1} should succeed (check that old functionality still works)
ssextra = [CScriptNum(int(2**31 - 1))]
rsextra = [OP_BIN2NUM, bytes.fromhex('ffffff7f'), OP_EQUALVERIFY]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0, tx], node)
mempool += [tx0.hash, tx.hash]
spendable_txns.insert(0, tx) # Recycle te output from this tx
assert_equal(node.getrawmempool(), mempool)
# OP_PICK - {4294967297 OP_PICK} should FAIL on both 64-bit and 32-bit systems
ssextra = [OP_16, OP_15, CScriptNum(4294967297)]
rsextra = [OP_PICK, OP_2, OP_PICK, OP_EQUALVERIFY, OP_DROP, OP_DROP]
tx0, tx = create_fund_and_spend_tx(ssextra, rsextra)
node.p2p.send_txs_and_test([tx0], node)
node.p2p.send_txs_and_test([tx], node, success=False, expect_disconnect=True,
reject_reason=INVALID_STACK_OPERATION)
mempool += [tx0.hash]
assert_equal(node.getrawmempool(), mempool)
self.reconnect_p2p() # we lost the connection from above bad tx, reconnect
# Finally, mine the mempool and ensure that all txns made it into a block
prevtiphash = node.getbestblockhash()
tiphash = self.generatetoaddress(node, 1, node.get_deterministic_priv_key().address)[0]
assert prevtiphash != tiphash
assert_equal(node.getrawmempool(), [])
blockinfo = node.getblock(tiphash, 1)
assert all(txid in blockinfo['tx'] for txid in mempool)
# --------------------------------------------------------------------
# Test that scripts fail evaluation if bigint64 feature is disabled
# --------------------------------------------------------------------
# 1. Restart the node with -reindex-chainstate (to be paranoid)
self.restart_node(0, self.extra_args[0] + ["-reindex-chainstate=1"])
assert_equal(node.getbestblockhash(), tiphash)
# The below tests have been disabled since BCHN no longer has the -upgrade8activationtime argument
# (it has activated already and the height has been hard-coded for all chains).
"""
def run_test(self):
node = self.nodes[0]
node.generate(1) # Leave IBD for sethdseed
self.nodes[0].createwallet(wallet_name='w0')
w0 = node.get_wallet_rpc('w0')
address1 = w0.getnewaddress()
self.log.info("Test disableprivatekeys creation.")
self.nodes[0].createwallet(wallet_name='w1', disable_private_keys=True)
w1 = node.get_wallet_rpc('w1')
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w1.getnewaddress)
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w1.getrawchangeaddress)
w1.importpubkey(w0.getaddressinfo(address1)['pubkey'])
self.log.info('Test that private keys cannot be imported')
eckey = ECKey()
eckey.generate()
privkey = bytes_to_wif(eckey.get_bytes())
assert_raises_rpc_error(
-4,
'Cannot import private keys to a wallet with private keys disabled',
w1.importprivkey, privkey)
if self.options.descriptors:
result = w1.importdescriptors([{
'desc':
descsum_create('wpkh(' + privkey + ')'),
'timestamp':
'now'
}])
else:
result = w1.importmulti([{
'scriptPubKey': {
'address': key_to_p2wpkh(eckey.get_pubkey().get_bytes())
},
'timestamp': 'now',
'keys': [privkey]
}])
assert not result[0]['success']
assert 'warning' not in result[0]
assert_equal(result[0]['error']['code'], -4)
assert_equal(
result[0]['error']['message'],
'Cannot import private keys to a wallet with private keys disabled'
)
self.log.info("Test blank creation with private keys disabled.")
self.nodes[0].createwallet(wallet_name='w2',
disable_private_keys=True,
blank=True)
w2 = node.get_wallet_rpc('w2')
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w2.getnewaddress)
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w2.getrawchangeaddress)
w2.importpubkey(w0.getaddressinfo(address1)['pubkey'])
self.log.info("Test blank creation with private keys enabled.")
self.nodes[0].createwallet(wallet_name='w3',
disable_private_keys=False,
blank=True)
w3 = node.get_wallet_rpc('w3')
assert_equal(w3.getwalletinfo()['keypoolsize'], 0)
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w3.getnewaddress)
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w3.getrawchangeaddress)
# Import private key
w3.importprivkey(generate_wif_key())
# Imported private keys are currently ignored by the keypool
assert_equal(w3.getwalletinfo()['keypoolsize'], 0)
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w3.getnewaddress)
# Set the seed
if self.options.descriptors:
w3.importdescriptors([{
'desc':
descsum_create(
'wpkh(tprv8ZgxMBicQKsPcwuZGKp8TeWppSuLMiLe2d9PupB14QpPeQsqoj3LneJLhGHH13xESfvASyd4EFLJvLrG8b7DrLxEuV7hpF9uUc6XruKA1Wq/0h/*)'
),
'timestamp':
'now',
'active':
True
}, {
'desc':
descsum_create(
'wpkh(tprv8ZgxMBicQKsPcwuZGKp8TeWppSuLMiLe2d9PupB14QpPeQsqoj3LneJLhGHH13xESfvASyd4EFLJvLrG8b7DrLxEuV7hpF9uUc6XruKA1Wq/1h/*)'
),
'timestamp':
'now',
'active':
True,
'internal':
True
}])
else:
w3.sethdseed()
assert_equal(w3.getwalletinfo()['keypoolsize'], 1)
w3.getnewaddress()
w3.getrawchangeaddress()
self.log.info(
"Test blank creation with privkeys enabled and then encryption")
self.nodes[0].createwallet(wallet_name='w4',
disable_private_keys=False,
blank=True)
w4 = node.get_wallet_rpc('w4')
assert_equal(w4.getwalletinfo()['keypoolsize'], 0)
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w4.getnewaddress)
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w4.getrawchangeaddress)
# Encrypt the wallet. Nothing should change about the keypool
w4.encryptwallet('pass')
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w4.getnewaddress)
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w4.getrawchangeaddress)
# Now set a seed and it should work. Wallet should also be encrypted
w4.walletpassphrase('pass', 60)
if self.options.descriptors:
w4.importdescriptors([{
'desc':
descsum_create(
'wpkh(tprv8ZgxMBicQKsPcwuZGKp8TeWppSuLMiLe2d9PupB14QpPeQsqoj3LneJLhGHH13xESfvASyd4EFLJvLrG8b7DrLxEuV7hpF9uUc6XruKA1Wq/0h/*)'
),
'timestamp':
'now',
'active':
True
}, {
'desc':
descsum_create(
'wpkh(tprv8ZgxMBicQKsPcwuZGKp8TeWppSuLMiLe2d9PupB14QpPeQsqoj3LneJLhGHH13xESfvASyd4EFLJvLrG8b7DrLxEuV7hpF9uUc6XruKA1Wq/1h/*)'
),
'timestamp':
'now',
'active':
True,
'internal':
True
}])
else:
w4.sethdseed()
w4.getnewaddress()
w4.getrawchangeaddress()
self.log.info(
"Test blank creation with privkeys disabled and then encryption")
self.nodes[0].createwallet(wallet_name='w5',
disable_private_keys=True,
blank=True)
w5 = node.get_wallet_rpc('w5')
assert_equal(w5.getwalletinfo()['keypoolsize'], 0)
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w5.getnewaddress)
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w5.getrawchangeaddress)
# Encrypt the wallet
assert_raises_rpc_error(
-16,
"Error: wallet does not contain private keys, nothing to encrypt.",
w5.encryptwallet, 'pass')
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w5.getnewaddress)
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
w5.getrawchangeaddress)
self.log.info('New blank and encrypted wallets can be created')
self.nodes[0].createwallet(wallet_name='wblank',
disable_private_keys=False,
blank=True,
passphrase='thisisapassphrase')
wblank = node.get_wallet_rpc('wblank')
assert_raises_rpc_error(
-13,
"Error: Please enter the wallet passphrase with walletpassphrase first.",
wblank.signmessage, "needanargument", "test")
wblank.walletpassphrase('thisisapassphrase', 60)
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
wblank.getnewaddress)
assert_raises_rpc_error(-4, "Error: This wallet has no available keys",
wblank.getrawchangeaddress)
self.log.info('Test creating a new encrypted wallet.')
# Born encrypted wallet is created (has keys)
self.nodes[0].createwallet(wallet_name='w6',
disable_private_keys=False,
blank=False,
passphrase='thisisapassphrase')
w6 = node.get_wallet_rpc('w6')
assert_raises_rpc_error(
-13,
"Error: Please enter the wallet passphrase with walletpassphrase first.",
w6.signmessage, "needanargument", "test")
w6.walletpassphrase('thisisapassphrase', 60)
w6.signmessage(w6.getnewaddress('', 'legacy'), "test")
w6.keypoolrefill(1)
# There should only be 1 key for legacy, 3 for descriptors
walletinfo = w6.getwalletinfo()
keys = 3 if self.options.descriptors else 1
assert_equal(walletinfo['keypoolsize'], keys)
assert_equal(walletinfo['keypoolsize_hd_internal'], keys)
# Allow empty passphrase, but there should be a warning
resp = self.nodes[0].createwallet(wallet_name='w7',
disable_private_keys=False,
blank=False,
passphrase='')
assert 'Empty string given as passphrase, wallet will not be encrypted.' in resp[
'warning']
w7 = node.get_wallet_rpc('w7')
assert_raises_rpc_error(
-15,
'Error: running with an unencrypted wallet, but walletpassphrase was called.',
w7.walletpassphrase, '', 60)
self.log.info('Test making a wallet with avoid reuse flag')
self.nodes[0].createwallet(
'w8', False, False, '', True
) # Use positional arguments to check for bug where avoid_reuse could not be set for wallets without needing them to be encrypted
w8 = node.get_wallet_rpc('w8')
assert_raises_rpc_error(
-15,
'Error: running with an unencrypted wallet, but walletpassphrase was called.',
w7.walletpassphrase, '', 60)
assert_equal(w8.getwalletinfo()["avoid_reuse"], True)
self.log.info(
'Using a passphrase with private keys disabled returns error')
assert_raises_rpc_error(
-4,
'Passphrase provided but private keys are disabled. A passphrase is only used to encrypt private keys, so cannot be used for wallets with private keys disabled.',
self.nodes[0].createwallet,
wallet_name='w9',
disable_private_keys=True,
passphrase='thisisapassphrase')
def run_test(self):
# Generate enough blocks to trigger certain block votes and activate BIP65 (version 4 blocks)
amt = 1352 - self.nodes[0].getblockcount()
for i in range(int(amt / 100)):
self.nodes[0].generate(100)
self.sync_all()
self.nodes[0].generate(1352 - self.nodes[0].getblockcount())
self.sync_all()
self.log.info("checking: not on chain tip")
badtip = self.nodes[0].getblockhash(self.nodes[0].getblockcount() - 1)
height = self.nodes[0].getblockcount()
tip = self.nodes[0].getblockhash(height)
coinbase = bu_create_coinbase(height + 1)
cur_time = int(time.time())
self.nodes[0].setmocktime(cur_time)
self.nodes[1].setmocktime(cur_time)
block = create_block(badtip, coinbase, cur_time + 600)
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: does not build on chain tip",
self.nodes[0].validateblocktemplate, hexblk)
self.log.info("checking: time too far in the past")
block = create_block(tip, coinbase, cur_time - 100)
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: time-too-old",
self.nodes[0].validateblocktemplate, hexblk)
self.log.info("checking: time too far in the future")
block = create_block(tip, coinbase, cur_time + 10000000)
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: time-too-new",
self.nodes[0].validateblocktemplate, hexblk)
self.log.info("checking: bad version 1")
block = create_block(tip, coinbase, cur_time + 600)
block.nVersion = 1
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: bad-version",
self.nodes[0].validateblocktemplate, hexblk)
self.log.info("checking: bad version 2")
block = create_block(tip, coinbase, cur_time + 600)
block.nVersion = 2
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: bad-version",
self.nodes[0].validateblocktemplate, hexblk)
self.log.info("checking: bad version 3")
block = create_block(tip, coinbase, cur_time + 600)
block.nVersion = 3
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: bad-version",
self.nodes[0].validateblocktemplate, hexblk)
# Note: 'bad-cb-height' test case cannot be tested , because regtest
# always has BIP34 checks disabled.
self.log.info("checking: bad merkle root")
block = create_block(tip, coinbase, cur_time + 600)
block.nVersion = 0x20000000
block.hashMerkleRoot = 0x12345678
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: bad-txnmrklroot",
self.nodes[0].validateblocktemplate, hexblk)
self.log.info("checking: no tx")
block = create_block(tip, None, cur_time + 600)
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: bad-cb-missing",
self.nodes[0].validateblocktemplate, hexblk)
self.log.info("checking: good block")
block = create_block(tip, coinbase, cur_time + 600)
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
# validate good block
self.nodes[0].validateblocktemplate(hexblk)
block.solve()
hexblk = ToHex(block)
self.nodes[0].submitblock(hexblk)
self.sync_all()
prev_block = block
# out_value is less than 50BTC because regtest halvings happen every 150 blocks, and is in Satoshis
out_value = block.vtx[0].vout[0].nValue
tx1 = create_transaction(prev_block.vtx[0], 0, b'\x61'*50 + b'\x51', [int(out_value / 2), int(out_value / 2)])
height = self.nodes[0].getblockcount()
tip = self.nodes[0].getblockhash(height)
coinbase = bu_create_coinbase(height + 1)
next_time = cur_time + 1200
self.log.info("checking: no coinbase")
block = create_block(tip, None, next_time, txns=[tx1])
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: bad-cb-missing",
self.nodes[0].validateblocktemplate, hexblk)
self.log.info("checking: double coinbase")
coinbase_key = ECKey()
#coinbase_key.set_secretbytes(b"horsebattery")
coinbase_key.set(b"horsbatt" * 4, True)
coinbase_pubkey = coinbase_key.get_pubkey()
coinbase2 = bu_create_coinbase(height + 1, coinbase_pubkey.get_bytes())
block = create_block(tip, coinbase, next_time, txns=[coinbase2, tx1])
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: bad-tx-coinbase",
self.nodes[0].validateblocktemplate, hexblk)
self.log.info("checking: premature coinbase spend")
block = create_block(tip, coinbase, next_time, txns=[tx1])
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: bad-txns-premature-spend-of-coinbase",
self.nodes[0].validateblocktemplate, hexblk)
self.nodes[0].generate(100)
self.sync_all()
height = self.nodes[0].getblockcount()
tip = self.nodes[0].getblockhash(height)
coinbase = bu_create_coinbase(height + 1)
next_time = cur_time + 1200
op1 = CScript([OP_1])
self.log.info("checking: inputs below outputs")
tx6 = create_transaction(prev_block.vtx[0], 0, op1, [out_value + 1000])
block = create_block(tip, coinbase, next_time, txns=[tx6])
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: bad-txns-in-belowout",
self.nodes[0].validateblocktemplate, hexblk)
tx5 = create_transaction(prev_block.vtx[0], 0, op1, [int(21000001 * COIN)])
self.log.info("checking: money range")
block = create_block(tip, coinbase, next_time, txns=[tx5])
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: bad-txns-vout-toolarge",
self.nodes[0].validateblocktemplate, hexblk)
self.log.info("checking: bad tx offset")
tx_bad = create_broken_transaction(prev_block.vtx[0], 1, op1, [int(out_value / 4)])
block = create_block(tip, coinbase, next_time, txns=[tx_bad])
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: bad-txns-inputs-missingorspent",
self.nodes[0].validateblocktemplate, hexblk)
self.log.info("checking: bad tx offset largest number")
tx_bad = create_broken_transaction(prev_block.vtx[0], 0xffffffff, op1, [int(out_value / 4)])
block = create_block(tip, coinbase, next_time, txns=[tx_bad])
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: bad-txns-inputs-missingorspent",
self.nodes[0].validateblocktemplate, hexblk)
self.log.info("checking: double tx")
tx2 = create_transaction(prev_block.vtx[0], 0, op1, [int(out_value / 4)])
block = create_block(tip, coinbase, next_time, txns=[tx2, tx2])
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: tx-duplicate",
self.nodes[0].validateblocktemplate, hexblk)
tx3 = create_transaction(prev_block.vtx[0], 0, op1, [int(out_value / 9), int(out_value / 10)])
tx4 = create_transaction(prev_block.vtx[0], 0, op1, [int(out_value / 8), int(out_value / 7)])
self.log.info("checking: double spend")
block = create_block(tip, coinbase, next_time, txns=[tx3, tx4])
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: bad-txns-inputs-missingorspent",
self.nodes[0].validateblocktemplate, hexblk)
txes = [tx3, tx4]
txes.sort(key=lambda x: x.hash, reverse=True)
self.log.info("checking: bad tx ordering")
block = create_block(tip, coinbase, next_time, txns=txes, ctor=False)
block.nVersion = 0x20000000
block.rehash()
hexblk = ToHex(block)
assert_raises_rpc_error(-25, "Invalid block: tx-ordering",
self.nodes[0].validateblocktemplate, hexblk)
tx_good = create_transaction(prev_block.vtx[0], 0, b'\x51', [int(out_value / 50)] * 50, out=b"")
self.log.info("checking: good tx")
block = create_block(tip, coinbase, next_time, txns=[tx_good])
block.nVersion = 0x20000000
block.rehash()
block.solve()
hexblk = ToHex(block)
self.nodes[0].validateblocktemplate(hexblk)
self.nodes[0].submitblock(hexblk)
self.sync_all()
height = self.nodes[0].getblockcount()
tip = self.nodes[0].getblockhash(height)
coinbase = bu_create_coinbase(height + 1)
next_time = next_time + 600
coinbase_key = ECKey()
#coinbase_key.set_secretbytes(b"horsebattery")
coinbase_key.set(b"horsbatt" * 4, True)
coinbase_pubkey = coinbase_key.get_pubkey()
#coinbase3 = bu_create_coinbase(height + 1, coinbase_pubkey)
bu_create_coinbase(height + 1, coinbase_pubkey.get_bytes())
txl = []
for i in range(0, 50):
ov = block.vtx[1].vout[i].nValue
txl.append(create_transaction(block.vtx[1], i, op1, [int(ov / 50)] * 50))
block = create_block(tip, coinbase, next_time, txns=txl)
block.nVersion = 0x20000000
block.rehash()
block.solve()
hexblk = ToHex(block)
for n in self.nodes:
n.validateblocktemplate(hexblk)
# Note: BCHN does not have RPC method like BU's 'setminingmaxblocksize' yet,
# therefore we omit some test cases related to excessiveblock size when
# modifying that setting on the fly.
#
# The related BU error messages that we do not test for here are:
# - RPC error 25, message: "Invalid block: excessive"
# - RPC error 25, message: "Sorry, your maximum mined block (1000) is larger than your proposed excessive size (999). This would cause you to orphan your own blocks."
# Randomly change bytes
for it in range(0, 100):
h2 = hexblk
pos = random.randint(0, len(hexblk))
val = random.randint(0, 15)
h3 = h2[:pos] + ('{:x}'.format(val)) + h2[pos + 1:]
try:
self.nodes[0].validateblocktemplate(h3)
except JSONRPCException as e:
if e.error["code"] in (-1, -22, -25):
self.log.info(f"Got expected exception: " + str(e))
else:
self.log.exception(f"Failed for iteration {it}")
# its ok we expect garbage
self.nodes[1].submitblock(hexblk)
self.sync_all()
height = self.nodes[0].getblockcount()
tip = self.nodes[0].getblockhash(height)
coinbase = bu_create_coinbase(height + 1)
next_time = next_time + 600
prev_block = block
txl = []
for tx in prev_block.vtx:
for outp in range(0, len(tx.vout)):
ov = tx.vout[outp].nValue
txl.append(create_transaction(tx, outp, CScript([OP_CHECKSIG] * 100), [int(ov / 2)] * 2))
block = create_block(tip, coinbase, next_time, txns=txl)
block.nVersion = 0x20000000
block.rehash()
block.solve()
hexblk = ToHex(block)
for n in self.nodes:
assert_raises_rpc_error(-25, "Invalid block: bad-txns-premature-spend-of-coinbase",
self.nodes[0].validateblocktemplate, hexblk)
def run_test(self):
node, = self.nodes
self.bootstrap_p2p()
tip = self.getbestblock(node)
self.log.info("Create some blocks with OP_1 coinbase for spending.")
blocks = []
for _ in range(10):
tip = self.build_block(tip)
blocks.append(tip)
node.p2p.send_blocks_and_test(blocks, node, success=True)
spendable_outputs = [block.vtx[0] for block in blocks]
self.log.info("Mature the blocks and get out of IBD.")
node.generatetoaddress(100, node.get_deterministic_priv_key().address)
tip = self.getbestblock(node)
self.log.info("Setting up spends to test and mining the fundings.")
fundings = []
# Generate a key pair
privkeybytes = b"Schnorr!" * 4
private_key = ECKey()
private_key.set(privkeybytes, True)
# get uncompressed public key serialization
public_key = private_key.get_pubkey().get_bytes()
def create_fund_and_spend_tx(dummy=OP_0, sigtype='ecdsa'):
spendfrom = spendable_outputs.pop()
script = CScript([OP_1, public_key, OP_1, OP_CHECKMULTISIG])
value = spendfrom.vout[0].nValue
# Fund transaction
txfund = create_tx_with_script(spendfrom, 0, b'', value, script)
txfund.rehash()
fundings.append(txfund)
# Spend transaction
txspend = CTransaction()
txspend.vout.append(CTxOut(value - 1000, CScript([OP_TRUE])))
txspend.vin.append(CTxIn(COutPoint(txfund.sha256, 0), b''))
# Sign the transaction
sighashtype = SIGHASH_ALL | SIGHASH_FORKID
hashbyte = bytes([sighashtype & 0xff])
sighash = SignatureHashForkId(script, txspend, 0, sighashtype,
value)
if sigtype == 'schnorr':
txsig = schnorr.sign(privkeybytes, sighash) + hashbyte
elif sigtype == 'ecdsa':
txsig = private_key.sign_ecdsa(sighash) + hashbyte
txspend.vin[0].scriptSig = CScript([dummy, txsig])
txspend.rehash()
return txspend
# This is valid.
ecdsa0tx = create_fund_and_spend_tx(OP_0, 'ecdsa')
# This is invalid.
ecdsa1tx = create_fund_and_spend_tx(OP_1, 'ecdsa')
# This is invalid.
schnorr0tx = create_fund_and_spend_tx(OP_0, 'schnorr')
# This is valid.
schnorr1tx = create_fund_and_spend_tx(OP_1, 'schnorr')
tip = self.build_block(tip, fundings)
node.p2p.send_blocks_and_test([tip], node)
self.log.info("Send a legacy ECDSA multisig into mempool.")
node.p2p.send_txs_and_test([ecdsa0tx], node)
assert_equal(node.getrawmempool(), [ecdsa0tx.hash])
self.log.info("Trying to mine a non-null-dummy ECDSA.")
self.check_for_ban_on_rejected_block(self.build_block(tip, [ecdsa1tx]),
BADINPUTS_ERROR)
self.log.info(
"If we try to submit it by mempool or RPC, it is rejected and we are banned"
)
assert_raises_rpc_error(-26, ECDSA_NULLDUMMY_ERROR,
node.sendrawtransaction, ToHex(ecdsa1tx))
self.check_for_ban_on_rejected_tx(ecdsa1tx, ECDSA_NULLDUMMY_ERROR)
self.log.info(
"Submitting a Schnorr-multisig via net, and mining it in a block")
node.p2p.send_txs_and_test([schnorr1tx], node)
assert_equal(set(node.getrawmempool()),
{ecdsa0tx.hash, schnorr1tx.hash})
tip = self.build_block(tip, [schnorr1tx])
node.p2p.send_blocks_and_test([tip], node)
self.log.info(
"That legacy ECDSA multisig is still in mempool, let's mine it")
assert_equal(node.getrawmempool(), [ecdsa0tx.hash])
tip = self.build_block(tip, [ecdsa0tx])
node.p2p.send_blocks_and_test([tip], node)
assert_equal(node.getrawmempool(), [])
self.log.info(
"Trying Schnorr in legacy multisig is invalid and banworthy.")
self.check_for_ban_on_rejected_tx(schnorr0tx,
SCHNORR_LEGACY_MULTISIG_ERROR)
self.check_for_ban_on_rejected_block(
self.build_block(tip, [schnorr0tx]), BADINPUTS_ERROR)
def run_test(self):
self.log.info("Mining blocks...")
self.nodes[0].generate(101)
self.sync_all()
# address
address1 = self.nodes[0].getnewaddress()
# pubkey
address2 = self.nodes[0].getnewaddress()
# privkey
eckey = ECKey()
eckey.generate()
address3_privkey = bytes_to_wif(eckey.get_bytes())
address3 = key_to_p2wpkh(eckey.get_pubkey().get_bytes())
self.nodes[0].importprivkey(address3_privkey)
# Check only one address
address_info = self.nodes[0].getaddressinfo(address1)
assert_equal(address_info['ismine'], True)
self.sync_all()
# Node 1 sync test
assert_equal(self.nodes[1].getblockcount(), 101)
# Address Test - before import
address_info = self.nodes[1].getaddressinfo(address1)
assert_equal(address_info['iswatchonly'], False)
assert_equal(address_info['ismine'], False)
address_info = self.nodes[1].getaddressinfo(address2)
assert_equal(address_info['iswatchonly'], False)
assert_equal(address_info['ismine'], False)
address_info = self.nodes[1].getaddressinfo(address3)
assert_equal(address_info['iswatchonly'], False)
assert_equal(address_info['ismine'], False)
# Send funds to self
txnid1 = self.nodes[0].sendtoaddress(address1, 0.1)
self.nodes[0].generate(1)
rawtxn1 = self.nodes[0].gettransaction(txnid1)['hex']
proof1 = self.nodes[0].gettxoutproof([txnid1])
txnid2 = self.nodes[0].sendtoaddress(address2, 0.05)
self.nodes[0].generate(1)
rawtxn2 = self.nodes[0].gettransaction(txnid2)['hex']
proof2 = self.nodes[0].gettxoutproof([txnid2])
txnid3 = self.nodes[0].sendtoaddress(address3, 0.025)
self.nodes[0].generate(1)
rawtxn3 = self.nodes[0].gettransaction(txnid3)['hex']
proof3 = self.nodes[0].gettxoutproof([txnid3])
self.sync_all()
# Import with no affiliated address
assert_raises_rpc_error(-5, "No addresses",
self.nodes[1].importprunedfunds, rawtxn1,
proof1)
balance1 = self.nodes[1].getbalance()
assert_equal(balance1, Decimal(0))
# Import with affiliated address with no rescan
self.nodes[1].createwallet('wwatch', disable_private_keys=True)
wwatch = self.nodes[1].get_wallet_rpc('wwatch')
wwatch.importaddress(address=address2, rescan=False)
wwatch.importprunedfunds(rawtransaction=rawtxn2, txoutproof=proof2)
assert [
tx for tx in wwatch.listtransactions(include_watchonly=True)
if tx['txid'] == txnid2
]
# Import with private key with no rescan
w1 = self.nodes[1].get_wallet_rpc(self.default_wallet_name)
w1.importprivkey(privkey=address3_privkey, rescan=False)
w1.importprunedfunds(rawtxn3, proof3)
assert [tx for tx in w1.listtransactions() if tx['txid'] == txnid3]
balance3 = w1.getbalance()
assert_equal(balance3, Decimal('0.025'))
# Addresses Test - after import
address_info = w1.getaddressinfo(address1)
assert_equal(address_info['iswatchonly'], False)
assert_equal(address_info['ismine'], False)
address_info = wwatch.getaddressinfo(address2)
if self.options.descriptors:
assert_equal(address_info['iswatchonly'], False)
assert_equal(address_info['ismine'], True)
else:
assert_equal(address_info['iswatchonly'], True)
assert_equal(address_info['ismine'], False)
address_info = w1.getaddressinfo(address3)
assert_equal(address_info['iswatchonly'], False)
assert_equal(address_info['ismine'], True)
# Remove transactions
assert_raises_rpc_error(-8, "Transaction does not exist in wallet.",
w1.removeprunedfunds, txnid1)
assert not [
tx for tx in w1.listtransactions(include_watchonly=True)
if tx['txid'] == txnid1
]
wwatch.removeprunedfunds(txnid2)
assert not [
tx for tx in wwatch.listtransactions(include_watchonly=True)
if tx['txid'] == txnid2
]
w1.removeprunedfunds(txnid3)
assert not [
tx for tx in w1.listtransactions(include_watchonly=True)
if tx['txid'] == txnid3
]
def run_test(self):
node = self.nodes[0]
node.add_p2p_connection(P2PDataStore())
node.setmocktime(REPLAY_PROTECTION_START_TIME)
self.genesis_hash = int(node.getbestblockhash(), 16)
self.block_heights[self.genesis_hash] = 0
spendable_outputs = []
# save the current tip so it can be spent by a later block
def save_spendable_output():
spendable_outputs.append(self.tip)
# get an output that we previously marked as spendable
def get_spendable_output():
return PreviousSpendableOutput(spendable_outputs.pop(0).vtx[0], 0)
# move the tip back to a previous block
def tip(number):
self.tip = self.blocks[number]
# adds transactions to the block and updates state
def update_block(block_number, new_transactions):
block = self.blocks[block_number]
block.vtx.extend(new_transactions)
old_sha256 = block.sha256
make_conform_to_ctor(block)
block.hashMerkleRoot = block.calc_merkle_root()
block.solve()
# Update the internal state just like in next_block
self.tip = block
if block.sha256 != old_sha256:
self.block_heights[
block.sha256] = self.block_heights[old_sha256]
del self.block_heights[old_sha256]
self.blocks[block_number] = block
return block
# shorthand
block = self.next_block
# Create a new block
block(0)
save_spendable_output()
node.p2p.send_blocks_and_test([self.tip], node)
# Now we need that block to mature so we can spend the coinbase.
maturity_blocks = []
for i in range(99):
block(5000 + i)
maturity_blocks.append(self.tip)
save_spendable_output()
node.p2p.send_blocks_and_test(maturity_blocks, node)
# collect spendable outputs now to avoid cluttering the code later on
out = []
for i in range(100):
out.append(get_spendable_output())
# Generate a key pair to test P2SH sigops count
private_key = ECKey()
private_key.generate()
public_key = private_key.get_pubkey().get_bytes()
# This is a little handier to use than the version in blocktools.py
def create_fund_and_spend_tx(spend, forkvalue=0):
# Fund transaction
script = CScript([public_key, OP_CHECKSIG])
txfund = create_tx_with_script(spend.tx,
spend.n,
b'',
amount=50 * COIN - 1000,
script_pub_key=script)
txfund.rehash()
# Spend transaction
txspend = CTransaction()
txspend.vout.append(CTxOut(50 * COIN - 2000, CScript([OP_TRUE])))
txspend.vin.append(CTxIn(COutPoint(txfund.sha256, 0), b''))
# Sign the transaction
sighashtype = (forkvalue << 8) | SIGHASH_ALL | SIGHASH_FORKID
sighash = SignatureHashForkId(script, txspend, 0, sighashtype,
50 * COIN - 1000)
sig = private_key.sign_ecdsa(sighash) + \
bytes(bytearray([SIGHASH_ALL | SIGHASH_FORKID]))
txspend.vin[0].scriptSig = CScript([sig])
txspend.rehash()
return [txfund, txspend]
def send_transaction_to_mempool(tx):
tx_id = node.sendrawtransaction(ToHex(tx))
assert tx_id in set(node.getrawmempool())
return tx_id
# Before the fork, no replay protection required to get in the mempool.
txns = create_fund_and_spend_tx(out[0])
send_transaction_to_mempool(txns[0])
send_transaction_to_mempool(txns[1])
# And txns get mined in a block properly.
block(1)
update_block(1, txns)
node.p2p.send_blocks_and_test([self.tip], node)
# Replay protected transactions are rejected.
replay_txns = create_fund_and_spend_tx(out[1], 0xffdead)
send_transaction_to_mempool(replay_txns[0])
assert_raises_rpc_error(-26, RPC_INVALID_SIGNATURE_ERROR,
node.sendrawtransaction, ToHex(replay_txns[1]))
# And block containing them are rejected as well.
block(2)
update_block(2, replay_txns)
node.p2p.send_blocks_and_test([self.tip],
node,
success=False,
reject_reason='blk-bad-inputs')
# Rewind bad block
tip(1)
# Create a block that would activate the replay protection.
bfork = block(5555)
bfork.nTime = REPLAY_PROTECTION_START_TIME - 1
update_block(5555, [])
node.p2p.send_blocks_and_test([self.tip], node)
activation_blocks = []
for i in range(5):
block(5100 + i)
activation_blocks.append(self.tip)
node.p2p.send_blocks_and_test(activation_blocks, node)
# Check we are just before the activation time
assert_equal(node.getblockchaininfo()['mediantime'],
REPLAY_PROTECTION_START_TIME - 1)
# We are just before the fork, replay protected txns still are rejected
assert_raises_rpc_error(-26, RPC_INVALID_SIGNATURE_ERROR,
node.sendrawtransaction, ToHex(replay_txns[1]))
block(3)
update_block(3, replay_txns)
node.p2p.send_blocks_and_test([self.tip],
node,
success=False,
reject_reason='blk-bad-inputs')
# Rewind bad block
tip(5104)
# Send some non replay protected txns in the mempool to check
# they get cleaned at activation.
txns = create_fund_and_spend_tx(out[2])
send_transaction_to_mempool(txns[0])
tx_id = send_transaction_to_mempool(txns[1])
# Activate the replay protection
block(5556)
node.p2p.send_blocks_and_test([self.tip], node)
# Check we just activated the replay protection
assert_equal(node.getblockchaininfo()['mediantime'],
REPLAY_PROTECTION_START_TIME)
# Non replay protected transactions are not valid anymore,
# so they should be removed from the mempool.
assert tx_id not in set(node.getrawmempool())
# Good old transactions are now invalid.
send_transaction_to_mempool(txns[0])
assert_raises_rpc_error(-26, RPC_INVALID_SIGNATURE_ERROR,
node.sendrawtransaction, ToHex(txns[1]))
# They also cannot be mined
block(4)
update_block(4, txns)
node.p2p.send_blocks_and_test([self.tip],
node,
success=False,
reject_reason='blk-bad-inputs')
# Rewind bad block
tip(5556)
# The replay protected transaction is now valid
replay_tx0_id = send_transaction_to_mempool(replay_txns[0])
replay_tx1_id = send_transaction_to_mempool(replay_txns[1])
# Make sure the transaction are ready to be mined.
tmpl = node.getblocktemplate()
found_id0 = False
found_id1 = False
for txn in tmpl['transactions']:
txid = txn['txid']
if txid == replay_tx0_id:
found_id0 = True
elif txid == replay_tx1_id:
found_id1 = True
assert found_id0 and found_id1
# And the mempool is still in good shape.
assert replay_tx0_id in set(node.getrawmempool())
assert replay_tx1_id in set(node.getrawmempool())
# They also can also be mined
block(5)
update_block(5, replay_txns)
node.p2p.send_blocks_and_test([self.tip], node)
# Ok, now we check if a reorg work properly across the activation.
postforkblockid = node.getbestblockhash()
node.invalidateblock(postforkblockid)
assert replay_tx0_id in set(node.getrawmempool())
assert replay_tx1_id in set(node.getrawmempool())
# Deactivating replay protection.
forkblockid = node.getbestblockhash()
node.invalidateblock(forkblockid)
# The funding tx is not evicted from the mempool, since it's valid in
# both sides of the fork
assert replay_tx0_id in set(node.getrawmempool())
assert replay_tx1_id not in set(node.getrawmempool())
# Check that we also do it properly on deeper reorg.
node.reconsiderblock(forkblockid)
node.reconsiderblock(postforkblockid)
node.invalidateblock(forkblockid)
assert replay_tx0_id in set(node.getrawmempool())
assert replay_tx1_id not in set(node.getrawmempool())
def gen_privkey():
pk = ECKey()
pk.generate()
return pk
