honeypotscan — Scanner gratuito di token honeypot per Ethereum, Polygon e Arbitrum. Rileva i token truffa prima di acquistarli. Analisi istantanea degli smart contract utilizzando 13 pattern specializzati. Nessuna chiave API, nessun limite, 100% gratuito. Costruito con Next.js 16 e Cloudflare Workers. | Kitploit

### Cronologia delle scansioni

Le ultime 10 scansioni vengono salvate automaticamente in locale:
- Accesso rapido ai contratti scansionati in precedenza
- Nessun archivio sul server - privacy completa
- Include nome del token, simbolo e timestamp della scansione
- Funzionalità di riescansion o condivisione con un clic

### Condivisione ed esportazione

**Condividi risultati tramite URL:**```
https://honeypotscan.com#result=eyJhIjoiMHguLi4ifQ==

**Copia come testo:**```
🔍 HoneypotScan Result
════════════════════════════════════════
Token: Scam Token (SCAM)
Address: 0x...
Chain: Ethereum

Status: 🚨 HONEYPOT DETECTED
Confidence: 95%

⚠️ Patterns Found (3):
  • tx_origin_require (line 123)
  • hidden_sell_tax (line 456)
  • transfer_whitelist_only (line 789)

## 🧬 Algoritmo di rilevamento

HoneypotScan utilizza un'**analisi statica** avanzata per rilevare pattern dannosi nel codice sorgente degli smart contract. Il nostro algoritmo è progettato per un'elevata precisione minimizzando i falsi positivi.

### Come Funziona```
1. Input Validation
   └─> EIP-55 checksum validation (keccak256)
   └─> Format verification (0x + 40 hex chars)
   └─> Chain detection (Ethereum/Polygon/Arbitrum)

2. Contract Source Retrieval
   └─> Fetch from Etherscan API
   └─> 6 API keys with intelligent rotation
   └─> 10-second timeout protection
   └─> Zod schema validation

3. Code Sanitization
   └─> Remove comments and whitespace
   └─> Normalize line endings
   └─> Verify Solidity structure
   └─> Size validation (50 chars - 2MB)

4. Pattern Matching
   └─> Run 13 specialized regex patterns
   └─> Each pattern detects specific honeypot techniques
   └─> Record all matches

5. Confidence Scoring
   └─> ≥2 patterns = HONEYPOT (95% confidence)
   └─> 1 pattern = SUSPICIOUS (needs review)
   └─> 0 patterns = SAFE (100% confidence)

Pattern	Descrizione	Rischio
`balance_tx_origin`	La funzione `balanceOf()` controlla tx.origin	Mostra saldi diversi al compratore originale rispetto al router
`allowance_tx_origin`	La funzione `allowance()` controlla tx.origin	Impedisce al DEX di ottenere l'approvazione per vendere
`transfer_tx_origin`	La funzione `transfer()` controlla tx.origin	Blocca i trasferimenti non avviati dal compratore originale

#### 2️⃣ **Funzioni Helper Nascoste (2 pattern)**

Funzioni interne che abilitano la vendita selettiva:

| Pattern | Descrizione | Rischio |
|---------|-------------|--------|
| `hidden_fee_taxPayer` | L'helper `_taxPayer()` usa tx.origin | Logica fiscale nascosta che prende di mira acquirenti non originali |
| `isSuper_tx_origin` | L'helper `_isSuper()` usa tx.origin | Funzione di whitelist che consente solo al truffatore di vendere |

#### 3️⃣ **Bypass di Autenticazione (4 pattern)**

Uso di `tx.origin` per il controllo degli accessi (pattern pericoloso):

| Pattern | Descrizione | Rischio |
|---------|-------------|--------|
| `tx_origin_require` | L'istruzione `require()` controlla tx.origin | Annulla le transazioni dai router DEX |
| `tx_origin_if_auth` | Istruzione `if` con tx.origin per l'autenticazione | Logica condizionale che blocca la rivendita |
| `tx_origin_assert` | L'istruzione `assert()` controlla tx.origin | Fallimento grave su transazioni non originali |
| `tx_origin_mapping` | Accesso alla mappatura tramite `[tx.origin]` | Tracciamento/blacklist basato sul chiamante originale |

**Perché tx.origin è pericoloso:**
- Quando acquisti tramite Uniswap: `tx.origin = IL_TUO_PORTAMONETE` ✅
- Quando vendi tramite Uniswap: `tx.origin = IL_TUO_PORTAMONETE`, ma `msg.sender = ROUTER_UNISWAP` ❌
- Gli honeypot sfruttano questa differenza per bloccare le vendite mentre consentono gli acquisti

#### 4️⃣ **Restrizioni al Trasferimento (4 pattern)**

Meccanismi diretti di blocco delle vendite:

| Pattern | Descrizione | Rischio |
|---------|-------------|--------|
| `sell_block_pattern` | `_isSuper(destinatario)` restituisce false | Blocca esplicitamente le vendite a indirizzi non nella whitelist |
| `asymmetric_transfer_logic` | `_canTransfer()` restituisce sempre false | Impedisce qualsiasi trasferimento dopo l'acquisto iniziale |
| `transfer_whitelist_only` | Richiede che sia il mittente che il destinatario siano nella whitelist | Solo il truffatore può spostare i token |
| `hidden_sell_tax` | Tassa di vendita del 95-100% nella logica della coppia DEX | Drena completamente i tuoi token alla vendita |

### Perché Soglia = 2?

**La nostra soglia di rilevamento richiede ≥2 pattern corrispondenti** per la classificazione honeypot. Ecco perché:

#### ✅ **Riduce i Falsi Positivi**
- Pattern singoli possono apparire in contratti legittimi per caso
- 2+ pattern indicano **progettazione dannosa intenzionale**
- Esempio: Un contratto potrebbe avere un solo controllo `tx.origin` per la protezione anti-bot (sicuro), ma 2+ indicano abuso sistematico

#### ✅ **Mantiene Alta Precisione**
- I nostri test mostrano che gli honeypot in genere presentano **3-7 pattern**
- I contratti legittimi raramente mostrano più di 1 pattern
- Soglia di 2 = **equilibrio ottimale** tra sensibilità e specificità

#### ✅ **Livelli di Confidenza**```
0 patterns  = 100% Safe (no suspicious code)
1 pattern   = Needs Review (possibly safe anti-bot measures)
2+ patterns = 95% Honeypot (intentional malicious design)

Caratteristica	Implementazione	Protezione
Validazione del checksum EIP-55	Proper keccak256 using @noble/hashes	Previene attacchi di manipolazione degli indirizzi
Validazione del formato	Regex + length checks (0x + 40 hex)	Rifiuta input malformati prima dell'elaborazione
Sanificazione degli input	Trim, lowercase, character filtering	Difesa a strati contro l'iniezione
Limiti di dimensione	Min 50 chars, max 2MB contract code	Previene DoS tramite payload sovradimensionati

Caratteristica	Implementazione	Protezione
Content Security Policy	Strict CSP headers on all pages	Previene XSS, clickjacking, iniezione di dati
CORS Whitelist	Origin validation against allowed list	Blocca l'uso non autorizzato dell'API da domini sconosciuti
Rate Limiting	Per-IP request limits (30 req/min)	Previene abusi e garantisce un uso equo
Request Timeouts	10-second timeout with AbortController	Previene richieste sospese ed esaurimento delle risorse

### 🔒 Sicurezza delle API

| Caratteristica | Implementazione | Protezione |
|---------|---------------|------------|
| **Rotazione delle chiavi API** | 6 chiavi Etherscan con selezione casuale | Distribuisce il carico, previene l'esaurimento di una singola chiave |
| **Validazione dello schema** | Validazione Zod su tutte le risposte API | Previene che dati malformati causino errori di runtime |
| **Sanificazione degli errori** | Messaggi di errore generici agli utenti | Previene la divulgazione di informazioni |
| **Logging strutturato** | Log JSON con timestamp e metadati | Traccia di controllo per debug e monitoraggio di sicurezza |

### 🏗️ Sicurezza dell'infrastruttura

| Caratteristica | Implementazione | Protezione |
|---------|---------------|------------|
| **Nessun segreto hardcoded** | Tutte le credenziali tramite variabili d'ambiente | Previene l'esposizione di segreti nel repository |
| **Cloudflare Workers** | Edge computing con esecuzione isolata | Protezione DDoS e auto-scaling |
| **Cache KV con TTL** | Scadenza automatica (24 ore) | Previene attacchi con dati obsoleti |
| **Autenticazione OAuth** | Token OAuth di Cloudflare per i deployment | CI/CD sicuro senza chiavi API nel codice |

### 🔍 Sicurezza del codice

| Caratteristica | Implementazione | Protezione |
|---------|---------------|------------|
| **Modalità strict di TypeScript** | Compilazione strict completa | Rileva errori di tipo in fase di compilazione |
| **Accesso difensivo agli array** | Controlli di undefined prima dell'accesso | Previene crash a runtime |
| **Sicurezza delle regex** | Quantificatori limitati nei pattern | Mitiga gli attacchi ReDoS |
| **Niente eval() o Function()** | Analisi statica pura | Previene l'iniezione di codice |

### 🚨 Cosa NON memorizziamo

**Un design incentrato sulla privacy significa ZERO raccolta dati:**
- ❌ Nessun account utente o autenticazione
- ❌ Nessuna cronologia di scansione o log
- ❌ Nessuna tracciabilità dell'indirizzo IP oltre al rate limiting (in memoria, cancellato ogni minuto)
- ❌ Nessun cookie o fingerprint del browser
- ❌ Nessuna analisi o tracker di terze parti

**Le tue scansioni sono completamente anonime.**

### 📋 Intestazioni di sicurezza

Ogni risposta include:```http
Content-Security-Policy: default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; 
  style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; 
  font-src 'self' data:; connect-src 'self' https://honeypotscan-api.teycircoder4.workers.dev; 
  frame-ancestors 'none'; base-uri 'self'; form-action 'self'
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Referrer-Policy: no-referrer
Permissions-Policy: camera=(), microphone=(), geolocation=()

### Utilizzo API```bash
# Scan a token contract
curl "https://your-worker.workers.dev/api/scan?address=0x...&chain=ethereum"

# Response format
{
  "isHoneypot": true,
  "confidence": "high",
  "patterns": ["tx.origin abuse", "hidden fees"],
  "riskScore": 85,
  "cached": false
}

## 📈 Scalabilità

**Capacità del livello gratuito:**
- 100k richieste/giorno (Cloudflare Workers)
- 100k letture/giorno (Cloudflare KV)
- 2,6M chiamate API/giorno (Etherscan)
- **Con il 95% di cache hit: 2M scansioni/giorno**

**Costo: $0/mese** 🎉

## 🛠️ Stack Tecnologico

- **Frontend**: Next.js 16, React 19, Tailwind CSS v4, Framer Motion
- **Backend**: Cloudflare Workers
- **Cache**: Cloudflare KV
- **Scanner**: TypeScript (rilevamento pattern personalizzato)
- **API**: Etherscan, Polygonscan, Arbiscan
- **Distribuzione**: Cloudflare Pages + Workers

## 🧪 Test```bash
# Run contract scanner tests
npm run test:scan

# Test specific contract
tsx test/scan-contracts.ts 0x...

# Debug pattern detection
tsx test/debug-pattern.ts

Progetto	Descrizione
TimeSeal.online	Timbra e prova l'esistenza di documenti sulla blockchain
SanctumVault.online	Archiviazione e condivisione sicura di file crittografati
Ghost-Chat	Messaggistica anonima crittografata

honeypotscan

Più Popolari

Informazioni

Supporta lo Sviluppo

🛡️ HoneypotScan

🍯 Cosa Sono i Token Honeypot?

Come Funzionano gli Honeypot

I Rischi

⚠️ Importante: Questo NON è un Audit di Sicurezza Completo

✨ Funzionalità

📚 Funzionalità Educative

Spiegazioni dei Pattern

🎯 Casi d'uso

📸 Come Usare

🔍 Scansiona per Indirizzo

📝 Scansiona per Codice Sorgente

🏗️ Architettura```

I 13 schemi di rilevamento

1️⃣ Abuso ERC20 Core (3 schemi)

📊 Prestazioni nel mondo reale

Casi limite e limitazioni

🔐 Funzionalità di sicurezza

🛡️ Sicurezza degli input

🌐 Sicurezza di rete

🔐 Divulgazione Responsabile

🚀 Avvio Rapido

Sviluppo Locale```bash

Clone the repository

Install dependencies

Set up environment variables

Edit .env.local with your API keys

Run development server

Open http://localhost:3000

Build for production

Deploy to Cloudflare

📊 Pattern di Rilevamento

🔧 Variabili d'Ambiente```env

Etherscan API Keys (6 keys for rotation)

Cloudflare (for deployment)

📚 Documentazione

🤝 Contributi

📝 Licenza

❓ FAQ

🌐 Altri Progetti

⚠️ Dichiarazione di non responsabilità

👤 Autore

💼 Assumimi