cryo + Chainstack: Developer's guide to blockchain data mastery with Python

ETH_RPC="https://ethereum-mainnet.core.chainstack.com/YOUR_CREDENTIALS"

import os
import cryo
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# Retrieve the Ethereum RPC URL from environment variables
eth_rpc = os.getenv("ETH_RPC")

# Collect blockchain data using the cryo library and return it as a pandas DataFrame
# Specifying blocks range and output format
data = cryo.collect(
    "blocks",
    blocks=["18734050:18735050"],
    rpc=eth_rpc,
    output_format="pandas",
    hex=True
)

# Displaying the column names of the DataFrame
print("Columns in the DataFrame:")
for column in data.columns:
    print(column)

# Print the entire DataFrame
print(data)

Columns in the DataFrame:
block_hash
author
block_number
gas_used
extra_data
timestamp
base_fee_per_gas
chain_id
                                            block_hash                                      author  ...  base_fee_per_gas  chain_id
0    0xdf6d5d7526eb50e68278998b2cc7a519a4c3daddb14a...  0xcdbf58a9a9b54a2c43800c50c7192946de858321  ...       37583327088         1
1    0x2818389bb471ebe60a74fb1865574c0ac50f40daf575...  0xdafea492d9c6733ae3d56b7ed1adb60692c98bc5  ...       38781853745         1
2    0xd65229e3d67c28f71b978ae789df6ee58c27420f8a35...  0x1f9090aae28b8a3dceadf281b0f12828e676c326  ...       38448400269         1
3    0x218f26e524d889d20604ad01b91feec5c2285dc3e747...  0x4675c7e5baafbffbca748158becba61ef3b0a263  ...       38316617096         1
4    0xace296b1c263fee4f35d831086c93aa820577dcc1bea...  0x388c818ca8b9251b393131c08a736a67ccb19297  ...       37638298982         1
..                                                 ...                                         ...  ...               ...       ...
995  0xc59d9ad3444b0352c36f3ec7e3a3561bbc90d9118232...  0x690b9a9e9aa1c9db991c7721a92d351db4fac990  ...       71896254942         1
996  0xd611033a7769913ba0e8abdc8ae0ab0fee224435c512...  0x4838b106fce9647bdf1e7877bf73ce8b0bad5f97  ...       70283122265         1
997  0x2a4448fe72e37c169868e37ea4fce71789c31ecc9108...  0x95222290dd7278aa3ddd389cc1e1d165cc4bafe5  ...       73132855124         1
998  0x6ce066a304e334c6a98154b51f2a1b24edf749467424...  0x4838b106fce9647bdf1e7877bf73ce8b0bad5f97  ...       74400095143         1
999  0xbc293dc0e8d0a61f24256433f7faaf2a8e754a5557d9...  0x4838b106fce9647bdf1e7877bf73ce8b0bad5f97  ...       73090669589         1

[1000 rows x 8 columns]

cryo blocks --blocks 18734050:18735050 --rpc YOU_CHAINSTACK_NODE

data = cryo.collect(
    "blocks",
    blocks=["18734050:18735050"],
    rpc=eth_rpc,
    output_format="pandas",
    hex=True,
    requests_per_second=25
)

import os
from dotenv import load_dotenv
import cryo

# Load environment variables from the .env file
load_dotenv()

# Retrieve the Ethereum RPC URL from environment variables
eth_rpc = os.getenv("ETH_RPC")

# Fetch and save blocks data in JSON
data = cryo.freeze(
    "blocks",
    blocks=["18734050:18735050"],
    rpc=eth_rpc,
    output_dir="blocks_data/",
    file_format="json",
    hex=True,
    requests_per_second=500
)

import os
from dotenv import load_dotenv
import cryo

# Load environment variables
load_dotenv()

# Access Ethereum RPC URL from environment variables
eth_rpc = os.getenv("ETH_RPC")

# Fetch ERC-20 token balances for a specified address within a block range
data = cryo.freeze(
    "erc20_balances",
    blocks=["18.68M:18.69M"],
    contract=['0x4d224452801ACEd8B2F0aebE155379bb5D594381'],
    address=['0xF977814e90dA44bFA03b6295A0616a897441aceC'],
    rpc=eth_rpc,
    output_dir="blocks_data/",
    file_format="json",
    hex=True,
    requests_per_second=900
)

Schema for ERC-20 Balances
─────────────────────────
- block_number: uint32
- erc20: hex
- address: hex
- balance_binary: binary
- balance_string: string
- balance_f64: float64
- chain_id: uint64

import os
import time
import pandas as pd
import matplotlib.pyplot as plt
from dotenv import load_dotenv
from web3 import Web3
import cryo

# Constants
ETH_RPC_VAR = "ETH_RPC"
LOOKBACK_BLOCKS = 5000
TOP_AUTHORS_COUNT = 10

# Load environment variables
load_dotenv()

# Function to get the block range
def get_block_range(web3, lookback_blocks):
    latest_block = web3.eth.block_number
    start_block = max(0, latest_block - lookback_blocks)  # Avoid negative block numbers
    return f"{start_block}:{latest_block}"

# Function to fetch data from cryo
def fetch_block_data(block_range, eth_rpc):
    try:
        # Start timer for fetching blocks
        fetch_start_time = time.time()

        # Fetch the block data
        data = cryo.collect(
            "blocks", blocks=[block_range], rpc=eth_rpc, output_format="pandas", hex=True
        )

        # Calculate and print the time taken to fetch the blocks
        fetch_time = time.time() - fetch_start_time
        print(f"Time taken to fetch blocks: {fetch_time:.2f} seconds")
        return data
    except Exception as e:
        print(f"An error occurred while fetching block data: {e}")
        return pd.DataFrame()  # Return an empty DataFrame on error

# Function to plot the top authors
def plot_top_authors(data, num_entries):
    top_authors = data['author'].value_counts().head(TOP_AUTHORS_COUNT)
    plt.figure(figsize=(12, 6))
    top_authors.plot(kind='bar')
    plt.xticks(rotation=45, ha='right')
    plt.title(f'Top {TOP_AUTHORS_COUNT} Authors by number of blocks mined from past {num_entries} blocks', fontsize=14)
    plt.xlabel('Author', fontsize=14)
    plt.ylabel('Number of Blocks', fontsize=14)
    plt.tight_layout()
    plt.show()

# Main execution
def main():
    eth_rpc = os.getenv(ETH_RPC_VAR)
    if not eth_rpc:
        raise ValueError(f"Environment variable {ETH_RPC_VAR} not found")

    w3 = Web3(Web3.HTTPProvider(eth_rpc))
    if not w3.is_connected():
        print("Failed to connect to Ethereum node.")
        return

    block_range = get_block_range(w3, LOOKBACK_BLOCKS)
    print(f"Fetching blocks from {block_range} range.")

    data = fetch_block_data(block_range, eth_rpc)
    if not data.empty:
        num_entries = len(data)
        print(f"Number of blocks fetched: {num_entries}")
        plot_top_authors(data, num_entries)

if __name__ == "__main__":
    main()

Fetching blocks from 18874064:18879064 range.
Time taken to fetch blocks: 30.83 seconds
Number of blocks fetched: 5000

Top Authors by Number of Blocks Mined:
0x95222290dd7278aa3ddd389cc1e1d165cc4bafe5: 1417 blocks
0x1f9090aae28b8a3dceadf281b0f12828e676c326: 1385 blocks
0x4838b106fce9647bdf1e7877bf73ce8b0bad5f97: 443 blocks
0x388c818ca8b9251b393131c08a736a67ccb19297: 295 blocks
0xb9342d6a9789cc6479e48cfef67590c1bd05744e: 213 blocks
0x88c6c46ebf353a52bdbab708c23d0c81daa8134a: 183 blocks
0xdafea492d9c6733ae3d56b7ed1adb60692c98bc5: 175 blocks
0x0aa8ebb6ad5a8e499e550ae2c461197624c6e667: 89 blocks
0x4675c7e5baafbffbca748158becba61ef3b0a263: 55 blocks
0x690b9a9e9aa1c9db991c7721a92d351db4fac990: 52 blocks

import os
import time
from dotenv import load_dotenv
import cryo
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
from web3 import Web3

# Constants
ETH_RPC_VAR = "ETH_RPC"
LOOKBACK_BLOCKS = 7200 # Approx a day in the past
CONTRACT_ADDRESS = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2' # WETH
WALLET_ADDRESS = '0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852'   # WETH-USDT pool Uniswap V2

# Initialize environment variables and Web3
load_dotenv()
eth_rpc = os.getenv(ETH_RPC_VAR)
w3 = Web3(Web3.HTTPProvider(eth_rpc))

def check_eth_rpc_connection(eth_rpc):
    """Check connection to Ethereum RPC."""
    if not eth_rpc:
        raise ValueError(f"Environment variable {ETH_RPC_VAR} not found")
    if not w3.is_connected():
        raise ConnectionError("Failed to connect to Ethereum node.")

def get_block_range(lookback_blocks):
    """Determine the range of blocks to fetch."""
    latest_block = w3.eth.block_number
    start_block = max(0, latest_block - lookback_blocks)
    return f"{start_block}:{latest_block}"

def fetch_erc20_balances(block_range):
    """Fetch ERC-20 token balances within a given block range."""
    return cryo.collect(
        "erc20_balances",
        blocks=[block_range],
        contract=[CONTRACT_ADDRESS],
        address=[WALLET_ADDRESS],
        rpc=eth_rpc,
        output_format="pandas",
        hex=True,
        requests_per_second=900 # Adapt the RPS to your endpoint
    )

def convert_balance_to_ether(balance_str):
    """Convert balance from Wei to Ether, handling None values."""
    return None if balance_str is None else Web3.from_wei(int(balance_str), 'ether')

def plot_balance_change_over_time(data):
    """Plot the balance change over time on a chart."""
    plt.figure(figsize=(12, 6))
    plt.plot(data['block_number'], data['balance_ether'], marker='o')

    # Set axis labels and chart title with contract and address
    plt.xlabel("Block Number")
    plt.ylabel("Balance (Ether)")
    plt.title(f"ERC-20 Token Balance Change for {CONTRACT_ADDRESS}\nWallet {WALLET_ADDRESS}")

    # Manually set the x-axis ticks based on the block range
    block_numbers = data['block_number']
    tick_spacing = (block_numbers.max() - block_numbers.min()) // 10  # for example, 10 evenly spaced ticks
    ticks = range(int(block_numbers.min()), int(block_numbers.max()), int(tick_spacing))
    plt.xticks(ticks, [f"{tick:,.0f}" for tick in ticks])

    # Format the y-axis to show balances rounded to 4 decimal places
    plt.gca().yaxis.set_major_formatter(ticker.StrMethodFormatter('{x:,.4f}'))

    # Add grid, tighten layout, and display the plot
    plt.grid(True)
    plt.tight_layout()
    plt.show()

def main():
    """Main function to fetch and plot ERC-20 token balance changes."""
    check_eth_rpc_connection(eth_rpc)
    block_range = get_block_range(LOOKBACK_BLOCKS)

    # Start timing the data fetch
    start_time = time.time()

    # Fetch the data
    data = fetch_erc20_balances(block_range)

    # End timing the data fetch
    end_time = time.time()
    elapsed_time = end_time - start_time
    print(f"Data fetched in {elapsed_time:.2f} seconds.")

    if data.empty:
        print("No data available for plotting.")
        return

    # Prepare data for plotting
    data = data[['block_number', 'erc20', 'address', 'balance_string']]
    data['balance_ether'] = data['balance_string'].apply(convert_balance_to_ether)
    data = data[data['balance_ether'].notnull()]  # Filter out rows with None values

    # Print data summary to the console
    print("\nData summary:")
    print(f"Block rage: {block_range}")
    print(f"Start balance in Ether: {data.iloc[0]['balance_ether']}")
    print(f"End balance in Ether: {data.iloc[-1]['balance_ether']}")

    # Plot the balance changes over time
    plot_balance_change_over_time(data)

if __name__ == "__main__":
    main()

Data fetched in 16.51 seconds.

Data summary:
Block rage: 18872292:18879492
Start balance in Ether: 27034.167858289615425314
End balance in Ether: 27039.186876795597977365