FlareWatch weist jedem P-Chain-Validator einen zusammengesetzten Score von 0–100 über 9 Dimensionen zu. Die Mathematik ist deterministisch, die Eingaben stammen aus öffentlichen Chain-Daten [Flare Explorer] [FSE] [Flaremetrics], und der gleiche Algorithmus gilt für jeden Validator im Netzwerk – einschließlich FlareWatch's eigenem Validator-Node, der nach dieser exakten Funktion ohne Sonderbehandlung bewertet wird. Diese Seite dokumentiert jede Dimension und jeden Schwellenwert, damit Betreiber und Staker genau sehen können, wie der Score berechnet wird und warum jeder Wert gewählt wurde. Jede Aussage hier verlinkt auf ihre primäre On-Chain- oder Upstream-Quelle – siehe Quellen & Referenzen am Ende.
Staking-Modus auf der Validators-Seite sehen (Delegation von FLR an einen P-Chain-Validator für VRM + MIRROR-Belohnungen). Der FTSO-Provider-Score, der im Delegations-Modus angezeigt wird (Delegation von WFLR an FTSO-Datenprovider), verwendet einen separaten 13-Dimensions-Algorithmus, der sich auf Datenprovider-Performance konzentriert – Genauigkeit, V2-Protokoll-Partizipation usw. Dies sind unterschiedliche On-Chain-Rollen mit unterschiedlichen Belohnungen, die separat bewertet werden. Siehe FTSO-Provider-Score-Methodik für die Delegationsseite.Die APY in der Staking-Tabelle ist der Gesamtsatz, den ein Delegator erhält — eine Zahl, keine mentale Mathematik. Sie wird aus Flares Reward-Scripts gemessen (tatsächliche Auszahlungen, nicht eine Formel), abzüglich der Gebühr des Validators, und sie bewegt sich jede Epoche mit echten Rewards. Überall auf FlareWatch bedeutet APY nach der Gebühr und APY bedeutet davor.
Vergleich mit Flare Systems Explorer? FSE und andere Explorer zeigen nur die Delegationsrate — sie addieren MIRROR nicht — also ist unsere Gesamt-APY bei jedem MIRROR-aktiven Validator höher (die Lücke ist genau die MIRROR-Linie oben). Beide Zahlen sind ~8-Epochen-Trailing-Durchschnitte aus denselben Reward-Scripts-Daten, daher verzögert sich eine Gebührenänderung eines Validators in der Mitte des Fensters gegenüber einem aktuellen Gebühren-Snapshot auf beiden Seiten, bis sie sich durch das Fenster durcharbeitet.
Zwei weitere Zahlen erscheinen im APY-Tooltip und sind nicht der Delegatensatz: die theoretische Baseline (Netzwerk-Brutto-APY × (1 − Gebühr), nur Staking — verwendet als Fallback, bevor genug gemessene Historie vorhanden ist), und die Eigenkapitalrendite des Operators (die Rendite des eigenen Stakes des Validators, verstärkt durch Gebührenerfassung — eine Operator-Metrik, nicht das, was Sie verdienen).
Für Scoring: die Net Yield-Dimension bewertet nur die VRM-Delegationsrate, und MIRROR wird in seiner eigenen Dimension bewertet — daher wird MIRROR niemals doppelt gezählt, obwohl es in der angezeigten Gesamt-APY enthalten ist.
| 90+ | Top-Tier – Top ~10–20% der Betreiber. Typisches Profil: Full-Stack-Validator + FTSO + FDC, niedrige Gebühr, MIRROR-aktiv, konsistente FIP-10-Zuverlässigkeit, gesunde Delegator-Basis, bedeutungsvolles Eigenkapital. Keine einzelne Dimension erforderlich – Betreiber erreichen Top-Tier durch Stapelung von Stärke über die meisten Kategorien hinweg. |
| 80–89 | Stark – erfüllt die meisten wichtigen Benchmarks; eine oder zwei Dimensionen unter Top-Tier. |
| 70–79 | Gut – erfüllt alle Basis-Kriterien; keine großen Lücken. |
| 60–69 | Akzeptabel – brauchbar, aber nicht differenziert. |
| <60 | Unter Median – signifikante Lücken in einer oder mehr Dimensionen. Mathematische Tatsache, keine Qualitätsbewertung. |
if (uptime >= 99.5) raw = 17 + (uptime - 99.5) * 6
else if (uptime >= 99) raw = 13 + (uptime - 99) * 8
else if (uptime >= 95) raw = 4 + (uptime - 95) * 2.25 // v3.9: was (u - 95) * 3.25 starting at 0
else raw = max(0, uptime - 90) * 0.8 // 90 → 0, 95 → 4 (continuity)
raw = clamp(raw, 0, 20)
reliability = epochsIncluded / epochsObserved // last ~8 epochs · v4.2: the
// FULL FIP-10 minimums set
// (uptime + FSP + FTSO + FDC),
// not RPC-uptime alone
score = raw * clamp(reliability, 0, 1) // dimension max 20scoreAPR = delegationAPY > 0 ? delegationAPY : baseAPR // VRM, net of fee medianAPR = median(scoreAPR across all validators) cappedAPR = min(scoreAPR, 25) // APY_DISPLAY_CAP if (medianAPR > 0): ratio = cappedAPR / medianAPR score = clamp(((ratio - 0.6) / 0.6) * 18, 0, 18) else: score = min(18, (cappedAPR / 8) * 18) // fallback: BASE_APY = 8
// anchor = max(observed minimum active fee, 20% protocol floor) d = fee - anchor // distance above market best if (d <= 0) score = 7 // at/below best available else if (d <= 5) score = 7 - d * 0.2 // 0 → 5 over: 7 → 6 else if (d <= 10) score = 6 - (d - 5) * 0.3 // 5 → 10 over: 6 → 4.5 else if (d <= 15) score = 4.5 - (d - 10) * 0.4 // 10 → 15 over: 4.5 → 2.5 else if (d <= 20) score = 2.5 - (d - 15) * 0.5 // 15 → 20 over: 2.5 → 0 else score = 0 // fees > anchor+20 saturate at 0/7 — the v4.5 extreme-fee // penalty below takes over from there
// Verification baseline (v3.10 hybrid) isCurated = (in KNOWN_VALIDATORS) OR ( daysObserved >= 90 AND operatorDelegatorCount >= 25 AND retention30d >= -15% AND selfBondFLR >= 1_000_000 ) if (isCurated) verification = 7 else if (name auto-discovered) verification = 3 else verification = 0 // FTSO-derived (only when ftsoOperatorScore is a number) clamped = clamp(ftsoOperatorScore, 50, 100) ftsoDerived = 4 + (clamped - 50) * (8/50) // FTSO 50 → 4, FTSO 100 → 12 // Final score score = max(verification, ftsoDerived)
passthrough = max(0, 1 - fee / 100) if (mirrorStatus == "active") base = 10 * passthrough else if (mirrorStatus == "paused") base = 5 * passthrough else if (mirrorStatus == "inactive") base = 0 else base = 5 * passthrough // no data yet // v4.6 — capped, median-anchored bonus for delivered MIRROR yield. // Only mirror-active validators paying ABOVE 1.2x the network median // delivered rate (mirrorAPY, net of fee) earn it; size-neutral. ratio = mirrorAPY / networkMedianMirrorAPY bonus = clamp((ratio - 1.2) * 5, 0, 2) // active only, else 0 score = base + bonus // dimension max 12
utilization = clamp(1 - freeSpaceFLR / maxDelegationFLR, 0, 1) if (utilization <= 0.70): score = 1.75 + (utilization / 0.70) * 5.25 // 1.75 → 7 ramp else: score = 7 - ((utilization - 0.70) / 0.30) * 1.75 // 7 → 5.25 ramp
// Count signal (max 6)
if (delegatorCount <= 5) countScore = 0
else if (delegatorCount >= 500) countScore = 6
else countScore = clamp(log(delegatorCount / 5) / log(100) * 6, 0, 6)
// Concentration adjustment (-1 to +1) — skip if <3 delegators
avgFLR = delegatedFLR / delegatorCount
if (avgFLR < 500_000) concentrationAdj = +1
else if (avgFLR < 5_000_000) concentrationAdj = +0.5
else if (avgFLR > 50_000_000) concentrationAdj = -1
else if (avgFLR > 20_000_000) concentrationAdj = -0.5
else concentrationAdj = 0
// Longevity bonus (0 to +1)
daysObserved = (now - firstObservedAtMs) / 86400000
if (daysObserved >= 90) longevityBonus = +1
else if (daysObserved >= 30) longevityBonus = +0.5
else longevityBonus = 0
// Self-bond alignment (-1 to +2, two-axis since v4.7)
if (selfBondFLR < 1_000_000) selfBondAdj = -1 // hollow-operator floor
else:
ratio = selfBondFLR / totalStake // totalStake = selfBond + delegated
proportional = ratio >= 0.10 ? +2 : ratio >= 0.05 ? +1 : 0
absolute = min(1, selfBondFLR / 20_000_000) * 2 // saturates at top-decile bond
selfBondAdj = max(proportional, absolute) // the better of the two axes
// Retention (-0.5 to +0.5, v3.7) — skip if no 30-day baseline yet
delta = (delegatedFLR - delegatedFLR30dAgo) / delegatedFLR30dAgo
if (delta >= +0.10) retentionAdj = +0.5
else if (delta <= -0.15) retentionAdj = -0.5
else retentionAdj = 0
// Self-bond trajectory (-0.5 to +0.5, v3.7) — skip if no baseline
sbDelta = (selfBondFLR - selfBondFLR30dAgo) / selfBondFLR30dAgo
if (sbDelta >= +0.20) selfBondTrajectoryAdj = +0.5
else if (sbDelta <= -0.10) selfBondTrajectoryAdj = -0.5
else selfBondTrajectoryAdj = 0
score = clamp(countScore + concentrationAdj + longevityBonus + selfBondAdj
+ retentionAdj + selfBondTrajectoryAdj, 0, 11)// Time-weighted rate is computed upstream from per-epoch // reward-scripts data with decay = 0.85 per epoch back. r = deliveryRatio // capped at 1.0 if (r >= 1.00) base = 10 else if (r >= 0.97) base = 9 + (r - 0.97) * (1 / 0.03) // 0.97 → 9, 1.00 → 10 else if (r >= 0.95) base = 8 + (r - 0.95) * (1 / 0.02) // 0.95 → 8, 0.97 → 9 else if (r >= 0.90) base = 6 + (r - 0.90) * (2 / 0.05) // 0.90 → 6, 0.95 → 8 else if (r >= 0.85) base = 4 + (r - 0.85) * (2 / 0.05) // 0.85 → 4, 0.90 → 6 else if (r >= 0.80) base = 2 + (r - 0.80) * (2 / 0.05) // 0.80 → 2, 0.85 → 4 else base = max(0, r * 2.5) // 0 → 0, 0.80 → 2 // Variance penalty (CoV = std-dev / mean across per-epoch rates) variancePenalty = min(0.30, coefficientOfVariation * 0.5) score = base * (1 - variancePenalty) // Sample-size confidence dampener for < 3 epochs if (totalStakesCompleted < 3): confidence = totalStakesCompleted / 3 score = 5 + (score - 5) * confidence
daysLeft = (endTimeMs - now) / 86_400_000 if (daysLeft < 14) score = 0 else if (daysLeft < 30) score = 0 + (daysLeft - 14) * (2 / 16) // 14 → 0, 30 → 2 else if (daysLeft < 60) score = 2 + (daysLeft - 30) * (1 / 30) // 30 → 2, 60 → 3 else if (daysLeft < 120) score = 3 + (daysLeft - 60) * (2 / 60) // 60 → 3, 120 → 5 else score = 5
consecutiveMisses = 0 for entry in participation.recent (newest-first): if entry.eligible: break consecutiveMisses++ if consecutiveMisses < 2: penalty = 0 elif consecutiveMisses == 2: penalty = 3 elif consecutiveMisses == 3: penalty = 6 else: penalty = 10 // 4+ score = max(0, positiveDimensionsSum - penalty)
// v4.5 — fees beyond the Fee dimension's range (anchor+20)
if fee <= 50: penalty = 0
else: fraction = min(1, (fee - 50) / 50) * 0.75
penalty = positiveDimensionsSum * fraction
// fee 50% → no change · 75% → −37.5% of score · 100% → −75%
score = max(0, positiveDimensionsSum - outagePenalty - penalty)delegationFee, selfBond, delegatedStake und FTSO-Punktzahl (falls Sie auch ein Datenanbieter sind).generated-files/reward-epoch-N/nodes-data.json. Zählen Sie, wie viele Epochs Ihre nodeID uptimeEligible: true hatte. Dieses Verhältnis bestimmt Ihren Uptime-Dimensionsmultiplikator.RewardClaimed-Ereignissen mit claimType=3, die Ihre nodeID referenzieren. Wenn es kürzlich keine gibt, zeigen Sie sich als MIRROR-inaktiv.GET /api/validators/{nodeID}/score-breakdown treffen, um die persistierte Breakdown abzurufen — jeder Dimensionswert, die Algorithmesversion, die ihn erzeugt hat, und die neuere Punktzahlhistorie — als JSON. Das Punktzahl-Breakdown-Panel in der Benutzeroberfläche liest aus derselben Quelle.// Step 1 — Raw composite (sum of dimensions, minus the two penalties)
positive = uptime + netYield + fee + operatorQuality
+ mirror + capacity + trust + delivery + timeRemaining
// Penalties (see the two penalty cards above):
// v4.3 active-outage streak — 0-1 missed epochs → 0, 2 → 3, 3 → 6, 4+ → 10
// v4.5 extreme fee (>50%) — positive × min(1, (fee - 50) / 50) × 0.75
raw = clamp(positive - streakPenalty - extremeFeePenalty, 0, 100)
// Step 2 — Smooth across recent cron snapshots (v3.5)
// Weights: current 0.5, prev1 0.3, prev2 0.15, prev3 0.05
smoothed = 0.5*raw + 0.3*prev1 + 0.15*prev2 + 0.05*prev3
// Step 3 — Apply sudden-change penalty if flagged this run
// Triggers: fee +50% or +5pt jump, self-bond -20% drop, uptime -5% crash
// Magnitude: -10 pts on detection, decays -7, -4, -1 over 3 runs
suddenPenalty = -10 if any flag triggered else (decaying remainder)
// Step 4 — Final score
score = clamp(smoothed + suddenPenalty, 0, 100)services/validators/scoring.ts in der FlareWatch-Codebasis implementiert. Operatoren oder Forscher, die die Implementierung direkt inspizieren möchten (anstatt die obige Prosa + Formeln zu lesen) — oder sie für ihre eigene Nutzung forken möchten — können [email protected] eine E-Mail senden, um Zugriff anzufordern. Wir werden die Datei als eigenständiges Open-Source-Paket veröffentlichen, falls es echte Nachfrage gibt./api/cron/refresh-validators berechnet den Score jedes aktiven Validators alle 5 Minuten neu. Eingaben (P-Chain-RPC-Abfragen, Flaremetrics, FSE, Reward-Scripts) werden bei jedem Durchlauf aktualisiert abgerufen.Flare slasht keine Validator-Stakes. Der gesamte Strafmechanismus für Validator-Fehlverhalten ist Reward-Verwirkung plus das FIP-10-Passes-System. Es gibt keine Double-Signing-Slash, keine Equivocation-Slash, kein Stake-Destruction-Event, das wir verfolgen müssen. Validators, die die FIP-10-Mindestbedingungen nicht erfüllen, verlieren die Rewards dieser Epoche (vollständige Verwirkung bei Null Passes, ansonsten ein Pass pro Protokoll, bei dem sie fehlgeschlagen sind); ihr gesperrtes Prinzipal bleibt unverändert.
Das bedeutet, dass der Score keine "Slashing-Historie"-Dimension hat — es gibt keine solche Historie zum Verfolgen. Was wir VERFOLGEN, sind die Konsequenzen jeden Mindestausfalls: Der Validator verdiente in dieser Epoche Null, was in epochsIncluded / epochsObserved erfasst wird. Das v4.2-Update vom 14.05.2026 erweiterte den Zuverlässigkeitsmultiplikator des Scores, um dieses Verhältnis über die gesamte FIP-10-Mindestmenge (Uptime, FSP-Signing, FTSO-Submission-Rate, FDC-Teilnahme) zu nutzen, sodass ein Validator, der einen Mindestwert nicht erfüllt, proportional in der Uptime-Dimension bestraft wird, unabhängig davon, welche Achse fehlgeschlagen ist.
FIP-10-Mindestschwellen, bezogen von dev.flare.network/network/fsp/rewarding: Staking erfordert 80% Uptime + 1 Mio. FLR aktives Self-Bond; FTSO-Anchor-Feeds erfordern Schätzungen innerhalb von 0,5% des Konsens-Medians in 80% der Runden; FTSO-Block-Latency-Feeds erfordern Einreichung von 80% der erwarteten Updates; FDC erfordert Teilnahme an 60% der Abstimmungsrunden. Validators, die die 80%-Uptime- + 1-Mio.-Self-Bond-Grenze erfüllen, aber unter den 3-Mio.- / 15-Mio.-Verdienst-Schwellen liegen, erhalten weiterhin Rewards, können aber keine Passes sammeln — die Grauzone wird durch die passEligibility: "at-risk"-Klassifizierung dieser Karte sichtbar gemacht.