validator_dashboard_hardening.patch

*** Begin Patch
*** Update File: app/models/endpoint.py
@@
-from sqlalchemy import String, Integer, DateTime, ForeignKey
+from sqlalchemy import String, Integer, DateTime, ForeignKey, UniqueConstraint, func
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from app.models.base import Base
 
 
 class NetworkEndpoint(Base):
     __tablename__ = "network_endpoints"
+    __table_args__ = (
+        UniqueConstraint(
+            "network_id",
+            "endpoint_type",
+            "url",
+            name="uq_network_endpoint_network_type_url",
+        ),
+    )
+
     id: Mapped[int] = mapped_column(primary_key=True)
     network_id: Mapped[int] = mapped_column(ForeignKey("networks.id"), index=True)
     endpoint_type: Mapped[str] = mapped_column(String(20))  # rpc, rest, grpc
     label: Mapped[str | None] = mapped_column(String(20))  # rpc1, rpc2, rest1
     url: Mapped[str] = mapped_column(String(500))
     priority: Mapped[int] = mapped_column(Integer, default=1)
     is_public: Mapped[int] = mapped_column(Integer, default=1)
     is_enabled: Mapped[int] = mapped_column(Integer, default=1)
-    created_at: Mapped[DateTime | None] = mapped_column(DateTime)
-    updated_at: Mapped[DateTime | None] = mapped_column(DateTime)
+    created_at: Mapped[DateTime] = mapped_column(DateTime, server_default=func.now())
+    updated_at: Mapped[DateTime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        onupdate=func.now(),
+    )
@@
 class EndpointCheck(Base):
     __tablename__ = "endpoint_checks"
*** Update File: app/models/validator.py
@@
-from sqlalchemy import String, Integer, DateTime, ForeignKey, UniqueConstraint
+from sqlalchemy import String, Integer, DateTime, ForeignKey, UniqueConstraint, func
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from app.models.base import Base
@@
-    created_at: Mapped[DateTime | None] = mapped_column(DateTime)
-    updated_at: Mapped[DateTime | None] = mapped_column(DateTime)
+    created_at: Mapped[DateTime] = mapped_column(DateTime, server_default=func.now())
+    updated_at: Mapped[DateTime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        onupdate=func.now(),
+    )
*** Update File: app/models/network_asset.py
@@
-from sqlalchemy import String, Integer, DateTime, ForeignKey
+from sqlalchemy import String, Integer, DateTime, ForeignKey, UniqueConstraint, func
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from app.models.base import Base
 
 
 class NetworkAsset(Base):
     __tablename__ = "network_assets"
+    __table_args__ = (
+        UniqueConstraint(
+            "network_id",
+            "base_denom",
+            name="uq_network_asset_network_base_denom",
+        ),
+    )
+
     id: Mapped[int] = mapped_column(primary_key=True)
     network_id: Mapped[int] = mapped_column(ForeignKey("networks.id"), index=True)
     base_denom: Mapped[str] = mapped_column(String(200), index=True)
     display_denom: Mapped[str | None] = mapped_column(String(100))
     exponent: Mapped[int] = mapped_column(Integer, default=0)
     symbol: Mapped[str | None] = mapped_column(String(50))
     coingecko_id: Mapped[str | None] = mapped_column(String(120))
-    created_at: Mapped[DateTime | None] = mapped_column(DateTime)
-    updated_at: Mapped[DateTime | None] = mapped_column(DateTime)
+    created_at: Mapped[DateTime] = mapped_column(DateTime, server_default=func.now())
+    updated_at: Mapped[DateTime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        onupdate=func.now(),
+    )
     network = relationship("Network")
*** Update File: app/models/tracked_network.py
@@
-from sqlalchemy import String, Integer, DateTime, ForeignKey
+from sqlalchemy import String, Integer, DateTime, ForeignKey, func
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from app.models.base import Base
@@
-    created_at: Mapped[DateTime | None] = mapped_column(DateTime)
-    updated_at: Mapped[DateTime | None] = mapped_column(DateTime)
+    created_at: Mapped[DateTime] = mapped_column(DateTime, server_default=func.now())
+    updated_at: Mapped[DateTime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        onupdate=func.now(),
+    )
     network = relationship("Network")
*** Update File: app/models/public_rpc.py
@@
-from sqlalchemy import String, Integer, DateTime, ForeignKey
+from sqlalchemy import String, Integer, DateTime, ForeignKey, UniqueConstraint, func
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from app.models.base import Base
 
 
 class PublicRpcEndpoint(Base):
     __tablename__ = "public_rpc_endpoints"
+    __table_args__ = (
+        UniqueConstraint(
+            "network_id",
+            "url",
+            name="uq_public_rpc_endpoint_network_url",
+        ),
+    )
+
     id: Mapped[int] = mapped_column(primary_key=True)
     network_id: Mapped[int] = mapped_column(ForeignKey("networks.id"), index=True)
     label: Mapped[str | None] = mapped_column(String(50))
     url: Mapped[str] = mapped_column(String(500), index=True)
     priority: Mapped[int] = mapped_column(Integer, default=1)
     is_enabled: Mapped[int] = mapped_column(Integer, default=1)
     source: Mapped[str | None] = mapped_column(String(100))  # chain-registry, manual, etc.
-    created_at: Mapped[DateTime | None] = mapped_column(DateTime)
-    updated_at: Mapped[DateTime | None] = mapped_column(DateTime)
+    created_at: Mapped[DateTime] = mapped_column(DateTime, server_default=func.now())
+    updated_at: Mapped[DateTime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        onupdate=func.now(),
+    )
     network = relationship("Network")
*** Update File: app/models/snapshot.py
@@
-from sqlalchemy import String, Integer, DateTime, ForeignKey
+from sqlalchemy import String, Integer, DateTime, ForeignKey, UniqueConstraint, func
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from app.models.base import Base
 
 
 class SnapshotTarget(Base):
     __tablename__ = "snapshot_targets"
+    __table_args__ = (
+        UniqueConstraint(
+            "network_id",
+            "snapshot_path",
+            name="uq_snapshot_target_network_path",
+        ),
+    )
+
     id: Mapped[int] = mapped_column(primary_key=True)
     network_id: Mapped[int] = mapped_column(ForeignKey("networks.id"), index=True)
     snapshot_path: Mapped[str] = mapped_column(String(500))
     filename_pattern: Mapped[str | None] = mapped_column(String(200), default="data_latest%")
     compression_type: Mapped[str | None] = mapped_column(String(50))
     min_expected_size_bytes: Mapped[int | None] = mapped_column(Integer)
     max_age_hours: Mapped[int] = mapped_column(Integer, default=24)
     is_enabled: Mapped[int] = mapped_column(Integer, default=1)
-    created_at: Mapped[DateTime | None] = mapped_column(DateTime)
-    updated_at: Mapped[DateTime | None] = mapped_column(DateTime)
+    created_at: Mapped[DateTime] = mapped_column(DateTime, server_default=func.now())
+    updated_at: Mapped[DateTime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        onupdate=func.now(),
+    )
     network = relationship("Network", back_populates="snapshot_targets")
*** Add File: app/collectors/governance_collector.py
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+import requests
+from sqlalchemy import update
+
+from app.core.db import SessionLocal
+from app.models import CollectorRun, GovernanceProposal, Network, NetworkEndpoint, Validator
+
+REQUEST_TIMEOUT = 15
+ACTIVE_PROPOSAL_STATUSES = {
+    "PROPOSAL_STATUS_VOTING_PERIOD",
+    "PROPOSAL_STATUS_DEPOSIT_PERIOD",
+    "voting_period",
+    "deposit_period",
+}
+
+
+def _pick_rest_url(db, network_id: int) -> str | None:
+    endpoint = (
+        db.query(NetworkEndpoint)
+        .filter(NetworkEndpoint.network_id == network_id)
+        .filter(NetworkEndpoint.endpoint_type == "rest")
+        .filter(NetworkEndpoint.is_enabled == 1)
+        .order_by(NetworkEndpoint.is_public.desc(), NetworkEndpoint.priority.asc())
+        .first()
+    )
+    return endpoint.url.rstrip("/") if endpoint else None
+
+
+def _pick_validator_voter(db, network_id: int) -> str | None:
+    validator = (
+        db.query(Validator)
+        .filter(Validator.network_id == network_id)
+        .filter(Validator.is_enabled == 1)
+        .filter(Validator.is_main == 1)
+        .first()
+    )
+    return validator.delegator_address if validator else None
+
+
+def _fetch_proposals(rest_url: str) -> list[dict]:
+    url = f"{rest_url}/cosmos/gov/v1/proposals"
+    resp = requests.get(url, timeout=REQUEST_TIMEOUT)
+    resp.raise_for_status()
+    data = resp.json()
+    return data.get("proposals", [])
+
+
+def main() -> None:
+    db = SessionLocal()
+    run = CollectorRun(
+        collector_name="governance_collector",
+        status="running",
+        started_at=datetime.now(timezone.utc),
+    )
+    db.add(run)
+    db.commit()
+
+    processed = 0
+
+    try:
+        networks = (
+            db.query(Network)
+            .filter(Network.is_enabled == 1)
+            .order_by(Network.name.asc())
+            .all()
+        )
+
+        snapshot_at = datetime.now(timezone.utc).isoformat()
+
+        for network in networks:
+            rest_url = _pick_rest_url(db, network.id)
+            if not rest_url:
+                continue
+
+            voter = _pick_validator_voter(db, network.id)
+
+            try:
+                proposals = _fetch_proposals(rest_url)
+            except Exception as exc:
+                print(f"[WARN] governance fetch failed for {network.name}: {exc}")
+                continue
+
+            db.execute(
+                update(GovernanceProposal)
+                .where(GovernanceProposal.network_id == network.id)
+                .values(is_latest=0)
+            )
+
+            for proposal in proposals:
+                status = proposal.get("status")
+                if status not in ACTIVE_PROPOSAL_STATUSES:
+                    continue
+
+                final_tally = proposal.get("final_tally_result") or {}
+
+                row = GovernanceProposal(
+                    network_id=network.id,
+                    proposal_id=int(proposal.get("id", 0)),
+                    title=(proposal.get("title") or proposal.get("metadata") or "")[:1000] or None,
+                    description=(proposal.get("summary") or "")[:4000] or None,
+                    status=status,
+                    voting_start_time=proposal.get("voting_start_time"),
+                    voting_end_time=proposal.get("voting_end_time"),
+                    yes_votes=final_tally.get("yes_count"),
+                    no_votes=final_tally.get("no_count"),
+                    abstain_votes=final_tally.get("abstain_count"),
+                    no_with_veto_votes=final_tally.get("no_with_veto_count"),
+                    validator_voter_address=voter,
+                    validator_voted=0,
+                    validator_vote_option=None,
+                    snapshot_at=snapshot_at,
+                    last_updated_at=snapshot_at,
+                    is_latest=1,
+                )
+                db.add(row)
+                processed += 1
+
+        run.status = "success"
+        run.items_processed = processed
+        run.finished_at = datetime.now(timezone.utc)
+        db.commit()
+        print(f"governance_collector completed: {processed} rows")
+
+    except Exception as exc:
+        run.status = "failed"
+        run.error_message = str(exc)
+        run.finished_at = datetime.now(timezone.utc)
+        db.commit()
+        raise
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    main()
*** Add File: app/collectors/reward_status_collector.py
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+
+from app.core.db import SessionLocal
+from app.models import CollectorRun, Event, Network, Validator
+
+
+def main() -> None:
+    db = SessionLocal()
+    run = CollectorRun(
+        collector_name="reward_status_collector",
+        status="running",
+        started_at=datetime.now(timezone.utc),
+    )
+    db.add(run)
+    db.commit()
+
+    processed = 0
+    try:
+        now = datetime.now(timezone.utc)
+        stale_after = now - timedelta(days=2)
+
+        networks = db.query(Network).filter(Network.is_enabled == 1).all()
+        for network in networks:
+            validator = (
+                db.query(Validator)
+                .filter(Validator.network_id == network.id)
+                .filter(Validator.is_enabled == 1)
+                .filter(Validator.is_main == 1)
+                .first()
+            )
+            if validator is None:
+                continue
+
+            existing = (
+                db.query(Event)
+                .filter(Event.network_id == network.id)
+                .filter(Event.event_type == "reward_pipeline")
+                .filter(Event.event_key == f"reward_pipeline:{network.id}")
+                .filter(Event.status == "open")
+                .first()
+            )
+
+            if validator.updated_at is None or validator.updated_at < stale_after:
+                if existing is None:
+                    db.add(
+                        Event(
+                            network_id=network.id,
+                            validator_id=validator.id,
+                            event_type="reward_pipeline",
+                            severity="warning",
+                            title=f"Reward pipeline has no recent data for {network.name}",
+                            message="Rewards collector is not yet integrated into the bootstrap pipeline.",
+                            event_key=f"reward_pipeline:{network.id}",
+                            status="open",
+                            first_seen_at=now,
+                            last_seen_at=now,
+                            metadata_json='{"source": "reward_status_collector"}',
+                        )
+                    )
+                else:
+                    existing.last_seen_at = now
+                processed += 1
+            elif existing is not None:
+                existing.status = "resolved"
+                existing.resolved_at = now
+                existing.last_seen_at = now
+
+        run.status = "success"
+        run.items_processed = processed
+        run.finished_at = datetime.now(timezone.utc)
+        db.commit()
+        print(f"reward_status_collector completed: {processed} events updated")
+    except Exception as exc:
+        run.status = "failed"
+        run.error_message = str(exc)
+        run.finished_at = datetime.now(timezone.utc)
+        db.commit()
+        raise
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    main()
*** Update File: app/services/network_status_aggregator.py
@@
 from app.models import (
     EndpointCheck,
     Event,
+    GovernanceProposal,
     Network,
     NetworkEndpoint,
     NetworkStatusCurrent,
     SnapshotCheck,
     SnapshotTarget,
@@
 def validator_status_from_row(row: ValidatorStatusCurrent | None) -> str:
@@
     if row.status:
         return "warning"
     return "unknown"
+
+
+def governance_status_from_rows(rows: list[GovernanceProposal]) -> str:
+    if not rows:
+        return "unknown"
+    if any((row.validator_voted or 0) == 0 for row in rows):
+        return "warning"
+    return "ok"
+
+
+def reward_status_from_events(open_events_count: int) -> str:
+    if open_events_count > 0:
+        return "warning"
+    return "ok"
@@
         validator_rows = db.execute(
@@
         validator_map: dict[int, ValidatorStatusCurrent] = {}
         for status_row, validator in validator_rows:
             validator_map[validator.network_id] = status_row
+
+        governance_rows = db.execute(
+            select(GovernanceProposal)
+            .where(GovernanceProposal.network_id.in_(network_ids))
+            .where(GovernanceProposal.is_latest == 1)
+        ).scalars().all()
+        governance_map: dict[int, list[GovernanceProposal]] = defaultdict(list)
+        for row in governance_rows:
+            governance_map[row.network_id].append(row)
+
         alert_counts = dict(
             db.execute(
                 select(Event.network_id, func.count(Event.id))
@@
                 .group_by(Event.network_id)
             ).all()
         )
+
+        reward_alert_counts = dict(
+            db.execute(
+                select(Event.network_id, func.count(Event.id))
+                .where(Event.status == "open")
+                .where(Event.event_type == "reward_pipeline")
+                .where(Event.network_id.in_(network_ids))
+                .group_by(Event.network_id)
+            ).all()
+        )
@@
-            governance_status = "unknown"
-            reward_status = "unknown"
+            governance_status = governance_status_from_rows(governance_map.get(network.id, []))
+            reward_status = reward_status_from_events(reward_alert_counts.get(network.id, 0))
*** Update File: app/tasks/run_health_cycle.py
@@
 from app.collectors.endpoint_health_collector import main as endpoint_main
+from app.collectors.governance_collector import main as governance_main
+from app.collectors.reward_status_collector import main as reward_main
 from app.collectors.validator_status_collector import main as validator_main
 from app.services.network_status_aggregator import main as aggregator_main
 
 
 def main() -> None:
     endpoint_main()
     validator_main()
+    governance_main()
+    reward_main()
     aggregator_main()
*** Update File: reset_db.sh
@@
 rm -f validator_dashboard.db
 python3 -m scripts.init_db
 python3 -m scripts.load_chain_registry
 python3 -m scripts.load_tracked_networks
 python3 -m scripts.load_posthuman_endpoints
 python3 -m scripts.load_public_rpcs
 python3 -m app.collectors.endpoint_health_collector
 python3 -m app.collectors.validator_status_collector
+python3 -m app.collectors.governance_collector
+python3 -m app.collectors.reward_status_collector
 python3 -m app.services.network_status_aggregator
 python3 -m app.tasks.run_health_cycle
*** Add File: alembic/versions/20260313_01_harden_constraints_and_timestamps.py
+"""harden endpoint constraints and timestamp defaults
+
+Revision ID: 20260313_01
+Revises:
+Create Date: 2026-03-13
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+
+revision = "20260313_01"
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    with op.batch_alter_table("network_endpoints") as batch_op:
+        batch_op.create_unique_constraint(
+            "uq_network_endpoint_network_type_url",
+            ["network_id", "endpoint_type", "url"],
+        )
+
+    with op.batch_alter_table("public_rpc_endpoints") as batch_op:
+        batch_op.create_unique_constraint(
+            "uq_public_rpc_endpoint_network_url",
+            ["network_id", "url"],
+        )
+
+    with op.batch_alter_table("network_assets") as batch_op:
+        batch_op.create_unique_constraint(
+            "uq_network_asset_network_base_denom",
+            ["network_id", "base_denom"],
+        )
+
+    with op.batch_alter_table("snapshot_targets") as batch_op:
+        batch_op.create_unique_constraint(
+            "uq_snapshot_target_network_path",
+            ["network_id", "snapshot_path"],
+        )
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("snapshot_targets") as batch_op:
+        batch_op.drop_constraint("uq_snapshot_target_network_path", type_="unique")
+
+    with op.batch_alter_table("network_assets") as batch_op:
+        batch_op.drop_constraint("uq_network_asset_network_base_denom", type_="unique")
+
+    with op.batch_alter_table("public_rpc_endpoints") as batch_op:
+        batch_op.drop_constraint("uq_public_rpc_endpoint_network_url", type_="unique")
+
+    with op.batch_alter_table("network_endpoints") as batch_op:
+        batch_op.drop_constraint("uq_network_endpoint_network_type_url", type_="unique")
*** End Patch