Seshat — On-chain Intelligence

Developer Scoring

A composite 0–100 score measuring how credible and active a token's creator is. Combines FrontrunPro wallet intelligence with on-chain transaction history across four weighted dimensions.

The four dimensions

Follower Quality

Smart follower count from FrontrunPro — wallets that are followed by known alpha traders and deployers.

Ecosystem Presence

Number of on-chain interactions across DeFi protocols: Uniswap, Aave, Compound, Curve — active DeFi users.

Activity Recency

Time since last on-chain transaction. A developer who last transacted 2 years ago scores near 0 on this dimension.

Tech Alignment

Presence in Base-native protocols, L2 tooling, and smart contract deployment history. Filters for genuine builders.

Score formula

The composite score is a weighted sum of the four normalized dimensions. Weights are initialized at equal values (0.25 each) and updated weekly by the self-learning model based on outcome correlation.

// scoring.ts
interface DevScore {
  follower_quality:    number; // 0–100 normalized
  ecosystem_presence:  number;
  activity_recency:    number;
  tech_alignment:      number;
}

interface ScoringWeights {
  w_follower:   number; // e.g. 0.30
  w_ecosystem:  number; // e.g. 0.25
  w_recency:    number; // e.g. 0.25
  w_tech:       number; // e.g. 0.20
}

function computeDevScore(
  dims: DevScore,
  weights: ScoringWeights
): number {
  const raw =
    dims.follower_quality   * weights.w_follower   +
    dims.ecosystem_presence * weights.w_ecosystem  +
    dims.activity_recency   * weights.w_recency    +
    dims.tech_alignment     * weights.w_tech;

  // Clip to [0, 100]
  return Math.min(100, Math.max(0, Math.round(raw)));
}

FrontrunPro integration

FrontrunPro is a wallet intelligence platform that ranks wallets by their quality of social connections among on-chain traders. Seshat scrapes the public profile pages (no official API is available yet) and caches results in Cloudflare KV with a 6-hour TTL.

// providers/frontrunpro.ts
async function getSmartFollowerCount(
  walletAddress: string,
  env: Env
): Promise<number> {
  const cacheKey = `frontrunpro:${walletAddress.toLowerCase()}`;
  const cached   = await env.KV.get(cacheKey);
  if (cached !== null) return parseInt(cached, 10);

  const url = `https://frontrunpro.xyz/profile/${walletAddress}`;
  const res = await fetch(url, {
    headers: { "User-Agent": "Mozilla/5.0 (compatible; SeshatBot/1.0)" }
  });

  const html    = await res.text();
  const match   = html.match(/Smart Followers[^\d]*(\d+)/i);
  const count   = match ? parseInt(match[1], 10) : 0;

  await env.KV.put(cacheKey, String(count), { expirationTtl: 21600 });
  return count;
}

// Normalize follower count to 0–100
// Scale: 0 → 0, 100 followers → ~80, 500+ → 100
function normalizeFollowerCount(count: number): number {
  return Math.min(100, Math.round(100 * (1 - Math.exp(-count / 80))));
}

On-chain activity scoring

Ecosystem presence (D2)

// Count unique DeFi protocol interactions
const PROTOCOL_ADDRESSES = [
  "0x...", // Uniswap V3 Router
  "0x...", // Aave V3 Pool
  "0x...", // Compound V3
  // etc.
];

async function getEcosystemScore(wallet: string): Promise<number> {
  // Fetch last 1000 txs via Alchemy
  const txs = await alchemy.core.getAssetTransfers({
    fromAddress: wallet,
    category: ["external", "erc20"],
    maxCount: 1000,
  });

  const uniqueProtocols = new Set(
    txs.transfers
      .filter(tx => PROTOCOL_ADDRESSES.includes(tx.to?.toLowerCase() ?? ""))
      .map(tx => tx.to?.toLowerCase())
  );

  // 0 protocols → 0, 10+ → 100
  return Math.min(100, uniqueProtocols.size * 10);
}

Activity recency (D3)

function scoreRecency(lastTxTimestamp: number): number {
  const daysSince = (Date.now() / 1000 - lastTxTimestamp) / 86400;

  if (daysSince < 7)   return 100;
  if (daysSince < 30)  return 80;
  if (daysSince < 90)  return 55;
  if (daysSince < 180) return 30;
  if (daysSince < 365) return 10;
  return 0; // >1 year inactive
}

Hidden gem detection

A token is flagged as a “hidden gem” when its developer scores well but the market hasn't discovered it yet. The check runs after every dev enrichment cycle.

function isHiddenGem(token: TokenWithScore): boolean {
  return (
    token.dev_composite_score > 50 &&   // credible dev
    token.volume_usd_24h     < 5000 &&  // under the radar
    token.mcap_usd           > 1000 &&  // has some traction
    token.larp_probability   < 0.3  &&  // not a LARP
    token.dev_activity_score > 30       // dev is still active
  );
}

Score storage

CREATE TABLE developer_scores (
  id                   TEXT PRIMARY KEY,
  wallet_address       TEXT NOT NULL,
  composite_score      INTEGER NOT NULL,     -- 0–100
  follower_quality     INTEGER NOT NULL,
  ecosystem_presence   INTEGER NOT NULL,
  activity_recency     INTEGER NOT NULL,
  tech_alignment       INTEGER NOT NULL,
  smart_follower_count INTEGER NOT NULL,
  last_tx_timestamp    INTEGER,
  scoring_weight_version INTEGER NOT NULL,
  scored_at            INTEGER NOT NULL
);

Score interpretation

75–100

Very high confidence

Strong signal. Developer well-known in ecosystem with recent activity.

60–74

High confidence

Good signal. Some credibility gaps but mostly solid.

45–59

Medium confidence

Mixed signals. Worth watching but not a strong buy indicator.

0–44

Low confidence

Little to no credibility. Anonymous or inactive developer.