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

265 lines
11 KiB
Python

"""B5 — real deposits on the ORM: DEP-20..DEP-23, DAT-62, DAT-77, DAT-82, DAT-84."""
import pytest
from django.contrib.auth import get_user_model
from django.db import IntegrityError, transaction
from apps.lottery import chain, deposits, keys
from apps.lottery.balances import balance_of
from apps.lottery.deposits import Observation, ScanResult, Seen
from apps.lottery.models import AuditEntry, Deposit, LotteryConfig, Movement, TransactionVersion, Utxo, ChainTransaction
pytestmark = pytest.mark.django_db
User = get_user_model()
PLM = 100_000_000
TXID = "ab" * 32
OTHER = "cd" * 32
class FakeChain:
"""The network phase, scripted: a tip, what each address lists, and which coins the 'servers' corroborate."""
def __init__(self, tip=1000):
self.tip, self.entries, self.verified, self.coinbase, self.absent, self.silent = tip, {}, set(), set(), set(), set()
self.policies = []
def observe(self, policy):
self.policies.append(policy)
result = ScanResult(self.tip, {})
for address in policy.addresses:
if address in self.silent:
result.addresses[address] = Observation(None)
continue
entries = self.entries.get(address, [])
result.addresses[address] = Observation(
entries, {o for o in self.verified}, {o for o in self.absent}, set(self.coinbase))
return result
@pytest.fixture
def player(settings, tmp_path):
settings.PLM_ACCOUNT_XPUB = keys.generate_keys(tmp_path / "keys", settings.PLM_PROFILE)
user = User.objects.create_user("mario", password="x" * 12)
return user, chain.assign_deposit_address(user).address
def coin(txid=TXID, vout=0, value=5 * PLM, height=995):
return Seen(txid, vout, value, height)
def scan(fake):
return deposits.scan_deposits(fake)
# --- DEP-21: thresholds ------------------------------------------------------------------------------
def test_a_deposit_is_credited_exactly_at_its_threshold(player):
user, address = player
fake = FakeChain()
fake.entries[address] = [coin(height=1000 - 5 + 1)] # 5 confirmations, the threshold is 6
fake.verified = {(TXID, 0)}
assert scan(fake) == {"detected": 1, "credited": 0, "orphaned": 0, "reinstated": 0}
assert balance_of(user).spendable_sats == 0
fake.tip = 1001 # 6 confirmations
assert scan(fake)["credited"] == 1
assert balance_of(user).spendable_sats == 5 * PLM
def test_the_threshold_is_the_configured_one(player):
"""DAT-77: the operator changes it and the next scan uses it."""
user, address = player
config = LotteryConfig.get()
config.deposit_confirmations = 2
config.save()
fake = FakeChain()
fake.entries[address] = [coin(height=999)] # 2 confirmations
fake.verified = {(TXID, 0)}
assert scan(fake)["credited"] == 1
def test_a_coinbase_needs_120(player):
user, address = player
fake = FakeChain(tip=2000)
fake.coinbase = {TXID}
fake.verified = {(TXID, 0)}
fake.entries[address] = [coin(height=2000 - 118)] # 119 confirmations
assert scan(fake)["credited"] == 0
fake.tip = 2001 # 120
assert scan(fake)["credited"] == 1
def test_the_change_of_our_own_transactions_is_spendable_but_never_a_deposit(player):
"""BET-30: the stake was taken from the balance when the bet was placed; its change coming back must not be credited."""
user, address = player
tx = ChainTransaction.objects.create(kind="bet", user=user)
chain.register_version(tx, TXID, "00")
fake = FakeChain()
fake.entries[address] = [coin(height=1000)] # one confirmation
assert scan(fake) == {"detected": 0, "credited": 0, "orphaned": 0, "reinstated": 0}
utxo = Utxo.objects.get()
assert utxo.user == user and utxo.confirmed_height == 1000 and not Deposit.objects.exists()
assert not Movement.objects.exists() and balance_of(user).spendable_sats == 0
scan(fake) # and once only
assert Utxo.objects.count() == 1
def test_dust_and_mempool_coins_are_ignored(player):
user, address = player
fake = FakeChain()
fake.entries[address] = [coin(vout=0, value=293), coin(vout=1, height=0), coin(vout=2, height=-1)]
assert scan(fake) == {"detected": 0, "credited": 0, "orphaned": 0, "reinstated": 0}
assert not Utxo.objects.exists() and not Movement.objects.exists()
# --- DEP-22: verified, idempotent ------------------------------------------------------------------------
def test_an_unverified_deposit_is_deferred_not_lost(player):
user, address = player
fake = FakeChain()
fake.entries[address] = [coin(height=900)] # deep enough, but nobody corroborated it
scan(fake)
assert balance_of(user).spendable_sats == 0 and Deposit.objects.get().status == "detected"
fake.verified = {(TXID, 0)}
assert scan(fake)["credited"] == 1
def test_scanning_twice_credits_once(player):
user, address = player
fake = FakeChain()
fake.entries[address] = [coin(height=900)]
fake.verified = {(TXID, 0)}
assert scan(fake)["credited"] == 1
assert scan(fake) == {"detected": 0, "credited": 0, "orphaned": 0, "reinstated": 0}
assert Movement.objects.filter(kind="deposit").count() == 1 and balance_of(user).spendable_sats == 5 * PLM
def test_the_credit_is_audited(player):
user, address = player
fake = FakeChain()
fake.entries[address] = [coin(height=900)]
fake.verified = {(TXID, 0)}
scan(fake)
entry = AuditEntry.objects.get(action="deposit_credited")
assert entry.actor_label == "worker" and entry.payload["amount_sats"] == 5 * PLM and entry.payload["threshold"] == 6
def test_the_database_refuses_a_second_deposit_for_the_same_output(player):
user, address = player
fake = FakeChain()
fake.entries[address] = [coin(height=900)]
scan(fake)
with pytest.raises(IntegrityError), transaction.atomic():
Utxo.objects.create(txid=TXID, vout=0, amount_sats=1, address=address)
def test_silence_concludes_nothing(player):
user, address = player
fake = FakeChain()
fake.entries[address] = [coin(height=900)]
fake.silent = {address}
assert scan(fake) == {"detected": 0, "credited": 0, "orphaned": 0, "reinstated": 0}
result = ScanResult(None, {address: Observation([coin(height=900)])}) # no usable tip: nothing is written either
assert deposits.apply_observations(result, deposits.plan())["detected"] == 0
# --- DEP-23: waiting deposits ------------------------------------------------------------------------------
def test_a_waiting_deposit_shows_as_incoming(player):
user, address = player
fake = FakeChain()
fake.entries[address] = [coin(height=999)]
scan(fake)
balance = balance_of(user)
assert (balance.spendable_sats, balance.incoming_sats) == (0, 5 * PLM)
def test_a_vanished_waiting_deposit_is_orphaned_and_can_return(player):
user, address = player
fake = FakeChain()
fake.entries[address] = [coin(height=999)]
scan(fake)
fake.entries[address] = []
scan(fake) # gone, but the others did not confirm that: nothing changes
assert Deposit.objects.get().status == "detected"
fake.absent = {(TXID, 0)}
assert scan(fake)["orphaned"] == 1
assert Deposit.objects.get().status == "orphaned" and balance_of(user).incoming_sats == 0
fake.entries[address], fake.absent = [coin(height=999)], set()
assert scan(fake)["reinstated"] == 1
assert balance_of(user).incoming_sats == 5 * PLM
def test_a_credited_deposit_is_left_alone_by_this_module(player):
"""What happens to a credited coin that later disappears is B7."""
user, address = player
fake = FakeChain()
fake.entries[address] = [coin(height=900)]
fake.verified = {(TXID, 0)}
scan(fake)
fake.entries[address], fake.absent = [], {(TXID, 0)}
assert scan(fake)["orphaned"] == 0 and Deposit.objects.get().status == "credited"
def test_the_policy_names_what_the_network_phase_needs(player):
user, address = player
fake = FakeChain()
fake.entries[address] = [coin(height=999)]
scan(fake)
scan(fake) # the second scan reads what the first one wrote
policy = fake.policies[-1]
assert policy.addresses == (address,) and policy.deposit_confirmations == 6
assert policy.waiting == {address: frozenset({(TXID, 0)})}
# --- configuration (DAT-77, ELC-31) ----------------------------------------------------------------------
def test_the_operator_changes_the_threshold_from_the_admin_and_it_is_audited(client):
admin = User.objects.create_superuser("boss", password="x" * 12)
client.force_login(admin)
config = LotteryConfig.get()
data = {f: getattr(config, f) for f in ("fee_address", "bet_amount_sats", "round_duration_seconds", "round_cooldown_seconds",
"draw_confirmations", "deposit_confirmations", "max_round_pool_sats", "fee_rate_sat_vb", "rbf_timeout_seconds")}
data["deposit_confirmations"] = 3
assert client.post("/admin/lottery/lotteryconfig/1/change/", data).status_code == 302
assert LotteryConfig.get().deposit_confirmations == 3
entry = AuditEntry.objects.get(action="config_changed")
assert entry.actor == admin and entry.payload == {"changed": {"deposit_confirmations": [6, 3]}}
@pytest.mark.parametrize("value", [0, 101])
def test_the_database_refuses_a_threshold_out_of_range(value):
config = LotteryConfig.get()
config.deposit_confirmations = value
with pytest.raises(IntegrityError), transaction.atomic():
config.save()
def _settings_import(**env):
import os
import subprocess
import sys
from pathlib import Path
clean = {"PATH": os.environ["PATH"], "PYTHONPATH": str(Path(__file__).resolve().parents[2]),
"DJANGO_SECRET_KEY": "k" * 60, "LEDGER_BACKEND": "chain", **env}
return subprocess.run([sys.executable, "-c", "import config.settings as s; print(len(s.ELECTRUM_ENDPOINTS))"],
cwd=Path(__file__).resolve().parents[2], env=clean, capture_output=True, text=True)
def test_a_real_ledger_needs_servers_and_a_quorum():
assert "ELECTRUM_SERVERS" in _settings_import().stderr
assert "three servers" in _settings_import(ELECTRUM_SERVERS="a:1,b:1").stderr
assert _settings_import(ELECTRUM_SERVERS="a:1,b:1,c:1").stdout.strip() == "3"
assert _settings_import(ELECTRUM_SERVERS="a:1", ELECTRUM_ALLOW_NO_QUORUM="true").stdout.strip() == "1"
assert _settings_import(ELECTRUM_SERVERS="bad").returncode != 0
def test_no_quorum_is_refused_on_mainnet():
result = _settings_import(PLM_NETWORK="mainnet", PLM_MAINNET_CONFIRMED="yes", ELECTRUM_SERVERS="a:1",
ELECTRUM_ALLOW_NO_QUORUM="true")
assert result.returncode != 0 and "mainnet" in result.stderr