J'ai abandonné l'enfer RPC pour de bon : Votre guide complet Parquet du Genesis au Tip pour une rapidité fulgurante…

J'ai abandonné l'enfer des RPC pour de bon : Votre guide complet Genesis-to-Tip Parquet pour une analyse on-chain ultra-rapide

(Fini les limites de taux, fini les factures mensuelles de 500 $)

Salut, je suis Mike Kuykendall — plus de 20 ans en tant qu'ingénieur logiciel, ancien sergent d'état-major de l'USAF, père de deux enfants, et maintenant le gars derrière Delta Zero Labs (@_MikeKuykendall sur X).

Pendant des années, j'ai vécu la vie RPC. Vous voulez tous les transferts ERC20 pour un portefeuille de baleine depuis 2020 ? Lancez un script qui boucle eth_getLogs avec des plages de 10 000 blocs, gérez les limites de taux, réessayez sur les 429, paginez, dédupliquez, décodez l'ABI vous-même, stockez-le quelque part… rincez et répétez pour les swaps DEX, les ticks d'oracle, les liquidations.

Un projet de week-end s'est transformé en une facture Alchemy de 400 $/mois et un nœud d'archive de 14 To dévorant mon SSD. Je me suis juré qu'il devait y avoir une meilleure solution.

Il y en a une.

J'ai construit (et je vends maintenant) des ensembles de données Parquet de qualité production, entièrement décodés, de genesis à tip pour Ethereum mainnet, BSC et Sepolia. Un téléchargement. Un fichier (ou un ensemble partitionné propre). Zéro RPC pour toujours. Interrogez 7,77 milliards d'événements BSC ou 334 millions d'événements Sepolia en quelques secondes sur votre ordinateur portable avec DuckDB ou Polars.

Ce n'est pas un autre indexeur ou subgraph. Ce sont les données que vous auriez extraites vous-même — mais déjà faites, décodées, classées par signal_type, compressées et prêtes à posséder pour toujours.

Dans cet article, je vous donne le guide détaillé exact que j'aurais aimé avoir il y a deux ans. À la fin, vous saurez précisément comment :

• Récupérer l'échantillon gratuit de 10 000 lignes
• Le charger localement
• Répondre à toutes les questions pour lesquelles vous aviez l'habitude de marteler les RPC
• Passer à la bête complète de plusieurs milliards de lignes

Tuons ensemble la taxe RPC.

Pourquoi les RPC échouent pour le travail historique réel

Vérification rapide de la réalité (vous le savez déjà, mais quantifions la douleur) :

• La plage maximale d'eth_getLogs est généralement de 10 000 à 50 000 blocs sur les fournisseurs payants.
• Mainnet complet = environ 22 millions de blocs aujourd'hui.
• Un scan complet de tous les événements de transfert ? Attendez-vous à 200 à 500 appels API, des heures d'attente et des factures surprises de 87 $.
• Vous voulez du backtesting MEV sur 3 ans d'Uniswap V3 ? Bonne chance.
• Limites de taux, coûts des nœuds d'archive, dérive des données lorsque les fournisseurs changent de schémas… cauchemar.

J'en ai eu assez. J'ai donc écrit un moteur d'extraction zéro-RPC (Fused Semantic Execution en instance de brevet — FSE). Il lit les données brutes de la chaîne une fois, décode chaque événement en colonnes propres, le marque avec signal_type et le déverse directement dans Parquet.

Résultat ? Des ensembles de données comme :

• Ethereum Mainnet (oracles Chainlink + flux WETH + cœur DEX complet) : environ 358 millions de signaux, genesis → tip, environ 16 Go compressés. Licence à vie 999 $ (25 % de réduction pour les 1 000 premiers acheteurs).
• BSC (7,77 milliards d'événements décodés — PancakeSwap, Aave, Chainlink, Wormhole, tout) : genesis → bloc 82M+. Achat unique dans la fourchette de 999 $ à 9 999 $ selon le sous-ensemble.
• Archive complète Sepolia (334M+ événements, toutes catégories) : Parquet unique d'environ 12,3 Go.

Tout livré en Parquet. Colonnaire, incroyablement compressé (5 à 10 fois plus petit que le CSV), prêt pour le pushdown de prédicats, fonctionne avec tous les outils de données modernes.

Ce qui se trouve réellement dans le Parquet (Le schéma de 19 colonnes sur lequel vous pouvez compter)

Chaque ligne est un événement décodé. Voici les colonnes principales que vous utiliserez tous les jours (la spécification complète de 19 colonnes se trouve dans la documentation de téléchargement) :

• block_number (int64)
• block_hash (string)
• timestamp (int64 — secondes Unix)
• tx_hash (string)
• tx_index (int32)
• from_address (string)
• to_address (string)
• contract_address (string — le contrat de token ou de protocole)
• signal_type (string — par exemple ERC20_Transfer, UniswapV3_Swap, Chainlink_PriceUpdate, AaveV3_Liquidation, WETH_Deposit, DAO_Vote, etc.)
• value / amount / amount0 / amount1 (décimal ou int256 normalisé)
• price (pour les oracles)
• log_index, topic0–topic3, champs de données brutes pour les utilisateurs expérimentés
• Plus les paramètres décodés spécifiques à chaque signal_type (adresse de pool, tick, sqrtPriceX96, etc. pour les swaps DEX)

Une ligne = un enregistrement cristallin, prêt pour l'analyse. Plus jamais de décodage ABI dans votre code.

Étape par étape : De zéro à l'interrogation de plus de 300 millions de lignes en moins de 5 minutes

Étape 1 : Récupérez l'échantillon gratuit (pas d'e-mail, pas d'inscription)

Allez sur l'échantillon officiel :

https://huggingface.co/datasets/MikeKuykendall/ethereum-signals-sample

Ou miroir Kaggle : https://www.kaggle.com/datasets/mikekuykendall/ethereum-onchain-signals

Téléchargez le fichier Parquet (environ 5 à 10 Mo, 10 000 lignes stratifiées couvrant chaque signal_type).

Étape 2 : Installez les outils (prend 60 secondes)

Je recommande DuckDB — c'est magique pour cela.

pip install duckdb pandas pyarrow
# ou simplement brew install duckdb sur Mac

Étape 3 : Chargez et explorez (copiez-collez ceux-ci)

Ouvrez un notebook Jupyter ou simplement le CLI DuckDB.

Python + Pandas (pour une petite exploration)

import pandas as pd

df = pd.read_parquet("ethereum_signals_sample.parquet")
print(df.shape) # (10000, 19)
print(df['signal_type'].value_counts())
print(df.head())

DuckDB SQL (c'est là que la magie opère — zéro mémoire pour les énormes fichiers)

-- Lancez DuckDB
duckdb

-- Attachez l'échantillon
SELECT * FROM read_parquet('ethereum_signals_sample.parquet') LIMIT 10;

Étape 4 : Questions réelles auxquelles vous pouvez répondre instantanément

"Combien de transferts ERC20 cette adresse a-t-elle effectués ?"

SQL

SELECT COUNT(*) as transfers,
SUM(amount) as total_volume
FROM read_parquet('your_full_dataset.parquet')
WHERE from_address = '0x1234...'
OR to_address = '0x1234...'
AND signal_type = 'ERC20_Transfer';

"Top 10 des tokens par nombre de transferts en 2024"

SQL

SELECT contract_address,
COUNT(*) as tx_count
FROM read_parquet('your_full_dataset.parquet')
WHERE signal_type = 'ERC20_Transfer'
AND timestamp >= 1704067200 -- 1er janvier 2024
AND timestamp < 1735689600 -- 1er janvier 2025
GROUP BY contract_address
ORDER BY tx_count DESC
LIMIT 10;

"Tous les swaps Uniswap V3 pour un pool spécifique, avec impact sur le prix"

SQL

SELECT timestamp,
amount0,
amount1,
sqrtPriceX96,
(amount1::double / NULLIF(amount0,0)) as price_impact
FROM read_parquet('full_dataset.parquet')
WHERE signal_type = 'UniswapV3_Swap'
AND contract_address = '0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640' -- USDC/ETH 0.05%
ORDER BY block_number DESC
LIMIT 1000;

"Ticks de prix Chainlink pour ETH/USD au fil du temps" (parfait pour le backtesting)

SQL

SELECT
date_trunc('day', to_timestamp(timestamp)) as day,
AVG(price) as avg_eth_price
FROM read_parquet('full_dataset.parquet')
WHERE signal_type = 'Chainlink_PriceUpdate'
AND contract_address = '0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419' -- ETH/USD
GROUP BY day
ORDER BY day;

Conseil de pro : DuckDB peut également lire des dossiers partitionnés :

SQL

SELECT COUNT(*) FROM read_parquet('mainnet_parquets/*.parquet');

Il utilise automatiquement le pushdown de prédicats — le filtrage sur block_number ou signal_type ignore 99 % des données sur le disque. Vous interrogerez des milliards de lignes plus rapidement que la plupart des gens ne peuvent faire défiler Twitter.

Étape 5 : Passer à l'ensemble de données complet

1. Achetez votre licence sur https://deltazerolabs.dev (bundles mainnet, BSC ou Sepolia).
2. Lien de téléchargement instantané + clé de re-téléchargement à vie.
3. Décompressez (si nécessaire) → pointez vos requêtes vers le(s) Parquet(s).
4. Terminé. Plus jamais de facture mensuelle.

Note de stockage : L'ensemble complet BSC est volumineux mais compressible et fonctionne bien sur une machine de 64 Go de RAM. Pour des flux de travail plus importants, lancez simplement une box Hetzner bon marché avec 128 Go de RAM et DuckDB surpasse toujours les entrepôts cloud en termes de coût.

Victoires concrètes que mes acheteurs obtiennent

• Chercheurs MEV effectuant des backtests de logique de routage sur 4 ans de données DEX en moins de 2 minutes.
• Équipes de conformité traçant chaque transfert NFT pour une collection sans Etherscan limité en taux.
• Fonds quantitatifs construisant des scores de santé de portefeuille à partir du flux WETH complet + historique de liquidation.
• Chercheurs rédigeant des articles avec des requêtes reproductibles (partagez simplement le SQL + version de l'ensemble de données).

Un acheteur m'a dit : "J'ai annulé mon plan RPC de 1 200 $/mois le jour même où l'ensemble de données est arrivé."

Tableau comparatif (parce que vous adorez ça)

ApprochCoûtVitesse pour l'historique sur 3 ansMaintenancePropriétéBoucles RPC brutes200 $ à 2 000 $/moisHeures–joursConstanteVous reconstruisezSubgraphs/The GraphGratuit–payantRapide mais incompletRisque fournisseurNonCryo auto-extractionVotre temps + nœudJours pour extraireContinu/OuiNonDelta Zero Parquet999 $+ uniqueSecondesZéroPour toujours

Prêt à tuer votre facture RPC ?

1. Téléchargez l'échantillon gratuit maintenant : https://huggingface.co/datasets/MikeKuykendall/ethereum-signals-sample
2. Exécutez les requêtes ci-dessus. Ressentez la vitesse.
3. Lorsque vous êtes prêt pour la bête complète genesis-to-tip (mainnet, BSC ou Sepolia), rendez-vous sur https://deltazerolabs.dev/bsc et obtenez votre licence à vie.

Les 1 000 premiers acheteurs sur mainnet/BSC bénéficient de 25 % de réduction avec le code EARLY25 lors du paiement.

Des questions ? Envoyez-moi un DM sur X @_MikeKuykendall ou rejoignez le canal Telegram lié sur le site. Je réponds à chacun — c'est une opération solo appartenant à un vétéran et je me soucie vraiment que vous gagniez avec les données.

Arrêtez de payer un loyer pour des données qui devraient être à vous.

Téléchargez l'échantillon. Exécutez les requêtes. Puis n'appelez plus jamais eth_getLogs.

On se voit on-chain (hors ligne).

— Mike Kuykendall Delta Zero Labs P.S. Le prochain drop de chaîne arrive bientôt. Vous voulez un accès anticipé + types de signaux personnalisés ? Envoyez-moi un DM.

I Ditched RPC Hell for Good: Your Complete Genesis-to-Tip Parquet Handbook for Lightning-Fast… a été initialement publié dans Coinmonks sur Medium, où les gens poursuivent la conversation en mettant en évidence et en répondant à cette histoire.