Ik heb RPC-Hell Voorgoed Vaarwel Gezegd: Je Complete Genesis-tot-Tip Parquet-Handboek voor Bliksemsnelle…

Ik heb afscheid genomen van RPC-hel voor altijd: jouw complete Genesis-to-Tip Parquet-handboek voor bliksemsnelle on-chain analyse

(Geen snelheidslimieten meer, geen maandelijkse rekeningen van $500 meer)

Hé, ik ben Mike Kuykendall — 20+ jaar als software-engineer, voormalig USAF Staff Sergeant, vader van twee kinderen, en nu de man achter Delta Zero Labs (@_MikeKuykendall op X).

Jarenlang leefde ik het RPC-leven. Wil je elke ERC20-transfer voor een whale-wallet sinds 2020? Start een script dat eth_getLogs loopt met 10.000-block bereiken, handel snelheidslimieten af, probeer opnieuw bij 429's, pagineer, ontdubbel, decodeer de ABI zelf, sla het ergens op… herhaal dit voor DEX-swaps, oracle-ticks, liquidaties.

Eén weekendproject veranderde in een Alchemy-rekening van $400/maand en een 14 TB archiefnode die mijn SSD opat. Ik zwoer dat er een betere manier moest zijn.

Die is er.

Ik heb productiekwaliteit, volledig gedecodeerde, genesis-to-tip Parquet-datasets gebouwd (en verkoop ze nu) voor Ethereum mainnet, BSC en Sepolia. Eén download. Eén bestand (of een schone gepartitioneerde set). Nul RPC's voor altijd. Bevraag 7,77 miljard BSC-events of 334 miljoen Sepolia-events in seconden op je laptop met DuckDB of Polars.

Dit is geen nieuwe indexer of subgraph. Dit is de data die je zelf zou hebben geëxtraheerd — maar al klaar, gedecodeerd, geclassificeerd op signal_type, gecomprimeerd en klaar om voor altijd te bezitten.

In dit bericht geef ik je de exacte stap-voor-stap handleiding die ik twee jaar geleden wilde hebben. Aan het einde weet je precies hoe:

• De gratis 10k-rij sample te pakken
• Het lokaal te laden
• Elke vraag te beantwoorden waarvoor je vroeger RPC's hamerde
• Op te schalen naar het volledige multi-miljard-rij beest

Laten we samen de RPC-belasting doden.

Waarom RPC's het laten afweten bij echt historisch werk

Snelle realiteitscheck (je weet dit al, maar laten we de pijn kwantificeren):

• eth_getLogs max bereik is meestal 10k–50k blocks bij betaalde providers.
• Volledige mainnet = ~22 miljoen blocks vandaag.
• Eén volledige scan van alle Transfer-events? Verwacht 200–500 API-aanroepen, uren wachten en verrassende rekeningen van $87.
• Wil je MEV-backtesting over 3 jaar Uniswap V3? Succes.
• Snelheidslimieten, archiefnode-kosten, data-drift wanneer providers schema's wijzigen… een nachtmerrie.

Ik werd het zat. Dus schreef ik een zero-RPC extractie-engine (patent-aangevraagd Fused Semantic Execution — FSE). Het leest ruwe chain-data eenmaal, decodeert elk event naar schone kolommen, taggt het met signal_type en dumpt het rechtstreeks naar Parquet.

Resultaat? Datasets zoals:

• Ethereum Mainnet (Chainlink oracles + WETH flows + volledige DEX core): ~358 miljoen signalen, genesis → tip, ~16 GB gecomprimeerd. Levenslange licentie $999 (25% korting voor de eerste 1.000 kopers).
• BSC (7,77 miljard gedecodeerde events — PancakeSwap, Aave, Chainlink, Wormhole, alles): genesis → block 82M+. Eenmalige aankoop in het $999–$9.999 bereik afhankelijk van subset.
• Sepolia volledig archief (334M+ events, elke categorie): enkel ~12,3 GB Parquet.

Alles geleverd als Parquet. Kolomgericht, waanzinnig gecomprimeerd (5–10× kleiner dan CSV), predicate pushdown klaar, werkt met elk modern data tool.

Wat zit er eigenlijk in de Parquet (het 19-kolommen schema waarop je kunt vertrouwen)

Elke rij is één gedecodeerd event. Hier zijn de kernkolommen die je elke dag zult gebruiken (volledige 19-kolommen specificatie is in de download docs):

• block_number (int64)
• block_hash (string)
• timestamp (int64 — Unix-seconden)
• tx_hash (string)
• tx_index (int32)
• from_address (string)
• to_address (string)
• contract_address (string — het token- of protocolcontract)
• signal_type (string — bijv. ERC20_Transfer, UniswapV3_Swap, Chainlink_PriceUpdate, AaveV3_Liquidation, WETH_Deposit, DAO_Vote, enz.)
• value / amount / amount0 / amount1 (decimaal of int256 genormaliseerd)
• price (voor oracles)
• log_index, topic0–topic3, ruwe datavelden voor powerusers
• Plus gedecodeerde params specifiek voor elk signal_type (pooladres, tick, sqrtPriceX96, enz. voor DEX-swaps)

Eén rij = één kristalhelder, analyse-klaar record. Nooit meer ABI-decodering in je code.

Stap-voor-stap: van nul naar het bevragen van 300M+ rijen in minder dan 5 minuten

Stap 1: pak de gratis sample (geen e-mail, geen aanmelding)

Ga naar de officiële sample:

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

Of Kaggle-mirror: https://www.kaggle.com/datasets/mikekuykendall/ethereum-onchain-signals

Download het Parquet-bestand (~5–10 MB, 10.000 gestratificeerde rijen die elk signal_type dekken).

Stap 2: installeer de tools (duurt 60 seconden)

Ik raad DuckDB aan — het is magisch hiervoor.

pip install duckdb pandas pyarrow
# of gewoon brew install duckdb op Mac

Stap 3: laden en verkennen (kopieer-plak deze)

Open een Jupyter-notebook of gewoon de DuckDB-CLI.

Python + Pandas (voor kleine verkenning)

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 (hier gebeurt de magie — nul geheugen voor enorme bestanden)

-- Start DuckDB
duckdb

-- Koppel de sample
SELECT * FROM read_parquet('ethereum_signals_sample.parquet') LIMIT 10;

Stap 4: echte vragen die je direct kunt beantwoorden

"Hoeveel ERC20-transfers heeft dit adres gedaan?"

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 tokens op basis van transferaantal in 2024"

SQL

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

"Alle Uniswap V3-swaps voor een specifieke pool, met prijsimpact"

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;

"Chainlink-prijsticks voor ETH/USD in de loop van de tijd" (perfect voor 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;

Pro tip: DuckDB kan ook gepartitioneerde mappen lezen:

SQL

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

Het gebruikt automatisch predicate pushdown — filteren op block_number of signal_type slaat 99% van de data op schijf over. Je bevraagt miljarden rijen sneller dan de meeste mensen Twitter kunnen scrollen.

Stap 5: naar de volledige dataset

1. Koop je licentie op https://deltazerolabs.dev (mainnet, BSC of Sepolia-bundels).
2. Directe downloadlink + levenslange herdownload-sleutel.
3. Uitpakken (indien nodig) → wijs je queries naar de Parquet(s).
4. Klaar. Nooit meer een maandelijkse rekening.

Opslagopmerking: de BSC volledige set is groot maar comprimeerbaar en draait prima op een 64 GB RAM-machine. Voor grotere workflows draai je gewoon een goedkope Hetzner-box met 128 GB RAM en DuckDB verslaat nog steeds cloud-warehouses op kosten.

Echte successen die mijn kopers behalen

• MEV-zoekers die routing-logica backtesten over 4 jaar DEX-data in <2 minuten.
• Compliance-teams die elke NFT-transfer voor een collectie traceren zonder snelheidsbeperkte Etherscan.
• Quant-fondsen die wallet-gezondheidsscores bouwen vanuit volledige WETH-flow + liquidatiegeschiedenis.
• Onderzoekers die papers schrijven met reproduceerbare queries (deel gewoon de SQL + dataset-versie).

Eén koper vertelde me: "Ik heb mijn $1.200/maand RPC-abonnement geannuleerd op dezelfde dag dat de dataset aankwam."

Vergelijkingstabel (omdat je van deze houdt)

BenaderingKostenSnelheid voor 3 jaar geschiedenisOnderhoudeigendomRuwe RPC-loops$200–2000/maandUren–dagenConstantJe herbouwtSubgraphs/The GraphGratis–betaaldSnel maar onvolledigProvider-risicoNeeCryo zelf-extractieJouw tijd + nodeDagen om te extracterenLopendJaDelta Zero ParquetEenmalig $999+SecondenNulVoor altijd

Klaar om je RPC-rekening te doden?

1. Download de gratis sample nu: https://huggingface.co/datasets/MikeKuykendall/ethereum-signals-sample
2. Voer de bovenstaande queries uit. Voel de snelheid.
3. Als je klaar bent voor het volledige genesis-to-tip beest (mainnet, BSC of Sepolia), ga naar https://deltazerolabs.dev/bsc en pak je levenslange licentie.

De eerste 1.000 kopers op mainnet/BSC krijgen 25% korting met code EARLY25 bij het afrekenen.

Vragen? DM me op X @_MikeKuykendall of word lid van het Telegram-kanaal dat op de site is gelinkt. Ik beantwoord elke vraag — dit is een door veteranen geleide solo-operatie en ik geef echt om jouw succes met de data.

Stop met huur betalen voor data die van jou zou moeten zijn.

Download de sample. Voer de queries uit. Roep dan nooit meer een eth_getLogs aan.

Tot ziens on-chain (offline).

— Mike Kuykendall Delta Zero Labs P.S. De volgende chain-drop komt binnenkort. Wil je vroege toegang + aangepaste signaaltypes? DM me.

I Ditched RPC Hell for Good: Your Complete Genesis-to-Tip Parquet Handbook for Lightning-Fast… was oorspronkelijk gepubliceerd in Coinmonks op Medium, waar mensen het gesprek voortzetten door dit verhaal te markeren en erop te reageren.