AI token and crypto project scoring in mobile app

AI-Powered Token and Project Scoring in Mobile Applications

Dozens of new tokens launch each week. Most are low-quality, some are outright scams, and few are legitimate projects. A scoring system helps quickly filter obvious candidates and prioritize analysis of the rest.

Scoring Parameters: What We Evaluate

A robust scoring system covers multiple dimensions:

Technology and Development:

• GitHub activity: commits over the last 30/90 days, contributor count, open issues
• Code quality: presence of tests, audit reports
• Technology stack: blockchains used, token standards

Team:

• Verified identities vs anonymous developers (risk factor)
• LinkedIn profiles, public track record
• Previous projects and their outcomes

Tokenomics:

• Token distribution: percentage held by team, investors, and public
• Vesting schedule: presence of lock-up periods
• Inflationary/deflationary model
• Circulating vs total supply ratio

Market Metrics:

• Market cap / FDV ratio (Fully Diluted Valuation)
• Liquidity depth: DEX pool volume
• Holder distribution: top-10 holders and their supply percentage

Community:

• Twitter followers and genuine engagement rate
• Telegram/Discord activity relative to size

Data Sources

class TokenDataAggregator:

    def get_github_metrics(self, repo_url: str) -> dict:
        # GitHub API v3
        import requests
        owner, repo = self._parse_repo_url(repo_url)
        headers = {"Authorization": f"token {GITHUB_TOKEN}"}

        commits_30d = requests.get(
            f"https://api.github.com/repos/{owner}/{repo}/commits",
            params={"since": (datetime.now() - timedelta(days=30)).isoformat()},
            headers=headers
        ).json()

        contributors = requests.get(
            f"https://api.github.com/repos/{owner}/{repo}/contributors",
            headers=headers
        ).json()

        return {
            "commits_30d": len(commits_30d) if isinstance(commits_30d, list) else 0,
            "contributors_count": len(contributors) if isinstance(contributors, list) else 0,
            "stars": self._get_repo_stars(owner, repo, headers)
        }

    def get_onchain_metrics(self, contract_address: str, chain: str) -> dict:
        # Moralis API — supports ETH, BSC, Polygon, and more
        response = requests.get(
            f"https://deep-index.moralis.io/api/v2.2/erc20/{contract_address}/owners",
            params={"chain": chain, "limit": 10},
            headers={"X-API-Key": MORALIS_API_KEY}
        )
        holders = response.json()
        top10_concentration = sum(h["percentage_relative_to_total_supply"]
                                  for h in holders.get("result", [])[:10])
        return {"top10_holder_concentration": top10_concentration}

Moralis API aggregates on-chain data across EVM-compatible networks. Covalent API is an alternative with historical data. For Solana, use Helius or direct Solana RPC.

Scoring Model

Rule-Based Scoring Foundation

Start with a weighted rule set. This approach is transparent and explainable—important for users who want to understand scores:

class TokenScorer:
    WEIGHTS = {
        "github_activity": 0.15,
        "team_transparency": 0.20,
        "tokenomics_health": 0.25,
        "liquidity_score": 0.20,
        "community_quality": 0.10,
        "audit_status": 0.10,
    }

    def score_github(self, metrics: dict) -> float:
        score = 0.0
        if metrics["commits_30d"] > 50:
            score += 0.4
        elif metrics["commits_30d"] > 10:
            score += 0.2

        if metrics["contributors_count"] > 5:
            score += 0.3
        elif metrics["contributors_count"] > 2:
            score += 0.15

        return min(score, 1.0)

    def score_tokenomics(self, data: dict) -> float:
        score = 1.0

        # Penalty for high team allocation
        if data["team_allocation_pct"] > 30:
            score -= 0.3
        # Penalty for missing vesting
        if not data["has_vesting"]:
            score -= 0.25
        # Penalty for low circulating ratio (many tokens still to be released)
        if data["circulating_ratio"] < 0.2:
            score -= 0.2

        return max(score, 0.0)

ML on Top of Rules: Anomaly and Rug Pull Pattern Detection

ML component identifies patterns characteristic of scams. Train on historical data: tokens that executed rug pulls and legitimate projects.

Rug pull indicators in data:

• Contract creator removed liquidity pool within 30 days
• Honeypot: token cannot be sold (sell function blocked in contract)
• Proxy contract with no timelock for logic changes
• 90%+ supply held by single address

from sklearn.ensemble import GradientBoostingClassifier

# Rug pull detector
features = [
    "top1_holder_pct",
    "lp_lock_days",
    "is_proxy_contract",
    "sell_function_exists",
    "owner_renounced",
    "audit_score",
    "github_commits_30d",
    "holder_count"
]

model = GradientBoostingClassifier(n_estimators=100, max_depth=4)
model.fit(X_train, y_train)  # y: 1 = rug pull, 0 = legitimate

Dataset: confirmed rug pull tokens from DeFiLlama Hacks dashboard, Token Sniffer historical data.

Honeypot Detection

A separate critical check: can the token actually be sold? Use go-ethereum / ethers.js transaction simulation before interacting with the contract:

from web3 import Web3

def check_honeypot(contract_address: str, router_address: str) -> bool:
    w3 = Web3(Web3.HTTPProvider(RPC_URL))
    # Simulate selling minimal amount
    try:
        router = w3.eth.contract(address=router_address, abi=ROUTER_ABI)
        router.functions.swapExactTokensForETHSupportingFeeOnTransferTokens(
            1,  # 1 wei token equivalent
            0,
            [contract_address, WETH_ADDRESS],
            ZERO_ADDRESS,
            int(time.time()) + 60
        ).call({"from": TEST_WALLET})
        return False  # sale succeeded = not honeypot
    except Exception:
        return True  # revert = honeypot

This is a call, not a send—no gas spent, no blockchain transaction written.

Mobile UI

Final score is a 0–100 number with color coding (red < 40, yellow 40–70, green > 70). But a score without explanation is a black box. Display a breakdown alongside: which factors lowered the score.

struct TokenScore: Codable {
    let overallScore: Double           // 0-100
    let riskLevel: RiskLevel           // .low, .medium, .high, .critical
    let breakdown: ScoreBreakdown
    let warnings: [String]             // ["Honeypot detected", "No audit report"]
    let lastUpdated: Date
}

struct ScoreBreakdown: Codable {
    let technology: Double
    let team: Double
    let tokenomics: Double
    let liquidity: Double
    let community: Double
}

Prioritize warnings: honeypot detection gets a red banner immediately, low liquidity appears as a yellow warning lower on the page.

Process Overview

Define scoring parameters with the client. Build a data pipeline (GitHub API, on-chain data, social metrics). Develop rule-based scoring engine. Train ML model for rug pull/honeypot detection. Deploy REST API with caching (token data refreshes hourly). Build mobile UI: token card with score and category breakdown.

Timeline Estimates

Rule-based scoring with core metrics: 1–2 weeks. Complete system with ML rug pull detector, honeypot checking, and mobile UI: 3–5 weeks.