262 lines
11 KiB
Python
262 lines
11 KiB
Python
"""B5 — the network phase with scripted servers: rotation, genesis, quorum, corroboration, merkle proof, coinbase
|
|
(ELC-14, ELC-17, ELC-26, ELC-30, ELC-31, DEP-21, DEP-22)."""
|
|
|
|
import hashlib
|
|
import struct
|
|
|
|
import pytest
|
|
from embit.transaction import Transaction
|
|
from plm_engine.electrum.client import ElectrumEndpoint, ElectrumError, parse_server_list
|
|
from plm_engine.electrum.scripthash import address_to_scripthash
|
|
from plm_engine.headers import header_meets_its_own_target
|
|
from plm_engine.network import MAINNET, REGTEST
|
|
|
|
from apps.lottery.deposits import Policy
|
|
from apps.lottery.electrum_chain import ElectrumChain
|
|
|
|
ADDRESS = "rplm1qz3r3xc0dxx470c9dhv78dmvlr0cd34vw3vvmsx"
|
|
SCRIPTHASH = address_to_scripthash(ADDRESS)
|
|
POW = REGTEST.pow_limit
|
|
|
|
|
|
def raw_tx(prevout: bytes) -> str:
|
|
"""A one-input one-output transaction: `prevout` all zero makes it a coinbase."""
|
|
return ("01000000" + "01" + prevout.hex() + "ffffffff" + "00" + "ffffffff" + "01" + "00ca9a3b00000000" + "00" + "00000000")
|
|
|
|
|
|
ORDINARY_RAW = raw_tx(bytes.fromhex("11" * 32))
|
|
COINBASE_RAW = raw_tx(bytes(32))
|
|
ORDINARY_TXID = Transaction.parse(bytes.fromhex(ORDINARY_RAW)).txid().hex()
|
|
COINBASE_TXID = Transaction.parse(bytes.fromhex(COINBASE_RAW)).txid().hex()
|
|
OUTPOINT = (ORDINARY_TXID, 0)
|
|
|
|
|
|
def mined_header(merkle_root_internal: bytes = bytes(32), nonce_from: int = 0) -> str:
|
|
for nonce in range(nonce_from, nonce_from + 10_000):
|
|
header = (struct.pack("<I", 1) + bytes(32) + merkle_root_internal + struct.pack("<II", 0, 0x207FFFFF) + struct.pack("<I", nonce)).hex()
|
|
if header_meets_its_own_target(header, POW):
|
|
return header
|
|
raise AssertionError("no header mined")
|
|
|
|
|
|
TX_ROOT = bytes.fromhex(OUTPOINT[0])[::-1] # a block with that one transaction: the root is the txid
|
|
HEADER = mined_header(TX_ROOT)
|
|
COINBASE_HEADER = mined_header(bytes.fromhex(COINBASE_TXID)[::-1])
|
|
|
|
|
|
class FakeServer:
|
|
"""What one server says. Fields are set per test."""
|
|
|
|
def __init__(self, name, *, up=True, genesis=REGTEST.genesis_hash, height=1000, header=HEADER,
|
|
coins=None, proof="valid", silent_on=()):
|
|
self.name, self.up, self.genesis, self.height, self.header = name, up, genesis, height, header
|
|
self.coins = [{"tx_hash": OUTPOINT[0], "tx_pos": 0, "value": 500_000_000, "height": 990}] if coins is None else coins
|
|
self.proof, self.silent_on, self.raw_tx = proof, set(silent_on), ORDINARY_RAW
|
|
|
|
|
|
class FakeClient:
|
|
def __init__(self, server):
|
|
self.s = server
|
|
self.closed = False
|
|
|
|
async def connect(self):
|
|
if not self.s.up:
|
|
raise OSError("down")
|
|
if self.s.genesis != REGTEST.genesis_hash:
|
|
raise ElectrumError("not on the PLM chain")
|
|
|
|
async def close(self):
|
|
self.closed = True
|
|
|
|
async def subscribe_headers(self):
|
|
return {"height": self.s.height, "hex": self.s.header}
|
|
|
|
async def get_block_header(self, height):
|
|
if "header" in self.s.silent_on:
|
|
raise OSError("timeout")
|
|
return self.s.header
|
|
|
|
async def listunspent(self, scripthash):
|
|
if "listunspent" in self.s.silent_on:
|
|
raise OSError("timeout")
|
|
assert scripthash == SCRIPTHASH
|
|
return self.s.coins
|
|
|
|
async def get_merkle(self, txid, height):
|
|
if "merkle" in self.s.silent_on:
|
|
raise OSError("timeout")
|
|
if self.s.proof == "valid":
|
|
return {"block_height": height, "merkle": [], "pos": 0}
|
|
return {"block_height": height, "merkle": ["00" * 32], "pos": 0}
|
|
|
|
async def get_transaction(self, txid, verbose=False):
|
|
return COINBASE_RAW if txid == COINBASE_TXID else self.s.raw_tx
|
|
|
|
|
|
def chain_of(servers, allow_no_quorum=False):
|
|
by_endpoint = {ElectrumEndpoint(s.name, 1, False): s for s in servers}
|
|
return ElectrumChain(list(by_endpoint), REGTEST, allow_no_quorum, lambda e: FakeClient(by_endpoint[e]))
|
|
|
|
|
|
def policy(deposit_confirmations=6, own=frozenset(), credited=frozenset(), waiting=None):
|
|
return Policy((ADDRESS,), own, deposit_confirmations, credited, waiting or {})
|
|
|
|
|
|
async def observe(servers, allow_no_quorum=False, **kw):
|
|
return await chain_of(servers, allow_no_quorum).observe(policy(**kw))
|
|
|
|
|
|
def three(**overrides):
|
|
return [FakeServer(name, **overrides.get(name, {})) for name in "abc"]
|
|
|
|
|
|
def four(**overrides):
|
|
return [FakeServer(name, **overrides.get(name, {})) for name in "abcd"]
|
|
|
|
|
|
# --- servers --------------------------------------------------------------------------------------------
|
|
|
|
|
|
def test_the_server_list_is_parsed_in_order():
|
|
endpoints = parse_server_list("a.example:50002, b.example:50001:notls ,a.example:50002")
|
|
assert [(e.host, e.port, e.use_ssl) for e in endpoints] == [("a.example", 50002, True), ("b.example", 50001, False)]
|
|
with pytest.raises(ValueError):
|
|
parse_server_list("no-port")
|
|
|
|
|
|
async def test_the_first_usable_server_is_active_and_a_dead_one_is_skipped():
|
|
result = await observe(four(a={"up": False})) # b is active; c and d answer: a quorum of two
|
|
assert result.tip == 1000 and result.addresses[ADDRESS].entries[0].value == 500_000_000
|
|
|
|
|
|
async def test_a_server_on_another_chain_is_never_used():
|
|
result = await observe(three(a={"genesis": MAINNET.genesis_hash}, b={"genesis": MAINNET.genesis_hash}))
|
|
# only c is usable, and it cannot be corroborated by anyone: no tip, nothing concluded
|
|
assert result.tip is None and result.addresses == {}
|
|
|
|
|
|
async def test_with_no_server_at_all_nothing_is_concluded():
|
|
result = await observe(three(a={"up": False}, b={"up": False}, c={"up": False}))
|
|
assert result.tip is None
|
|
|
|
|
|
# --- quorum (ELC-14) ---------------------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.parametrize("answers,expected", [
|
|
([True, True], True), ([True, False], False), ([True, None], False), ([None, None], False),
|
|
([True, True, False], True), ([True, False, False], False), ([], False), ([True], False),
|
|
])
|
|
def test_the_quorum_needs_two_answers_and_a_strict_majority(answers, expected):
|
|
assert chain_of(three()).majority(answers) is expected
|
|
|
|
|
|
@pytest.mark.parametrize("answers,expected", [([True], True), ([False], False), ([None], False), ([True, False], False)])
|
|
def test_the_development_exception_accepts_one_agreeing_answer(answers, expected):
|
|
assert chain_of(three(), allow_no_quorum=True).majority(answers) is expected
|
|
|
|
|
|
def test_the_development_exception_with_a_single_server_passes():
|
|
assert chain_of([FakeServer("only")], allow_no_quorum=True).majority([]) is True
|
|
assert chain_of([FakeServer("only")], allow_no_quorum=False).majority([]) is False
|
|
|
|
|
|
# --- tip -----------------------------------------------------------------------------------------------------
|
|
|
|
|
|
async def test_a_tip_without_valid_work_is_refused():
|
|
fake_header = struct.pack("<I", 1).hex() + "00" * 72 # bits 0: no target
|
|
result = await observe(three(a={"header": fake_header}, b={"header": fake_header}, c={"header": fake_header}))
|
|
assert result.tip is None
|
|
|
|
|
|
async def test_a_tip_the_others_do_not_confirm_is_refused():
|
|
other = mined_header(bytes(32), 50_000)
|
|
assert other != HEADER
|
|
result = await observe(three(b={"header": other}, c={"header": other}))
|
|
assert result.tip is None
|
|
|
|
|
|
# --- credit (ELC-17, ELC-26) ----------------------------------------------------------------------------------
|
|
|
|
|
|
async def test_a_deep_enough_coin_corroborated_with_a_proof_is_verified():
|
|
observation = (await observe(three())).addresses[ADDRESS]
|
|
assert OUTPOINT in observation.verified
|
|
|
|
|
|
async def test_a_coin_that_is_too_shallow_is_not_verified():
|
|
result = await observe(three(), deposit_confirmations=20) # 11 confirmations
|
|
assert OUTPOINT not in result.addresses[ADDRESS].verified
|
|
|
|
|
|
async def test_a_coin_the_others_do_not_list_is_not_verified():
|
|
result = await observe(three(b={"coins": []}, c={"coins": []}))
|
|
assert OUTPOINT not in result.addresses[ADDRESS].verified
|
|
|
|
|
|
async def test_a_coin_with_another_value_at_the_others_is_not_verified():
|
|
cheat = [{"tx_hash": OUTPOINT[0], "tx_pos": 0, "value": 1, "height": 990}]
|
|
result = await observe(three(b={"coins": cheat}, c={"coins": cheat}))
|
|
assert OUTPOINT not in result.addresses[ADDRESS].verified
|
|
|
|
|
|
async def test_a_wrong_merkle_proof_is_not_accepted():
|
|
result = await observe(three(b={"proof": "wrong"}, c={"proof": "wrong"}))
|
|
assert OUTPOINT not in result.addresses[ADDRESS].verified
|
|
|
|
|
|
async def test_one_silent_server_out_of_four_still_leaves_a_quorum():
|
|
result = await observe(four(d={"up": False}))
|
|
assert OUTPOINT in result.addresses[ADDRESS].verified
|
|
|
|
|
|
async def test_with_only_one_other_server_answering_nothing_is_concluded():
|
|
"""Three configured, one down: the active server plus one answer is not a quorum (ELC-14)."""
|
|
result = await observe(three(c={"up": False}))
|
|
assert result.tip is None and result.addresses == {}
|
|
|
|
|
|
async def test_silence_on_a_corroboration_does_not_count_as_agreement():
|
|
result = await observe(four(c={"silent_on": ["merkle"]}, d={"silent_on": ["merkle"]}))
|
|
assert OUTPOINT not in result.addresses[ADDRESS].verified
|
|
|
|
|
|
# --- coinbase (DEP-21) ---------------------------------------------------------------------------------------
|
|
|
|
|
|
async def test_a_coinbase_is_recognised_and_needs_120():
|
|
coin = [{"tx_hash": COINBASE_TXID, "tx_pos": 0, "value": 500_000_000, "height": 990}]
|
|
result = await observe(three(a={"coins": coin, "header": COINBASE_HEADER}, b={"coins": coin, "header": COINBASE_HEADER},
|
|
c={"coins": coin, "header": COINBASE_HEADER}))
|
|
observation = result.addresses[ADDRESS]
|
|
assert COINBASE_TXID in observation.coinbase and (COINBASE_TXID, 0) not in observation.verified # 11 < 120
|
|
|
|
|
|
async def test_an_unreadable_transaction_is_not_credited_as_an_ordinary_deposit():
|
|
servers = three()
|
|
for server in servers:
|
|
server.raw_tx = "zz"
|
|
result = await observe(servers)
|
|
assert OUTPOINT not in result.addresses[ADDRESS].verified
|
|
|
|
|
|
async def test_our_own_transaction_is_not_checked_for_coinbase():
|
|
own = frozenset({OUTPOINT[0]})
|
|
servers = three()
|
|
for server in servers:
|
|
server.raw_tx = "zz" # would block an ordinary deposit; irrelevant for our own
|
|
result = await chain_of(servers).observe(policy(own=own))
|
|
assert OUTPOINT in result.addresses[ADDRESS].verified
|
|
|
|
|
|
# --- vanished waiting deposits ----------------------------------------------------------------------------------
|
|
|
|
|
|
async def test_a_vanished_waiting_deposit_needs_the_others_to_agree():
|
|
result = await observe(three(a={"coins": []}), waiting={ADDRESS: frozenset({OUTPOINT})})
|
|
# a (active) lists nothing, b and c still list it: not confirmed absent
|
|
assert OUTPOINT not in result.addresses[ADDRESS].absent_confirmed
|
|
result = await observe(three(a={"coins": []}, b={"coins": []}, c={"coins": []}), waiting={ADDRESS: frozenset({OUTPOINT})})
|
|
assert OUTPOINT in result.addresses[ADDRESS].absent_confirmed
|