A crypto Bloomberg terminal — real-time chain metrics dashboard, AI-powered VC sentiment tracking, and on-chain metric publishing with Flare verification.

30 supported chains across L1s, L2s, and EVM-compatible networks.

• Python 3.12+ with uv
• Node.js 22+
• (Optional) Docker & Docker Compose

cd backend
cp ../.env.example ../.env  # edit with your API keys

# Install dependencies and run
uv sync --extra dev
uv run python -m cli serve --reload

The API is live at http://localhost:8000. Docs at http://localhost:8000/docs.

cd frontend
npm install
npm run dev

Open http://localhost:3000.

cp .env.example .env
docker compose up --build

Backend at :8000, frontend at :3000.

cd backend
uv run pytest

cd backend
uv run ruff check src/
uv run ruff format --check src/

Live price data from CoinGecko, refreshed every 60 seconds via batch API call.

If the live price is missing or zero (rate-limited), the system falls back to the most recent price from the 1-day history endpoint.

Server-side aggregated from price history ticks via _aggregate_ohlc(). Auto-selects candle interval based on the requested time range:

Allowed explicit intervals: 1, 4, 24, 72, 168 (hours).

Raw price ticks from CoinGecko with granularity determined by the time range:

Includes singleflight deduplication — chains sharing the same CoinGecko ID (e.g., Base and Ethereum both use "ethereum") trigger only one API call. Larger cached tiers (90d, 365d) are sliced to serve shorter ranges without extra API calls.

Composite score computed from four equally-weighted factors (25 points each). Missing data scores 12.5 (neutral midpoint). Includes a confidence field (0.0-1.0) reflecting the fraction of factors with real data.

Labels: excellent (>=85), good (>=70), neutral (>=50), caution (>=30), poor (<30)

Contributing factors are returned as human-readable strings (e.g., "strong dev activity (+)", "high concentration (-)") when a factor scores above or below key thresholds.

Pulled from the GitHub commits API for each chain's tracked repositories (30-day window by default).

Derivatives market data from Binance Futures perpetual contracts.

Token holder distribution from on-chain data. Uses a representative token per chain (typically USDC for EVM chains, native token for non-EVM).

AI-computed sentiment index from classified intel items. Uses sigmoid normalization on raw weighted scores.

Computation: For each classified intel item, per-chain impact is scored as magnitude * confidence * direction_sign. Raw scores are aggregated and normalized via sigmoid: 100 / (1 + exp(-raw / 200)).

Windows: 1d (24h), 7d (7 days), 30d (30 days).

Base URL: http://localhost:8000

Valid metric types: flow_1d, flow_7d, flow_30d, risk

Valid targets: evm, flare, auto (prefers Flare if enabled, falls back to EVM, then simulated)

Publish modes: real (EVM), flare_direct (Flare), flare_attested (Flare + FDC proof), simulated (SQLite-only)

# Health check
curl http://localhost:8000/health

# List all chains
curl http://localhost:8000/chains

# Get Ethereum metrics (price, sentiment, holders, dev, reputation)
curl http://localhost:8000/chains/ethereum

# Get 90-day OHLC candles with 1-day interval
curl "http://localhost:8000/chains/bitcoin/ohlc?days=90&interval=24"

# Get 7-day price history for Solana
curl "http://localhost:8000/chains/solana/history?days=7"

# Get 60-day dev activity for Sui
curl "http://localhost:8000/chains/sui/dev-activity?days=60"

# Keyword query
curl -X POST http://localhost:8000/query \
  -H 'Content-Type: application/json' \
  -d '{"query": "polygon"}'

# Flow index table (all chains)
curl http://localhost:8000/api/intel/flow

# Publish Ethereum 7-day flow index on-chain
curl -X POST http://localhost:8000/api/onchain/publish \
  -H 'Content-Type: application/json' \
  -d '{"chain": "ethereum", "metric_type": "flow_7d", "value": 0, "target": "auto"}'

# Force refresh (admin)
curl -X POST http://localhost:8000/admin/refresh \
  -H 'X-Admin-Token: your-token-here'

BlockBerg features a Bloomberg-style command bar (/ or Ctrl+K to focus). All commands are case-insensitive.

Symbols: BTC, ETH, SOL, ARB, OP, POL/MATIC, SUI, AVAX, BNB, ADA, DOT, ATOM, NEAR, TON, TRX, APT, FTM, ALGO, TIA, SEI, HBAR, ICP, STRK, ZK, MNT, INJ, XRP, DOGE, LTC, FIL

AI-powered VC and crypto funding sentiment tracker.

1. Sources: Configured in backend/config/intel_sources.yaml — RSS feeds and HTML scraping from major crypto VCs and news outlets
2. Fetch: Background scheduler fetches all sources every 30 minutes (configurable via INTEL_FETCH_INTERVAL_SECONDS)
3. Classify: Each item is sent to OpenAI (gpt-4o-mini by default) for structured JSON classification:
   • Item type: funding_round, portfolio_update, grant, partnership, blog_post, other
   • Entity extraction: companies (name, website, confidence) and people (name, role, confidence)
   • Funding info: round type, amount in USD, investors list
   • Per-chain impact: chain name, direction (positive/negative/neutral), magnitude (0-100), confidence (0-1), rationale
4. Flow Index: Computed per chain per window (1d/7d/30d) from classified items using sigmoid normalization

Edit backend/config/intel_sources.yaml:

sources:
  - slug: my-vc
    name: My VC Firm
    kind: rss          # or "html"
    url: https://myvc.com/feed/
    tags: [crypto]

Publish computed metrics (flow index, reputation score) to EVM-compatible blockchains with a two-tier fallback:

• Tier A (Real): Send transactions via JSON-RPC to any EVM chain or Flare network
• Tier B (Simulated): Store publish records in SQLite with deterministic fake tx hashes (0xSIM... for EVM, 0xFLR... for Flare)

No web3.py dependency — uses raw httpx JSON-RPC calls for minimal footprint.

Reference Solidity contract at backend/contracts/MetricStore.sol:

• publishMetric(string chain, string metricType, uint256 value) — standard metric publish, emits MetricPublished event
• setMetricWithAttestation(string chain, string metricType, uint256 value, bytes32 attestationProof) — FDC-verified publish, emits MetricPublishedWithAttestation event
• getLatest(string chain, string metricType) — view function returning latest value, timestamp, and publisher address
• Metric values are scaled by 1e4 (4 decimal places). A flow index of 65.5 is stored as 655000.

BlockBerg integrates with the Flare blockchain for verifiable metric publishing and external data attestation.

1. Flare Publisher (backend/src/blockberg/onchain/flare_publisher.py): Dedicated publisher targeting Flare/Coston2 RPC. Supports direct metric publishing (mode=flare_direct) and FDC-attested updates (mode=flare_attested) via setMetricWithAttestation().

2. FDC Attestation (backend/src/blockberg/onchain/fdc.py): Flare Data Connector integration for verifying intel items. Builds AddressValidity attestation payloads, computes deterministic SHA-256 payload hashes, and tracks verification status: requested -> verified -> on-chain.

3. FTSO Price Provider (backend/src/blockberg/providers/flare_ftso.py): Skeleton provider for reading prices from Flare Time Series Oracle. Maps 16 CoinGecko IDs to FTSO symbols. Behind FLARE_ENABLED feature flag — CoinGecko remains the default price source.

4. Smart Contract (backend/contracts/MetricStore.sol): Reference Solidity contract with publishMetric() for standard updates and setMetricWithAttestation(bytes32 attestationProof) for FDC-verified updates.

5. Frontend: Flare mode badges (FLARE DIRECT / FLARE ATTESTED / SIMULATED) on publish records, and VERIFY buttons on intel items for requesting FDC attestation.

FLARE_ENABLED=true
FLARE_RPC_URL=https://coston2-api.flare.network/ext/C/rpc
FLARE_PRIVATE_KEY=0x...  # NEVER commit
FLARE_CONTRACT_ADDRESS=0x...
FLARE_NETWORK_NAME=flare-coston2

Intel Item -> AI Classification -> Flow Index Computation
                                        |
                          PUBLISH ETH FLOW 7D (command)
                                        |
                          target=auto -> FlarePublisher
                                        |
                          publishMetric() on Flare Coston2
                                        |
                          MetricPublished event emitted
                                        |
                          Record stored in SQLite + shown in UI

Intel Item -> VERIFY button -> FDC Attestation Request
                                        |
                          Build payload -> hash -> store
                                        |
                          FDC verifier (when available)
                                        |
                          Merkle proof -> setMetricWithAttestation()

BlockBerg/
├── backend/
│   ├── src/
│   │   ├── cli.py                      # CLI entry point (serve, etc.)
│   │   ├── blockberg/
│   │   │   ├── api/
│   │   │   │   ├── app.py              # FastAPI factory + lifespan
│   │   │   │   ├── routes.py           # Core chain/query/admin endpoints
│   │   │   │   ├── middleware.py        # Rate limiting, CORS, Prometheus instrumentation
│   │   │   │   └── deps.py             # FastAPI dependency injection
│   │   │   ├── core/
│   │   │   │   ├── config.py           # Pydantic Settings (env vars)
│   │   │   │   ├── cache.py            # In-memory TTL cache
│   │   │   │   ├── chains.py           # 30 chain definitions (ChainId, ChainInfo)
│   │   │   │   ├── rate_limiter.py     # Token-bucket per-IP rate limiter
│   │   │   │   ├── logging.py          # structlog JSON logging setup
│   │   │   │   └── metrics.py          # Prometheus counters and gauges
│   │   │   ├── models/
│   │   │   │   └── chains.py           # Pydantic v2 response schemas
│   │   │   ├── providers/
│   │   │   │   ├── base.py             # Abstract provider interfaces
│   │   │   │   ├── coingecko.py        # CoinGecko price/history provider
│   │   │   │   ├── github.py           # GitHub dev activity provider
│   │   │   │   ├── binance.py          # Binance funding rate provider
│   │   │   │   ├── etherscan.py        # EVM holder concentration provider
│   │   │   │   ├── blockvision.py      # Sui holder concentration provider
│   │   │   │   ├── evm_rpc.py          # EVM JSON-RPC (block number)
│   │   │   │   ├── sui_rpc.py          # Sui JSON-RPC (block number)
│   │   │   │   └── flare_ftso.py       # Flare FTSO price provider (skeleton)
│   │   │   ├── services/
│   │   │   │   ├── metrics_service.py  # Orchestrates providers + caching
│   │   │   │   ├── reputation.py       # Reputation score computation
│   │   │   │   └── scheduler.py        # Background refresh tasks
│   │   │   ├── intel/
│   │   │   │   ├── config.py           # Intel env var configuration
│   │   │   │   ├── db.py              # SQLite async database (aiosqlite)
│   │   │   │   ├── fetcher.py         # RSS/HTML source fetcher
│   │   │   │   ├── flow.py            # Flow index computation
│   │   │   │   ├── llm.py            # OpenAI classification provider
│   │   │   │   ├── models.py         # Pydantic v2 intel schemas
│   │   │   │   ├── routes.py         # Intel API endpoints
│   │   │   │   └── service.py        # Intel service orchestrator
│   │   │   └── onchain/
│   │   │       ├── config.py          # Onchain + Flare env var config
│   │   │       ├── db.py             # SQLite for publishes + attestations
│   │   │       ├── models.py         # Pydantic v2 onchain schemas
│   │   │       ├── publisher.py      # Publisher factory (create_publisher)
│   │   │       ├── evm_publisher.py  # EVM JSON-RPC publisher
│   │   │       ├── sim_publisher.py  # Simulated publisher (SQLite only)
│   │   │       ├── flare_publisher.py # Flare-specific publisher
│   │   │       ├── fdc.py            # FDC attestation builder
│   │   │       ├── service.py        # Onchain service orchestrator
│   │   │       └── routes.py         # Onchain API endpoints
│   │   └── blockberg_tests/           # pytest tests (87 tests)
│   ├── config/
│   │   └── intel_sources.yaml         # VC/news source definitions
│   ├── contracts/
│   │   └── MetricStore.sol            # Reference Solidity contract
│   ├── deployments/
│   ├── Dockerfile
│   └── pyproject.toml
├── frontend/
│   ├── src/
│   │   ├── app/                       # Next.js 15 App Router
│   │   │   ├── page.tsx               # Home — chain overview grid
│   │   │   ├── chains/[chainId]/      # Chain detail dashboard
│   │   │   ├── screener/              # Screener + comparison charts
│   │   │   └── intel/                 # VC list, detail, flow, news
│   │   ├── components/                # React components (command bar, help modal, charts)
│   │   └── lib/
│   │       ├── api.ts                 # Typed API client
│   │       ├── hooks.ts               # TanStack Query hooks
│   │       └── commands.ts            # Command parser + autocomplete
│   ├── deployments/
│   ├── Dockerfile
│   └── package.json
├── libs/                              # Shared libraries (scaffolding)
├── docker-compose.yml
└── .env.example

• FastAPI + uvicorn + uvloop for async request handling
• ORJSONResponse for fast JSON serialization
• In-memory TTL cache with per-key expiration and periodic eviction (every 5 min)
• Batch price fetching: single CoinGecko API call pre-warms prices for all 30 chains
• Singleflight deduplication: concurrent requests for the same price history share one in-flight API call
• Cache tier slicing: larger cached ranges (90d, 365d) are sliced to serve shorter ranges without extra calls
• Per-provider timeout: 15s timeout per provider prevents one slow source from blocking all metrics
• Route-level timeout: 30s timeout on all API endpoints, returns 504 on timeout

Token-bucket algorithm per client IP (in-memory). Default: 20 tokens/sec, burst of 40. Auto-cleanup at >10,000 entries to prevent memory leaks. Extensible to Redis via Lua script for multi-process deployments.

Pure asyncio task scheduler — no Celery dependency:

• Intel data: SQLite via aiosqlite (intel_sources, intel_items, intel_classifications, chain_flow_snapshots)
• Publish records: SQLite via aiosqlite (onchain_publishes, attestation_requests)
• No Redis required — in-memory cache handles all caching needs for single-process deployment

• structlog JSON logging with configurable log level
• Prometheus metrics: blockberg_request_count, blockberg_request_latency, blockberg_cache_hits, blockberg_cache_misses, blockberg_app_info
• Path normalization prevents unbounded Prometheus label cardinality

• Backend: Pydantic v2 validation on all models, mypy strict mode
• Frontend: TypeScript strict, typed API client, TanStack Query with generic types

Abstract base classes (PriceProvider, DevActivityProvider, SentimentProvider, HolderProvider, RPCProvider) enable swapping data sources without changing business logic. CoinGecko can be replaced by Flare FTSO via feature flag.