Files
plm-lottery/tests/django/test_network_profile.py
T

130 lines
6.1 KiB
Python

"""B2 — the network profile: ADR-58, ELC-30, ADR-05. Everything that differs between mainnet and regtest
(hrp, prefixes, genesis, powLimit, coin type) comes from one `Profile`."""
import os
import subprocess
import sys
from pathlib import Path
import pytest
from embit import script
from embit.bip32 import HDKey
from plm_engine import hd
from plm_engine.address import is_valid_address, is_valid_plm_address
from plm_engine.electrum.client import ElectrumClient, ElectrumError
from plm_engine.headers import header_meets_its_own_target
from plm_engine.network import MAINNET, PROFILES, REGTEST, get_profile
ROOT = Path(__file__).resolve().parents[2]
MASTER = HDKey.from_seed(bytes(range(32)), version=MAINNET.embit["xprv"])
def settings_import(**env) -> subprocess.CompletedProcess:
clean = {"PATH": os.environ["PATH"], "PYTHONPATH": str(ROOT), "DJANGO_SECRET_KEY": "k" * 60, **env}
return subprocess.run([sys.executable, "-c", "import config.settings as s; print(s.PLM_PROFILE.name)"],
cwd=ROOT, env=clean, capture_output=True, text=True)
def test_each_profile_has_its_own_chain_parameters():
"""The values are palladiumcore's chainparams.cpp (mainnet, CRegTestParams)."""
assert (MAINNET.hrp, MAINNET.coin_type, MAINNET.genesis_hash) == (
"plm", 746, "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f")
assert (REGTEST.hrp, REGTEST.coin_type, REGTEST.genesis_hash) == (
"rplm", 1, "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")
assert MAINNET.pow_limit == int("00000000" + "ff" * 28, 16)
assert REGTEST.pow_limit == int("7f" + "ff" * 31, 16)
assert (REGTEST.embit["p2pkh"], REGTEST.embit["p2sh"], REGTEST.embit["wif"]) == (bytes([127]), bytes([115]), bytes([255]))
assert REGTEST.account_path == "m/84h/1h/0h" and MAINNET.account_path == "m/84h/746h/0h"
def test_profiles_are_looked_up_by_the_value_of_plm_network():
assert get_profile("mainnet") is MAINNET and get_profile("regtest") is REGTEST and set(PROFILES) == {"mainnet", "regtest"}
with pytest.raises(ValueError):
get_profile("testnet")
def test_the_same_account_derives_a_different_address_on_each_profile():
on_main = hd.user_address(hd.account_key(MASTER, MAINNET), 0, MAINNET)
on_regtest = hd.user_address(hd.account_key(MASTER, REGTEST), 0, REGTEST)
assert on_main.startswith("plm1") and on_regtest.startswith("rplm1") and on_main != on_regtest
assert hd.pool_address(hd.account_key(MASTER, REGTEST), 3, REGTEST).startswith("rplm1")
def test_an_address_is_valid_only_on_the_chain_of_its_hrp():
main = hd.user_address(hd.account_key(MASTER, MAINNET), 5, MAINNET)
regtest = hd.user_address(hd.account_key(MASTER, REGTEST), 5, REGTEST)
assert is_valid_address(main, MAINNET) and not is_valid_address(main, REGTEST)
assert is_valid_address(regtest, REGTEST) and not is_valid_address(regtest, MAINNET)
bitcoin = script.p2wpkh(hd.user_key(hd.account_key(MASTER, MAINNET), 5).to_public()).address()
assert bitcoin.startswith("bc1") and not is_valid_address(bitcoin, MAINNET) and not is_valid_address(bitcoin, REGTEST)
assert not is_valid_address(regtest[:-1] + ("q" if regtest[-1] != "q" else "p"), REGTEST) # bad checksum
def test_the_old_check_is_still_mainnet_only():
assert is_valid_plm_address(hd.user_address(hd.account_key(MASTER, MAINNET), 1, MAINNET))
assert not is_valid_plm_address(hd.user_address(hd.account_key(MASTER, REGTEST), 1, REGTEST))
def test_the_site_validates_addresses_with_the_configured_profile(settings):
from apps.lottery.addresses import is_valid_address as site_valid
regtest = hd.user_address(hd.account_key(MASTER, REGTEST), 2, REGTEST)
mainnet = hd.user_address(hd.account_key(MASTER, MAINNET), 2, MAINNET)
assert settings.PLM_PROFILE is REGTEST # the test settings run on regtest
assert site_valid(regtest) and not site_valid(mainnet)
def test_the_pow_floor_follows_the_profile():
"""A header mined at the regtest target passes the regtest floor and not the mainnet one."""
import struct
def build(nonce):
return (struct.pack("<I", 1) + bytes(32) + bytes(32) + struct.pack("<II", 0, 0x207FFFFF) + struct.pack("<I", nonce)).hex()
header = next(h for h in map(build, range(1000)) if header_meets_its_own_target(h, REGTEST.pow_limit))
assert header_meets_its_own_target(header, REGTEST.pow_limit) is True
assert header_meets_its_own_target(header, MAINNET.pow_limit) is False
@pytest.mark.parametrize("profile", [MAINNET, REGTEST], ids=lambda p: p.name)
@pytest.mark.asyncio
async def test_the_handshake_expects_the_genesis_of_its_profile(profile):
other = REGTEST if profile is MAINNET else MAINNET
def client_for(genesis):
client = ElectrumClient("h", 1, genesis_hash=profile.genesis_hash)
async def request(method, *params):
return {"genesis_hash": genesis}
client.request = request
return client
await client_for(profile.genesis_hash)._check_genesis()
with pytest.raises(ElectrumError):
await client_for(other.genesis_hash)._check_genesis()
def test_regtest_is_the_default_and_the_profile_is_exposed():
done = settings_import()
assert done.returncode == 0 and done.stdout.strip() == "regtest"
def test_mainnet_needs_an_explicit_confirmation():
refused = settings_import(PLM_NETWORK="mainnet", LEDGER_BACKEND="chain", ELECTRUM_SERVERS="a:1,b:1,c:1")
assert refused.returncode != 0 and "PLM_MAINNET_CONFIRMED" in refused.stderr
wrong = settings_import(PLM_NETWORK="mainnet", LEDGER_BACKEND="chain", ELECTRUM_SERVERS="a:1,b:1,c:1", PLM_MAINNET_CONFIRMED="true")
assert wrong.returncode != 0
confirmed = settings_import(PLM_NETWORK="mainnet", LEDGER_BACKEND="chain", ELECTRUM_SERVERS="a:1,b:1,c:1", PLM_MAINNET_CONFIRMED="yes")
assert confirmed.returncode == 0 and confirmed.stdout.strip() == "mainnet"
def test_the_simulated_ledger_still_cannot_run_on_mainnet():
refused = settings_import(PLM_NETWORK="mainnet", PLM_MAINNET_CONFIRMED="yes")
assert refused.returncode != 0 and "simulated ledger" in refused.stderr
def test_an_unknown_network_is_refused():
assert settings_import(PLM_NETWORK="testnet").returncode != 0