def check_delegation_init_error(delegation, message):
node.assert_start_raises_init_error(
self.extra_args[0] + [
"-avadelegation={}".format(delegation),
"-avaproof={}".format(proof),
"-avamasterkey={}".format(
bytes_to_wif(delegated_privkey.get_bytes())),
],
expected_msg="Error: " + message,
)
def get_keys(self):
self.pub = []
self.priv = []
node0, node1, node2 = self.nodes
for _ in range(self.nkeys):
k = ECKey()
k.generate()
self.pub.append(k.get_pubkey().get_bytes().hex())
self.priv.append(bytes_to_wif(k.get_bytes(), k.is_compressed))
self.final = node2.getnewaddress()
def get_generate_key():
"""Generate a fresh key
Returns a named tuple of privkey, pubkey and all address and scripts."""
eckey = ECKey()
eckey.generate()
privkey = bytes_to_wif(eckey.get_bytes())
pubkey = eckey.get_pubkey().get_bytes().hex()
pkh = hash160(hex_str_to_bytes(pubkey))
return Key(privkey=privkey,
pubkey=pubkey,
p2pkh_script=CScript(
[OP_DUP, OP_HASH160, pkh, OP_EQUALVERIFY, OP_CHECKSIG]).hex(),
p2pkh_addr=key_to_p2pkh(pubkey))
def gen_proof(self, node):
blockhashes = node.generate(10)
privkey = ECKey()
privkey.generate()
pubkey = privkey.get_pubkey()
stakes = create_coinbase_stakes(node, blockhashes,
node.get_deterministic_priv_key().key)
proof_hex = node.buildavalancheproof(42, 2000000000,
pubkey.get_bytes().hex(), stakes)
return bytes_to_wif(privkey.get_bytes()), FromHex(
AvalancheProof(), proof_hex)
def test_receive_proof(self):
self.log.info("Test a peer is created on proof reception")
node = self.nodes[0]
_, proof = self.gen_proof(node)
peer = node.add_p2p_connection(P2PInterface())
msg = msg_avaproof()
msg.proof = proof
peer.send_message(msg)
wait_until(lambda: proof.proofid in get_proof_ids(node))
self.log.info("Test receiving a proof with missing utxo is orphaned")
privkey = ECKey()
privkey.generate()
orphan_hex = node.buildavalancheproof(
42, 2000000000,
privkey.get_pubkey().get_bytes().hex(),
[{
'txid': '0' * 64,
'vout': 0,
'amount': 10e6,
'height': 42,
'iscoinbase': False,
'privatekey': bytes_to_wif(privkey.get_bytes()),
}])
orphan = FromHex(AvalancheProof(), orphan_hex)
orphan_proofid = "{:064x}".format(orphan.proofid)
msg = msg_avaproof()
msg.proof = orphan
peer.send_message(msg)
wait_for_proof(node, orphan_proofid, expect_orphan=True)
def test_orphan_download(self, context):
node = self.nodes[0]
privkey = ECKey()
privkey.generate()
privkey_wif = bytes_to_wif(privkey.get_bytes())
# Build a proof with missing utxos so it will be orphaned
orphan = node.buildavalancheproof(
42, 2000000000,
privkey.get_pubkey().get_bytes().hex(), [{
'txid': '0' * 64,
'vout': 0,
'amount': 10e6,
'height': 42,
'iscoinbase': False,
'privatekey': privkey_wif,
}])
proofid = FromHex(AvalancheProof(), orphan).proofid
proofid_hex = "{:064x}".format(proofid)
self.restart_node(0,
extra_args=self.extra_args[0] + [
"-avaproof={}".format(orphan),
"-avamasterkey={}".format(privkey_wif),
])
node.generate(1)
wait_for_proof(node, proofid_hex, expect_orphan=True)
peer = node.add_p2p_connection(context.p2p_conn())
peer.send_message(msg_inv([CInv(t=context.inv_type, h=proofid)]))
# Give enough time for the node to eventually request the proof.
node.setmocktime(
int(time.time()) + context.constants.getdata_interval + 1)
peer.sync_with_ping()
assert_equal(peer.getdata_count, 0)
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,
create_coinbase_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)
if self.is_wallet_compiled():
self.log.info(
"A proof using the maximum number of stakes is accepted...")
new_blocks = node.generate(AVALANCHE_MAX_PROOF_STAKES // 10 + 1)
# confirm the coinbase UTXOs
node.generate(101)
too_many_stakes = create_stakes(
node, new_blocks, AVALANCHE_MAX_PROOF_STAKES + 1)
maximum_stakes = too_many_stakes[:-1]
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
no_stake = node.buildavalancheproof(
proof_sequence, proof_expiration, proof_master, [])
assert_raises_rpc_error(-8, "The proof is invalid",
node.delegateavalancheproof,
no_stake,
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")
dust = node.buildavalancheproof(
proof_sequence, proof_expiration, proof_master,
create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key, amount="0"))
dust_amount = Decimal(f"{PROOF_DUST_THRESHOLD * 0.9999:.4f}")
dust2 = node.buildavalancheproof(
proof_sequence, proof_expiration, proof_master,
create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key,
amount=str(dust_amount)))
duplicate_stake = node.buildavalancheproof(
proof_sequence, proof_expiration, proof_master,
create_coinbase_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(dust2,
"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")
if self.is_wallet_compiled():
# 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 run_test(self):
# Turn off node 1 while node 0 mines blocks to generate stakes,
# so that we can later try starting node 1 with an orphan proof.
self.stop_node(1)
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
stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
proof = node.buildavalancheproof(proof_sequence, proof_expiration,
proof_master, stakes)
self.log.info("Test decodeavalancheproof RPC")
proofobj = FromHex(AvalancheProof(), proof)
decodedproof = node.decodeavalancheproof(proof)
limited_id_hex = f"{proofobj.limited_proofid:0{64}x}"
assert_equal(decodedproof["sequence"], proof_sequence)
assert_equal(decodedproof["expiration"], proof_expiration)
assert_equal(decodedproof["master"], proof_master)
assert_equal(decodedproof["proofid"], f"{proofobj.proofid:0{64}x}")
assert_equal(decodedproof["limitedid"], limited_id_hex)
assert_equal(decodedproof["stakes"][0]["txid"], stakes[0]["txid"])
assert_equal(decodedproof["stakes"][0]["vout"], stakes[0]["vout"])
assert_equal(decodedproof["stakes"][0]["height"], stakes[0]["height"])
assert_equal(decodedproof["stakes"][0]["iscoinbase"],
stakes[0]["iscoinbase"])
assert_equal(decodedproof["stakes"][0]["signature"],
base64.b64encode(proofobj.stakes[0].sig).decode("ascii"))
# Invalid hex (odd number of hex digits)
assert_raises_rpc_error(-22, "Proof must be an hexadecimal string",
node.decodeavalancheproof, proof[:-1])
# Valid hex but invalid proof
assert_raises_rpc_error(-22, "Proof has invalid format",
node.decodeavalancheproof, proof[:-2])
# Restart the node with this proof
self.restart_node(
0, self.extra_args[0] + [
"-avaproof={}".format(proof),
"-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
])
self.log.info("The proof is registered at first chaintip update")
assert_equal(len(node.getavalanchepeerinfo()), 0)
node.generate(1)
wait_until(lambda: len(node.getavalanchepeerinfo()) == 1, timeout=5)
# This case will occur for users building proofs with a third party
# tool and then starting a new node that is not yet aware of the
# transactions used for stakes.
self.log.info("Start a node with an orphan proof")
self.start_node(
1, self.extra_args[0] + [
"-avaproof={}".format(proof),
"-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
])
# Mine a block to trigger an attempt at registering the proof
self.nodes[1].generate(1)
wait_for_proof(self.nodes[1],
f"{proofobj.proofid:0{64}x}",
expect_orphan=True)
self.log.info("Connect to an up-to-date node to unorphan the proof")
connect_nodes(self.nodes[1], node)
self.sync_all()
wait_for_proof(self.nodes[1],
f"{proofobj.proofid:0{64}x}",
expect_orphan=False)
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(
limited_id_hex,
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
no_stake = node.buildavalancheproof(proof_sequence, proof_expiration,
proof_master, [])
# Invalid privkey
assert_raises_rpc_error(
-5,
"The private key is invalid",
node.delegateavalancheproof,
limited_id_hex,
bytes_to_wif(bytes(32)),
random_pubkey,
)
# Invalid delegation
bad_dg = AvalancheDelegation()
assert_raises_rpc_error(
-8,
"The delegation does not match the proof",
node.delegateavalancheproof,
limited_id_hex,
bytes_to_wif(privkey.get_bytes()),
random_pubkey,
bad_dg.serialize().hex(),
)
# Still invalid, but with a matching proofid
bad_dg.limited_proofid = proofobj.limited_proofid
bad_dg.proof_master = proofobj.master
bad_dg.levels = [AvalancheDelegationLevel()]
assert_raises_rpc_error(
-8,
"The delegation is invalid",
node.delegateavalancheproof,
limited_id_hex,
bytes_to_wif(privkey.get_bytes()),
random_pubkey,
bad_dg.serialize().hex(),
)
# Wrong privkey, match the proof but does not match the delegation
assert_raises_rpc_error(
-5,
"The private key does not match the delegation",
node.delegateavalancheproof,
limited_id_hex,
bytes_to_wif(privkey.get_bytes()),
random_pubkey,
delegation,
)
# Delegation not hex
assert_raises_rpc_error(
-22,
"Delegation must be an hexadecimal string.",
node.delegateavalancheproof,
limited_id_hex,
bytes_to_wif(privkey.get_bytes()),
random_pubkey,
"f00",
)
# Delegation is hex but ill-formed
assert_raises_rpc_error(
-22,
"Delegation has invalid format",
node.delegateavalancheproof,
limited_id_hex,
bytes_to_wif(privkey.get_bytes()),
random_pubkey,
"dead",
)
# Test invalid proofs
dust = node.buildavalancheproof(
proof_sequence, proof_expiration, proof_master,
create_coinbase_stakes(node, [blockhashes[0]],
addrkey0.key,
amount="0"))
dust_amount = Decimal(f"{PROOF_DUST_THRESHOLD * 0.9999:.4f}")
dust2 = node.buildavalancheproof(
proof_sequence, proof_expiration, proof_master,
create_coinbase_stakes(node, [blockhashes[0]],
addrkey0.key,
amount=str(dust_amount)))
duplicate_stake = node.buildavalancheproof(
proof_sequence, proof_expiration, proof_master,
create_coinbase_stakes(node, [blockhashes[0]] * 2, addrkey0.key))
missing_stake = node.buildavalancheproof(
proof_sequence, proof_expiration, proof_master,
[{
'txid': '0' * 64,
'vout': 0,
'amount': 10000000,
'height': 42,
'iscoinbase': False,
'privatekey': addrkey0.key,
}])
bad_sig = (
"0b000000000000000c0000000000000021030b4c866585dd868a9d62348"
"a9cd008d6a312937048fff31670e7e920cfc7a7440105c5f72f5d6da3085"
"583e75ee79340eb4eff208c89988e7ed0efb30b87298fa30000000000f20"
"52a0100000003000000210227d85ba011276cf25b51df6a188b75e604b3"
"8770a462b2d0e9fb2fc839ef5d3faf07f001dd38e9b4a43d07d5d449cc0"
"f7d2888d96b82962b3ce516d1083c0e031773487fc3c4f2e38acd1db974"
"1321b91a79b82d1c2cfd47793261e4ba003cf5")
self.log.info(
"Check the verifyavalancheproof and sendavalancheproof RPCs")
if self.is_wallet_compiled():
self.log.info(
"Check a proof with the maximum number of UTXO is valid")
new_blocks = node.generate(AVALANCHE_MAX_PROOF_STAKES // 10 + 1)
# confirm the coinbase UTXOs
node.generate(101)
too_many_stakes = create_stakes(node, new_blocks,
AVALANCHE_MAX_PROOF_STAKES + 1)
maximum_stakes = too_many_stakes[:-1]
good_proof = node.buildavalancheproof(proof_sequence,
proof_expiration,
proof_master, maximum_stakes)
too_many_utxos = node.buildavalancheproof(proof_sequence,
proof_expiration,
proof_master,
too_many_stakes)
assert node.verifyavalancheproof(good_proof)
for rpc in [node.verifyavalancheproof, node.sendavalancheproof]:
assert_raises_rpc_error(-22, "Proof must be an hexadecimal string",
rpc, "f00")
assert_raises_rpc_error(-22, "Proof has invalid format", rpc,
"f00d")
def check_rpc_failure(proof, message):
assert_raises_rpc_error(-8, "The proof is invalid: " + message,
rpc, proof)
check_rpc_failure(no_stake, "no-stake")
check_rpc_failure(dust, "amount-below-dust-threshold")
check_rpc_failure(duplicate_stake, "duplicated-stake")
check_rpc_failure(missing_stake, "utxo-missing-or-spent")
check_rpc_failure(bad_sig, "invalid-signature")
if self.is_wallet_compiled():
check_rpc_failure(too_many_utxos, "too-many-utxos")
conflicting_utxo = node.buildavalancheproof(proof_sequence + 1,
proof_expiration,
proof_master, stakes)
assert_raises_rpc_error(
-8, "The proof has conflicting utxo with an existing proof",
node.sendavalancheproof, conflicting_utxo)
# Good proof
assert node.verifyavalancheproof(proof)
peer = node.add_p2p_connection(P2PInterface())
proofid = FromHex(AvalancheProof(), proof).proofid
node.sendavalancheproof(proof)
assert proofid in get_proof_ids(node)
def inv_found():
with p2p_lock:
return peer.last_message.get(
"inv") and peer.last_message["inv"].inv[-1].hash == proofid
wait_until(inv_found)
self.log.info("Check the getrawproof RPC")
raw_proof = node.getrawavalancheproof("{:064x}".format(proofid))
assert_equal(raw_proof['proof'], proof)
assert_equal(raw_proof['orphan'], False)
assert_raises_rpc_error(-8, "Proof not found",
node.getrawavalancheproof, '0' * 64)
# Orphan the proof by sending the stake
raw_tx = node.createrawtransaction([{
"txid": stakes[-1]["txid"],
"vout": 0
}], {
ADDRESS_BCHREG_UNSPENDABLE:
stakes[-1]["amount"] - Decimal('10000')
})
signed_tx = node.signrawtransactionwithkey(raw_tx, [addrkey0.key])
node.sendrawtransaction(signed_tx["hex"])
node.generate(1)
wait_until(lambda: proofid not in get_proof_ids(node))
raw_proof = node.getrawavalancheproof("{:064x}".format(proofid))
assert_equal(raw_proof['proof'], proof)
assert_equal(raw_proof['orphan'], True)
self.log.info("Bad proof should be rejected at startup")
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(dust2, "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.")
if self.is_wallet_compiled():
# 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,
)
# Master private key mismatch
random_privkey = ECKey()
random_privkey.generate()
node.assert_start_raises_init_error(
self.extra_args[0] + [
"-avaproof={}".format(proof),
"-avamasterkey={}".format(
bytes_to_wif(random_privkey.get_bytes())),
],
expected_msg=
"Error: The master key does not match the proof public key.",
)
self.log.info("Bad delegation should be rejected at startup")
def check_delegation_init_error(delegation, message):
node.assert_start_raises_init_error(
self.extra_args[0] + [
"-avadelegation={}".format(delegation),
"-avaproof={}".format(proof),
"-avamasterkey={}".format(
bytes_to_wif(delegated_privkey.get_bytes())),
],
expected_msg="Error: " + message,
)
check_delegation_init_error(
AvalancheDelegation().serialize().hex(),
"The delegation does not match the proof.")
bad_level_sig = FromHex(AvalancheDelegation(), delegation)
# Tweak some key to cause the signature to mismatch
bad_level_sig.levels[-2].pubkey = bytes.fromhex(proof_master)
check_delegation_init_error(
bad_level_sig.serialize().hex(),
"The avalanche delegation has invalid signatures.")
node.assert_start_raises_init_error(
self.extra_args[0] + [
"-avadelegation={}".format(delegation),
"-avaproof={}".format(proof),
"-avamasterkey={}".format(
bytes_to_wif(random_privkey.get_bytes())),
],
expected_msg=
"Error: The master key does not match the delegation public key.",
)
def run_test(self):
node = self.nodes[0]
# duplicate the deterministic sig test from src/test/key_tests.cpp
privkey = ECKey()
privkey.set(
bytes.fromhex(
"12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747"
), True)
pubkey = privkey.get_pubkey()
self.log.info(
"Check the node is signalling the avalanche service bit only if there is a proof."
)
assert_equal(
int(node.getnetworkinfo()['localservices'], 16) & NODE_AVALANCHE,
0)
# Create stakes by mining blocks
addrkey0 = node.get_deterministic_priv_key()
blockhashes = node.generatetoaddress(2, addrkey0.address)
stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
proof_sequence = 11
proof_expiration = 12
proof = node.buildavalancheproof(proof_sequence, proof_expiration,
pubkey.get_bytes().hex(), stakes)
# Restart the node
self.restart_node(
0, self.extra_args[0] + [
"-avaproof={}".format(proof),
"-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
])
assert_equal(
int(node.getnetworkinfo()['localservices'], 16) & NODE_AVALANCHE,
NODE_AVALANCHE)
def check_avahello(args):
# Restart the node with the given args
self.restart_node(0, self.extra_args[0] + args)
peer = get_ava_p2p_interface(node)
avahello = peer.wait_for_avahello().hello
avakey = ECPubKey()
avakey.set(bytes.fromhex(node.getavalanchekey()))
assert avakey.verify_schnorr(avahello.sig,
avahello.get_sighash(peer))
self.log.info(
"Test the avahello signature with a generated delegation")
check_avahello([
"-avaproof={}".format(proof),
"-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN"
])
master_key = ECKey()
master_key.generate()
limited_id = FromHex(AvalancheProof(), proof).limited_proofid
delegation = node.delegateavalancheproof(
f"{limited_id:0{64}x}",
bytes_to_wif(privkey.get_bytes()),
master_key.get_pubkey().get_bytes().hex(),
)
self.log.info("Test the avahello signature with a supplied delegation")
check_avahello([
"-avaproof={}".format(proof),
"-avadelegation={}".format(delegation),
"-avamasterkey={}".format(bytes_to_wif(master_key.get_bytes())),
])
stakes = create_coinbase_stakes(node, [blockhashes[1]], addrkey0.key)
interface_proof_hex = node.buildavalancheproof(
proof_sequence, proof_expiration,
pubkey.get_bytes().hex(), stakes)
limited_id = FromHex(AvalancheProof(),
interface_proof_hex).limited_proofid
# delegate
delegated_key = ECKey()
delegated_key.generate()
interface_delegation_hex = node.delegateavalancheproof(
f"{limited_id:0{64}x}", bytes_to_wif(privkey.get_bytes()),
delegated_key.get_pubkey().get_bytes().hex(), None)
self.log.info("Test that wrong avahello signature causes a ban")
bad_interface = get_ava_p2p_interface(node)
wrong_key = ECKey()
wrong_key.generate()
with node.assert_debug_log([
"Misbehaving",
"peer=1 (0 -> 100) BAN THRESHOLD EXCEEDED: invalid-avahello-signature"
]):
bad_interface.send_avahello(interface_delegation_hex, wrong_key)
bad_interface.wait_for_disconnect()
self.log.info(
'Check that receiving a valid avahello triggers a proof getdata request'
)
good_interface = get_ava_p2p_interface(node)
proofid = good_interface.send_avahello(interface_delegation_hex,
delegated_key)
def getdata_found():
with p2p_lock:
return good_interface.last_message.get(
"getdata") and good_interface.last_message["getdata"].inv[
-1].hash == proofid
wait_until(getdata_found)
self.log.info('Check that we can download the proof from our peer')
node_proofid = FromHex(AvalancheProof(), proof).proofid
def wait_for_proof_validation():
# Connect some blocks to trigger the proof verification
node.generate(1)
wait_until(lambda: node_proofid in get_proof_ids(node))
wait_for_proof_validation()
getdata = msg_getdata([CInv(MSG_AVA_PROOF, node_proofid)])
self.log.info(
"Proof has been inv'ed recently, check it can be requested")
good_interface.send_message(getdata)
def proof_received(peer):
with p2p_lock:
return peer.last_message.get("avaproof") and peer.last_message[
"avaproof"].proof.proofid == node_proofid
wait_until(lambda: proof_received(good_interface))
# Restart the node
self.restart_node(
0, self.extra_args[0] + [
"-avaproof={}".format(proof),
"-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
])
wait_for_proof_validation()
self.log.info(
"The proof has not been announced, it cannot be requested")
peer = get_ava_p2p_interface(node, services=NODE_NETWORK)
peer.send_message(getdata)
# Give enough time for the node to answer. Since we cannot check for a
# non-event this is the best we can do
time.sleep(2)
assert not proof_received(peer)
self.log.info("The proof is known for long enough to be requested")
current_time = int(time.time())
node.setmocktime(current_time + UNCONDITIONAL_RELAY_DELAY)
peer.send_message(getdata)
wait_until(lambda: proof_received(peer))
def run_test(self):
node = self.nodes[0]
node.add_p2p_connection(P2PDataStore())
# Allocate as many UTXOs as are needed
num_utxos = sum(
len(test_case['sig_hash_types']) for test_case in TESTCASES
if isinstance(test_case, dict))
value = int(SUBSIDY * 1_000_000)
fee = 10_000
max_utxo_value = (value - fee) // num_utxos
private_keys = []
public_keys = []
spendable_outputs = []
executed_scripts = []
utxo_idx = 0
# Prepare UTXOs for the tests below
for test_case in TESTCASES:
if test_case == 'ENABLE_REPLAY_PROTECTION':
continue
for _ in test_case['sig_hash_types']:
private_key = ECKey()
private_key.generate()
private_keys.append(private_key)
public_key = private_key.get_pubkey()
public_keys.append(public_key)
utxo_value = max_utxo_value - utxo_idx * 100 # deduct 100*i coins for unique amounts
if test_case.get('opcodes', False):
opcodes = test_case['opcodes']
redeem_script = CScript(
opcodes + [public_key.get_bytes(), OP_CHECKSIG])
executed_scripts.append(redeem_script)
utxo_script = CScript(
[OP_HASH160,
hash160(redeem_script), OP_EQUAL])
elif test_case.get('is_p2pk', False):
utxo_script = CScript(
[public_key.get_bytes(), OP_CHECKSIG])
executed_scripts.append(utxo_script)
else:
utxo_script = CScript([
OP_DUP, OP_HASH160,
hash160(public_key.get_bytes()), OP_EQUALVERIFY,
OP_CHECKSIG
])
executed_scripts.append(utxo_script)
spendable_outputs.append(CTxOut(utxo_value, utxo_script))
utxo_idx += 1
anyonecanspend_address = node.decodescript('51')['p2sh']
burn_address = node.decodescript('00')['p2sh']
p2sh_script = CScript([OP_HASH160, bytes(20), OP_EQUAL])
node.generatetoaddress(1, anyonecanspend_address)
node.generatetoaddress(100, burn_address)
# Build and send fan-out transaction creating all the UTXOs
block_hash = node.getblockhash(1)
coin = int(node.getblock(block_hash)['tx'][0], 16)
tx_fan_out = CTransaction()
tx_fan_out.vin.append(CTxIn(COutPoint(coin, 1), CScript([b'\x51'])))
tx_fan_out.vout = spendable_outputs
tx_fan_out.rehash()
node.p2p.send_txs_and_test([tx_fan_out], node)
utxo_idx = 0
key_idx = 0
for test_case in TESTCASES:
if test_case == 'ENABLE_REPLAY_PROTECTION':
node.setmocktime(ACTIVATION_TIME)
node.generatetoaddress(11, burn_address)
continue
# Build tx for this test, will broadcast later
tx = CTransaction()
num_inputs = len(test_case['sig_hash_types'])
spent_outputs = spendable_outputs[:num_inputs]
del spendable_outputs[:num_inputs]
assert len(spent_outputs) == num_inputs
total_input_amount = sum(output.nValue for output in spent_outputs)
max_output_amount = (total_input_amount -
fee) // test_case['outputs']
for i in range(test_case['outputs']):
output_amount = max_output_amount - i * 77
output_script = CScript(
[OP_HASH160, i.to_bytes(20, 'big'), OP_EQUAL])
tx.vout.append(CTxOut(output_amount, output_script))
for _ in test_case['sig_hash_types']:
tx.vin.append(
CTxIn(COutPoint(tx_fan_out.txid, utxo_idx), CScript()))
utxo_idx += 1
# Keep unsigned tx for signrawtransactionwithkey below
unsigned_tx = tx.serialize().hex()
private_keys_wif = []
sign_inputs = []
# Make list of inputs for signrawtransactionwithkey
for i, spent_output in enumerate(spent_outputs):
sign_inputs.append({
'txid':
tx_fan_out.txid_hex,
'vout':
key_idx + i,
'amount':
Decimal(spent_output.nValue) / COIN,
'scriptPubKey':
spent_output.scriptPubKey.hex(),
})
for i, sig_hash_type in enumerate(test_case['sig_hash_types']):
# Compute sighash for this input; we sign it manually using sign_ecdsa/sign_schnorr
# and then broadcast the complete transaction
sighash = SignatureHashLotus(
tx_to=tx,
spent_utxos=spent_outputs,
sig_hash_type=sig_hash_type,
input_index=i,
executed_script_hash=hash256(executed_scripts[key_idx]),
codeseparator_pos=test_case.get('codesep', 0xffff_ffff),
)
if test_case.get('schnorr', False):
signature = private_keys[key_idx].sign_schnorr(sighash)
else:
signature = private_keys[key_idx].sign_ecdsa(sighash)
signature += bytes(
[test_case.get('suffix', sig_hash_type & 0xff)])
# Build correct scriptSig
if test_case.get('opcodes'):
tx.vin[i].scriptSig = CScript(
[signature, executed_scripts[key_idx]])
elif test_case.get('is_p2pk'):
tx.vin[i].scriptSig = CScript([signature])
else:
tx.vin[i].scriptSig = CScript(
[signature, public_keys[key_idx].get_bytes()])
sig_hash_type_str = self.get_sig_hash_type_str(sig_hash_type)
if sig_hash_type_str is not None and 'opcodes' not in test_case and 'error' not in test_case:
# If we're a simple output type (P2PKH or P2KH) and aren't supposed to fail,
# we sign using signrawtransactionwithkey and verify the transaction signed
# the expected sighash. We won't broadcast it though.
# Note: signrawtransactionwithkey will not sign using replay-protection.
private_key_wif = bytes_to_wif(
private_keys[key_idx].get_bytes())
raw_tx_signed = self.nodes[0].signrawtransactionwithkey(
unsigned_tx, [private_key_wif], sign_inputs,
sig_hash_type_str)['hex']
# Extract signature from signed
signed_tx = CTransaction()
signed_tx.deserialize(
io.BytesIO(bytes.fromhex(raw_tx_signed)))
sig = list(CScript(signed_tx.vin[i].scriptSig))[0]
pubkey = private_keys[key_idx].get_pubkey()
sighash = SignatureHashLotus(
tx_to=tx,
spent_utxos=spent_outputs,
sig_hash_type=sig_hash_type & 0xff,
input_index=i,
executed_script_hash=hash256(
executed_scripts[key_idx]),
)
# Verify sig signs the above sighash and has the expected sighash type
assert pubkey.verify_ecdsa(sig[:-1], sighash)
assert sig[-1] == sig_hash_type & 0xff
key_idx += 1
# Broadcast transaction and check success/failure
tx.rehash()
if 'error' not in test_case:
node.p2p.send_txs_and_test([tx], node)
else:
node.p2p.send_txs_and_test([tx],
node,
success=False,
reject_reason=test_case['error'])
