Skip to main content
Glama
jevscan
by jevbook

jevscan

Typed onchain verdicts for EVM tokens. Paste a contract address, get ape / watch / avoid with calibrated probabilities, plus rug_risk, momentum, liquidity_health and fdv_stress scores. One System One decision loop, three interfaces: a library, a CLI built for pipelines, and an MCP server so your agents can use it too.

Robinhood Chain (4663) first-class, Base and everything DexScreener indexes as fallback.

$ jevscan 0x4ed4e862860bed51a9570b96d89af5e1b0efefed --chain base

$DEGEN  Degen  [base/uniswap]  $0.004
liq $2,514,000 · vol24 $1,830,000 · fdv $148,000,000 · age 540d · b/s 1.1

verdict: WATCH  p=0.472
rug_risk          ███░░░░░░░░░░░░░░░░░░░ 0.135
momentum          ███████████░░░░░░░░░░░ 0.512
liquidity_health  ██████████████████░░░░ 0.812
fdv_stress        ██████████░░░░░░░░░░░░ 0.464

jevscan-local-0.1 · 231ms · typed, no prose

Why

Software cannot act on "this token looks pretty risky tbh". It can act on {verdict: "avoid", p: 0.93}. Every trading bot, launch gate and portfolio script eventually reinvents a risk heuristic and hides it in a for-loop; jevscan pulls that decision out into the open, gives it the System One shape (state in, typed answers + probabilities out), and makes it pipeable.

The decision loop is honest about what it is: a deterministic, feature-based local engine by default, and the real TypeSafe jev endpoint the moment you export a key. Same questions, same output contract, zero code changes.

Related MCP server: crypto-inspector-mcp

Install

git clone https://github.com/jevbook/jevscan
cd jevscan && npm install
npm link        # optional: makes `jevscan` available globally
npm test        # engine smoke test + one live scan

Node 18+ (uses global fetch). No API key required for the default engine.

CLI

jevscan <address> [--chain robinhood|base|ethereum|any] [--json]
jevscan <address> --assert ape [--min-p 0.6]     # exit 0 iff verdict matches
jevscan <a1> <a2> [...] --compare                # typed choice across tokens
cat addresses.txt | jevscan --stdin --json       # one JSON line per address
jevscan <address> --watch 60                     # rescan every 60s, log verdict changes

Exit codes are the whole point, grep-style:

code

meaning

0

verdict ape, or --assert passed

1

verdict watch

2

verdict avoid

3

no indexed liquidity anywhere

4

bad input

5

--assert failed

So a buy script becomes a one-liner gate:

jevscan $CA --assert ape --min-p 0.6 && ./buy.sh $CA

And a screening pipeline is just unix:

cat new_launches.txt | jevscan --stdin --json | jq -r 'select(.decision.answers[0].answer=="avoid") | .address'

Library

import { scanToken, compareTokens } from 'jevscan';

const scan = await scanToken('0x...', { chain: 'robinhood' });
// scan.decision.answers -> [{id:'scan_verdict', answer:'watch', distribution:{...}, probability:0.47}, ...]
// scan.features         -> liquidity, volume, fdv, pair age, buy/sell ratio, ...

const pick = await compareTokens(['0x...', '0x...', '0x...']);
// pick.answer -> {id:'best_token', answer:'$DEGEN', distribution:{'$DEGEN':0.61, '$OTHER':0.39}, ...}

MCP server

Give any MCP client typed onchain judgment:

claude mcp add jevscan -- node /path/to/jevscan/src/mcp.js

Tools: scan_token, compare_tokens, engine_info. Your agent stops guessing about tokens and starts quoting probabilities.

Using the real jev

export JEV_API_KEY=...            # TypeSafe System One key
export JEV_API_URL=...            # optional, defaults to api.typesafe.ai/v1/systemone

With a key set, the extracted features are serialized into a state string and the same five typed questions are asked of jev-latest. On any failure the local engine answers instead, and the output says so in decision.model. The output contract never changes.

Output contract

Every decision, local or remote, is the same shape:

{
  "model": "jevscan-local-0.1",
  "latency_ms": 1.8,
  "answers": [
    { "id": "scan_verdict", "type": "choice", "answer": "watch",
      "distribution": { "ape": 0.21, "watch": 0.47, "avoid": 0.32 }, "probability": 0.47 },
    { "id": "rug_risk", "type": "score", "answer": 0.135, "probability": 0.135 }
  ]
}

Limitations

  • Features come from DexScreener's public API: tokens without an indexed pair return a typed avoid with a note, not an error. Coverage on very new chains lags.

  • The local engine is a calibrated-looking heuristic, not a trained model. It is deterministic, inspectable (one file, src/engine.js) and deliberately conservative; it exists so the contract is usable today and swappable for real jev tomorrow.

  • None of this is financial advice. It is a typed opinion with a probability attached, which is already more than most financial advice.

Built for jevbook.dev, the typed social network. MIT.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Token safety oracle for AI agents. Honeypot detection, 17 scam pattern checks, LP lock verification across 6 EVM chains. Score 0-100 with risk flags. ERC Token Safety Score standard.
      1
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Check a token address before acting on a pool alert. VetAgent reports liquidity across eight chains. On Ethereum, BSC and Base, it reports available sell-simulation and tax evidence and whether the simulation matches the displayed pool. On Solana it checks token authorities and liquidity. An unavailable sell check is disclosed. Try one address over MCP or HTTP without an API key.
      3
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      Enables pre-trade risk screening for EVM and Solana tokens, returning a one-line verdict with detailed flags on liquidity, ownership, and other risk factors.
      1
      MIT