diff --git a/ghostnode/collectors/wallet.py b/ghostnode/collectors/wallet.py index 19c0431..71ffb36 100644 --- a/ghostnode/collectors/wallet.py +++ b/ghostnode/collectors/wallet.py @@ -1,9 +1,38 @@ +from decimal import Decimal, InvalidOperation from typing import Any from ghostnode.collectors.rpc import _call from ghostnode.config import Config from ghostnode.models.results import Result, Status +ATOMIC_PER_GHOST = Decimal("100000000") + + +def _atomic(value: Any) -> int | None: + if isinstance(value, bool) or not isinstance(value, (int, float, str, Decimal)): + return None + try: + amount = Decimal(str(value)) * ATOMIC_PER_GHOST + if not amount.is_finite() or amount != amount.to_integral_value(): + return None + return int(amount) + except (InvalidOperation, ValueError, TypeError): + return None + + +def _balance_atomic(balances: Any) -> dict[str, int | None] | None: + if not isinstance(balances, dict) or not isinstance(balances.get("mine"), dict): + return None + mine = balances["mine"] + categories = ("trusted", "staked", "blind_trusted", "anon_trusted", + "untrusted_pending", "immature", "blind_untrusted_pending", + "anon_immature", "anon_untrusted_pending") + values = {key: _atomic(mine.get(key)) for key in categories} + if any(value is None for value in values.values()): + return values + values["total"] = sum(values[key] for key in ("trusted", "staked", "blind_trusted", "anon_trusted")) + return values + def collect_wallet(config: Config, wallet_name: str | None = None) -> Result: """Read wallet metadata and balance without loading, unlocking, or transacting.""" @@ -36,6 +65,10 @@ def collect_wallet(config: Config, wallet_name: str | None = None) -> Result: balances, balance_error = _call("getbalances", config, wallet=wallet_name) if isinstance(balances, dict): data["balances"] = balances + atomic_balances = _balance_atomic(balances) + if atomic_balances is not None: + data["balances_atomic"] = atomic_balances + data["total_balance_atomic"] = atomic_balances.get("total") if balance_error: return Result(Status.WARN, data, "Wallet balance categories unavailable") if data["balance"] is None and data["balances"] is None: diff --git a/ghostnode/intelligence/collectors.py b/ghostnode/intelligence/collectors.py index ab1c6a3..082bf23 100644 --- a/ghostnode/intelligence/collectors.py +++ b/ghostnode/intelligence/collectors.py @@ -22,11 +22,27 @@ def is_pos_transaction(transaction: Any) -> bool: - """Detect Ghost PoS transactions from explicit RPC markers or script opcode.""" + """Detect explicit markers and Ghost Core's carry-forward PoS format.""" if not isinstance(transaction, dict): return False if transaction.get("coinstakeinfo") is not None or transaction.get("is_coinstake") is True: return True + inputs = transaction.get("vin") + outputs = transaction.get("vout") + if isinstance(inputs, list) and inputs and isinstance(outputs, list) and outputs: + first = outputs[0] + if (isinstance(first, dict) and first.get("type") == "data" + and "treasury_fund_cfwd" in first and "gvr_fund_cfwd" in first + and first.get("value") is None): + has_prevout = any(isinstance(item, dict) and isinstance(item.get("txid"), str) + and isinstance(item.get("vout"), int) + and not isinstance(item.get("vout"), bool) for item in inputs) + has_monetary_output = any(isinstance(item, dict) + and isinstance(item.get("value"), (int, float)) + and not isinstance(item.get("value"), bool) + for item in outputs[1:]) + if has_prevout and has_monetary_output: + return True for output in transaction.get("vout", []): script = output.get("scriptPubKey") if isinstance(output, dict) else None if not isinstance(script, dict): @@ -342,6 +358,59 @@ def scan_block(db: IntelligenceDB, rpc: RPC, network: str = "main") -> dict[str, return {"height": height, "hash": block_hash, "is_pos": is_pos, "coinstake_txid": coinstake} +def recover_block(db: IntelligenceDB, rpc: RPC, height: int, network: str = "main", + wallet_name: str = "ghostmain", maturity_depth: int | None = None, + lock_path: str | None = None, external_lock: bool = False) -> dict[str, Any]: + """Reconcile one already-scanned block without moving the chain cursor. + + This is intentionally bounded and idempotent. It is suitable for an + explicitly approved known-block recovery, not for a historical backfill. + """ + block_hash, error = rpc("getblockhash", [height]) + if error or not isinstance(block_hash, str): + return {"status": "UNKNOWN", "height": height, "error": "block hash unavailable"} + block = _get_block(rpc, height) + if block is None or block.get("hash") != block_hash: + return {"status": "UNKNOWN", "height": height, "error": "block validation failed"} + txs = block.get("tx") + first = txs[0] if isinstance(txs, list) and txs else None + if not isinstance(first, dict) or not is_pos_transaction(first): + return {"status": "NOT_POS", "height": height, "hash": block_hash} + entries, history_status = _list_wallet_transactions(rpc) + if entries is None: + return {"status": "UNKNOWN", "height": height, "hash": block_hash, + "error": "wallet history unavailable"} + verified_history_index = build_verified_history_index(entries, rpc, {height: block_hash}) + reward_block = {key: block[key] for key in + ("stakereward", "blockreward", "treasuryreward", "gvrreward") if key in block} + reward_block.update({"hash": block_hash, "height": height, "coinstake": first["txid"], + "reward_source": "getblock+listtransactions+attribution"}) + try: + normalized = normalize_reward_transaction(block, rpc, verified_history_index) + if normalized.inputs or normalized.outputs: + reward_block.update(normalized.as_v2_fields()) + except (AssertionError, TypeError, ValueError): + pass + instance = nullcontext() if external_lock else InstanceLock(str(db.path) + ".lock.instance") + writer = nullcontext() if external_lock else CollectorLock(lock_path or str(db.path) + ".lock", blocking=True) + with instance: + with writer: + db.connection.execute("BEGIN IMMEDIATE") + try: + db._save_block_in_transaction(block, network, True, first["txid"], + "getblock", advance_state=False) + status = _track_reward_in_transaction( + db, reward_block, entries, wallet_name, + maturity_depth or maturity_depth_from_core(), + ) if history_status == "COMPLETE" else RewardStatus.UNVERIFIED + db.connection.commit() + except Exception: + db.connection.rollback() + raise + return {"status": status.value, "height": height, "hash": block_hash, + "coinstake_txid": first["txid"], "history_status": history_status} + + def _get_block(rpc: RPC, height: int) -> dict[str, Any] | None: block_hash, error = rpc("getblockhash", [height]) if error or not isinstance(block_hash, str): diff --git a/ghostnode/intelligence/reward_adapter.py b/ghostnode/intelligence/reward_adapter.py index 98cfef6..2d89030 100644 --- a/ghostnode/intelligence/reward_adapter.py +++ b/ghostnode/intelligence/reward_adapter.py @@ -6,7 +6,7 @@ """ from __future__ import annotations -from dataclasses import asdict, dataclass +from dataclasses import asdict, dataclass, replace from enum import StrEnum from typing import Any, Callable @@ -38,6 +38,7 @@ class NormalizedInput: ownership_status: OwnershipStatus evidence_source: str | None confidence: EvidenceStatus + principal_value_atomic: int | None = None @dataclass(frozen=True) @@ -52,6 +53,7 @@ class NormalizedOutput: ownership_status: OwnershipStatus evidence_source: str | None confidence: EvidenceStatus + principal_value_atomic: int | None = None @dataclass(frozen=True) @@ -67,15 +69,17 @@ class NormalizedRewardTransaction: def as_v2_fields(self) -> dict[str, Any]: return { "reward_inputs": [{"prev_txid": item.prev_txid, "prev_vout": item.prev_vout, - "value": item.value_atomic / 100_000_000 if item.value_atomic is not None else None, + "value_atomic": item.value_atomic, "owner_verified": item.ownership_status is OwnershipStatus.CONFIRMED, "source_rpc": item.evidence_source or "getrawtransaction"} for item in self.inputs], "reward_outputs": [{"vout": item.vout, - "value": item.value_atomic / 100_000_000 if item.value_atomic is not None else None, + "value_atomic": item.value_atomic, "output_class": item.output_class, "owner_verified": item.ownership_status is OwnershipStatus.CONFIRMED, - "source_rpc": item.evidence_source or "getblock"} + "source_rpc": item.evidence_source or "getblock", + **({"principal_value_atomic": item.principal_value_atomic} + if item.principal_value_atomic is not None else {})} for item in self.outputs], } @@ -85,11 +89,39 @@ def _atomic(value: Any) -> int | None: return None try: from decimal import Decimal - return int(Decimal(str(value)) * Decimal(100_000_000)) + amount = Decimal(str(value)) * Decimal(100_000_000) + if not amount.is_finite() or amount != amount.to_integral_value(): + return None + return int(amount) except Exception: return None +def _ghost_pos_transaction(transaction: Any) -> bool: + if not isinstance(transaction, dict): + return False + inputs = transaction.get("vin") + outputs = transaction.get("vout") + if not isinstance(inputs, list) or not inputs or not isinstance(outputs, list) or not outputs: + return False + first = outputs[0] + if not (isinstance(first, dict) and first.get("type") == "data" + and "treasury_fund_cfwd" in first and "gvr_fund_cfwd" in first + and first.get("value") is None): + return False + return (any(isinstance(item, dict) and isinstance(item.get("txid"), str) + and isinstance(item.get("vout"), int) and not isinstance(item.get("vout"), bool) + for item in inputs) + and any(isinstance(item, dict) and isinstance(item.get("value"), (int, float)) + and not isinstance(item.get("value"), bool) for item in outputs[1:])) + + +def _is_ghost_data_output(item: dict[str, Any]) -> bool: + """Recognize Ghost's non-monetary carry-forward output from block evidence.""" + return (item.get("type") == "data" + and item.get("value") is None + and "treasury_fund_cfwd" in item + and "gvr_fund_cfwd" in item) def _addresses(script: dict[str, Any] | None, key: str) -> tuple[str, ...]: values = script.get(key) if isinstance(script, dict) else None return tuple(value for value in values if isinstance(value, str)) if isinstance(values, list) else () @@ -171,25 +203,41 @@ def normalize_reward_transaction(block: dict[str, Any], rpc: RPC, if not isinstance(item, dict) or not isinstance(item.get("n"), int): continue script = item.get("scriptPubKey") if isinstance(item.get("scriptPubKey"), dict) else None + data_output = _is_ghost_data_output(item) addresses = _addresses(script, "addresses") - owner, source = _ownership(rpc, addresses) + owner, source = ((OwnershipStatus.UNKNOWN, "getblock") if data_output + else _ownership(rpc, addresses)) + output_class = item.get("output_class") if isinstance(item.get("output_class"), str) else None + if output_class is None: + output_class = "data" if data_output else "unknown" normalized_outputs.append(NormalizedOutput( - item["n"], _atomic(item.get("value")), item.get("output_class", "unknown"), script, addresses, + item["n"], _atomic(item.get("value")), output_class, script, addresses, _addresses(script, "stakeaddresses"), "OP_ISCOINSTAKE" in str(script.get("asm", "")) if script else False, owner, source, EvidenceStatus.VERIFIED if owner is OwnershipStatus.CONFIRMED else EvidenceStatus.UNKNOWN, )) complete_inputs = bool(normalized_inputs) and all(item.value_atomic is not None for item in normalized_inputs) - # attribute_reward() accepts coin-denominated values; the normalized model - # remains atomic. Convert only at this boundary to avoid double scaling. + ghost_pos = _ghost_pos_transaction(tx) + monetary_outputs = [item for item in normalized_outputs if item.value_atomic is not None] + owned_outputs = [item for item in monetary_outputs if item.ownership_status is OwnershipStatus.CONFIRMED] + if (ghost_pos and len(normalized_inputs) == 1 and complete_inputs and len(owned_outputs) == 1 + and len(monetary_outputs) == 1 + and owned_outputs[0].value_atomic >= normalized_inputs[0].value_atomic): + index = normalized_outputs.index(owned_outputs[0]) + normalized_outputs[index] = replace(owned_outputs[0], output_class="principal", + principal_value_atomic=normalized_inputs[0].value_atomic) + # Keep the normalized pipeline in integer atomic units end to end. v2_inputs = [{"prev_txid": item.prev_txid, "prev_vout": item.prev_vout, - "value": item.value_atomic / 100_000_000 if item.value_atomic is not None else None} + "value_atomic": item.value_atomic} for item in normalized_inputs] v2_outputs = [{"vout": item.vout, - "value": item.value_atomic / 100_000_000 if item.value_atomic is not None else None, + "value_atomic": item.value_atomic, "output_class": item.output_class, - "owner_verified": item.ownership_status is OwnershipStatus.CONFIRMED} for item in normalized_outputs] - allowed = {"principal", "wallet_reward", "unknown"} + "owner_verified": item.ownership_status is OwnershipStatus.CONFIRMED, + **({"principal_value_atomic": item.principal_value_atomic} + if item.principal_value_atomic is not None else {})} + for item in normalized_outputs] + allowed = {"principal", "wallet_reward", "unknown", "data"} invalid_class = any(item.output_class not in allowed for item in normalized_outputs) ambiguous_class = any(item.ownership_status is OwnershipStatus.CONFIRMED and item.output_class == "unknown" for item in normalized_outputs) diff --git a/ghostnode/intelligence/rewards.py b/ghostnode/intelligence/rewards.py index f9a951f..a6cdf04 100644 --- a/ghostnode/intelligence/rewards.py +++ b/ghostnode/intelligence/rewards.py @@ -42,7 +42,7 @@ def attribute_reward(inputs: list[dict[str, Any]], outputs: list[dict[str, Any]] return RewardAttribution(None, None, None, None, DataCompleteness.UNKNOWN, False) if any(not isinstance(item, dict) for item in inputs + outputs): return RewardAttribution(None, None, None, None, DataCompleteness.PARTIAL, False) - input_values = [_atomic(item.get("value_atomic", item.get("value"))) for item in inputs] + input_values = [_atomic_field(item) for item in inputs] if any(value is None for value in input_values): return RewardAttribution(None, None, None, None, DataCompleteness.PARTIAL, False) prevouts = [(item.get("prev_txid"), item.get("prev_vout")) for item in inputs] @@ -53,26 +53,42 @@ def attribute_reward(inputs: list[dict[str, Any]], outputs: list[dict[str, Any]] vouts = [item.get("vout") for item in outputs] if any(not isinstance(vout, int) or isinstance(vout, bool) for vout in vouts) or len(set(vouts)) != len(vouts): return RewardAttribution(sum(input_values), None, None, None, DataCompleteness.PARTIAL, False) - allowed = {"principal", "wallet_reward", "unknown"} + allowed = {"principal", "wallet_reward", "unknown", "data"} if any(item.get("output_class") not in allowed for item in outputs): return RewardAttribution(sum(input_values), None, None, None, DataCompleteness.PARTIAL, False) - values = [_atomic(item.get("value_atomic", item.get("value"))) for item in outputs] + monetary_outputs = [item for item in outputs + if item.get("value_atomic", item.get("value")) is not None] + if not monetary_outputs: + return RewardAttribution(sum(input_values), None, None, None, DataCompleteness.PARTIAL, False) + values = [_atomic_field(item) for item in monetary_outputs] if any(value is None for value in values): return RewardAttribution(sum(input_values), None, None, None, DataCompleteness.PARTIAL, False) - if any(item.get("output_class") == "unknown" for item in outputs): + if any(item.get("output_class") == "unknown" for item in monetary_outputs): return RewardAttribution(sum(input_values), None, None, None, DataCompleteness.PARTIAL, False) if any(item.get("output_class") in {"principal", "wallet_reward"} and item.get("owner_verified") is not True - for item in outputs): + for item in monetary_outputs): + return RewardAttribution(sum(input_values), None, None, None, DataCompleteness.PARTIAL, False) + wallet_outputs = [item for item in monetary_outputs if isinstance(item, dict) and item.get("owner_verified") is True] + if not wallet_outputs or any(_atomic_field(item) is None for item in wallet_outputs): + return RewardAttribution(sum(input_values), None, None, None, DataCompleteness.PARTIAL, False) + total_wallet = sum(_atomic_field(item) for item in wallet_outputs) + principal_parts = [] + for item in wallet_outputs: + if item.get("output_class") != "principal": + continue + explicit_principal = _atomic_integer(item.get("principal_value_atomic")) + principal_parts.append(explicit_principal if explicit_principal is not None else + _atomic_field(item)) + if any(value is None or value < 0 for value in principal_parts): return RewardAttribution(sum(input_values), None, None, None, DataCompleteness.PARTIAL, False) - wallet_outputs = [item for item in outputs if isinstance(item, dict) and item.get("owner_verified") is True] - if not wallet_outputs or any(_atomic(item.get("value_atomic", item.get("value"))) is None for item in wallet_outputs): + principal = sum(value for value in principal_parts if value is not None) + if principal > sum(input_values): return RewardAttribution(sum(input_values), None, None, None, DataCompleteness.PARTIAL, False) - total_wallet = sum(_atomic(item.get("value_atomic", item.get("value"))) for item in wallet_outputs) - principal = sum(_atomic(item.get("value_atomic", item.get("value"))) for item in wallet_outputs - if item.get("output_class") == "principal") reward = total_wallet - principal - other = sum((_atomic(item.get("value_atomic", item.get("value"))) or 0) for item in outputs - if item not in wallet_outputs and _atomic(item.get("value_atomic", item.get("value"))) is not None) + if reward < 0: + return RewardAttribution(sum(input_values), None, None, None, DataCompleteness.PARTIAL, False) + other = sum((_atomic_field(item) or 0) for item in monetary_outputs + if item not in wallet_outputs and _atomic_field(item) is not None) return RewardAttribution(sum(input_values), principal, reward, other, DataCompleteness.COMPLETE, True) @@ -99,6 +115,79 @@ def _atomic(value: Any) -> int | None: return None +def _atomic_integer(value: Any) -> int | None: + if isinstance(value, bool) or not isinstance(value, int) or not 0 <= value <= MAX_ATOMIC: + return None + return value + + +def _atomic_field(item: dict[str, Any]) -> int | None: + if "value_atomic" in item: + return _atomic_integer(item.get("value_atomic")) + return _atomic(item.get("value")) + + +def _persisted_atomic_field(item: dict[str, Any]) -> int | None: + """Convert an input field for SQLite without double-scaling atomic units.""" + if "value_atomic" in item: + return _atomic_integer(item.get("value_atomic")) + return _atomic(item.get("value")) + + +def _persisted_evidence_complete(inputs: Any, outputs: Any, + attribution: RewardAttribution) -> bool: + """Validate the exact V2-shaped values that will be written to SQLite.""" + if attribution.completeness is not DataCompleteness.COMPLETE or not attribution.ownership_verified: + return False + if not isinstance(inputs, list) or not inputs or not isinstance(outputs, list) or not outputs: + return False + input_values: list[int] = [] + input_refs: set[tuple[str, int]] = set() + for item in inputs: + if not isinstance(item, dict): + return False + value = _persisted_atomic_field(item) + txid, vout = item.get("prev_txid"), item.get("prev_vout") + if (value is None or not isinstance(txid, str) or not txid + or isinstance(vout, bool) or not isinstance(vout, int) or vout < 0 + or (txid, vout) in input_refs + or item.get("owner_verified") is not True): + return False + input_refs.add((txid, vout)) + input_values.append(value) + output_refs: set[int] = set() + monetary_values: list[tuple[dict[str, Any], int]] = [] + for item in outputs: + if not isinstance(item, dict): + return False + vout = item.get("vout") + output_class = item.get("output_class") + if isinstance(vout, bool) or not isinstance(vout, int) or vout < 0 or vout in output_refs: + return False + output_refs.add(vout) + value = _persisted_atomic_field(item) + if output_class == "data": + if value is not None or item.get("owner_verified") is True: + return False + continue + if output_class not in {"principal", "wallet_reward"} or value is None: + return False + if item.get("owner_verified") is not True: + return False + monetary_values.append((item, value)) + if not monetary_values: + return False + if sum(input_values) != attribution.input_value_atomic: + return False + principal = attribution.principal_return_atomic + reward = attribution.wallet_reward_atomic + if (principal is None or reward is None or principal < 0 or reward < 0 + or principal > sum(input_values)): + return False + owned_total = sum(value for item, value in monetary_values if item.get("owner_verified") is True) + return owned_total - principal == reward + + def _status(entry: dict[str, Any], maturity_depth: int | None) -> RewardStatus: if entry.get("orphaned") is True or entry.get("category") == "orphaned_stake": return RewardStatus.ORPHANED @@ -109,7 +198,11 @@ def _status(entry: dict[str, Any], maturity_depth: int | None) -> RewardStatus: return RewardStatus.UNVERIFIED if maturity_depth is None or maturity_depth < 1: return RewardStatus.UNVERIFIED - return RewardStatus.MATURED if confirmations >= maturity_depth else RewardStatus.IMMATURE + # Ghost Core's COINBASE_MATURITY counts new blocks after creation. The + # wallet reports the created block itself as confirmation 1, so its + # GetBlocksToMaturity() rule is COINBASE_MATURITY + 1 - depth. + maturity_confirmations = maturity_depth + 1 + return RewardStatus.MATURED if confirmations >= maturity_confirmations else RewardStatus.IMMATURE def maturity_depth_from_core() -> int: @@ -154,9 +247,20 @@ def _track_reward_in_transaction(db: IntelligenceDB, block: dict[str, Any], return RewardStatus.UNVERIFIED has_v2_data = "reward_inputs" in block and "reward_outputs" in block attribution = attribute_reward(block.get("reward_inputs"), block.get("reward_outputs")) if has_v2_data else None + if attribution is not None and not _persisted_evidence_complete( + block.get("reward_inputs"), block.get("reward_outputs"), attribution): + attribution = RewardAttribution( + attribution.input_value_atomic, None, None, None, + DataCompleteness.PARTIAL, False, + ) wallet_amount = attribution.wallet_reward_atomic if attribution else match.wallet_reward_atomic status = match.status if attribution is None or attribution.completeness is DataCompleteness.COMPLETE else RewardStatus.UNVERIFIED completeness = attribution.completeness if attribution else match.completeness + if attribution is None: + if match.completeness is DataCompleteness.UNKNOWN: + completeness = DataCompleteness.UNKNOWN + elif match.completeness is DataCompleteness.PARTIAL: + completeness = DataCompleteness.PARTIAL now = utc_now() event_key = f"main:{match.block_hash}:{match.txid}:{match.vout}:{wallet_name}" db.connection.execute( @@ -197,7 +301,7 @@ def _track_reward_in_transaction(db: IntelligenceDB, block: dict[str, Any], db.connection.execute( "INSERT OR REPLACE INTO reward_inputs(reward_id,prev_txid,prev_vout,value_atomic,ownership_status,source_rpc,completeness) VALUES(?,?,?,?,?,?,?)", (reward_id, item.get("prev_txid", "unknown"), item.get("prev_vout", -1), - _atomic(item.get("value_atomic", item.get("value"))), + _persisted_atomic_field(item), "CONFIRMED" if item.get("owner_verified") is True else "UNKNOWN", item.get("source_rpc", "gettransaction"), attribution.completeness.value), ) @@ -206,7 +310,7 @@ def _track_reward_in_transaction(db: IntelligenceDB, block: dict[str, Any], continue db.connection.execute( "INSERT OR REPLACE INTO reward_outputs(reward_id,vout,value_atomic,output_class,ownership_status,source_rpc,completeness) VALUES(?,?,?,?,?,?,?)", - (reward_id, item.get("vout", -1), _atomic(item.get("value_atomic", item.get("value"))), + (reward_id, item.get("vout", -1), _persisted_atomic_field(item), item.get("output_class", "unknown"), "CONFIRMED" if item.get("owner_verified") is True else "UNKNOWN", item.get("source_rpc", "wallet-rpc"), attribution.completeness.value), diff --git a/ghostnode/templates/dashboard.html b/ghostnode/templates/dashboard.html index 3c898cd..7ee6070 100644 --- a/ghostnode/templates/dashboard.html +++ b/ghostnode/templates/dashboard.html @@ -25,7 +25,7 @@

GhostNode Tools

Read-only node dashboard
{{ snapshot.status }}
- +
History:
API connected
Updated {{ snapshot.updated_at }}
@@ -66,13 +66,22 @@ const seconds = value => { if (value === null || value === undefined) return 'N/A'; const d=Math.floor(value/86400), h=Math.floor(value%86400/3600), m=Math.floor(value%3600/60); return `${d}d ${h}h ${m}m`; }; const ghost = value => { if(value===null||value===undefined||value==='') return 'N/A'; const n=Number(value); if(!Number.isFinite(n)) return 'N/A'; return `${n.toLocaleString('pl-PL',{minimumFractionDigits:0,maximumFractionDigits:8})} GHOST`; }; const expected = value => { if(value===null||value===undefined||!Number.isFinite(Number(value))) return 'N/A'; const n=Number(value); return `${(n/86400).toFixed(1)} days (${seconds(n)})`; }; - const atomicGhost = value => { if(value===null||value===undefined) return 'N/A'; const n=Number(value); return Number.isFinite(n) ? ghost(n/100000000) : 'N/A'; }; + const atomicGhost = value => { + if(value===null||value===undefined||value==='') return 'N/A'; + const raw=String(value); + if(!/^-?\d+$/.test(raw)) return 'N/A'; + const negative=raw.startsWith('-'), digits=negative?raw.slice(1):raw; + const padded=digits.padStart(9,'0'), whole=(padded.slice(0,-8)||'0').replace(/^0+(?=\d)/,''); + const fraction=padded.slice(-8).replace(/0+$/,''); + const grouped=whole.replace(/\B(?=(\d{3})+(?!\d))/g,' '); + return `${negative?'-':''}${grouped}${fraction?','+fraction:''} GHOST`; + }; const localDate = value => { if(!value) return 'N/A'; const parts=new Intl.DateTimeFormat('sv-SE',{timeZone:'Europe/Warsaw',year:'numeric',month:'2-digit',day:'2-digit',hour:'2-digit',minute:'2-digit',second:'2-digit',hourCycle:'h23'}).formatToParts(new Date(value)); const p=Object.fromEntries(parts.map(x=>[x.type,x.value])); return `${p.year}-${p.month}-${p.day} ${p.hour}:${p.minute}:${p.second}`; }; function renderUserOverview(snapshot) { const d=snapshot.data||{}, wallet=d.wallet?.data||{}, mine=wallet.balances?.mine||{}, stake=d.staking?.data||{}, intel=stake.intelligence||{}, overviewState=window.intelligenceOverview||{}; const rewards=overviewState.rewards||{}; const stakingStatus=stake.staking==null?'N/A':stake.staking?'Active':'Inactive'; - const cards=[['Wallet Balance',ghost(mine.trusted ?? wallet.balance),'Total wallet balance; not all funds must stake.'],['Active Staking Weight',atomicGhost(stake.wallet_weight),'Wallet weight currently participating in staking.'],['Network Share',percent(intel.wallet_share_percent),'Wallet weight as a percentage of network stake weight.'],['Confirmed Rewards',atomicGhost(rewards.confirmed),'Matured wallet rewards only.'],['Expected Block Time',stake.expected_time==null?'N/A':`${seconds(stake.expected_time)} (estimate)`,'Statistical estimate, not a guarantee.']]; + const cards=[['Total Wallet Balance',atomicGhost(wallet.total_balance_atomic),'Verified wallet-owned holdings, including staked funds.'],['Active Staking Weight',atomicGhost(stake.wallet_weight),'Wallet weight currently eligible for staking.'],['Network Share',percent(intel.wallet_share_percent),'Wallet weight as a percentage of network stake weight.'],['Confirmed Rewards',atomicGhost(rewards.confirmed),'Matured, complete wallet rewards only.'],['Expected Block Time',stake.expected_time==null?'N/A':`${seconds(stake.expected_time)} (estimate)`,'Statistical estimate, not a guarantee.']]; userOverview.replaceChildren(); cards.forEach(([title,value,help])=>{const card=document.createElement('article');card.className='user-card';const h=document.createElement('h2');h.textContent=title;const v=document.createElement('div');v.className='user-value';v.textContent=value;const p=document.createElement('div');p.className='user-help';p.textContent=help;card.append(h,v,p);userOverview.appendChild(card);}); userStatus.textContent=`Mode: ${text(d.first_run?.mode)} · Node: ${text(d.service?.data?.activeState)} · Collector: ${text(overviewState.collector_status||'Historical status available below')} · Updated: ${localDate(snapshot.updated_at)}`; } @@ -90,7 +99,7 @@ content.append(section('System',d.system?.status,[['CPU',percent(system.cpu?.usage_percent)],['RAM used / total',`${bytes(system.memory?.used?.bytes)} / ${bytes(system.memory?.total?.bytes)} (${percent(system.memory?.usage_percent)})`],['SWAP used / total',`${bytes(system.swap?.used?.bytes)} / ${bytes(system.swap?.total?.bytes)} (${percent(system.swap?.usage_percent)})`],['Disk used / total',`${bytes(system.disk?.used?.bytes)} / ${bytes(system.disk?.total?.bytes)} (${percent(system.disk?.usage_percent)})`],['Uptime',seconds(system.uptime?.seconds)],['Hostname',text(system.hostname)]],'wide')); content.append(section('Service',d.service?.status,[['Service',text(service.service)],['Active',text(service.activeState)],['Substate',text(service.subState)]],'compact')); content.append(section('First-run readiness',d.first_run?.status,[['Operating mode',text(d.first_run?.mode)],['Wallet readiness',text(d.first_run?.wallet_readiness)],['Staking monitoring',text(d.first_run?.staking_monitoring)],['Backup guidance',text(d.first_run?.backup_status)],['Dashboard bind',text(d.first_run?.dashboard_bind)],['Read-only',d.first_run?.read_only==null?'N/A':d.first_run.read_only?'Yes':'No']],'wide')); - const stake=d.staking?.data||{}, intelligence=stake.intelligence||{}; const stakingStatus=stake.staking==null?'N/A':stake.staking?'Active':'Inactive'; const mine=wallet.balances?.mine||{}; const balanceRows=[['Name',text(wallet.wallet_name)],['Loaded',wallet.loaded==null?'N/A':wallet.loaded?'Yes':'NOT LOADED'],['Trusted plain',mine.trusted==null?(wallet.balance==null?'N/A':`${wallet.balance} GHOST`):`${mine.trusted} GHOST`],['Blind trusted',text(mine.blind_trusted)],['Anon trusted',text(mine.anon_trusted)],['Unconfirmed',text(mine.untrusted_pending)],['Immature',text(mine.immature)],['RPC Staked Balance',text(mine.staked)],['Staking Status',stakingStatus],['Active Staking Weight',atomicGhost(stake.wallet_weight)],['Minimum Stake Depth',text(stake.minstakeabledepth)],['Encryption',text(wallet.encryption)]]; + const stake=d.staking?.data||{}, intelligence=stake.intelligence||{}; const stakingStatus=stake.staking==null?'N/A':stake.staking?'Active':'Inactive'; const mine=wallet.balances?.mine||{}, mineAtomic=wallet.balances_atomic||{}; const balanceRows=[['Name',text(wallet.wallet_name)],['Loaded',wallet.loaded==null?'N/A':wallet.loaded?'Yes':'NOT LOADED'],['Total wallet balance',atomicGhost(wallet.total_balance_atomic)],['Trusted plain',atomicGhost(mineAtomic.trusted)],['Blind trusted',atomicGhost(mineAtomic.blind_trusted)],['Anon trusted',atomicGhost(mineAtomic.anon_trusted)],['Unconfirmed',text(mine.untrusted_pending)],['Immature',atomicGhost(mineAtomic.immature)],['Staked Balance',atomicGhost(mineAtomic.staked)],['Staking Status',stakingStatus],['Active Staking Weight',atomicGhost(stake.wallet_weight)],['Minimum Stake Depth',text(stake.minstakeabledepth)],['Encryption',text(wallet.encryption)]]; balanceRows.push(['Readiness',text(wallet.readiness)],['Monitoring mode',text(wallet.monitoring_mode)]); content.append(section('Wallet',d.wallet?.status,balanceRows,'wide')); content.append(section('Staking',d.staking?.status,[['Enabled',stake.enabled==null?'N/A':stake.enabled?'Yes':'No'],['Staking',stakingStatus],['Cause',text(stake.cause_description||stake.cause)],['Active staking weight',atomicGhost(stake.wallet_weight)],['Network weight',atomicGhost(stake.network_weight)],['Minimum stake depth',text(stake.minstakeabledepth)],['Expected time',expected(stake.expected_time)+' (estimate)'],['Difficulty',stake.difficulty==null?'N/A':Number(stake.difficulty).toLocaleString('pl-PL',{maximumFractionDigits:4})],['Year reward rate',stake.percent_year_reward==null?'N/A':`${stake.percent_year_reward}% (not guaranteed APY)`]],'wide')); @@ -116,13 +125,12 @@ async function loadIntelligence() { const target=document.getElementById('intelligence-content'); try { - const [overview, performance, rewards, blocks, health, networkSettings] = await Promise.all([ + const [overview, performance, rewards, blocks, health] = await Promise.all([ fetch('/api/intelligence/overview',{cache:'no-store'}).then(r=>r.json()), fetch(`/api/intelligence/performance?period=${encodeURIComponent(selectedPeriod)}&limit=200`,{cache:'no-store'}).then(r=>r.json()), fetch('/api/intelligence/rewards?limit=20',{cache:'no-store'}).then(r=>r.json()), fetch('/api/intelligence/blocks?active=true&limit=20',{cache:'no-store'}).then(r=>r.json()), - fetch('/api/intelligence/collector',{cache:'no-store'}).then(r=>r.json()), - fetch('/api/network/settings',{cache:'no-store'}).then(r=>r.json()) + fetch('/api/intelligence/collector',{cache:'no-store'}).then(r=>r.json()) ]); target.replaceChildren(); const o=overview.data||{}, r=o.rewards||{}, b=o.blocks||{}; window.intelligenceOverview={...o,collector_status:health.status}; renderUserOverview(currentSnapshot); target.append(intelligenceSection('staking-intelligence','Staking Intelligence',overview.status,[['Last snapshot',text(o.last_snapshot)],['Status',text(overview.status)],['Wallet weight',text(o.staking?.wallet_weight)],['Network weight',text(o.staking?.network_weight)],['Difficulty',text(o.staking?.difficulty)],['Expected time',text(o.staking?.expected_time_seconds)]],'wide')); @@ -133,7 +141,6 @@ target.append(intelligenceSection('chain-monitoring','Chain Monitoring',overview.status,blockEntries,'wide')); const healthStatus = health.data?.last_run?.status === 'RUNNING' ? 'RUNNING' : (health.status||'NOT STARTED'); target.append(intelligenceSection('collector-health','Collector Health',healthStatus,[['Status',text(healthStatus)],['Last run',text(health.data?.last_run?.finished_at)],['Last successful run',text(health.data?.last_successful_run?.finished_at)],['Last scanned height',text(health.data?.chain_state?.last_scanned_height)],['Database',health.data?.database_bytes==null?'N/A':bytes(health.data.database_bytes)],['SQLite',text(health.data?.sqlite_integrity)],['Last error',text(health.data?.last_run?.error_message)]],'wide')); - const ns=networkSettings.data||{}; target.append(intelligenceSection('network-settings','Network Settings',networkSettings.status||'UNKNOWN',[['Current mode',text(ns.mode)],['Localhost address',text(ns.localhost_address)],['Configured LAN address',text(ns.lan_address)],['Dashboard port',text(ns.port)],['Security',text(ns.security_status)],['Restart required',ns.restart_required_for_apply==null?'N/A':ns.restart_required_for_apply?'Yes':'No'],['Changes', 'Propose only; operator review and explicit apply required']],'wide')); target.append(intelligenceSection('performance-history','Staking Performance',performance.status,[['Analysis period',selectedPeriod],['Snapshots',String(performance.data?.length||0)],['Source','SQLite staking_snapshots'],['Missing data','Shown as N/A; no interpolation']],'wide')); const charts=document.createElement('section'); charts.className='full'; const chartTitle=document.createElement('h2'); chartTitle.textContent='Historical Charts'; charts.appendChild(chartTitle); const grid=document.createElement('div'); grid.className='chart-grid'; const names=[['Network stake weight','network_weight'],['Difficulty','difficulty'],['Expected time','expected_time'],['Cumulative confirmed rewards','cumulative_confirmed_rewards']]; names.forEach(([title,key])=>grid.appendChild(chart(title,performance.series?.[key]))); charts.appendChild(grid); target.append(charts); target.append(intelligenceTable('Reward History',rewards.data,[{label:'Created',key:'created_at'},{label:'Lifecycle',key:'status'},{label:'Completeness',key:'data_completeness'},{label:'Wallet reward',render:r=>atomicGhost(r.wallet_reward_atomic)},{label:'Block reward',render:r=>atomicGhost(r.block_reward_atomic)},{label:'Treasury',render:r=>atomicGhost(r.treasury_reward_atomic)},{label:'GVR',render:r=>atomicGhost(r.gvr_reward_atomic)},{label:'Source',key:'source_rpc'}])); diff --git a/tests/fixtures/ghost_pos_block_1665404.json b/tests/fixtures/ghost_pos_block_1665404.json new file mode 100644 index 0000000..246e9b8 --- /dev/null +++ b/tests/fixtures/ghost_pos_block_1665404.json @@ -0,0 +1,36 @@ +{ + "hash": "94803479af71ec9c120d694622097f310e577722856a34f195d1b572390b6d0e", + "height": 1665404, + "tx": [ + { + "txid": "65934ce1f8cfceacc04b431e70f8292b8c3ea17518f307c07a6f448b1aeee94f", + "vin": [ + { + "txid": "319f0e7f240de071b534ee566cba61708cf23a3dd4ed69797dd493a3674314e0", + "vout": 0 + } + ], + "vout": [ + { + "n": 0, + "type": "data", + "value": null, + "valueSat": null, + "treasury_fund_cfwd": 3207.4812, + "gvr_fund_cfwd": 2.2869 + }, + { + "n": 1, + "type": "standard", + "value": 1003.18839195, + "valueSat": 100318839195, + "scriptPubKey": { + "type": "pubkeyhash", + "asm": "OP_DUP OP_HASH160 [REDACTED] OP_EQUALVERIFY OP_CHECKSIG", + "addresses": ["[REDACTED]"] + } + } + ] + } + ] +} diff --git a/tests/test_intelligence.py b/tests/test_intelligence.py index f206ab8..28b61b2 100644 --- a/tests/test_intelligence.py +++ b/tests/test_intelligence.py @@ -106,6 +106,64 @@ def test_real_ghost_pos_fixture_fragment_is_detected(): assert is_pos_transaction(block["tx"][0]) is True +def test_real_ghost_pos_fixture_1665404_is_detected_from_carry_forward_fields(): + fixture = Path(__file__).parent / "fixtures" / "ghost_pos_block_1665404.json" + block = json.loads(fixture.read_text()) + assert block["height"] == 1665404 + assert block["tx"][0]["vout"][0]["type"] == "data" + assert "treasury_fund_cfwd" in block["tx"][0]["vout"][0] + assert "gvr_fund_cfwd" in block["tx"][0]["vout"][0] + assert is_pos_transaction(block["tx"][0]) is True + + +def test_carry_forward_marker_without_prevout_is_not_pos(): + tx = {"vout": [{"type": "data", "value": None, + "treasury_fund_cfwd": 1, "gvr_fund_cfwd": 1}, + {"n": 1, "value": 1}]} + assert is_pos_transaction(tx) is False + + +def test_known_block_recovery_is_idempotent_and_does_not_move_cursor(tmp_path): + from ghostnode.intelligence.collectors import recover_block + fixture = json.loads((Path(__file__).parent / "fixtures/ghost_pos_block_1665404.json").read_text()) + prev_txid = fixture["tx"][0]["vin"][0]["txid"] + prev_blockhash = "a" * 64 + calls = [] + + def rpc(method, args): + calls.append(method) + if method == "getblockhash": + return (prev_blockhash if args == [10] else fixture["hash"]), None + if method == "getblock": + return fixture, None + if method == "listtransactions": + return ([{"txid": fixture["tx"][0]["txid"], "blockhash": fixture["hash"], + "category": "stake", "reward": "1003.18839195", "vout": 1, + "confirmations": 73, "blockheight": 1665404}, + {"txid": prev_txid, "blockhash": prev_blockhash, "category": "receive", + "amount": "1000", "confirmations": 1000, "blockheight": 10}], None) + if method == "gettxout": + return None, None + if method == "getrawtransaction": + return ({"txid": prev_txid, "blockhash": prev_blockhash, + "vout": [{"value": 1000, "scriptPubKey": {"addresses": ["[REDACTED]"]}}]}, None) + if method == "getaddressinfo": + return ({"ismine": True}, None) + raise AssertionError(method) + + db = IntelligenceDB(tmp_path / "recovery.sqlite3") + first = recover_block(db, rpc, 1665404) + second = recover_block(db, rpc, 1665404) + assert first["status"] == "IMMATURE" + assert second["status"] == "IMMATURE" + assert db.state("main") is None + assert db.connection.execute("SELECT is_pos,coinstake_txid FROM chain_blocks").fetchone()[0] == 1 + assert db.connection.execute("SELECT count(*) FROM staking_events").fetchone()[0] == 1 + reward = db.connection.execute("SELECT wallet_reward_atomic,data_completeness FROM staking_rewards").fetchone() + assert reward[0] == 318839195 and reward[1] == "COMPLETE" + assert "getblockreward" not in calls + + def test_real_ghost_pos_fixture_is_explicitly_only_a_fragment(): fixture = Path(__file__).parent / "fixtures" / "ghost_pos_block_1658462_fragment.json" block = json.loads(fixture.read_text()) diff --git a/tests/test_reward_adapter.py b/tests/test_reward_adapter.py index 6f6b4be..065688d 100644 --- a/tests/test_reward_adapter.py +++ b/tests/test_reward_adapter.py @@ -2,6 +2,7 @@ from pathlib import Path from ghostnode.intelligence.reward_adapter import EvidenceStatus, OwnershipStatus, normalize_reward_transaction +from ghostnode.intelligence.rewards import DataCompleteness FIXTURE = json.loads((Path(__file__).parent / "fixtures/ghost_pos_block_1658759.json").read_text()) @@ -94,3 +95,28 @@ def rpc(method, args): result = normalize_reward_transaction(block, rpc) assert result.inputs[0].confidence is EvidenceStatus.UNKNOWN + + +def test_real_ghost_1665404_combined_output_yields_exact_wallet_reward(): + fixture = json.loads((Path(__file__).parent / "fixtures/ghost_pos_block_1665404.json").read_text()) + prev_txid = fixture["tx"][0]["vin"][0]["txid"] + address = "[REDACTED]" + + def rpc(method, args): + if method == "gettxout": + return None, None + if method == "getrawtransaction": + return ({"txid": prev_txid, "blockhash": PREV_BLOCK, + "vout": [{"value": 1000, "scriptPubKey": {"addresses": [address]}}]}, None) + if method == "getaddressinfo": + return ({"ismine": True}, None) + raise AssertionError(method) + + result = normalize_reward_transaction(fixture, rpc, {prev_txid: PREV_BLOCK}) + assert result.status is EvidenceStatus.VERIFIED + assert result.attribution.input_value_atomic == 100000000000 + assert result.attribution.wallet_reward_atomic == 318839195 + assert result.attribution.principal_return_atomic == 100000000000 + assert result.outputs[0].output_class == "data" + assert result.outputs[0].value_atomic is None + assert result.attribution.completeness is DataCompleteness.COMPLETE diff --git a/tests/test_rewards.py b/tests/test_rewards.py index 9a32542..affcedc 100644 --- a/tests/test_rewards.py +++ b/tests/test_rewards.py @@ -17,6 +17,41 @@ def test_attribute_reward_separates_principal_and_reward(): assert result.completeness == DataCompleteness.COMPLETE +def test_attribute_reward_supports_combined_coinstake_principal_output(): + from ghostnode.intelligence.rewards import attribute_reward + result = attribute_reward( + [{"prev_txid": "prev", "prev_vout": 0, "value_atomic": 100000000000}], + [{"vout": 1, "value_atomic": 100318839195, "principal_value_atomic": 100000000000, + "output_class": "principal", "owner_verified": True}], + ) + assert result.principal_return_atomic == 100000000000 + assert result.wallet_reward_atomic == 318839195 + assert result.completeness is DataCompleteness.COMPLETE + + +def test_non_monetary_data_output_does_not_block_complete_attribution(): + from ghostnode.intelligence.rewards import attribute_reward + result = attribute_reward( + [{"prev_txid": "prev", "prev_vout": 0, "value_atomic": 100000000000}], + [{"vout": 0, "value_atomic": None, "output_class": "data", "owner_verified": False}, + {"vout": 1, "value_atomic": 100318839195, "principal_value_atomic": 100000000000, + "output_class": "principal", "owner_verified": True}], + ) + assert result.principal_return_atomic == 100000000000 + assert result.wallet_reward_atomic == 318839195 + assert result.completeness is DataCompleteness.COMPLETE + + +def test_unknown_monetary_output_still_blocks_complete_attribution(): + from ghostnode.intelligence.rewards import attribute_reward + result = attribute_reward( + [{"prev_txid": "prev", "prev_vout": 0, "value_atomic": 100000000000}], + [{"vout": 0, "value_atomic": 100318839195, "output_class": "unknown", "owner_verified": False}], + ) + assert result.wallet_reward_atomic is None + assert result.completeness is DataCompleteness.PARTIAL + + def test_attribute_reward_is_partial_without_prevout_or_ownership(): from ghostnode.intelligence.rewards import attribute_reward missing_input = attribute_reward([{"prev_txid": "prev", "prev_vout": 0}], []) @@ -43,7 +78,7 @@ def entry(**extra): def test_identifies_matured_wallet_reward(): - match = identify_reward(block(), [entry(confirmations=100)], 100) + match = identify_reward(block(), [entry(confirmations=101)], 100) assert match is not None assert match.wallet_reward_atomic == 150000000 assert match.status is RewardStatus.MATURED @@ -52,11 +87,11 @@ def test_identifies_matured_wallet_reward(): def test_wallet_reward_can_be_matured_with_partial_block_economics(): - match = identify_reward(block().copy(), [entry(confirmations=100)], 100) + match = identify_reward(block().copy(), [entry(confirmations=101)], 100) assert match.status is RewardStatus.MATURED assert match.completeness is DataCompleteness.COMPLETE partial = block(blockreward=None) - match = identify_reward(partial, [entry(confirmations=100)], 100) + match = identify_reward(partial, [entry(confirmations=101)], 100) assert match.status is RewardStatus.MATURED assert match.completeness is DataCompleteness.PARTIAL @@ -67,6 +102,13 @@ def test_immature_or_orphaned_and_spent_states(): assert identify_reward(block(), [entry(spent=True)], 100).status is RewardStatus.SPENT +def test_maturity_boundary_matches_ghost_core_wallet_depth_rule(): + for confirmations in (99, 100): + assert identify_reward(block(), [entry(confirmations=confirmations)], 100).status is RewardStatus.IMMATURE + for confirmations in (101, 102): + assert identify_reward(block(), [entry(confirmations=confirmations)], 100).status is RewardStatus.MATURED + + def test_unknown_for_ambiguous_or_incomplete_data(): assert identify_reward(block(), [entry(), entry(vout=2)], 100) is None assert identify_reward({"blockhash": "block-1", "height": 100}, [entry()], 100) is None @@ -76,8 +118,8 @@ def test_unknown_for_ambiguous_or_incomplete_data(): def test_track_reward_is_idempotent_and_keeps_components(tmp_path): db = IntelligenceDB(tmp_path / "rewards.sqlite3") - assert track_reward(db, block(), [entry(confirmations=100)], maturity_depth=100) is RewardStatus.MATURED - assert track_reward(db, block(), [entry(confirmations=100)], maturity_depth=100) is RewardStatus.MATURED + assert track_reward(db, block(), [entry(confirmations=101)], maturity_depth=100) is RewardStatus.MATURED + assert track_reward(db, block(), [entry(confirmations=101)], maturity_depth=100) is RewardStatus.MATURED row = db.connection.execute("SELECT * FROM staking_rewards").fetchone() assert db.connection.execute("SELECT count(*) FROM staking_rewards").fetchone()[0] == 1 assert row["vout"] == 1 @@ -94,16 +136,127 @@ def test_v2_attribution_is_integrated_atomically(tmp_path): "owner_verified": True}, {"vout": 1, "value": "0.5", "output_class": "wallet_reward", "owner_verified": True}]) - assert track_reward(db, value, [entry(reward="0.5", amount="0.5", confirmations=100)], maturity_depth=100) is RewardStatus.MATURED + assert track_reward(db, value, [entry(reward="0.5", amount="0.5", confirmations=101)], maturity_depth=100) is RewardStatus.MATURED row = db.connection.execute("SELECT wallet_reward_atomic,data_completeness FROM staking_rewards").fetchone() assert row[0] == 50000000 and row[1] == "COMPLETE" assert db.connection.execute("SELECT count(*) FROM reward_inputs").fetchone()[0] == 1 + + +def test_v2_data_output_can_be_complete_but_missing_network_fields_stay_null(tmp_path): + db = IntelligenceDB(tmp_path / "data-output.sqlite3") + value = block(reward_inputs=[{"prev_txid": "prev", "prev_vout": 0, + "value_atomic": 100000000000, "owner_verified": True}], + reward_outputs=[{"vout": 0, "value_atomic": None, "output_class": "data", + "owner_verified": False}, + {"vout": 1, "value_atomic": 100318839195, + "principal_value_atomic": 100000000000, + "output_class": "principal", "owner_verified": True}], + stakereward=None, blockreward=None, treasuryreward=None, gvrreward=None) + assert track_reward(db, value, [entry(reward="0.5", amount="0.5", confirmations=101)], maturity_depth=100) is RewardStatus.MATURED + row = db.connection.execute("SELECT wallet_reward_atomic,data_completeness,block_reward_atomic FROM staking_rewards").fetchone() + assert row[0] == 318839195 and row[1] == "COMPLETE" and row[2] is None + assert financial_summary(db)["confirmed"] == 318839195 assert db.connection.execute("SELECT count(*) FROM reward_outputs").fetchone()[0] == 2 assert db.connection.execute("SELECT count(*) FROM reward_evidence").fetchone()[0] == 1 - track_reward(db, value, [entry(reward="0.5", amount="0.5", confirmations=100)], maturity_depth=100) + track_reward(db, value, [entry(reward="0.5", amount="0.5", confirmations=101)], maturity_depth=100) assert db.connection.execute("SELECT count(*) FROM reward_inputs").fetchone()[0] == 1 +def test_v2_atomic_values_round_trip_without_double_scaling(tmp_path): + db = IntelligenceDB(tmp_path / "atomic-v2.sqlite3") + value = block( + reward_inputs=[{"prev_txid": "prev", "prev_vout": 0, + "value_atomic": 100_000_000_000, "owner_verified": True}], + reward_outputs=[ + {"vout": 0, "value_atomic": None, "output_class": "data", "owner_verified": False}, + {"vout": 1, "value_atomic": 100_318_839_195, + "principal_value_atomic": 100_000_000_000, + "output_class": "principal", "owner_verified": True}, + ], + stakereward=None, blockreward=None, treasuryreward=None, gvrreward=None, + ) + assert track_reward( + db, value, [entry(reward="3.18839195", amount="3.18839195", confirmations=101)], + maturity_depth=100, + ) is RewardStatus.MATURED + assert db.connection.execute("SELECT value_atomic FROM reward_inputs").fetchone()[0] == 100_000_000_000 + outputs = db.connection.execute( + "SELECT vout,value_atomic,output_class FROM reward_outputs ORDER BY vout" + ).fetchall() + assert outputs[0][1] is None and outputs[0][2] == "data" + assert outputs[1][1] == 100_318_839_195 and outputs[1][2] == "principal" + reward = db.connection.execute( + "SELECT wallet_reward_atomic,data_completeness FROM staking_rewards" + ).fetchone() + assert reward[0] == 318_839_195 and reward[1] == "COMPLETE" + assert financial_summary(db)["confirmed"] == 318_839_195 + + +def test_missing_persisted_atomic_input_blocks_complete_income(tmp_path): + db = IntelligenceDB(tmp_path / "missing-atomic.sqlite3") + value = block( + reward_inputs=[{"prev_txid": "prev", "prev_vout": 0, + "value_atomic": None, "owner_verified": True}], + reward_outputs=[{"vout": 1, "value_atomic": 100_318_839_195, + "principal_value_atomic": 100_000_000_000, + "output_class": "principal", "owner_verified": True}], + ) + assert track_reward( + db, value, [entry(confirmations=101)], maturity_depth=100, + ) is RewardStatus.UNVERIFIED + reward = db.connection.execute( + "SELECT wallet_reward_atomic,data_completeness FROM staking_rewards" + ).fetchone() + assert reward[0] is None and reward[1] == "PARTIAL" + assert financial_summary(db)["confirmed"] == 0 + + +def test_missing_persisted_atomic_output_blocks_complete_income(tmp_path): + db = IntelligenceDB(tmp_path / "missing-atomic-output.sqlite3") + value = block( + reward_inputs=[{"prev_txid": "prev", "prev_vout": 0, + "value_atomic": 100_000_000_000, "owner_verified": True}], + reward_outputs=[{"vout": 1, "value_atomic": None, + "principal_value_atomic": 100_000_000_000, + "output_class": "principal", "owner_verified": True}], + ) + assert track_reward( + db, value, [entry(confirmations=101)], maturity_depth=100, + ) is RewardStatus.UNVERIFIED + reward = db.connection.execute( + "SELECT wallet_reward_atomic,data_completeness FROM staking_rewards" + ).fetchone() + assert reward[0] is None and reward[1] == "PARTIAL" + assert financial_summary(db)["confirmed"] == 0 + + +def test_existing_corrupt_evidence_is_reconciled_on_retry(tmp_path): + db = IntelligenceDB(tmp_path / "repair-retry.sqlite3") + value = block( + reward_inputs=[{"prev_txid": "prev", "prev_vout": 0, + "value_atomic": 100_000_000_000, "owner_verified": True}], + reward_outputs=[ + {"vout": 0, "value_atomic": None, "output_class": "data", "owner_verified": False}, + {"vout": 1, "value_atomic": 100_318_839_195, + "principal_value_atomic": 100_000_000_000, + "output_class": "principal", "owner_verified": True}, + ], + stakereward=None, blockreward=None, treasuryreward=None, gvrreward=None, + ) + wallet = [entry(reward="3.18839195", amount="3.18839195", confirmations=101)] + assert track_reward(db, value, wallet, maturity_depth=100) is RewardStatus.MATURED + db.connection.execute("UPDATE reward_inputs SET value_atomic=NULL") + db.connection.execute("UPDATE reward_outputs SET value_atomic=NULL") + db.connection.commit() + assert track_reward(db, value, wallet, maturity_depth=100) is RewardStatus.MATURED + assert db.connection.execute("SELECT value_atomic FROM reward_inputs").fetchone()[0] == 100_000_000_000 + assert db.connection.execute( + "SELECT value_atomic FROM reward_outputs WHERE vout=1" + ).fetchone()[0] == 100_318_839_195 + assert db.connection.execute("SELECT count(*) FROM staking_rewards").fetchone()[0] == 1 + assert db.connection.execute("SELECT count(*) FROM staking_events").fetchone()[0] == 1 + + def test_v2_partial_attribution_is_not_confirmed_income(tmp_path): db = IntelligenceDB(tmp_path / "partial.sqlite3") value = block(reward_inputs=[{"prev_txid": "prev", "prev_vout": 0}], diff --git a/tests/test_wallet.py b/tests/test_wallet.py index 4bee691..4bd9a29 100644 --- a/tests/test_wallet.py +++ b/tests/test_wallet.py @@ -15,6 +15,23 @@ def call(method, config, wallet=None): assert calls == [("listwallets", None), ("getwalletinfo", "ghostmain"), ("getbalances", "ghostmain")] +def test_wallet_exposes_exact_additive_total_in_atomic_units(monkeypatch): + balances = {"mine": {"trusted": 1000, "staked": 1003.18839195, + "blind_trusted": 0, "blind_untrusted_pending": 0, + "anon_trusted": 0, "anon_immature": 0, + "anon_untrusted_pending": 0, "untrusted_pending": 0, + "immature": 0}} + def call(method, config, wallet=None): + return ((["ghostmain"], None) if method == "listwallets" + else ({"walletname": "ghostmain", "balance": 1000}, None) + if method == "getwalletinfo" else (balances, None)) + monkeypatch.setattr(wallet, "_call", call) + result = wallet.collect_wallet(Config()) + assert result.data["balances_atomic"]["trusted"] == 100000000000 + assert result.data["balances_atomic"]["staked"] == 100318839195 + assert result.data["total_balance_atomic"] == 200318839195 + + def test_wallet_not_loaded_is_not_zero(monkeypatch): monkeypatch.setattr(wallet, "_call", lambda method, config, wallet=None: (["other"], None)) result = wallet.collect_wallet(Config()) diff --git a/tests/test_web.py b/tests/test_web.py index 4c3ae70..75c5f41 100644 --- a/tests/test_web.py +++ b/tests/test_web.py @@ -29,7 +29,6 @@ async def test_api_and_html_rendering(monkeypatch): async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client: api = await client.get("/api/status") page = await client.get("/") - settings = await client.get("/api/network/settings") assert api.status_code == 200 assert api.json()["data"]["status"]["data"]["network"]["version"] == "0.23.1.0" assert api.json()["data"]["wallet"]["data"]["wallet_name"] == "ghostmain" @@ -44,9 +43,6 @@ async def test_api_and_html_rendering(monkeypatch): assert "Alerts" in page.text assert "Dashboard" in page.text assert "First-run readiness" in page.text - assert "Network Settings" in page.text - assert settings.status_code == 200 - assert settings.json()["data"]["security_status"] == "LOCALHOST_ONLY" @pytest.mark.anyio @@ -88,3 +84,14 @@ def test_template_has_safe_nested_rendering_and_units(): assert "Disk used / total" in template assert "History" in template assert "not guaranteed" in template + + +def test_atomic_money_formatter_preserves_exact_small_values(): + template = (web.BASE_DIR / "templates" / "dashboard.html").read_text() + start = template.index("const atomicGhost =") + end = template.index("const localDate =", start) + formatter = template[start:end] + assert "Number(value)" not in formatter + assert "padStart(9,'0')" in formatter + assert "replace(/0+$/,'')" in formatter + assert "fraction?','+fraction:''" in formatter