130 lines
6.1 KiB
Python
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")
|
|
assert refused.returncode != 0 and "PLM_MAINNET_CONFIRMED" in refused.stderr
|
|
wrong = settings_import(PLM_NETWORK="mainnet", LEDGER_BACKEND="chain", PLM_MAINNET_CONFIRMED="true")
|
|
assert wrong.returncode != 0
|
|
confirmed = settings_import(PLM_NETWORK="mainnet", LEDGER_BACKEND="chain", 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
|