Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
33 changes: 33 additions & 0 deletions ghostnode/collectors/wallet.py
Original file line number Diff line number Diff line change
@@ -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."""
Expand Down Expand Up @@ -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:
Expand Down
71 changes: 70 additions & 1 deletion ghostnode/intelligence/collectors.py
Original file line number Diff line number Diff line change
Expand Up @@ -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):
Expand Down Expand Up @@ -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):
Expand Down
74 changes: 61 additions & 13 deletions ghostnode/intelligence/reward_adapter.py
Original file line number Diff line number Diff line change
Expand Up @@ -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

Expand Down Expand Up @@ -38,6 +38,7 @@ class NormalizedInput:
ownership_status: OwnershipStatus
evidence_source: str | None
confidence: EvidenceStatus
principal_value_atomic: int | None = None


@dataclass(frozen=True)
Expand All @@ -52,6 +53,7 @@ class NormalizedOutput:
ownership_status: OwnershipStatus
evidence_source: str | None
confidence: EvidenceStatus
principal_value_atomic: int | None = None


@dataclass(frozen=True)
Expand All @@ -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],
}

Expand All @@ -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 ()
Expand Down Expand Up @@ -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)
Expand Down
Loading
Loading