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 @@