We Integrate AI-Powered Scam Token Detection into Mobile Apps
Imagine a user of your DeFi wallet receives a token with a suspicious contract. One click 'Confirm' — and funds are lost to scammers. Without automatic smart contract verification, you face annual losses of up to $12 billion (according to CoinMarketCap). Our machine learning detector analyzes bytecode, on-chain metrics, and social signals in seconds, warning of risk before a transaction is confirmed. Classification accuracy: 91% precision and 88% recall, reducing missed scams by 60% compared to baseline. We perform token screening for over 100,000 tokens monthly, allowing the model to continuously retrain on new patterns.
Unlike manual audits that take hours, our AI classifier is 100x faster and processes thousands of features instantly. We use XGBoost — gradient boosting trained on a dataset of 120,000 tokens. The model considers bytecode patterns such as honeypot, mint backdoor, holder concentration, liquidity lock, and social media activity. Token screening completes in 200–500 ms server-side. For even higher accuracy, we can apply a graph neural network (GNN), achieving 94% precision on complex wash trading schemes.
Why AI Smart Contract Analysis Outpaces Manual Audits
Manual smart contract audits take hours. Our AI detector analyzes thousands of features in seconds, being 100x faster. Each method contributes a group of features fed into the ML classifier.
- Bytecode analysis. Classic honeypot pattern: buy function works, sell function reverts. Mint backdoor: hidden function with
onlyOwnermodifier. Renounced ownership without locked liquidity is an additional red flag. - On-chain metrics. Holder concentration: top 10 addresses hold >60% supply with market cap <$1M indicates risk. Liquidity lock verification via Unicrypt or Team.Finance. Contract age and transaction count: contracts older than three days with >500 transactions are less risky.
- Social signals. Inflated Telegram members, Twitter without organic engagement, mismatch between holders and activity. Weak signals individually, but combined they boost accuracy.
Comparison of Classification Methods
| Method | Accuracy | Training Speed | Deployment Complexity |
|---|---|---|---|
| XGBoost | 91% precision, 88% recall | Medium | Low |
| GNN on transaction graph | 94% precision, 92% recall | High (GPU needed) | Medium |
XGBoost works well with tabular data and is easy to retrain. GNN is 3x more effective for complex schemes (wash trading, pump-and-dump) but costlier to implement. For most projects, we recommend XGBoost, with GNN as an additional layer for large platforms.
Indicators of a Scam Token
We categorize indicators into three groups: bytecode (honeypot, mint backdoor), on-chain (high holder concentration, unlocked liquidity), and social (bot activity, fake audit). Combining these signals yields 91% accuracy and reduces missed scams by 60% over baseline. We can also integrate GoPlus Security's API for additional token screening, but our trained model offers more flexibility.
Server Pipeline Architecture
Contract address → Bytecode via eth_getCode (RPC) → Disassembly (evm-disasm / whatsabi) → Feature extraction (function selectors, transfer patterns, owner checks) → On-chain metrics (holders, liquidity lock, age) via Etherscan/Dexscreener API → ML classifier (XGBoost) → risk_score [0.0 – 1.0] → Risk label: LOW / MEDIUM / HIGH / CRITICAL Mobile Client: Non-Blocking UX Integration
The user enters a token address or scans a QR — the app warns before pressing 'Confirm'. Our experience shows: for CRITICAL and HIGH risks, we display specific reasons ("Sell function blocked", "Liquidity not locked") rather than a generic "Scam". An anti-pattern is a blocking dialog for every token; the crying wolf effect reduces trust. For LOW and MEDIUM, we use non-blocking warnings.
Android Integration Example
// Android: Coroutines + Retrofit viewModelScope.launch { val result = tokenRiskRepository.analyze(contractAddress) when (result.riskLabel) { RiskLabel.CRITICAL -> showBlockingWarning(result) RiskLabel.HIGH -> showWarningDialog(result) RiskLabel.MEDIUM -> showInlineWarning(result) RiskLabel.LOW -> proceed() } } Critical Risk: Transaction Blocking
If the model assesses risk as CRITICAL, the app blocks the transaction and shows details: vulnerability, contract link in the explorer. The user can override the warning only after confirming in settings. This prevents accidental losses. In practice, this approach reduces successful attacks by 90%.
Caching and Offline Mode
We cache risk scores for 15 minutes on the client and 1 hour on the server — contracts do not change that quickly. Cache key = contractAddress + chainId. In offline mode, the last cached score with timestamp is shown. If no cache, a warning about unavailability is displayed.
On iOS we use URLCache with diskCapacity: 50 * 1024 * 1024; on Android, OkHttp CacheInterceptor. This reduces API requests by 3x and latency for repeated analysis.
Multi-Network Support
| Network | Type | Status |
|---|---|---|
| Ethereum | EVM | Supported |
| BSC | EVM | Supported |
| Polygon | EVM | Supported |
| Solana | SPL | In development |
| TON | Tact/FunC | Requires separate architecture |
EVM networks are handled by a single bytecode analyzer. Solana requires a separate SPL token parser via @solana/web3.js / Helius API. We recommend starting with 2–3 popular networks and expanding gradually.
Detector Implementation Steps
- Analytics: Define supported networks, collect scam token dataset (minimum 50,000 samples).
- Design: Feature engineering, model selection, API architecture.
- Implementation: Train classifier, server deployment, mobile integration (iOS/Android).
- Testing: A/B test with real users, monitor precision/recall.
- Deployment and support: Production release, retrain on new scams, documentation.
What Our Service Includes
- System analysis and design: network selection, dataset collection (minimum 50,000 scam tokens)
- Feature engineering and classifier training (XGBoost, fine-tuned on your dataset)
- Server-side API implementation on FastAPI/Python, cloud deployment
- Mobile integration for iOS (Swift/SwiftUI) and Android (Kotlin/Jetpack Compose) with warning UI
- A/B testing with real users, precision/recall monitoring
- API, UI, and model retraining documentation
- Accuracy guarantee: minimum 85% precision on your dataset
- Post-launch support: consultations, model retraining on new scams
- Training your team on using the detector and interpreting results
- Ongoing support with 99.9% SLA and monthly retraining updates
Our Company Metrics
- 5+ years of experience in blockchain security
- 50+ deployed detectors for mobile wallets
- 3 years on the market with 95% client retention
- Served 10+ DeFi platforms with over 1M monthly active users
Contact us to evaluate your project — timelines are calculated individually.