Page MenuHomePhabricator
Differential D9614 Diff 28694 test/functional/abc_rpc_avalancheproof.py

Changeset View

Standalone View

View Options

test/functional/abc_rpc_avalancheproof.py

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines def run_test(self):
proof_expiration = 12 proof_expiration = 12
stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key) stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
proof = node.buildavalancheproof( proof = node.buildavalancheproof(
proof_sequence, proof_expiration, proof_master, stakes) proof_sequence, proof_expiration, proof_master, stakes)
self.log.info("Test decodeavalancheproof RPC") self.log.info("Test decodeavalancheproof RPC")
proofobj = FromHex(AvalancheProof(), proof) proofobj = FromHex(AvalancheProof(), proof)
decodedproof = node.decodeavalancheproof(proof) decodedproof = node.decodeavalancheproof(proof)
limited_id_hex = f"{proofobj.limited_proofid:0{64}x}"
assert_equal(decodedproof["sequence"], proof_sequence) assert_equal(decodedproof["sequence"], proof_sequence)
assert_equal(decodedproof["expiration"], proof_expiration) assert_equal(decodedproof["expiration"], proof_expiration)
assert_equal(decodedproof["master"], proof_master) assert_equal(decodedproof["master"], proof_master)
assert_equal(decodedproof["proofid"], f"{proofobj.proofid:0{64}x}") assert_equal(decodedproof["proofid"], f"{proofobj.proofid:0{64}x}")
assert_equal( assert_equal(decodedproof["limitedid"], limited_id_hex)
decodedproof["limitedid"],
f"{proofobj.limited_proofid:0{64}x}")
assert_equal(decodedproof["stakes"][0]["txid"], stakes[0]["txid"]) assert_equal(decodedproof["stakes"][0]["txid"], stakes[0]["txid"])
assert_equal(decodedproof["stakes"][0]["vout"], stakes[0]["vout"]) assert_equal(decodedproof["stakes"][0]["vout"], stakes[0]["vout"])
assert_equal(decodedproof["stakes"][0]["height"], stakes[0]["height"]) assert_equal(decodedproof["stakes"][0]["height"], stakes[0]["height"])
assert_equal( assert_equal(
decodedproof["stakes"][0]["iscoinbase"], decodedproof["stakes"][0]["iscoinbase"],
stakes[0]["iscoinbase"]) stakes[0]["iscoinbase"])
assert_equal( assert_equal(
decodedproof["stakes"][0]["signature"], decodedproof["stakes"][0]["signature"],
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines def run_test(self):
pk.generate() pk.generate()
return pk return pk
delegator_privkey = privkey delegator_privkey = privkey
delegation = None delegation = None
for _ in range(10): for _ in range(10):
delegated_privkey = gen_privkey() delegated_privkey = gen_privkey()
delegation = node.delegateavalancheproof( delegation = node.delegateavalancheproof(
proof, limited_id_hex,
bytes_to_wif(delegator_privkey.get_bytes()), bytes_to_wif(delegator_privkey.get_bytes()),
get_hex_pubkey(delegated_privkey), get_hex_pubkey(delegated_privkey),
delegation, delegation,
) )
delegator_privkey = delegated_privkey delegator_privkey = delegated_privkey
random_privkey = gen_privkey() random_privkey = gen_privkey()
random_pubkey = get_hex_pubkey(random_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 # Invalid privkey
assert_raises_rpc_error(-5, "The private key is invalid", assert_raises_rpc_error(-5, "The private key is invalid",
node.delegateavalancheproof, node.delegateavalancheproof,
proof, limited_id_hex,
bytes_to_wif(bytes(32)), bytes_to_wif(bytes(32)),
random_pubkey, random_pubkey,
) )
# Invalid delegation # Invalid delegation
bad_dg = AvalancheDelegation() bad_dg = AvalancheDelegation()
assert_raises_rpc_error(-8, "The supplied delegation does not match the proof", assert_raises_rpc_error(-8, "The supplied delegation does not match the proof",
node.delegateavalancheproof, node.delegateavalancheproof,
proof, limited_id_hex,
bytes_to_wif(privkey.get_bytes()), bytes_to_wif(privkey.get_bytes()),
random_pubkey, random_pubkey,
bad_dg.serialize().hex(), bad_dg.serialize().hex(),
) )
# Still invalid, but with a matching proofid # Still invalid, but with a matching proofid
bad_dg.limited_proofid = proofobj.limited_proofid bad_dg.limited_proofid = proofobj.limited_proofid
bad_dg.proof_master = proofobj.master bad_dg.proof_master = proofobj.master
bad_dg.levels = [AvalancheDelegationLevel()] bad_dg.levels = [AvalancheDelegationLevel()]
assert_raises_rpc_error(-8, "The supplied delegation is not valid", assert_raises_rpc_error(-8, "The supplied delegation is not valid",
node.delegateavalancheproof, node.delegateavalancheproof,
proof, limited_id_hex,
bytes_to_wif(privkey.get_bytes()), bytes_to_wif(privkey.get_bytes()),
random_pubkey, random_pubkey,
bad_dg.serialize().hex(), 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 # 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", assert_raises_rpc_error(-8, "The private key does not match the proof or the delegation",
node.delegateavalancheproof, node.delegateavalancheproof,
proof, limited_id_hex,
bytes_to_wif(privkey.get_bytes()), bytes_to_wif(privkey.get_bytes()),
random_pubkey, random_pubkey,
delegation, delegation,
) )
# Test invalid proofs # Test invalid proofs
dust = node.buildavalancheproof( dust = node.buildavalancheproof(
proof_sequence, proof_expiration, proof_master, proof_sequence, proof_expiration, proof_master,
Show All 23 Lines def run_test(self):
node.verifyavalancheproof, "f00") node.verifyavalancheproof, "f00")
assert_raises_rpc_error(-8, "Proof has invalid format", assert_raises_rpc_error(-8, "Proof has invalid format",
node.verifyavalancheproof, "f00d") node.verifyavalancheproof, "f00d")
def check_verifyavalancheproof_failure(proof, message): def check_verifyavalancheproof_failure(proof, message):
assert_raises_rpc_error(-8, "The proof is invalid: " + message, assert_raises_rpc_error(-8, "The proof is invalid: " + message,
node.verifyavalancheproof, proof) node.verifyavalancheproof, proof)
no_stake = node.buildavalancheproof(proof_sequence, proof_expiration,
proof_master, [])
check_verifyavalancheproof_failure(no_stake, "no-stake") check_verifyavalancheproof_failure(no_stake, "no-stake")
check_verifyavalancheproof_failure(dust, "amount-below-dust-threshold") check_verifyavalancheproof_failure(dust, "amount-below-dust-threshold")
check_verifyavalancheproof_failure(duplicate_stake, "duplicated-stake") check_verifyavalancheproof_failure(duplicate_stake, "duplicated-stake")
check_verifyavalancheproof_failure(bad_sig, "invalid-signature") check_verifyavalancheproof_failure(bad_sig, "invalid-signature")
if self.is_wallet_compiled(): if self.is_wallet_compiled():
check_verifyavalancheproof_failure( check_verifyavalancheproof_failure(
too_many_utxos, "too-many-utxos") too_many_utxos, "too-many-utxos")
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines