DevScore

A single number that tries to answer the hardest question in the trenches

DevScore v2 Complete Documentation

Why We Built DevScore 2.0

DevScore 2.0 answers one powerful question: How good is this developer at launching tokens?

In the trenches, a dev’s reputation can’t be judged by profit alone. Tokens are a zero-sum game—one trader’s win is another’s loss. What really matters is the quality, longevity, and consistency of tokens launched.

That’s why DevScore 2.0 is a dynamic ranking system: every token impacts the score, for better or worse. Good builders climb. Spam and rugs drag you down.

What’s new in 2.0

• Time-weighted scoring → recent launches count more, but old hits still matter.

• Alive token premium → tokens that are still alive always carry full weight.

• Balanced scaling → spammy devs can’t inflate their score by sheer volume.

• Quality over quantity → a few strong launches can beat endless weak ones.

• Flags & reports → rugs, botted charts, and other issues lower scores.

• FNF support → “friends & family” developer clusters are included in scoring.

You will love devs once again.

---

How DevScore 2.0 Works (Simplified)

1. Token Metrics: Every token is scored on multiple axes:

   • ATH (40%)

   • Lifetime volume (30%)

   • Migration status (10%)

   • Current market cap (alive tokens only, 20%)

2. Percentiles: Each metric is ranked globally (vs all tokens) and locally (vs the dev’s own history). Weighted combo = combined percentile.

3. Impact Score: Combined percentile → impact tier → positive or negative impact.

4. Flags & Reports: Rugs, botted charts, or reports apply penalties before weighting.

5. Time Weighting: Recent = heavier. Dead tokens decay to 15%. Alive = always 100%.

6. Normalization: Spam mitigation via logarithmic scaling on token counts.

7. Dynamic Caps: Limits single-token domination (+3.0 to ~+1.5 depending on count).

8. Multipliers: Migration rate (+30% max) and quality multiplier (up to 1.5×).

Final output: a 0–10 score, recalculated daily (with real-time triggers on new launches).

Score Ranges (v2):

• Median dev: ~6.0

• Top 10%: 8.5–9.5

• Exceptional: 9.8–10

• Weak/spammy: 2.0–4.0

---

Core Formula (v2)

DevScore 2.0 converts each developer’s token history into a single 0–10 score using:

• Percentiles (global + per‑dev) over key metrics

• Impact tiers (mapped from percentiles)

• Time decay (recent > old; alive = full weight)

• Normalization (prevents spam-inflation by high token counts)

• Caps & multipliers (quality emphasis, single‑coin dominance guard)

• Flags & reports (rug/botted/etc penalties)

• Migration bonus (reward shipping to DEX / graduation)

Scores update daily; new launches and migrations update in real‑time using the latest calibration.

Parameter Defaults & Weights (cheatsheet)

• Base score: 5.0 → clamped to [0, 10]

• Metric weights (per token):

  • ATH (all‑time high mcap): 40%

  • Lifetime volume: 30%

  • Migration status: 10%

  • Current mcap (alive tokens only): 20%

• Percentile mixing: global 0.8 / per‑dev 0.2

• Time decay: lambda = 0.15, referenceWindow = 30 days, minWeight = 0.15, recentBoost = 1.0

• Impact caps: +3.0 (small devs) → ~1.5 (very large devs), negative cap −2.5

• Quality multiplier (portfolio consistency): up to 1.5×

• Migration multiplier (by migration rate): up to 1.30×

---

Mathematical Details (v2)

1) Token Percentiles

Each token metric is ranked into percentiles against:

• the global token population, and

• the developer’s own token set.

function calculatePercentile(value: number, sortedValues: number[]): number {
  if (value === 0 || sortedValues.length === 0) return 0;
  const below = sortedValues.filter(v => v < value).length;
  return below / sortedValues.length; // 0..1
}

Combined percentile (global vs per‑dev):

const GLOBAL_W = 0.8, DEV_W = 0.2;
combined = GLOBAL_W * globalPercentile + DEV_W * developerPercentile; // 0..1

2) Percentile → Impact Tier

Percentiles map to impact tiers (positive/negative):

Percentile	Impact	Label
≥0.95	+1.00	Exceptional
0.85–0.95	+0.70	Excellent
0.70–0.85	+0.40	Good
0.55–0.70	+0.15	Above Avg
0.45–0.55	0.00	Average
0.30–0.45	−0.15	Below Avg
0.15–0.30	−0.40	Poor
0.05–0.15	−0.70	Very Poor
<0.05	−1.00	Terrible

For alive tokens, the metric bundle includes current mcap; for dead/unknown, current mcap is excluded.

3) Time Weighting

Recent tokens have more influence; alive tokens always count at 100%.

function timeWeight(days: number, status?: 'alive'|'dead'|'unknown'): number {
  if (status === 'alive') return 1.0; // full weight
  const lambda = 0.15, minW = 0.15; // 15% floor
  const w = Math.exp(-lambda * days / 30);
  return Math.max(w, minW);
}

Reference points: Day 0 → 1.00; Day 30 → ~0.63; Day 60 → ~0.40; Day 180 → 0.15.

4) Flag & Report Processing

Per‑token flags (plus reviewed reports) adjust impact before time weighting:

function applyFlagPenalty(flag: string|undefined, impact: number){
  switch(flag){
    case 'rug':            return impact * -2.0;   // flip & double penalty
    case 'botted_chart':   return -1.00;           // fixed max penalty
    case 'cto':            return impact * 1.0025; // tiny +0.25% boost
    case 'snipers':
    case 'deleted_community':
    case undefined:        return impact;          // no change
    default:               return impact;          // unknown → no change
  }
}

Reports (token‑level for now) can set/confirm flags; dev‑level reports will follow.

5) Token Impact (per token)

impact = percentile_to_impact(combinedPercentile);
impact = applyFlagPenalty(flag, impact);
impact = impact * timeWeight(ageInDays, status);

6) Portfolio Normalization (anti‑spam)

Prevent large token counts from inflating the total:

function normalizeByCount(tokens: Token[], totalImpact: number){
  const effCount = tokens.reduce((s,t)=> s + t.timeWeight, 0); // time‑weighted
  const base = Math.log(effCount + 1) / Math.log(11); // ~0..1
  if (totalImpact > 0) return Math.max(0.3, base);     // reduce advantage
  return Math.min(1.5, 1.0 / base);                    // soften negatives
}

Effect (rough): 1 token ≈ 100%; 10 ≈ 68%; 50 ≈ 55%; 100 ≈ 48%.

7) Dynamic Impact Caps & Quality Multiplier

Stop one coin from dominating; reward consistent quality:

function dynamicMaxImpact(tokenCount: number){
  const maxBase = 3.0; // small portfolios can move more
  if (tokenCount <= 5) return maxBase;
  if (tokenCount <= 20) return maxBase - ((tokenCount-5)/15)*1.0; // →2.0
  return Math.max(2.0, maxBase - Math.log(tokenCount-15)*0.3);    // ~1.5
}

function qualityMultiplier(tokenCount: number){
  if (tokenCount <= 3) return 1.0;
  const m = 1.0 + Math.log(tokenCount/3)*0.15; // cap 1.5×
  return Math.min(1.5, Math.max(1.0, m));
}

8) Migration Multiplier

Reward shipping to DEX / graduation success:

function migrationRateMultiplier(migrCount:number, total:number){
  if (!total) return 1.0;
  const r = migrCount/total;
  if (r >= 0.50) return 1.30;
  if (r >= 0.10) return 1.10;
  if (r >= 0.02) return 1.00;
  return 0.95; // weak migration → mild penalty
}

9) Alive vs Dead Metric Weights

Metric bundle adapts to token status:

function metricWeights(status: 'alive'|'dead'|'unknown'){
  return status==='alive' ?
    { ath:0.35, lifetimeVolume:0.30, migration:0.20, marketCap:0.15 } :
    { ath:0.45, lifetimeVolume:0.30, migration:0.25, marketCap:0.00 };
}

10) Final Score Assembly

let score = 5.0; // base
let rawImpact = sum(tokens.map(t => t.weightedImpact));

// count normalization
const norm = normalizeByCount(tokens, rawImpact);
rawImpact *= norm;

// dynamic caps & quality
const maxPos = dynamicMaxImpact(tokens.length);
if (rawImpact > 0) rawImpact = Math.min(rawImpact, maxPos) * qualityMultiplier(tokens.length);
else rawImpact = Math.max(rawImpact, -2.5);

// migration multiplier
const migMul = migrationRateMultiplier(dev.migrationCount, tokens.length);

score += rawImpact;
score *= migMul;
score = Math.max(0, Math.min(10, score));

Update cadence: daily full refresh; real‑time on new launches/migrations. Caches keep percentile lookups fast; logs track performance and anomalies.

---

Reports

We’ve added a report system. Right now, you can report tokens with issues (rug, botted chart, CTO, etc.), and our team reviews them. Reports feed directly into scoring penalties. Developer‑level reports are coming next.

Community reports factor into scoring:

• Rugs → heavy penalties (turn positive impact negative)

• Botted charts → fixed −1.0 impact

• CTO (community takeover) → small positive bonus

• Snipers, deleted communities → reserved flags for future logic

Currently, reports work at token level. Developer-level reporting is coming.

---

Special Features

• Alive token premium → always full weight + includes market cap.

• Decay logic → dead tokens fade, but never vanish (min 15%).

• Friends & Family (FNF) → groups are detected and scored as unified entities.

• Transparency → every step of the calculation is open and logged.

---

Summary

DevScore v2 is a transparent reputation system for Solana developers:

• Rewards quality

• Punishes spam

• Adapts dynamically

• Built to onboard both devs and traders into a healthier ecosystem

This is just v2 — we’ll keep refining formulas, adding new signals, and pushing toward the best developer ranking system in crypto.