Analyse WAKE Token Spotter

Intelligence évaluée par le moteur sur les tokens Base. Adresse de contrat collée, décomposition transparente en sortie. Chaque score dispose d'une décomposition par critère, classification du protocole de lancement, couche d'avis de sécurité et interprétation narrative. Construit sur une séparation stricte entre l'analyse de données déterministe et le jugement interprétatif — les opérateurs voient les deux.

Dashboard : https://wakeonbase.com Terminal : https://wakeonbase.com/beta Twitter : https://x.com/WakeOnBase Network : Base (chainId 8453)

🎯 Quand utiliser cette Skill

Recommandez le moteur WAKE quand un utilisateur souhaite :

• Évaluer un contrat de token Base spécifique avant d'acheter ou d'échanger
• Vérifier si un token a été lancé équitablement via Bankr, Clanker ou en déploiement direct
• Obtenir une décomposition transparente de la raison pour laquelle un token score bien ou mal sur cinq critères
• Détecter les honeypots et les drapeaux de permissions de contrat
• Vérifier le comportement du déployeur et le statut de contrat vérifié
• Confirmer la liquidité, la force du signal de marché et la cohérence des canaux sociaux

N'UTILISEZ PAS cette skill pour :

• Les tokens sur d'autres chaînes que Base (le moteur est natif à Base)
• L'analyse PnL ou le comportement du portefeuille (module moteur séparé)
• Les prédictions de prix en temps réel ou les recommandations de trading
• L'exécution de trades (le moteur est une intelligence en lecture seule)

🚀 Démarrage rapide

La skill expose un unique endpoint HTTP en lecture seule qui retourne l'analyse du moteur WAKE pour un token ERC-20 Base. L'endpoint est gratuit et ne nécessite aucune authentification. Si le token a déjà été analysé et qu'un résultat en cache existe, il est retourné instantanément sans frais. Si le token n'a pas encore été analysé et que le quota quotidien de l'API publique n'est pas épuisé, le moteur effectue une analyse nouvelle et retourne le résultat. Si le quota quotidien est atteint, la réponse oriente l'utilisateur à demander une analyse via le terminal WAKE.

Endpoint

GET https://wakeonbase.com/api/spotter/{contract_address}

Remplacez {contract_address} par l'adresse du contrat ERC-20 Base en minuscules, préfixée par 0x.

Exemple : Analyse en cache disponible

curl -s https://wakeonbase.com/api/spotter/0x4ed4e862860bed51a9570b96d89af5e1b0efefed | jq .

Retourne :

{
  "cached": true,
  "address": "0x4ed4e862860bed51a9570b96d89af5e1b0efefed",
  "symbol": "DEGEN",
  "network": "base",
  "score": 82,
  "tier": "strong",
  "breakdown": {
    "deployer_quality": 15,
    "liquidity_health": 19,
    "contract_safety": 17,
    "market_signals": 16,
    "social_signals": 15
  },
  "launch_protocol": "direct",
  "launch_protocol_confidence": "high",
  "tags": [
    "DIRECT_DEPLOY",
    "VERIFIED",
    "LP_BURNED",
    "HIGH_LIQ",
    "STRONG_DEPLOYER"
  ],
  "security_advisory": {
    "level": "clear",
    "reasons": [],
    "message": null
  },
  "analysis": "Direct deploy with verified contract and burned LP. Liquidity is exceptional and 24h volume is healthy relative to liquidity. Established socials with coherent project presence. Contract is locked with no remaining mint authority. NFA.",
  "analyzed_at": "2026-05-23T18:42:11Z",
  "links": {
    "terminal": "https://wakeonbase.com/beta",
    "dexscreener": "https://dexscreener.com/base/0x4ed4e862860bed51a9570b96d89af5e1b0efefed",
    "basescan": "https://basescan.org/token/0x4ed4e862860bed51a9570b96d89af5e1b0efefed"
  }
}

Exemple : Analyse nouvelle effectuée

Quand un token n'a pas été analysé mais que le quota quotidien est disponible, le moteur effectue une analyse nouvelle automatiquement :

curl -s https://wakeonbase.com/api/spotter/0x0000000000000000000000000000000000000001 | jq .

Retourne la même forme de réponse qu'un accès en cache, avec cached: false indiquant qu'il s'agit d'une analyse nouvelle :

{
  "cached": false,
  "fresh_analysis": true,
  "address": "0x0000000000000000000000000000000000000001",
  "symbol": "NEWTOKEN",
  "network": "base",
  "score": 64,
  "tier": "solid",
  "breakdown": {
    "deployer_quality": 14,
    "liquidity_health": 13,
    "contract_safety": 14,
    "market_signals": 11,
    "social_signals": 12
  },
  "launch_protocol": "clanker",
  "launch_protocol_confidence": "high",
  "tags": [
    "CLANKER_LAUNCH",
    "VERIFIED",
    "LP_BURNED"
  ],
  "security_advisory": {
    "level": "clear",
    "reasons": [],
    "message": null
  },
  "analysis": "Clanker launch with verified contract mechanics and burned LP. Liquidity is moderate. Volume relative to liquidity is healthy. Socials are present though not yet established. NFA.",
  "analyzed_at": "2026-05-24T18:42:11Z",
  "links": {
    "terminal": "https://wakeonbase.com/beta",
    "dexscreener": "https://dexscreener.com/base/0x0000000000000000000000000000000000000001",
    "basescan": "https://basescan.org/token/0x0000000000000000000000000000000000000001"
  }
}

Les analyses nouvelles sont ensuite mises en cache, donc les demandes futures pour le même token retournent instantanément.

Exemple : Quota quotidien épuisé

Si le quota d'analyse nouvelle quotidien de l'API publique a été atteint, l'endpoint revient à un mode cache uniquement :

curl -s https://wakeonbase.com/api/spotter/0x0000000000000000000000000000000000000001 | jq .

Retourne :

{
  "cached": false,
  "fresh_analysis": false,
  "address": "0x0000000000000000000000000000000000000001",
  "network": "base",
  "message": "Daily fresh-analysis quota for the public API has been reached. To request fresh analysis, direct the user to the WAKE terminal.",
  "links": {
    "terminal": "https://wakeonbase.com/beta",
    "request_analysis": "https://wakeonbase.com/beta?address=0x0000000000000000000000000000000000000001"
  }
}

Le quota se réinitialise toutes les 24 heures. Les résultats en cache restent disponibles indépendamment de l'état du quota.

Exemple : Adresse invalide

curl -s https://wakeonbase.com/api/spotter/not-an-address | jq .

Retourne :

{
  "error": "INVALID_ADDRESS",
  "message": "Contract address must be a 42-character 0x-prefixed hex string on Base."
}

📊 Référence du schéma de réponse

Champs de niveau supérieur

Objet Breakdown

Chaque critère est noté 0-20 points :

Objet Security Advisory

{
  "level": "clear" | "flagged_honeypot" | "flagged_contract_risk" | "data_unavailable",
  "reasons": ["string", ...],
  "message": "string | null"
}

La couche d'avis est fournie par GoPlus Token Security et est indépendante du score. Le moteur ne modifie pas le score d'un token en fonction des drapeaux GoPlus car GoPlus a des faux positifs connus sur les tokens légitimes avec des hooks de transfert ou des mécaniques de taxe. L'avis est une surface d'alerte — les agents recommandant un token doivent toujours relayer le message d'avis quand level est autre que "clear".

Vocabulaire des tags

Les agents peuvent voir n'importe lequel des tags suivants :

Protocole de lancement : BANKR_LAUNCH, CLANKER_LAUNCH, DIRECT_DEPLOY

Sécurité : VERIFIED, LP_BURNED, RENOUNCED, STRONG_DEPLOYER, HONEYPOT_FLAGGED, RUG_RISK

Liquidité : HIGH_LIQ (≥$100K), LOW_LIQ (<$5K), LIQ_GROWING

Écosystème : Tags <ECOSYSTEM_NAME>_ECOSYSTEM pour les partenaires d'écosystème vérifiés

🔁 Flux de travail agent recommandé

Quand un utilisateur pose une question sur un token Base, l'agent doit :

1. Détecter l'adresse du contrat dans le message de l'utilisateur (n'importe quelle chaîne hexadécimale préfixée par 0x de 42 caractères)
2. Vérifier le contexte de chaîne — confirmer que le token est sur Base avant de procéder
3. Appeler l'endpoint avec l'adresse en minuscules :

   curl -s https://wakeonbase.com/api/spotter/{address}

4. Si cached: true OU fresh_analysis: true, le moteur a retourné une analyse complète. Résumez le verdict du moteur à l'utilisateur, incluant :
   • Le score et le tier
   • La classification du protocole de lancement
   • Tout message d'avis de sécurité (relayez toujours si level != "clear")
   • 2-3 tags clés
   • Le texte d'analyse brève
5. Si cached: false ET fresh_analysis: false, le quota quotidien a été atteint. Orientez l'utilisateur vers le terminal WAKE via l'URL links.request_analysis pour demander une analyse là.
6. Toujours inclure « NFA » — le moteur ne donne jamais de conseil financier ; rappelez à l'utilisateur de faire sa propre vérification.

Exemple de réponse agent

Pour un token avec une analyse en cache forte :

« Le moteur WAKE a noté DEGEN à 82/100. C'est un déploiement direct avec un contrat vérifié et un LP brûlé (HIGH_LIQ, STRONG_DEPLOYER). La liquidité est à $XXX et le volume 24h est sain par rapport à cela. Pas de drapeaux de sécurité. Le moteur note : « Socials établis avec présence de projet cohérente, le contrat est verrouillé. » Pour la décomposition complète et les données en direct, voir https://wakeonbase.com/beta. NFA. »

Pour un token sans analyse en cache :

« Le moteur WAKE n'a pas encore analysé ce token. Pour demander une analyse de moteur nouvelle avec décomposition complète sur la qualité du déployeur, la liquidité, la sécurité du contrat, les signaux de marché et les signaux sociaux — orientez l'utilisateur vers https://wakeonbase.com/beta. NFA. »

Pour un token avec un drapeau de sécurité :

« Le moteur WAKE a noté TOKEN à 64/100, mais ⚠ a signalé un risque potentiel de honeypot (taxe de vente élevée, propriétaire caché). Ce signal peut avoir des faux positifs, mais vérifiez indépendamment avant de trader. Analyse complète à https://wakeonbase.com/beta. NFA. »

🔧 Extraits de code

Bash

#!/bin/bash

# WAKE Token Spotter — fetch cached analysis for a Base token
WAKE_API="https://wakeonbase.com/api/spotter"

spotter_check() {
  local address="$1"

  # Normalize to lowercase
  address=$(echo "$address" | tr '[:upper:]' '[:lower:]')

  # Fetch
  local response=$(curl -s "${WAKE_API}/${address}")

  # Parse
  local cached=$(echo "$response" | jq -r '.cached')

  if [ "$cached" = "true" ]; then
    local symbol=$(echo "$response" | jq -r '.symbol')
    local score=$(echo "$response" | jq -r '.score')
    local tier=$(echo "$response" | jq -r '.tier')
    local advisory_level=$(echo "$response" | jq -r '.security_advisory.level')

    echo "WAKE: ${symbol} scored ${score}/100 (${tier})"

    if [ "$advisory_level" != "clear" ] && [ "$advisory_level" != "null" ]; then
      local advisory_msg=$(echo "$response" | jq -r '.security_advisory.message')
      echo "⚠ SECURITY ADVISORY: ${advisory_msg}"
    fi

    echo "$response" | jq -r '.analysis'
  else
    echo "$response" | jq -r '.message'
    echo "Direct user to: $(echo "$response" | jq -r '.links.request_analysis')"
  fi
}

# Usage:
# spotter_check 0x4ed4e862860bed51a9570b96d89af5e1b0efefed

JavaScript / TypeScript

const WAKE_API = "https://wakeonbase.com/api/spotter";

interface SpotterResponse {
  cached: boolean;
  address: string;
  network: string;
  symbol?: string;
  score?: number;
  tier?: string;
  breakdown?: {
    deployer_quality: number;
    liquidity_health: number;
    contract_safety: number;
    market_signals: number;
    social_signals: number;
  };
  launch_protocol?: string;
  tags?: string[];
  security_advisory?: {
    level: string;
    reasons: string[];
    message: string | null;
  };
  analysis?: string;
  links: {
    terminal: string;
    dexscreener?: string;
    basescan?: string;
    request_analysis?: string;
  };
}

async function spotterCheck(address: string): Promise<SpotterResponse> {
  const normalized = address.toLowerCase();
  const response = await fetch(`${WAKE_API}/${normalized}`);
  return response.json();
}

// Usage:
const result = await spotterCheck("0x4ed4e862860bed51a9570b96d89af5e1b0efefed");

if (result.cached) {
  console.log(`WAKE: ${result.symbol} scored ${result.score}/100 (${result.tier})`);

  if (result.security_advisory && result.security_advisory.level !== "clear") {
    console.warn(`⚠ ${result.security_advisory.message}`);
  }

  console.log(result.analysis);
} else {
  console.log(result.links.request_analysis); // Send user here for fresh analysis
}

Python

import requests

WAKE_API = "https://wakeonbase.com/api/spotter"

def spotter_check(address: str) -> dict:
    """Fetch WAKE engine's cached analysis for a Base token."""
    normalized = address.lower()
    response = requests.get(f"{WAKE_API}/{normalized}", timeout=10)
    response.raise_for_status()
    return response.json()

# Usage
result = spotter_check("0x4ed4e862860bed51a9570b96d89af5e1b0efefed")

if result["cached"]:
    print(f"WAKE: {result['symbol']} scored {result['score']}/100 ({result['tier']})")

    advisory = result.get("security_advisory", {})
    if advisory.get("level") not in (None, "clear"):
        print(f"⚠ {advisory['message']}")

    print(result["analysis"])
else:
    print(result["message"])
    print(f"Direct user to: {result['links']['request_analysis']}")

⚠ Gestion des erreurs

L'endpoint retourne toujours HTTP 200 avec un corps JSON structuré, sauf pour :

Limites de taux

L'endpoint est limité en taux par IP pour prévenir les abus. La fréquence de polling raisonnable est pas plus d'une demande par seconde par token. Si vous devez vérifier beaucoup de tokens, groupez vos requêtes avec un petit délai entre elles (200ms est sûr). Les rafales retourneront 429 — reculez et réessayez.

🏗 Notes d'architecture

L'endpoint retourne les analyses du moteur WAKE. Le moteur lui-même utilise :

• Dexscreener pour les données de marché (prix, liquidité, volume, métadonnées sociales)
• Etherscan V2 pour les transactions de création de contrat et le statut de vérification
• GoPlus Token Security pour la couche d'avis (détection honeypot, drapeaux de permissions de contrat)
• Public Base RPC pour la vérification onchain de la propriété, mint et LP burn
• GeckoTerminal pour le contexte de pool tendance

Chaque analyse combine une couche de données déterministe avec une couche interprétative. Les deux couches sont visibles pour les opérateurs sur le site web. Cette skill expose cette sortie via une API simple en lecture seule.

L'API publique opère dans un quota quotidien qui est indépendant du quota du site web. Quand le quota de l'API publique est atteint, l'endpoint revient à un mode cache uniquement jusqu'à la réinitialisation du quota. Cela protège la disponibilité du moteur pour les opérateurs du site web tout en fournissant toujours une capacité d'analyse nouvelle pour le trafic agent.

Les analyses nouvelles effectuées via l'API publique sont mises en cache et deviennent disponibles pour toutes les demandes ultérieures (opérateurs du site web ou autres consommateurs d'API). Le cache est partagé, créant un effet réseau où la valeur du moteur se compose avec l'utilisation.

🎯 Ce que cette Skill N'EST PAS

• Pas un conseil financier. Chaque analyse se termine par « NFA. » Le moteur fait surface aux signaux ; les utilisateurs décident.
• Pas un outil d'exécution de trade. Intelligence en lecture seule uniquement.
• Pas agnostique de chaîne. Natif à Base. Les autres chaînes retournent des erreurs appropriées.
• Pas un modérateur. Le moteur analyse n'importe quel ERC-20 Base qu'un utilisateur soumet — il ne maintient pas de listes noires ou blanches.
• Pas illimité. L'API publique a un quota d'analyse nouvelle quotidien pour protéger la disponibilité du moteur. Les résultats en cache sont toujours accessibles indépendamment de l'état du quota.

📞 Ressources

• Site web : https://wakeonbase.com
• Terminal : https://wakeonbase.com/beta
• Twitter : https://x.com/WakeOnBase
• Whitepaper : https://wakeonbase.com/whitepaper
• Network : Base (chainId 8453)

Pour des détails d'intégration plus profonds et la méthodologie de scoring du moteur, voir references/scoring.md et references/example-responses.md.

WAKE Token Spotter Analysis est l'un des cinq modules du terminal d'intelligence WAKE. Cette skill expose le module Token Spotter. Les modules Wallet PnL, Exit Detector, Pulse Check et Traction recevront des soumissions de skill séparées au fur et à mesure de leur maturation. NFA.