Polymarket is one of the most data-intensive protocols in Web3. Every trade, position, fee, liquidity event, and oracle resolution across its entire prediction market ecosystem lives onchain on Polygon. Querying any of it meaningfully requires a serious blockchain indexer.

For years, Polymarket's data infrastructure relied on 8 independent subgraphs on The Graph, each written in AssemblyScript, each tracking a separate domain, all running since 2021. This post documents how all 8 were replaced with a single Envio HyperIndex indexer, syncing over 4,000,000,000 events in 6 days on Polygon Mainnet.

The indexer is fully open source: github.com/enviodev/polymarket-indexer

Envio HyperIndex: The Fastest Blockchain Indexer Available​

Envio is a real-time multichain blockchain indexing framework for EVM chains. Developers write event handlers in TypeScript and deploy a single indexer that covers multiple contracts, chains, and domains simultaneously.

HyperIndex is independently benchmarked as the fastest blockchain indexer available. In the Uniswap V2 Factory benchmark run by Sentio in May 2025, HyperIndex completed in 1 minute, 143x faster than The Graph and 15x faster than the nearest competitor. In the LBTC benchmark (April 2025), HyperIndex completed in 3 minutes versus 3 hours 9 minutes for The Graph.

This performance comes from HyperSync, Envio's proprietary data engine. Instead of querying RPC endpoints block by block, HyperSync fetches filtered event data in bulk directly from a purpose-built data lake, delivering up to 2,000x faster data access than standard RPC. Polygon is one of 70+ EVM chains supported with native HyperSync coverage.

See full list of HyperSync supported networks here: https://docs.envio.dev/docs/HyperSync/hypersync-supported-networks

For a full breakdown of how HyperIndex compares across all major blockchain indexers, see the complete benchmark comparison.

The Problem: 8 Subgraphs, One Protocol, 4 Years of Fragmentation​

Polymarket's indexing infrastructure grew organically alongside the protocol. By the time the architecture was fully established, 8 independent subgraphs were running in parallel on The Graph:

The core problem with this setup is shared contracts. A single ConditionalTokens event was being listened for and processed independently across 3 or 4 separate subgraphs. Every shared event meant redundant processing, redundant infrastructure, and fragmented data that required joining across multiple APIs at query time. Handlers were written in AssemblyScript, a stricter WebAssembly-compiled subset of TypeScript, adding tooling overhead and limiting what logic could run inside a handler.

The Solution: One HyperIndex Indexer on Polygon​

Handler Merging​

The defining architectural decision in this indexer is handler merging. Rather than running separate listeners per domain for the same contract event, a single handler fires and updates all relevant entities simultaneously.

A ConditionalTokens.PositionSplit event previously triggered separate processing across the open-interest, activity, and pnl subgraphs. In the unified HyperIndex indexer, one handler fires once and simultaneously updates open interest, records the split activity, and adjusts user PnL positions. The event is processed once. That's it.

The full handler structure:

src/
  handlers/
    ConditionalTokens.ts       # Open interest + activity + PnL (merged from 4 subgraphs)
    Exchange.ts                # Orderbook + PnL
    NegRiskAdapter.ts          # Open interest + activity + PnL
    FixedProductMarketMaker.ts # FPMM analytics + PnL + LP tracking
    FPMMFactory.ts             # Dynamic contract registration
    FeeModule.ts               # Fee refund tracking
    UmaSportsOracle.ts         # Sports oracle
    Wallet.ts                  # Wallet creation + USDC balances

Contracts Indexed​

The indexer covers the full surface area of Polymarket's onchain contracts on Polygon:

• Exchange + NegRiskExchange: OrderFilled, OrdersMatched, TokenRegistered
• ConditionalTokens: ConditionPreparation, ConditionResolution, PositionSplit, PositionsMerge, PayoutRedemption
• NegRiskAdapter: MarketPrepared, QuestionPrepared, PositionSplit, PositionsMerge, PayoutRedemption, PositionsConverted
• FPMMFactory: FixedProductMarketMakerCreation, with dynamic contract registration for all FPMM instances
• FixedProductMarketMaker (dynamic): FPMMBuy, FPMMSell, FPMMFundingAdded, FPMMFundingRemoved, Transfer
• FeeModule + NegRiskFeeModule: FeeRefunded
• UmaSportsOracle: GameCreated, GameSettled, MarketCreated, MarketResolved, and more
• USDC / RelayHub / SafeProxyFactory: Transfer, TransactionRelayed, ProxyCreation

Dynamic contract registration is handled through FPMMFactory. As new Fixed Product Market Maker instances are created onchain, the indexer registers them automatically without a redeployment.

Schema: 25+ Entity Types Across All Domains​

The schema covers every domain previously spread across 8 separate subgraphs, all queryable from a single GraphQL endpoint:

• Orderbook: OrderFilledEvent, OrdersMatchedEvent, Orderbook, OrdersMatchedGlobal, MarketData
• Open Interest: Condition, MarketOpenInterest, GlobalOpenInterest, NegRiskEvent
• Activity: Split, Merge, Redemption, NegRiskConversion, Position
• PnL: UserPosition, tracking amount, average price, realized PnL, and total bought per user per token
• FPMM: FixedProductMarketMaker, FpmmTransaction, FpmmFundingAddition, FpmmFundingRemoval, FpmmPoolMembership, Collateral
• Wallet: Wallet, GlobalUSDCBalance
• Fee Module: FeeRefunded
• Sports Oracle: Game, Market

Envio HyperIndex vs The Graph: Before and After​

The Results​

The indexer synced Polymarket's full onchain history on Polygon from block 3,764,531 to 100% sync in 6 days, processing over 4,000,000,000 events. The repo includes 29 tests covering all handler phases, including a HyperSync integration test.

Run it locally with pnpm dev and compare the data with data from Polymarket subgraphs.

Live deployment: https://envio.dev/app/moose-code/polymarket-indexer/7cad3ad

Why Teams Migrate to HyperIndex from The Graph​

Polymarket's setup before this migration is a pattern that shows up across the ecosystem: multiple subgraphs, shared contracts, AssemblyScript handlers, fragmented data. Here is what changes when teams move to HyperIndex:

Speed. HyperIndex is 143x faster than The Graph on independent benchmarks. For protocols with years of history like Polymarket, that directly translates to days versus months on historical sync.

TypeScript, not AssemblyScript. Handlers are standard TypeScript with generated types from both the schema and ABIs. Any npm package works. No WebAssembly compilation. No AssemblyScript-specific constraints.

One codebase. All domains, all contracts, all chains in a single indexer. One deployment to ship, one codebase to maintain, one endpoint to query.

Single source of truth. Cross-domain queries happen at the database level, not at the application layer. No joining across APIs at runtime.

Dynamic contract registration. Factory contracts that create new instances onchain register them automatically, without requiring a redeployment.

Envio offers white-glove migration support for teams moving from The Graph or any other indexer. The Polymarket indexer is an open-source reference for what a large-scale migration looks like end to end.

Frequently Asked Questions​

What is Polymarket? Polymarket is the world's largest decentralized prediction market, built on Polygon. Users trade outcome shares on real-world events using USDC. All positions, trades, and settlements are handled entirely onchain via smart contracts with no central custodian.

What is a blockchain indexer? A blockchain indexer is a system that listens to onchain events and organises them into a structured, queryable database. Developers use blockchain indexers to build fast backends for DeFi protocols, trading interfaces, analytics tools, and onchain AI agents without querying slow RPC endpoints directly.

What is the fastest blockchain indexer? Envio HyperIndex is independently benchmarked as the fastest blockchain indexer available. In the Uniswap V2 Factory benchmark run by Sentio in May 2025, HyperIndex completed in 1 minute, 143x faster than The Graph and 15x faster than the nearest competitor (Subsquid).

What is HyperIndex? HyperIndex is a multichain blockchain indexing framework for EVM chains built by Envio. Developers write event handlers in TypeScript and deploy a single indexer covering multiple contracts, chains, and domains. It uses HyperSync, Envio's proprietary data engine, for historical sync speeds not achievable through standard RPC polling.

What is HyperSync? HyperSync is Envio's high-performance data engine. Instead of querying RPC endpoints block by block, HyperSync fetches filtered event data in bulk from a purpose-built data lake, delivering up to 2,000x faster data access than traditional RPC. 70+ EVM chains have native HyperSync coverage, with any EVM chain accessible via standard RPC.

How do I index Polymarket data? The fastest way to index Polymarket data on Polygon is with Envio HyperIndex and HyperSync. The full open-source reference implementation is available at github.com/enviodev/polymarket-indexer. It covers all 8 domains of Polymarket's onchain activity and syncs the full history in 6 days.

How long does it take to index Polymarket's full history on Polygon? Using Envio HyperIndex with HyperSync, the full historical sync of Polymarket's onchain data on Polygon, over 4,000,000,000 events from block 3,764,531, completed in 6 days.

How do I migrate from The Graph to HyperIndex? Because HyperIndex handlers are written in TypeScript, and AssemblyScript is a subset of TypeScript, most handler logic can be carried across directly. Envio also provides a full migration guide, a CLI validation tool to compare output between both endpoints, and white-glove migration support. The Polymarket indexer is a concrete open-source reference for a large-scale migration from The Graph.

Does HyperIndex support dynamic contract registration? Yes. New contract instances created onchain, like Polymarket's FPMM pools, are registered dynamically by a factory handler without requiring a redeployment.

What chains does Envio support? Envio supports any EVM chain. 70+ EVM chains have native HyperSync coverage for maximum speed, including Polygon, Ethereum, Base, Arbitrum, Optimism, and more. Any EVM chain without native HyperSync support can be indexed via standard RPC.

Get Started​

The Polymarket indexer is fully open source and available as a production reference for anyone building on Polygon or migrating from The Graph.

• Repo: https://github.com/enviodev/polymarket-indexer
• Live deployment: https://envio.dev/app/moose-code/polymarket-indexer/7cad3ad
• Envio docs: https://docs.envio.dev/
• Discord: https://discord.gg/envio
• Telegram: https://t.me/+kAIGElzPjApiMjI0
• Follow us on X: https://x.com/envio_indexer

Build With Envio​

Envio HyperIndex is independently benchmarked as the fastest EVM blockchain indexer available. The Polymarket indexer is one example of what's possible. If you're building onchain, check out the docs, run the benchmarks yourself, or talk to us about your data needs.

Subscribe to our newsletter

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

Co-authors: Jords & Nikhil
Head of Marketing & Operations & Growth Engineer at Envio

Built by Jonjon, Co-Founder at Envio.

Since the rise of prediction markets like Polymarket and Kalshi, many people have been tracking activity on them to get a sense of where the money is going. If we try to track every trade on these prediction markets, you will see many people betting like $10 here, $15 there. If you want a stronger signal, then you should track trades with higher amounts, since those traders have more conviction in the outcome they are betting on.

In this article, we are going to build a tool with HyperSync where you can track Polymarket trades above a certain amount. We also have one feature where you can track trades from certain addresses. If you know some addresses from good traders, you can follow them too.

Prerequisites​

We are going to use Bun for this article, so make sure you have it installed. If not, please check the Bun documentation for installation instructions. If you want to use some other runtime that supports TypeScript, you can do that too.

You will also need an Envio API token to access HyperSync. If you don’t have it already, go to https://envio.dev/app/api-tokens and you can find your token there.

Here are step-by-step instructions for creating new API tokens: https://docs.envio.dev/docs/HyperSync/api-tokens#generating-api-tokens

What is HyperSync​

HyperSync is Envio's high-performance blockchain data retrieval layer, built as an alternative to traditional JSON-RPC endpoints. It gives developers direct access to onchain data up to 2000x faster than standard RPC methods.

For this article, we are using HyperSync to stream real-time block heights and query Polymarket trade events on Polygon as they happen. Client libraries are available for Python, Rust, Node.js, and Go. HyperSync supports 70+ EVM chains, so the same approach works across any supported network.

OrderFilled Event​

Before we start writing the script, let’s talk about the OrderFilled event. This event is emitted when a trade has been filled, so these are confirmed trades where a user is buying or selling shares. Here is the event:

    event OrderFilled(
        bytes32 indexed orderHash,
        address indexed maker,
        address indexed taker,
        uint256 makerAssetId,
        uint256 takerAssetId,
        uint256 makerAmountFilled,
        uint256 takerAmountFilled,
        uint256 fee
    );

Most of the fields are self-explanatory, but we still haven’t answered one question: if this event is emitted for all orders, then how do we know which one is buy vs sell? If the value of makerAssetId is 0, then that is a buy order where the user is buying shares, and vice versa.

To calculate price per share for a buy trade, we can use makerAmountFilled and takerAmountFilled.

Price per share in a buy trade = makerAmountFilled / takerAmountFilled

To calculate per-share price in a sell trade, we just switch those values. Now that we have a basic understanding of what data to fetch and what that data tells us, we can start writing our script with Bun.

Using HyperSync Client​

To create a Bun project and install the HyperSync client along with Viem for decoding events, you can use the following commands:

mkdir track-trades && cd track-trades
bun init -y
bun add @envio-dev/hypersync-client viem

If you’re new to HyperSync clients, please start by going through these examples: https://docs.envio.dev/docs/HyperSync/hypersync-clients.

Let’s discuss how we are going to structure our script. Instead of streaming events directly, we are going to stream height. When we get a new height, we query HyperSync to fetch the data we need. Here is a visual representation of that:

Stream Height​

We already have a height-streaming example in the HyperSync Node client, and we are going to use that here. Open index.ts and paste the following snippet, then we can go over it.

import {
  HypersyncClient,
  type Query, // for later use
  type QueryResponseData, // for later use
} from "@envio-dev/hypersync-client";
import { decodeEventLog } from "viem"; // for later use

async function main() {
  // Create hypersync client using the mainnet hypersync endpoint
  const client = new HypersyncClient({
    url: "https://polygon.hypersync.xyz",
    apiToken: process.env.ENVIO_API_TOKEN!,
  });

  // Create a height stream to monitor blockchain height changes
  const heightStream = await client.streamHeight();

  console.log("Height stream created. Listening for height updates...");

  // Track the last known height to detect changes

  try {
    while (true) {
      // Receive the next event from the height stream
      const event = await heightStream.recv();

      if (event === null) {
        console.log("Height stream ended by server");
        break;
      }

      // Handle different types of events
      switch (event.type) {
        case "Height":
          await fetchOrderFilledEvents(client, event.height); // will be explained later
          break;

        case "Connected":
          console.log(`Connected to height stream`);
          break;

        case "Reconnecting":
          console.log(
            `Reconnecting to height stream in ${event.delayMillis}ms due to error: ${event.errorMsg}`,
          );
          break;

        default:
          // Tells the typescript compiler that we have covered all possible event types
          const _exhaustiveCheck: never = event;
          throw new Error("Unhandled event type");
      }
    }
  } catch (error) {
    console.error("Error in height stream:", error);
  } finally {
    // Always close the stream to clean up resources
    await heightStream.close();
    console.log("Height stream closed");
  }
}

main().catch(console.error);

The first thing we are doing in main is creating the HyperSync client with url and apiToken (which should be stored in a .env file, so create one and store your Envio API token there).

We have a streamHeight function on the client that emits 3 types of events: Height, Connected, and Reconnecting. When we get a new Height event with the latest block number, we call fetchOrderFilledEvents, where our parsing logic will live.

After creating the stream with streamHeight, we need to listen to those events, so we created a while loop that checks data from .recv() and a switch statement to act on the event type we get. The rest is mostly boilerplate error handling, so we don’t need to go too deep into that.

Now we have our streaming logic, so we can move to fetchOrderFilledEvents, which will handle the event parsing.

fetchOrderFilledEvents Function​

This function will take the height we got from streamHeight and query blocks to get the events we want. Let’s start with a few basic things we need for fetching and decoding the data:

• Contract addresses
• ABI of the event
• Event signature hash (aka Topic0)

Here they are, so add them somewhere at the top of the file.

export const EXCHANGE_ADDRESSES = [
  "0x4bfb41d5b3570defd03c39a9a4d8de6bd8b8982e",
  "0xc5d563a36ae78145c45a50134d48a1215220f80a",
].map((a) => a.toLowerCase());

const ORDER_FILLED_TOPIC =
  "0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6".toLowerCase();

const ORDER_FILLED_ABI = {
  anonymous: false,
  inputs: [
    {
      indexed: true,
      internalType: "bytes32",
      name: "orderHash",
      type: "bytes32",
    },
    {
      indexed: true,
      internalType: "address",
      name: "maker",
      type: "address",
    },
    {
      indexed: true,
      internalType: "address",
      name: "taker",
      type: "address",
    },
    {
      indexed: false,
      internalType: "uint256",
      name: "makerAssetId",
      type: "uint256",
    },
    {
      indexed: false,
      internalType: "uint256",
      name: "takerAssetId",
      type: "uint256",
    },
    {
      indexed: false,
      internalType: "uint256",
      name: "makerAmountFilled",
      type: "uint256",
    },
    {
      indexed: false,
      internalType: "uint256",
      name: "takerAmountFilled",
      type: "uint256",
    },
    {
      indexed: false,
      internalType: "uint256",
      name: "fee",
      type: "uint256",
    },
  ],
  name: "OrderFilled",
  type: "event",
} as const;

const ORDER_FILLED_ABI_ITEMS = [ORDER_FILLED_ABI] as const; // we can push it to query directly as an array

Let's define the function signature. We are going to pass the HyperSync client and block height to this function.

async function fetchOrderFilledEvents(client: HypersyncClient, height: number);

To fetch the data from HyperSync, we need to create a query. If you're not familiar with HyperSync queries, the query builder at https://builder.hypersync.xyz/ is a good starting point. In short, in this query we define which event from which contracts we want to fetch, and what fields we want in the response.

const query: Query = {
  fromBlock: height,
  logs: [
    {
      address: EXCHANGE_ADDRESSES,
      topics: [[ORDER_FILLED_TOPIC], [], [], []],
    },
  ],
  fieldSelection: {
    log: [
      "Data",
      "Address",
      "Topic0",
      "Topic1",
      "Topic2",
      "Topic3",
      "TransactionHash",
      "BlockNumber",
    ],
  },
};

Use the get function to fetch the data and store the logs/events in an array that we can loop over.

const res = await client.get(query);
const logs = (res.data as QueryResponseData).logs ?? [];

Let’s loop over that array and use decodeEventLog from Viem to decode the data so we can analyze it.

for (const log of logs) {
  const decoded = decodeEventLog({
    abi: ORDER_FILLED_ABI_ITEMS,
    data: log.data as `0x${string}`,
    topics: log.topics as [`0x${string}`, ...`0x${string}`[]],
  });

  if (decoded.eventName !== "OrderFilled") {
    continue;
  }

  const { makerAssetId, makerAmountFilled, takerAmountFilled, maker, taker } =
    decoded.args as {
      makerAssetId: bigint;
      makerAmountFilled: bigint;
      takerAmountFilled: bigint;
      maker: string;
      taker: string;
    };

  // TODO: Check if trade is Buy if yes, then log details along with price per share
}

The last part of this script is checking if the trade is a buy trade, which we can confirm when makerAssetId is 0. We also need to calculate price per share. We already know the formula: makerAmountFilled / takerAmountFilled. That value should be formatted to 6 decimals, and then we have the price per share.

function formatRatio(
  numerator: bigint,
  denominator: bigint,
  precision = 6,
): string {
  if (denominator === 0n) {
    return "0";
  }

  const scale = 10n ** BigInt(precision);
  const scaled = (numerator * scale) / denominator;
  const whole = scaled / scale;
  const fraction = (scaled % scale).toString().padStart(precision, "0");
  return `${whole}.${fraction}`;
}

fetchOrderFilledEvents should look like this at the end.

async function fetchOrderFilledEvents(client: HypersyncClient, height: number) {
  // Topic0: 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6

  const query: Query = {
    fromBlock: height,
    logs: [
      {
        address: EXCHANGE_ADDRESSES,
        topics: [[ORDER_FILLED_TOPIC], [], [], []],
      },
    ],
    fieldSelection: {
      log: [
        "Data",
        "Address",
        "Topic0",
        "Topic1",
        "Topic2",
        "Topic3",
        "TransactionHash",
        "BlockNumber",
      ],
    },
  };

  const res = await client.get(query);
  const logs = (res.data as QueryResponseData).logs ?? [];

  for (const log of logs) {
    const decoded = decodeEventLog({
      abi: ORDER_FILLED_ABI_ITEMS,
      data: log.data as `0x${string}`,
      topics: log.topics as [`0x${string}`, ...`0x${string}`[]],
    });

    if (decoded.eventName !== "OrderFilled") {
      continue;
    }

    const { makerAssetId, makerAmountFilled, takerAmountFilled, maker, taker } =
      decoded.args as {
        makerAssetId: bigint;
        makerAmountFilled: bigint;
        takerAmountFilled: bigint;
        maker: string;
        taker: string;
      };

    // TODO: Check if trade is Buy if yes, then log details along with price per share
    if (makerAssetId === 0n) {
      const pricePerShare = formatRatio(makerAmountFilled, takerAmountFilled);
      console.log(
        `[BUY] block=${log.blockNumber} tx=${log.transactionHash} maker=${maker} taker=${taker} pricePerShare=${pricePerShare}`,
      );
    }
  }
}

Complete Project​

You can check the project code in this repo: https://github.com/enviodev/track-poly-trades

Next Steps​

Our aim was to create a tracker that filters trades based on amount and addresses, but we haven’t completed that aim yet. This article gave you the main steps you need to create that tool, so your next step is to add filtering for amount and addresses.

Don’t forget to share it with us on socials or in our Discord. Looking forward to seeing what you build on top of this.

Poly-Whales TUI​

Don’t want to set up the full project but still want to try it out? You can use the Poly-Whales TUI.

Run the following command in your terminal:

pnpx poly-whales

Build With Envio​

Envio is a multi-chain EVM blockchain indexer for querying real-time and historical data. If you’re working on a Web3 project and want a smoother development process, Envio’s got your back(end). Check out our docs, join the community, and let’s talk about your data needs.

Stay tuned for more monthly updates by subscribing to our newsletter, following us on X, or hopping into our Discord for more up-to-date information.

Subscribe to our newsletter 💌

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

—

Author: Nikhil
Growth Engineer at Envio

March saw continued progress across HyperIndex, tooling, and the wider Envio ecosystem. We shipped multiple alpha releases focused on improving scale, flexibility, testing, and observability, alongside new workflows that make it easier to go from idea to production-ready indexers. This includes the latest v3.0.0-alpha.20 release, which introduces improved multiple data-sources support and primary source recovery logic. This month we also rebranded our Hosted Service to Envio Cloud. Alongside this, we introduced updates across subgraph hosting, agentic indexing workflows, and new ways to explore and interact with prediction market data. Across the ecosystem, we saw strong developer contributions, new projects being built with Envio, and continued momentum leading into upcoming events.

Let's dive in!

💻 Alpha Releases: Alpha.15 -> Alpha.20​

Loads of exciting progress landed across the latest alpha releases this month. This stretch focused on improving scale, flexibility, testing, and the overall developer experience across HyperIndex, with a mix of new features, internal improvements, and important updates to observability.

Alpha.20​

🔁 Improved Multiple Data-Sources Support​

With this change, we are introducing primary source recovery logic: after switching to a fallback source, HyperIndex attempts to recover to the primary source 60 seconds later. Previously, it would stay at the fallback source until the fallback source was down or the indexer was restarted.

Additionally, we improved the logic for choosing which data source to use next, enabling much better indexing resilience and reducing vendor lock-in to a single source, as well as stricter enforcement of the source usage configured for live mode.

Alpha.18​

⚡ Support indexers with 2.1B+ events per chain​

Scale indexers approaching int32 limits. Now you can build even larger, more performant indexers with HyperIndex.

🚨 Breaking: Official /metrics endpoint​

Existing Prometheus metrics just got a major upgrade.

We cleaned up metric names and measured data, switched time units to seconds instead of milliseconds, and started following Prometheus naming conventions more closely.

We also added metrics for data points previously covered by the --bench feature.

Starting with v3.0.0, Prometheus metrics are no longer experimental. The /metrics endpoint now follows semver and will be documented.

Alpha.15​

🔍 New getWhere operators: _gte, _lte, _in​

Three new filter operators have been added for getWhere queries, following Hasura-style conventions:

context.Entity.getWhere({ amount: { _gte: 100n } })
context.Entity.getWhere({ amount: { _lte: 500n } })
context.Entity.getWhere({ status: { _in: ["active", "pending"] } })

👨‍🚒 Support double handler registration​

Allows double handler registration for the same event with similar filters:

import { ERC20 } from "generated";

ERC20.Transfer.handler(async ({ event, context }) => {
  // Your logic here
});

ERC20.Transfer.handler(async ({ event, context }) => {
  // And here
});

🤖 Other improvements​

We consistently improve HyperIndex to make it easier to contribute to for both humans and AI. Recent work includes:

• Restructuring HyperIndex into a pnpm workspace
• Moving tests from mocha/chai to vitest
• Reworking the CI pipeline to run faster and reuse the production artifact for both testing and publishing
• Developing a highly customisable internal testing framework so AI can create reproduction tests for tricky edge cases

For more information and to stay up to date with all current and past releases, be sure to check out our release notes below.

👉 See full release notes
👉 Star us on GitHub ⭐

Hosted Service is now Envio Cloud​

We've renamed the Hosted Service to Envio Cloud. Same product, same infrastructure, no changes required on your end. For those new to it, Envio Cloud is a fully managed hosting solution for your indexers, taking care of all infrastructure, scaling, and monitoring so you can focus on building. Plans range from free dev environments through to enterprise-grade dedicated hosting, with static production endpoints, built-in alerts, and production-ready infrastructure across all tiers.

Learn more in our docs

Agentic blockchain indexing with Envio​

We explored what it looks like to go from prompt to production-ready indexers using Envio.

This walkthrough shows how to scaffold an indexer for any EVM-compatible chain, push it to GitHub, and deploy it to Envio's Cloud (previously Hosted Service) without manually touching a config file.

As an example, 400,000+ wstETH events were indexed on Monad in ~20 seconds.

Use the following command to scaffold your indexer:

pnpx envio@3.0.0-alpha.18 init template -t erc20 -l typescript -d ./my-indexer --api-token ""

Learn more in our blog and test it yourself here: https://docs.envio.dev/blog/agentic-blockchain-indexing-envio-hyperindex

Host your subgraphs on Envio​

Deploy and host your subgraphs with HyperIndex, with a fully subgraph-compatible GraphQL endpoint and no client changes required.

Migrate your existing subgraphs and keep the same API, with faster sync, quicker backfills, and deployments live in less than a day.

The process is handled end-to-end, converting your subgraph to HyperIndex and getting it up and running without needing to manage infrastructure.

Learn more here: https://envio.dev/pricing/subgraphs
Get started on Discord - open a support ticket: https://discord.com/invite/envio

Heatbook: Polymarket Orderbooks as Heatmaps​

An interface for visualising Polymarket orderbooks using historical heatmaps. Orderbook heatmaps for prediction markets, with 115M+ fills visualised. View any market and explore activity over time.

Supports Polymarket, Limitless, and more soon.

More here: https://heatbook.xyz/
See original post: https://x.com/jonjonclark/status/2031016707309949042?s=20

EthCC[9]: Sapphire Sponsor​

Envio is a Sapphire sponsor of EthCC[9], taking place at Palais des Festivals in Cannes from March 30 to April 2, 2026.

EthCC is an annual Ethereum community conference bringing together developers, researchers, and teams from across the ecosystem.

The team will be there across the week. Catch our talk on the Monroe stage and swing by our booth - let's chat about your data needs.

P.S. be sure to get your hands on one of our snazzy Envio caps and stickers.

Developer contributions: Uniswap CCA indexer​

Check out this Uniswap CCA indexer built with HyperIndex to index continuous clearing auction contracts across Ethereum, Base, Arbitrum, and Unichain. It tracks auctions, bids, ticks, steps, and checkpoints, using HyperSync for logs and selective RPC reads for derived onchain state.

Shoutout to @0xdivergence for sharing this and building with Envio.

Check it out on GitHub: https://github.com/dzmbs/uniswap-cca-indexer
Original post on X: https://x.com/0xdivergence/status/1769735600377133273

Open Indexer Benchmark​

We believe tech should speak for itself.

That's why we started working on and maintaining the Open Indexer Benchmark (originally forked from Sentio).

An honest, objective benchmark for blockchain indexers.

We're reopening it to benchmark new use cases and warmly welcome all contributions:
https://github.com/enviodev/open-indexer-benchmark

Wonderland CTF​

Envio is a proud sponsor of the Wonderland CTF. The event takes place on April 1, 2026, in person at EthCC[9] in Cannes.

Wonderland CTF is a capture-the-flag event featuring Solidity and Aztec Noir challenges, with tracks ranging from beginner to advanced and teams of 1 to 5 members.

Create your team and learn more here: https://ctf.wonderland.xyz

Polymarket Whale Tracker TUI​

We put together a simple whale tracker using HyperSync to track Polymarket whale activity in real time. It follows large traders on Polymarket and surfaces what they're doing as it happens, making it easier to monitor higher-conviction activity without sifting through smaller trades.

Clean, fast, and easy to plug into your workflows.

More here: https://github.com/enviodev/poly-whale-tracker

Run:

npx poly-whales

For a step-by-step guide on how to build your own, see: https://docs.envio.dev/blog/track-polymarket-trades-hypersync

Best blockchain indexers in 2026​

We put together a benchmark-driven comparison of blockchain indexers, looking at how different solutions perform in practice. The guide focuses on how indexers handle real workloads, comparing performance, sync speeds, and overall reliability across different approaches.

It's a practical breakdown of the trade-offs between tools and what to consider when choosing an indexer for your use case.

Learn and compare in our latest blog: https://docs.envio.dev/blog/best-blockchain-indexers-2026

🗓️ Current & Upcoming Events & Hackathons​

• EthCC - Cannes: March 30th -> April 2nd
• EthConf - New York: June 8th -> 10th

🧑‍💻 Featured Developer: Praveen Matheesha​

This month's featured developer is Praveen Matheesha, a developer focused on building advanced onchain analytics infrastructure. He is currently working on @paralensdotai, a next-generation blockchain analytics engine designed to extract economic behavior and strategy-level insights from raw blockchain transactions. His focus is on turning complex onchain data into meaningful signals for traders, researchers, and analysts, with a particular interest in transaction-level intelligence, MEV analysis, and understanding the economic intent behind smart contract interactions.

What Praveen had to say about Envio:

"Before discovering Envio, I was building my own EVM indexer from scratch in Rust. I implemented support for chain reorg handling, historical backfilling, batched RPC ingestion, and WebSocket streams for real-time updates. While it worked, a significant amount of time went into building and maintaining the infrastructure layer itself. When I discovered Envio and HyperSync, it immediately stood out as a much more efficient approach. It solves many of the challenges around reliable, high-performance blockchain data access that developers often end up rebuilding from scratch. If I had found it earlier, I likely could have saved weeks of work and focused more on the actual analytics and business logic rather than the ingestion pipeline. I also wrote a detailed article about building a production-ready EVM indexer in Rust, where I mentioned Envio as a great option for developers who want to avoid spending weeks building indexing infrastructure themselves. Overall, HyperSync makes it significantly easier to work with large volumes of on-chain data and allows developers to focus on building insights and applications instead of reinventing core data infrastructure."

Well done, Praveen. Be sure to follow the team on X and check out their GitHub to stay up to date with their latest developments.

🎧️ Playlist of the Month​

▶️ Open Spotify

Build with Envio​

Envio is a multi-chain EVM blockchain indexer for querying real-time and historical data. If you're working on a Web3 project and want a smoother development process, Envio's got your back(end). Check out our docs, join the community, and let's talk about your data needs.

Stay tuned for more monthly updates by subscribing to our newsletter, following us on X, or hopping into our Discord for more up-to-date information.

Subscribe to our newsletter 💌

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

Author: Jords
Head of Marketing & Operations

Agentic development works best when an AI agent can take a single prompt and run with it, end-to-end, without handing back to a human at every step. For blockchain indexing, that's exactly what we've built at Envio.

With the Envio Cloud CLI (envio-cloud) and HyperIndex, an agent can scaffold a production-ready indexer, configure it for any EVM-compatible chain, push it to GitHub, and deploy it to Envio Cloud, without a human ever touching a config file.

⚡ The result: 400,000 events indexed in ~20 seconds

What is HyperIndex?​

HyperIndex is Envio's high-performance blockchain indexing framework. It's designed to make indexing fast to build and even faster to run, with support for EVM-compatible networks and a developer experience built around real workflows.

HyperIndex is the default indexing framework for agentic development with the Envio Cloud CLI tool and comprehensive Claude skills. That means when an AI agent needs to spin up a blockchain data pipeline, HyperIndex is the go-to solution.

The Envio Cloud CLI: envio-cloud​

The envio-cloud CLI is the command-line interface for Envio Cloud, the managed infrastructure layer that runs your HyperIndex indexers in production.

With it you can:

• Authenticate via GitHub (envio-cloud login)
• Register a new indexer pointing to your GitHub repo (envio-cloud indexer add)
• Monitor sync progress and deployment status in real-time (envio-cloud deployment status, envio-cloud deployment metrics)
• Promote deployments to production (envio-cloud deployment promote)
• Pull JSON output for any command (-o json), making it fully scriptable and agent-friendly

⭐ No dashboard required. Everything that matters is exposed through the CLI.

End-to-End: Agentic deployment of a wstETH indexer on Monad​

Here's the full workflow an agent ran to deploy a live ERC20 indexer for wstETH on Monad Mainnet, start to finish.

Step 1: Scaffold the indexer​

pnpx envio@3.0.0-alpha.18 init template -t erc20 -l typescript -d ./my-indexer --api-token ""

The envio CLI scaffolds a TypeScript ERC20 indexer template. No API token is needed at this stage as authentication is handled through the hosted service at deployment time.

Step 2: Configure for Monad​

The agent edits config.yaml to target the wstETH contract on Monad Mainnet (chain ID 143, contract address 0x10Aeaf63194db8d453d4D85a06E5eFE1dd0b5417, start_block: 0).

Then runs codegen and a type check to confirm everything is clean:

pnpm codegen
pnpm tsc --noEmit

Note: the ERC20 template test file references a different contract address and network, so any resulting type errors need to be fixed before the type check passes.

Step 3: Push to GitHub​

Create a public repo and push:

gh repo create wsteth-monad-indexer-demo --public
git init && git add . && git commit -m "init"
git push -u origin main

If the push fails because your GitHub token lacks permission to push workflow files (like .github/workflows/test.yaml), refresh auth with workflow scope: gh auth refresh -s workflow

Envio Cloud deploys from the envio branch by default, so create and push it:

git checkout -b envio && git push -u origin envio

Step 4: Connect the Envio GitHub Bot​

The Envio GitHub App must have access to the repo before deployments will trigger. If the repo is not already linked, visit:

https://github.com/apps/envio-deployments/installations/select_target

Then grant the bot access to the wsteth-monad-indexer-demo repository.

Step 5: Deploy​

pnpx envio-cloud login
pnpx envio-cloud indexer add
  --name wsteth-monad-indexer-demo
  --repo wsteth-monad-indexer-demo
  --description "wstETH ERC20 indexer on Monad"
  --branch envio
  --skip-repo-check
  --yes

Step 6: Verify​

pnpx envio-cloud indexer get wsteth-monad-indexer-demo {org}
pnpx envio-cloud deployment status wsteth-monad-indexer-demo <commit-hash> {org}

Once synced, the indexer is viewable in the browser at https://envio.dev/app/{org}/{indexer-name}/{commit-hash}.

Check the live deployment from this demo here: https://envio.dev/app/denhampreen/wsteth-monad-indexer-demo/5d55d35

⚡400,000 events indexed. ~20 seconds

See the full walkthrough on Loom, covering the complete agent driven workflow from scaffold to deployment.

Why this matters for agentic development​

The blockchain data layer has historically been one of the friction points in agentic workflows. Spinning up an indexer meant reading docs, manually editing configs, managing infrastructure, and waiting for sync.

HyperIndex and the envio-cloud CLI change that equation. Every step in the workflow above is scriptable, CLI-driven, and designed to be executed by an agent without human intervention. The JSON output flag (-o json) makes it straightforward to pipe deployment status into downstream logic. The GitHub-native deployment flow means agents that can commit code can deploy indexers.

This is what it looks like in practice for HyperIndex to be the default indexing framework for agentic development.

Getting started​

Install the Envio Cloud CLI:

npm install -g envio-cloud

Scaffold your first indexer:

pnpx envio@3.0.0-alpha.18 init template -t erc20 -l typescript -d ./my-indexer --api-token ""

Whether you're building on Monad, Ethereum, or any other EVM compatible network, Envio enables agent driven indexing from first prompt to live deployment. The GitHub-native deployment flow means agents that can commit code can deploy indexers in minutes.

MCP loading.

About Envio Cloud​

Envio Cloud is a managed environment for running HyperIndex indexers in production.

It handles infrastructure, scaling, and monitoring, so indexers can run reliably without managing operational overhead. Multiple plans are available, from free development environments to dedicated production deployments, each with features such as static endpoints, built in alerts, and production ready infrastructure.

Build With Envio​

Envio is the fastest independently benchmarked EVM blockchain indexer for querying real-time and historical data. If you are building onchain and need indexing that keeps up with your chain, check out the docs, run the benchmarks yourself, and come talk to us about your data needs.

Stay tuned for more updates by subscribing to our newsletter, following us on X, or hopping into our Discord.

Subscribe to our newsletter 💌

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

Choosing a blockchain indexer should be straightforward, but most comparisons rely on self-reported metrics or product descriptions rather than independently benchmarked data and publicly verifiable sources.

This article takes a different approach. Every claim is backed by public documentation or third-party benchmarks, with clear notes where only self-reported data exists.

We cover seven blockchain indexers: Envio, The Graph (Subgraphs), Goldsky, SubQuery, Subsquid (SQD), Ormi and Ponder.

If you would like to review the raw benchmark data yourself, it is fully open: https://github.com/enviodev/open-indexer-benchmark

An open, honest, and objective benchmark for blockchain indexers across EVM, Solana, and more. It compares historical backfill speed, latency, data storage, developer experience, and anything else that matters.

We welcome anyone to contribute, run it, test it, and explore the results. We encourage you to share what you find.

What is a blockchain indexer?​

A blockchain indexer is a system that listens to blockchain events, organises raw onchain data (transactions, logs, state changes, and blocks) into structured, queryable formats, and exposes that data via APIs. Without an indexer, developers would need to query raw RPC endpoints for every piece of data, which is slow, expensive, and impractical at scale.

Custom indexing frameworks (the focus of this article) let you define exactly what data to track, write handlers that transform onchain events into your own data model, and query the results via a GraphQL or SQL API. This is different from pre-built data APIs like Dune Analytics or Covalent, which expose pre-indexed, read-only data that you query but cannot customise. Want a deeper breakdown? Check out our blog “What is a Blockchain Indexer”. Or watch our intro tutorial “How to set up a blockchain indexer” on YouTube.

TL;DR: Quick verdict​

How we evaluated​

Feature lists rarely tell the full story. We evaluated each indexer on six criteria that matter in production:

• Indexing speed: How fast can it sync historical data and stay at the chain head? We used the open benchmark results from Sentio (April 2025) as our primary reference, cross-checked against each indexer's own documentation.

• Feature completeness: Does it support event handlers, block handlers, wildcard indexing, and multichain from a single indexer? These are not nice-to-haves once you are building at scale.

• Developer experience: What language do you write handlers in? TypeScript is the standard. AssemblyScript adds friction.

• Chain support: EVM-only vs multi-ecosystem matters depending on what you are building.

• Operational model: Fully managed vs self-hosted vs decentralised. Each has real trade-offs.

• AI compatibility: Does the indexer have first-class support for AI-assisted development workflows? This includes Claude Code markdown, Claude skills, and tooling that integrates naturally into AI-native development environments.

The rankings​

#1 Envio: Fastest EVM indexer with one of the most complete feature sets​

Best for: Teams building on EVM chains who need the fastest possible indexing with minimal infrastructure overhead.

Envio is the only indexer in this list powered by a proprietary high-performance data engine. HyperSync delivers up to 2000x faster data access than traditional RPC. Two independent benchmarks run by Sentio confirm this: in the LBTC benchmark (April 2025), HyperIndex completed in 3 minutes versus 3 hours 9 minutes for The Graph. In the Uniswap V2 Factory benchmark (May 2025), HyperIndex completed in 1 minute, 15x faster than the nearest competitor (Subsquid), 143x faster than The Graph, and 158x faster than Ponder.

HyperSync's speed also makes HyperIndex the fastest data source for onchain AI agents, where query latency and data freshness directly impact decision quality.

Key strengths:​

• Powered by HyperSync, up to 2000x faster than RPC
• Independently benchmarked as fastest in class: 15x faster than nearest competitor, 158x faster than Ponder, 143x faster than The Graph (Sentio, May 2025, Uniswap V2 Factory benchmark)
• Wildcard indexing (only indexer in this list with full support)
• Single indexer across multiple chains with unordered multichain mode
• Write handlers in TypeScript or ReScript (no AssemblyScript required)
• Full block handler support
• Fully managed hosted service available, no infrastructure management required
• White glove migration support for teams moving from any stack

Honest caveats:​

HyperSync native support covers 70+ EVM chains and Fuel. For chains not supported by HyperSync, indexing falls back to standard RPC speed, which is subject to the RPS limits of the endpoint. If you need non-EVM chains like Polkadot or Cosmos, SubQuery or Subsquid are better options.

Get started:

pnpx envio init

#2 The Graph: Best for ecosystem access and public subgraphs​

Best for: Teams that need access to the existing ecosystem of public subgraphs, or who want a decentralised indexing network.

The Graph pioneered declarative blockchain indexing and remains the most established player in the space. Its decentralised network of indexers and curators provides a layer of resilience that no single managed service can replicate. If you need access to community-maintained subgraphs for major protocols such as Uniswap, Aave, and Compound, The Graph is where those live.

Key strengths:​

• Largest ecosystem of existing public subgraphs
• Decentralised network (not reliant on a single vendor's uptime)
• 40+ chains on The Graph Network, 90+ chains total

Honest caveats:​

Handlers are written in AssemblyScript, a TypeScript subset compiled to WebAssembly. It is stricter than TypeScript and adds a learning curve. Subgraphs are deployed per chain. There is no native single-subgraph multichain indexing. Based on the April 2025 Sentio benchmarks, The Graph was over 63x slower than HyperIndex on the same workload.

#3 Goldsky: Best for data streaming to your own database​

Best for: Teams that want to stream raw blockchain data directly into their own infrastructure alongside managed subgraph hosting.

Goldsky is the most infrastructure-oriented indexer in this list. Its two primary products are Subgraphs (instant GraphQL APIs, fully Graph-compatible, zero maintenance) and Mirror ( streaming of blockchain and some offchain data directly into your own database or data warehouse, no configuration needed). The Mirror product is particularly suited for data-heavy teams who want to own their entire downstream data pipeline.

Key strengths:​

• 150+ chains supported
• Fully managed, no infrastructure to run
• Mirror pipelines stream data directly to your own database automatically
• Reorg handling is fully automatic for Mirror pipelines (no configuration needed). For Compose pipelines, reorg handling is built-in but requires configuration via a depth setting and a chosen behaviour such as replay or log
• Graph-compatible subgraphs for instant GraphQL APIs
• Compose product for event-triggered onchain and offchain workflows

Honest caveats:​

Goldsky does not support traditional block handlers in the subgraph sense. Their docs do not cover this as a feature. For block-level data access, Goldsky provides pre-indexed Blocks Subgraphs. Block-triggered processing via Compose requires additional setup. Subgraph handlers are written in AssemblyScript (Graph-compatible), not TypeScript. Wildcard indexing is not documented as a feature.

#4 SubQuery: Best for non-EVM chain coverage​

Best for: Teams building across EVM and non-EVM ecosystems, including Polkadot, Cosmos, Bitcoin, and more.

SubQuery stands out for its chain coverage. With support for 300+ chains across EVM and non-EVM ecosystems,it is one of the most chain-inclusive indexers in this list. If your product lives on Polkadot or Cosmos and you also need EVM support, SubQuery is the most natural fit for now.

Key strengths:​

• 300+ chains, broadest coverage including non-EVM
• Single project can index data across multiple chains
• TypeScript handlers
• Block handlers supported
• Decentralised hosted service via SubQuery Network

Honest caveats:​

Data ingestion runs on standard RPC speed. Block handlers are noted in SubQuery's own documentation to slow indexing as they fire on every block.

#5 Subsquid (SQD): Best option with fast historical backfills​

Best for: Teams who want fast historical data access, and non-EVM chain support.

Subsquid's decentralised data lake processes historical blockchain data at tens of thousands of blocks per second. SQD describes this approach as up to 1000x faster than traditional methods like subgraphs, based on their own published benchmarks (source).

Key strengths:​

• Decentralised data lake, significantly faster than RPC for historical data (SQD’s own claim: up to 1000x faster than traditional methods like subgraphs (source))
• 100+ chains including EVM and non-EVM
• TypeScript handlers
• Block handlers supported
• Factory contract wildcard patterns supported

Honest caveats:​

The wildcard support is scoped to factory contract patterns and is not the same as Envio's fully address-free wildcard indexing. Live chain-head performance is not independently benchmarked against the other indexers in this list.

#6 Ormi (0xGraph): Best fully managed option for Graph-compatible subgraphs​

Best for: Teams already using The Graph's subgraph standard who want a managed, low-latency alternative without rebuilding their indexing logic.

Ormi's main pitch is a managed, high-performance layer on top of the subgraph standard. If you have existing subgraphs and want to migrate to a lower-latency managed service without rewriting your handlers, Ormi is a credible path. They also offer GraphQL, REST, and SQL query interfaces in a single platform, which is a genuine differentiator.

Key strengths:​

• Fully managed service
• GraphQL, REST, and SQL query interfaces
• The Graph subgraph standard compatible
• 70+ EVM chains

Honest caveats:​

Ormi's performance claims (sub-30ms query latency at 4,000 RPS) are self-reported and have not been independently verified in third-party benchmarks. Handlers are written in AssemblyScript only, with no native TypeScript support. Wildcard indexing is not documented.

#7 Ponder: Best for self-hosted TypeScript stacks​

Best for: Teams with strong DevOps capability who want full control over every layer of their indexing infrastructure.

Ponder is a TypeScript-native, self-hosted indexer designed for developers who want maximum flexibility and no managed dependency. It is clean, well-designed, and has a growing community. If you want to own your entire stack and have the engineering capacity to manage it, Ponder is worth evaluating.

Key strengths:​

• TypeScript-native throughout
• Full control over infrastructure
• Block handlers via configurable block intervals
• Multichain support

Honest caveats:​

There is no official hosted service. You deploy and manage your own infrastructure. Data ingestion relies on standard RPC endpoints. Not suited for teams who want managed reliability out of the box.

Feature comparison​

How to choose the right blockchain indexer​

The right indexer depends on what you are building, which chains you need, and how much infrastructure you want to manage.

If you need the fastest EVM indexing with the most complete feature set. Use Envio. It is the only indexer independently benchmarked as fastest in class, powered by HyperSync rather than standard RPC. It also has wildcard indexing, multichain in a single indexer, TypeScript throughout, a fully managed hosted service, and first-class support for AI-assisted development.

If you need non-EVM chains (Polkadot, Cosmos, Bitcoin, etc.). Use SubQuery (300+ chains) or Subsquid (100+ chains). Both support EVM and non-EVM networks in a single framework.

If you have existing Graph subgraphs and want a managed upgrade. Migrate to Envio for significantly faster indexing with white glove migration support. Or use Goldsky (149+ chains, Mirror streaming, fully managed) or Ormi (fully managed, GraphQL/REST/SQL) for a near-zero-rewrite migration. Both are Graph-compatible.

If you want to stream raw blockchain data into your own database. Use Envio HyperSync for custom pipelines, up to 2000x faster than RPC with client libraries for Python, Rust, Node.js, and Go. Or use Goldsky Mirror for automatic streaming to Postgres and other sinks with no code required.

If you need a self-hosted indexer with maximum performance. Use Envio. It is self-hostable via Docker, powered by HyperSync, and independently benchmarked as the fastest blockchain indexer available. 143x faster than The Graph on the Uniswap V2 Factory benchmark (Sentio, May 2025).

If you need access to the broadest ecosystem of existing community subgraphs. Use The Graph. Its decentralised network has the largest collection of publicly maintained subgraphs for major protocols.

The honest bottom line​

For most teams building on EVM chains, Envio HyperIndex is the strongest choice. It is the only indexer in this list independently benchmarked as fastest in class, the only one with true wildcard indexing, and the only one powered by a purpose-built data engine rather than standard RPC. It supports multichain indexing from a single indexer, offers fully managed hosting or self-hosted via Docker, and has white glove migration support for teams moving from The Graph or any other indexer.

If you are not on EVM chains, SubQuery or Subsquid cover the broadest non-EVM network range. If you need access to existing community subgraphs for major protocols, The Graph remains the largest ecosystem for those. For every other use case, start with Envio.

Get started in under 5 minutes: pnpx envio init

Frequently asked questions​

What is a blockchain indexer?​

A blockchain indexer is a system that listens to onchain events (transactions, logs, state changes, blocks) and organises them into a structured, queryable database. Developers use indexers to build fast, reliable backends for dApps, DeFi protocols, NFT platforms, and analytics tools without querying slow RPC endpoints directly.

What is the fastest blockchain indexer in 2026?​

Based on two independent benchmarks run by Sentio, Envio HyperIndex is the fastest blockchain indexer in independent benchmarks. In the Uniswap V2 Factory benchmark (May 2025), HyperIndex completed in 1 minute, 15x faster than the nearest competitor (Subsquid), 143x faster than The Graph, and 158x faster than Ponder. In the LBTC benchmark (April 2025), the same task took 3 minutes with HyperIndex and 3 hours 9 minutes with The Graph. All benchmark data is publicly available.

Which blockchain indexer supports the most chains?​

SubQuery supports the most chains at 300+, including both EVM and non-EVM networks such as Polkadot, Cosmos, and Bitcoin. Subsquid supports 100+ chains. Goldsky supports 150+ chains. Envio supports 70+ EVM chains with native HyperSync support for maximum speed, plus any EVM chain via RPC.

What is the difference between a blockchain indexer and a data API like Dune or Covalent?​

A custom indexing framework (HyperIndex, The Graph, Ponder, etc.) lets you define exactly what data to track, write handler logic that transforms onchain events into your own schema, and query the results via a generated API. A pre-built data API like Dune Analytics or Covalent exposes pre-indexed, read-only data. You query what they have already indexed, but you cannot define custom indexing logic or schemas. Both are useful, but they solve different problems.

How do I migrate from The Graph to Envio HyperIndex?​

HyperIndex has a dedicated migration guide that walks you through it in 3 simple steps. Envio also offers white glove migration support for teams moving from any stack. Reach out to us via Discord for support.

What is HyperSync?​

HyperSync is Envio's high-performance blockchain data engine that powers HyperIndex. It provides a low-level data access layer that is up to 2000x faster than traditional JSON-RPC endpoints. HyperSync can also be used directly for custom data pipelines in Python, Rust, Node.js, and Go. It supports 70+ EVM chains and Fuel.

Build With Envio​

Envio is the fastest independently benchmarked EVM blockchain indexer for querying real-time and historical data. If you are building onchain and need indexing that keeps up with your chain, check out the docs, run the benchmarks yourself, and come talk to us about your data needs.

Stay tuned for more updates by subscribing to our newsletter, following us on X, or hopping into our Discord.

Subscribe to our newsletter 💌

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

February brings a couple new HyperIndex V3 alpha release along with expanded network support and feature updates. We shipped HyperIndex v3.0.0 alpha.13 & alpha.14 with 3x faster historical backfills, support for DESC indices, improved RPC source support, experimental WebSocket support, and a breaking configuration change with rpc_config removed in favour of rpc, new getWhere API, removed ordered multichain mode support, big Cursor/Claude update and much more!

We expanded our indexing support to MegaETH mainnet and Sei. This month also includes a new multi-part YouTube series on building with HyperIndex and updates to our Uniswap v4 alert bots. Let’s dive in!

⚡ New release: HyperIndex v3.0.0 - alpha.13 & alpha.14​

Alpha.14​

🚨 Breaking: New getWhere API​

We updated our getWhere API to enable support for multiple filters at a time in future HyperIndex versions. Instead of chaining, it now uses a single function call with filters that match GraphQL style for familiarity.

Old: context.Entity.getWhere.fieldName.eq(value)
New: context.Entity.getWhere({ fieldName: { _eq: value } })

🔄 Breaking: Removed Ordered Multichain Mode Support​

Ordered Multichain Mode forced events across all processed chains into global onchain order, causing significant latency and allowing one bad chain to freeze the entire indexing process.

Events are still processed in on-chain order per chain. For cross-chain interactions, create a partial entity on one chain and finalize it when the related event arrives on another chain. This provides lower latency and a more reliable system.

🤖 Big Cursor/Claude Skills Update​

We updated envio init to create projects with multiple skills to support agentic driven development.

The LLM landscape changes quickly, so we welcome feedback to improve the skills and the development experience with them.

⛓️ Chain Info for Test Indexer​

const indexer = createTestIndexer();

indexer.chainIds
indexer.chains

indexer.chains[1].id
indexer.chains[1].name
indexer.chains[1].startBlock
indexer.chains[1].endBlock

indexer.chains[1].ERC20.abi
indexer.chains[1].ERC20.addresses // Useful to test dynamic registrations

Alpha.13​

This alpha release focused on performance improvements, expanded indexing capabilities, and RPC configuration changes as we continue iterating on V3.

Historical backfills are significantly faster, query flexibility has improved with support for descending indices, RPC sources now expose additional receipt level fields, and configuration has been streamlined with the removal of rpc_config in favour of a unified rpc structure.

🏎️ 3x Historical Backfill Performance​

We introduced chunking logic to request events across multiple ranges at once, fixed overfetching for contracts with much later start_block values, and sped up dynamic contract registration.

If data fetching was your bottleneck, this release helps.

25k events per second is now standard

📉 Support for DESC Indices​

You can now define indices with descending order to improve query performance:

type PoolDayData
  @index(fields: ["poolId", ["date", "DESC"]]) {
  id: ID!
  poolId: String!
  date: Timestamp!
}

⛽ Improved RPC Source Support​

Added support for receipt-only fields:

• gasUsed

• cumulativeGasUsed

• effectiveGasPrice

When one of these fields is added in field_selection, HyperIndex will automatically perform an additional eth_getTransactionReceipt request.

🔌 WebSocket Support for RPC (Experimental)​

Experimental WebSocket support for RPC sources to improve head latency.

If you run into issues, please open a GitHub issue. 🙏

chains:
  - id: 1
    rpc:
      url: ${ENVIO_RPC_ENDPOINT}
      ws: ${ENVIO_WS_ENDPOINT}
      for: live

🚨Breaking: rpc_config Removed​

rpc_config has been removed in favour of rpc.

- rpc_config
+ rpc:
      url: ${ENVIO_RPC_ENDPOINT}
+     for: sync # Add to force RPC usage instead of HyperSync

Additionally, you can specify multiple rpcs by providing a list:

rpc:
  - url: ${ENVIO_RPC_ENDPOINT}
    for: sync
  - url: ${ENVIO_RPC_FALLBACK_ENDPOINT}
    for: fallback

If for is not provided, the RPC URL is used as a fallback for HyperSync or as the main source when HyperSync is not supported.

We recommend migrating to v3.0.0 alpha. 13 to take advantage of the performance improvements and configuration updates. Give it a test and let us know how it goes. We welcome any feedback as we continue refining V3.

For information, be sure to check out the full release notes. More updates coming soon.

👉 See full release notes

👉 Star us on GitHub ⭐

Indexing Data on MegaEth Mainnet​

MegaETH launched its public Mainnet on February 9, 2026, marking the transition from testnet experimentation to a live production network. As a performance focused Ethereum Layer 2, MegaETH is built to support high throughput and low latency execution for onchain applications.

With mainnet now live, developers can deploy and operate applications directly on the network.

Envio proudly supports developers building on MegaETH Mainnet, providing efficient access to real-time and historical data for teams building in the ecosystem.

For more information, see the original post on X.

Building Indexers with HyperIndex​

Check out Decrypted Bytes’ new multi-part YouTube series that walks through how to build with HyperIndex. The series covers building an indexer using HyperIndex from scratch. It follows the full process in a live coding format, showing how to set up, iterate, and expand an indexer step by step.

If you want to learn how to build with HyperIndex in practice, this series is a great place to start.

Be sure to check out the series on YouTube and subscribe to follow along as more parts are released.

Tyde Terminal Tide Visualiser​

Tyde is an open source terminal based tool that visualises real world tide levels directly in the command line. It renders an animated tide scene with waves, sand, and foam, alongside a 24-hour tide chart showing the current position in the cycle. Sunrise and sunset times are also displayed, with support for a day and night cycle.

Tide predictions are computed locally using harmonic analysis across more than 50 global stations, with no external APIs required.

You can run Tyde directly in your terminal on macOS or Linux, or build it from source.

For more information, see the GitHub repo or the original post on X.

Index Data on Sei​

Just Sei it.

Build, index & scale high performance apps on Sei using Envio.

Instantly access real-time & historical data on one of the fastest L1 EVMs. Sync millions of events in minutes, 2000× faster than RPC.

Easy. Fast. Fully customizable.

For more information, see the original post on X.

Envio Alerts: Uniswap v4 Alert Bots​

Get automated alerts when a Uniswap v4 pool crosses 1m in TVL, including when an MEV bot trade causes the threshold to be hit.

Each alert includes:

• Token pair
• TVL threshold hit
• Chain

The MEV Alerts bot highlights MEV driven TVL events, while the Liquid Token Alerts bot tracks pools crossing the 1m TVL mark.

Be sure to join the bot groups on Telegram to receive alerts in real-time and stay up to date on Uniswap v4 pool activity.

🗓️ Current & Upcoming Events & Hackathons​

• EthDenver - Denver: Feb 17th → 21st
• EthCC - Cannes: March 30th → April 2nd
• EthConf - New York: June 8th → 10th

🎧️ Playlist of the Month​

▶️ Open Spotify

Build with Envio​

Envio is a multi-chain EVM blockchain indexer for querying real-time and historical data. If you’re working on a Web3 project and want a smoother development process, Envio’s got your back(end). Check out our docs, join the community, and let’s talk about your data needs.

Stay tuned for more monthly updates by subscribing to our newsletter, following us on X, or hopping into our Discord for more up-to-date information.

Subscribe to our newsletter 💌

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

A blockchain indexer is rarely the end product. For most teams, it is a core part of the backend that sits between the blockchain and their application.

This blog focuses on how developers and analysts actually use a blockchain indexer in practice, the problems it solves at the backend layer, and how blockchain indexers like Envio fit into that workflow and streamline the overall development process.

What is a blockchain indexer​

A blockchain indexer is a specialised tool that ingests raw blockchain data and transforms it into structured data that application backends can query efficiently.

Rather than querying blocks, transactions, or logs directly through RPC on every request, developers define how blockchain events should be processed and stored. The indexer applies this logic consistently as new data is produced and as historical data is processed.

The result is a reliable, queryable data layer built from on-chain activity.

How blockchain indexers work​

In practice, a blockchain indexer follows a simple model:

• Read blockchain data such as blocks, transactions, and event logs
• Apply developer-defined logic to the data
• Store the results as structured entities

This logic is deterministic and repeatable. Given the same inputs, the indexer produces the same outputs, which makes indexed data predictable and safe to depend on in application backends.

The backend problem blockchain apps run into​

Application backends need structured state. Blockchains expose raw data. When applications rely directly on RPC endpoints, backend logic quickly becomes responsible for:

• Reconstructing the state from historical events
• Tracking contract changes over time
• Handling retries, partial failures, and reorgs
• Translating low-level logs into usable application data

As your project scales, this logic becomes difficult to manage and expensive to maintain. Blockchain indexers like Envio exist to absorb this complexity by transforming on-chain events into structured, queryable data that your backend can depend on.

What role a blockchain indexer plays​

Rather than serving as an analytics layer, a blockchain indexer functions as backend infrastructure. It continuously processes blockchain data and maintains an up-to-date representation of application state that backends can query directly.

In practice, this means:

• Indexing contract events once instead of repeatedly
• Converting raw logs into structured entities
• Persisting derived state that applications can rely on
• Keeping blockchain-specific logic out of application code

This separation makes backends simpler, more predictable, and easier to scale.

Where the indexed data gets used​

Once data is indexed, application backends can:

• Serve APIs backed by indexed blockchain state
• Power user interfaces with pre-processed data
• Track contract state without rescanning history
• Build features that depend on event-driven updates

Because the indexing logic is deterministic and versioned, teams can evolve their schema and handlers without rewriting application logic.

When a blockchain indexer becomes necessary​

Most teams reach for a blockchain indexer when:

• Application logic depends on more than the latest block

• Application needs access to real-time & historical on-chain data

• Data needs to be queried frequently or predictably

• Applications span multiple supported networks and need a unified data layer

• Backend reliability becomes a priority

At that point, indexing once and querying structured data becomes the simplest approach.

Envio supports this by allowing developers to configure indexers that process data from multiple supported networks within a single project, while exposing indexed data through a consistent query interface.

Building a blockchain indexer with Envio​

Envio is designed around a developer-first indexing workflow. With Envio, developers define the contracts and events relevant to their application, write deterministic event handlers that map blockchain data into entities, and run the indexer locally to develop and validate logic. The same indexing code can then be used in hosted environments without changes.

As projects scale, Envio provides a set of optional capabilities that support more advanced indexing and production requirements:

• Flexible language support: Write event handling logic in supported languages such as JavaScript and TypeScript.

• HyperSync: A high-performance data retrieval layer designed to dramatically speed up access to historical blockchain data and reduce reliance on standard RPC-based syncing. HyperSync's endpoint allows up to 2000x faster indexing than standard RPC (use of RPC is optional).

• No-code Quickstart: Autogenerate the key boilerplate for an entire Indexer project off single or multiple smart contracts. Deploy within minutes.

• Multichain indexing: Aggregate data across multiple networks into a single database. Query all your data with a unified GraphQL API.

• On-chain and off-chain data ingestion: Combine indexed on-chain data with data fetched from off-chain sources to build a flexible API for richer application logic. This includes indexing off-chain NFT metadata, pulling token prices from aggregators like CoinGecko, or reading current chain state via RPC calls alongside indexed events.

• Factory contract support: Automatically register and process events emitted from all child contracts that are created by a specified factory/dynamic contract.

• Hosted service: An optional managed service platform for building, hosting, and querying Envio's Indexers with 99.99% guaranteed uptime and performance service level agreements.

The result is a backend data layer that remains consistent and reliable across development and production, allowing teams to scale their indexing setup without rewriting application logic.

Getting started​

Envio allows developers to start small and scale as you build:

• Index single or multiple contracts
• Map a small set of events into entities
• Run the indexer locally during development
• Expand the schema and handlers as application requirements grow

And much more!

For many applications, a blockchain indexer becomes a core part of the backend. Envio is designed to support this workflow from early development through production, using the same indexing code and development model across environments.

Conclusion​

As your application grows, working directly with raw on-chain data becomes harder to maintain.

A blockchain indexer moves that complexity into a dedicated layer that backends can rely on.

Envio provides a consistent way to build and run that layer, from local development through production, without changing how indexers are defined as requirements evolve.

About Envio​

Envio is a fast, developer friendly multichain blockchain indexer that makes real-time data accessible for builders across Web3.

With Envio, developers can query and stream blockchain data efficiently without the complexity of running their own infrastructure. Envio's blockchain indexing solution natively supports any EVM network and is trusted by many teams building everything from DeFi platforms to analytics dashboards and production applications.

If you're a blockchain developer or analyst looking to enhance your workflow, look no further. Join our growing community of Web3 builders and explore our docs.

Website | X | Discord | Farcaster | GitHub

Over the past month, we’ve continued making steady progress on HyperIndex V3, with a strong focus on improving how developers build, test, and operate indexers day to day.

This update covers the latest V3 alpha features including a new testing framework, Vitest adoption, improvements to envio init, configuration and state access updates, and several quality of life enhancements across the CLI and TUI. We’re also sharing recent ecosystem updates, production migration examples, and highlights from teams building with Envio.

As always, these changes are incremental building blocks toward a more reliable and flexible indexing workflow, from local development through to production.

HyperIndex V3 (alpha): Exciting Feature Updates​

🚨BIG feature alert: New Testing Framework (experimental)​

V3 supports testing handler logic using real blockchain data, programmatic debugging, & testing block handlers together with event handlers.

The framework also enables LLM workflows using a TDD approach, supports snapshotting indexer behaviour, & runs multiple tests in parallel using isolated worker threads.

import { describe, it, expect } from "vitest"
import { createTestIndexer } from "generated"


describe("Indexer Testing", () => {
  it("Should create accounts from ERC20 Transfer events", async () => {
    const indexer = createTestIndexer();

    expect(
      await indexer.process({
        chains: {
          1: {
            startBlock: 10_861_674,
            endBlock: 10_861_674,
          },
        },
      }),
      "Should find the first mint at block 10_861_674"
    ).toMatchInlineSnapshot(`
      {
        "changes": [
          {
            "Account": {
              "sets": [
                {
                  "balance": -1000000000000000000000000000n,
                  "id": "0x0000000000000000000000000000000000000000",
                },
                {
                  "balance": 1000000000000000000000000000n,
                  "id": "0x41653c7d61609d856f29355e404f310ec4142cfb",
                },
              ],
            },
            "block": 10861674,
            "blockHash": "0x32e4dd857b5b7e756551a00271e44b61dbda0a91db951cf79a3e58adb28f5c09",
            "chainId": 1,
            "eventsProcessed": 1,
          },
        ],
      }
    `);
  }
}   

Vitest - Recommended Testing Framework​

V3 recommends Vitest as the testing framework for indexer projects.

It replaces mocha, chai, and tsx with a single package that works out of the box, and supports features like snapshot testing.

All envio init templates have been updated to use Vitest, with tests living directly in src and support for handler specific test files.

"scripts": {
- "mocha": "tsc --noEmit && NODE_OPTIONS='--no-warnings --import tsx' mocha --exit test/**/*.ts",
- "test": "pnpm mocha",
+ "test": "vitest run"
},
"devDependencies": {
- "@types/chai": "^4.3.11",    
- "@types/mocha": "10.0.6",
- "chai": "4.3.10",
- "tsx": "4.21.0",
- "mocha": "10.2.0"
+ "vitest": "4.0.16"
}

Envio Init Improvements​

V3 improves the envio init flow to make project setup quicker and smoother.

The ERC20 template has been updated to be multichain and includes the new testing framework as a reference. New projects can also initialize git automatically.

The improved init flow can include additional setup options from upcoming releases, such as configured GitHub CI and an AGENTS.md file to support LLM-based development.

Expose Indexer Config & State​

V3 introduces the indexer value as a replacement for getGeneratedByChainId.

It provides typed chains and contract data from config, along with current indexing state such as isLive and addresses.

New official types are also introduced:

Indexer, EvmChainId, FuelChainId, SvmChainId.

Automatic Contract Configuration​

V3 automatically configures all globally defined contracts.

Globally defined contracts are handled automatically, even when they aren’t linked to a specific chain or address.

Conditional Event Handlers​

V3 allows event handlers to be enabled or disabled conditionally.

You can now return a boolean value from the eventFilters function to control whether a handler runs.

TUI Love​

V3 brings updates to the TUI, making it even more beautiful & compact.

It uses fewer resources, shares a link to the Hasura playground, and adjusts dynamically to the terminal width.

Envio API Token Required​

For indexers using HyperSync as a data source, setting an ENVI0_API_TOKEN is now required.

You can learn more about API tokens or create one for free at:

https://envio.dev/app/api-tokens

Alongside this, HyperIndex V3 also supports using Podman for local development, in addition to Docker.

This is just the beginning for V3. Many of these features are early building blocks, with loads more improvements, refinements, and additions already in underway.

For a deeper dive into everything included so far, be sure to check out the full release notes. More updates coming soon.

👉 See full release notes

👉 Star us on GitHub ⭐

Indexing Data on Injective​

Envio proudly supports developers and analysts building on Injective by providing efficient access to real-time and historical on-chain data to help teams build robust apps on Injective.

With Envio, teams can sync and query Injective data and define fully customizable indexing logic based on their application needs, without managing indexing infrastructure themselves.

Migrating Production Subgraphs: Polymarket Indexer​

A common question we hear is what migrating a real production subgraph setup actually looks like in practice.

This example shows every Polymarket subgraph migrated into a single Envio indexer, providing a concrete reference for teams looking to consolidate or migrate existing subgraph infrastructure.

The full implementation is available here:

https://github.com/enviodev/polymarket-indexer

⚠️ Note: This example is still a work in progress and under active testing

Blockchain Indexer For Application Backends​

Indexers are a core part of most application backends, sitting between the blockchain and the app. By transforming raw on-chain data into structured, queryable state, indexing removes a lot of complexity from backend logic and makes applications easier to build and scale as they grow. Envio fits into this workflow by providing a consistent indexing layer teams can use from local development through production, without changing how their backend logic is defined.

For more details, read the full blog.

Envio Powers Funnel with Efficient Data Indexing​

Funnel is back after completing a successful backend migration to Envio, which has improved the performance and reliability of the on-chain data powering their application heading into 2026.

Funnel uses Envio as its indexing layer to ingest and query on-chain data used across the app, including data supporting trading views and listings built on Hyperliquid.

The migration gives the Funnel team a more robust and maintainable data pipeline, allowing them to focus on shipping product without managing indexing infrastructure.

See this post on X for more info.

🗓️ Current & Upcoming Events & Hackathons​

• EthDenver - Denver: Feb 17th → 21st
• EthCC - Cannes: March 30th → April 2nd
• EthConf - New York: June 8th → 10th

🧑‍💻 Featured Developer: Zod​

This month’s featured developer is Zod. They’ve been building for a few decades and working on-chain since 2019. Over the past year, they’ve been actively using tools like Cursor and exploring in-the-loop agentic development.

In August 2024, Zod took over Scale from Equalizer and began transforming it into what they describe as a MetaIndex. This concept focuses on generating revenue across DeFi, rather than limiting revenue to V2 pools, to reduce fresh emissions by earning treasury revenue through other protocols such as Aerodrome.

Scale continues to emit its own token and run liquidity, while integrating Manual CL as part of this evolution.

“To power our instant-on, data-rich experience across millions of transactions, I need fast, real-time data and deep historical depth with tight latency. I run multiple Envio indexers in parallel with an orchestration layer, which gives us exactly that. Having the full source as a git submodule means I can do deep dives when facing issues, and the team has been super helpful. After previously unhappy experiences with other indexers, Envio has been a massive win.” - Zod, Co-Founder & Lead Developer at Scale

Well done, Zod. Be sure to check out Scale and follow the team on X to stay up to date with their latest developments.

🎧️ Playlist of the Month​

▶️ Open Spotify

🚢 Ship With Us​

Envio is a multi-chain EVM blockchain indexer for querying real-time and historical data. If you’re working on a Web3 project and want a smoother development process, Envio’s got your back(end). Check out our docs, join the community, and let’s talk about your data needs.

Stay tuned for more monthly updates by subscribing to our newsletter, following us on X, or hopping into our Discord for more up-to-date information.

Subscribe to our newsletter 💌

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

As we wrap up the end of the year, December’s developer update shares what’s next for Envio and what we’ve been working on across the product and community.

This month includes an early look at HyperIndex v3.0.0, early experimentation with Solana support, continued support for teams building on Sonic, updates from Decypted Bytes streams, a new USDT0 indexing example, and our featured developer for December, and much more.

Let’s dive in.

🚨 HyperIndex v3.0.0 is Coming​

HyperIndex v3.0.0 is an alpha release introducing ESM support with top-level await and automatic handler registration, alongside lower HyperSync latency and faster queries. The release also includes an experimental ClickHouse Sink, cleaner configuration and defaults, and early experimental Solana support, and much more to come.

CommonJS → ESM​

HyperIndex now runs ESM-only.

This unlocks support for modern libraries and enables top-level await across handlers, and envio init now comes with new templates and an updated tsconfig.json.

{
  /* For details: https://www.totaltypescript.com/tsconfig-cheat-sheet */
  "compilerOptions": {
    /* Base Options: */
    "esModuleInterop": true,
    "skipLibCheck": true,
    "target": "es2022",
    "allowJs": true,
    "resolveJsonModule": true,
    "moduleDetection": "force",
    "isolatedModules": true,
    "verbatimModuleSyntax": true,

    /* Strictness */
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitOverride": true,

    /* For running Envio: */
    "module": "ESNext",
    "moduleResolution": "bundler",
    "noEmit": true,

    /* Code doesn't run in the DOM: */
    "lib": ["es2022"]
  }
}

Top-level await​

You can now use top-level await directly in handlers files in HyperIndex V3.

This makes it easy to load things like whitelisted addresses or config from a server instead of hardcoding values into the codebase.

import { ERC20 } from "generated";

const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";

// THIS IS NEW
const addressesFromServer = await loadWhitelistedAddresses();

ERC20.Transfer.handler(
  async ({ event, context }) => {
    //... your handler logic
  },
  {
 wildcard: true,
 eventFilters: [
      { from: ZERO_ADDRESS, to: addressesFromServer },
      { from: addressesFromServer, to: ZERO_ADDRESS },
    ],
  }
);

src/handlers auto registration​

HyperIndex v3 automatically registers handler files from src/handlers. You no longer need to list explicit handler paths in config.yaml. Just place your files in src/handlers and they will be picked up automatically.

If you prefer a different structure, you can override this using the handlers option. Explicit handler paths still work as before.

⚠️ Deprecation: Explicit handler paths are still supported, so no changes are required.

Block handler indexers​

It is now possible to create indexers using only block handlers. Event handlers are no longer required, and contracts are optional in config.yaml.

Flexible entity fields​

Restrictions on entity field names have been removed. Improvements have also been made to ensure database columns are generated in the same order as they are defined in schema.graphql.

HyperSync source improvements​

Several updates on the HyperSync side reduce latency and unnecessary traffic. These include using server sent events for block updates, more efficient query serialization, and caching for repetitive queries.

Experimental ClickHouse Sink support​

HyperIndex v3 adds experimental ClickHouse Sink support.Postgres remains the primary database. You can additionally sink entities to ClickHouse for restart and reorg resistant workloads.

Experimental additions: Solana Support​

V3 introduces experimental Solana support using RPC as a source. Be sure to check out our docs for more information.

Try it out with:

pnpx envio@3.0.0-alpha.3 init solana

Cleanups and defaults​

Deprecated APIs and legacy options have been removed, defaults have been updated, and Node.js 22 is now the minimum supported version. Internal naming and metrics have also been cleaned up for consistency.

This is just the start, with a lot more to come. Stay tuned!

👉 See full release notes

👉 Star us on GitHub ⭐

Envio Supports Developers Building on Sonic​

Envio supports developers and analysts building on Sonic by providing access to real-time and historical on-chain data through a reliable indexing layer designed for high-throughput environments.

With Sonic’s fast finality and high transaction volumes, teams need indexing infrastructure that can keep up without adding operational complexity. Envio is built to handle these conditions, allowing developers and analysts to query, monitor, and analyze Sonic data efficiently.

This support makes it easier for teams to build data-heavy applications, analytics dashboards, and monitoring tools on Sonic without having to manage indexing infrastructure themselves.

👉 Start building on Sonic

Monad Testnet Re-Genesis: Reindex Required for Envio Users​

The Monad testnet underwent a full re-genesis, restarting the network from block 1.

For Envio users indexing Monad, this means indexers need to reindex from block 1 now that the refreshed testnet is live. As part of the re-genesis, all existing on-chain state was reset and any deployed contracts needed to be redeployed.

This update removes legacy behaviours from early testnet phases and is expected to reduce state sync time going forward. Teams indexing Monad can continue building against the refreshed testnet.

If you need support reindexing or redeploying after the re-genesis, feel free to reach out to the Envio team in our Discord.

Envio at Solana Breakpoint 2025 in Abu Dhabi​

The Envio team attended Solana Breakpoint in Abu Dhabi this month, spending time with teams across the Solana ecosystem and learning more about their data needs and how they’re building on Solana.

We had a great few days of conversations with builders, protocols, and infrastructure teams, getting a better sense of the tools, patterns, and challenges teams are working through as the ecosystem continues to grow.

Alongside the event, we’ve been experimenting with early, experimental Solana support in Envio. These conversations were valuable in helping us better understand Solana use cases and how indexing infrastructure can support developers and analysts building on the network.

Big thanks to everyone we met and spoke with at Solana Breakpoint. We’re looking forward to continuing these conversations as our Solana support evolves. Watch this space.

Envio Developer Workshops: Decypted Bytes Is Back​

Decypted Bytes streams are back and now running daily at 3:00pm UTC, focused on hands-on developer workflows using Envio.

Recent and upcoming sessions cover practical indexing patterns and data pipelines built with HyperIndex and HyperSync, walking through real examples end-to-end.

Recent streams include:​

• Base–Solana Bridge Indexer with HyperIndex, showing how to track cross-chain token transfers between Base and Solana

• DuckDB Sink for HyperSync, covering how to write indexed blockchain data into DuckDB for local analytics and querying

All stream links, topics, and the full schedule are available via the Decypted Bytes stream schedule. Be sure to subscribe to stay up to date with upcoming sessions.

Envio Adds Support for Tempo​

Envio now supports Tempo, giving teams an easier way to index and query data in real-time and build fully customizable data pipelines.

This support makes it simpler for developers to work with Tempo data using HyperIndex, without needing to set up or maintain custom indexing infrastructure. Teams can define their own indexing logic and query patterns while keeping full control over how data flows through their pipelines.

To get started and learn how to index data on Tempo, check out the setup guide in the Envio docs.

How to Index Cross-Chain USDT0 Transfers with Envio​

Learn how to build a USDT0 Indexer using Envio by exploring this example repository, which demonstrates how to track USDT0 transfers across multiple chains.

The repository shows how to use Envio and HyperSync to index USDT0 activity across supported networks, providing a practical reference for teams working with cross-chain token flows.

You can explore the full example, code, and setup instructions in the GitHub repository.

Envio Powers Slab.cash with Efficient Data Indexing​

Slab.cash recently went live, bringing on-chain collectibles to users.

Envio proudly powers Slab.cash with efficient data indexing, giving the team easy and reliable access to real-time and historical blockchain data so their app can run smoothly as usage grows.

Big congrats to the Slab.cash team on the launch. Be sure to check it out and see what they’ve shipped.

Getting Started with Envio for the MetaMask Advanced Permissions Hackathon​

As part of the MetaMask x Envio Advanced Permissions Hackathon, we ran a workshop walking developers through how to get started with Envio and how it can be used during the hackathon.

The session covered setting up an indexer, exploring demos and examples, and understanding how Envio can support data needs while building.

The MetaMask Advanced Permissions Hackathon is live and runs until December 31, 2025. If you’re taking part and building with Envio, we’re happy to help support teams throughout the hack.

🗓️ Current & Upcoming Events​

• MetaMask x Envio: Advanced Permissions Dev Cook-Off Hackathon: 18th Nov → 31st Dec 2025

🧑‍💻 Featured Developer: Port​

This month’s featured developer is Port, a builder who loves experimenting with ideas and shipping fast. His journey into development started a few years ago after a health scare, which pushed him to rethink how he wanted to spend his time. Coming from a non-technical background, he began learning web development through The Odin Project and quickly found his way into Web3.

After discovering Monad, Port became deeply involved in the ecosystem, moving on to Speedrun Ethereum and joining BuidlGuidl. Along the way, he built and contributed to a wide range of open source and community projects, including the block explorer for Scaffold ETH, address.vision, and contributions to abi.ninja.

Today, Port is part of the Monad devrel team, where he continues to explore what the tech makes possible while building and experimenting whenever he gets the chance. Some of his recent and notable projects include NFT Snapshot, Monad Monitor, Oracle Dashboard, Calculate My PnL, MonadClip, Splait, Gulltoppr, ConvertETH, Anvuil, and Vanitoor.

“I had an idea, asked it to Claude, and Claude suggested and built the app with Envio without me interfering at any point. I just added the API key to the env file. It was very easy to build with Envio, and the founders are very responsive so you can just ask them questions about how you should be using it.” - Port, DevRel at Monad

Be sure to follow them on X and check out their work on GitHub to stay up to date with what they are building.

Merry Xmas from the Envio Team​

As the year comes to a close, we want to say a big thank you to everyone building with Envio for your contributions, feedback, and continued support throughout the year.

We’re wishing many of you a fantastic time over the festive season. The Envio team will still be fully available throughout the Christmas period, so feel free to reach out if you need support or want to chat about what you’re building.

Merry Xmas from all of us at Envio 🎄

🎧️ Playlist of the Month​

▶️ Open Spotify

🚢 Ship With Us​

Envio is a multi-chain EVM blockchain indexer for querying real-time and historical data. If you’re working on a Web3 project and want a smoother development process, Envio’s got your back(end). Check out our docs, join the community, and let’s talk about your data needs.

Stay tuned for more monthly updates by subscribing to our newsletter, following us on X, or hopping into our Discord for more up-to-date information.

Subscribe to our newsletter 💌

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

Alchemy is sunsetting their Subgraph support on the 8th December 2025. If you are running production workloads or preparing for mainnet, you need a stable home for your data and a migration path that keeps most of your existing work intact.

Envio gives you a clean and fast way to easily migrate your existing Alchemy Subgraphs into Envio’s HyperIndex so your data stays live, stable and real-time. This guide covers exactly how to migrate your Alchemy Subgraph, what changes you need to make and why Envio is the best place to migrate your Alchemy Subgraphs.

Why Teams are Migrating their Alchemy Subgraphs to Envio:​

With Alchemy sunsetting its Subgraph support, a lot of builders are in the same position. You still rely on your data, you still need your indexers, and rebuilding the entire stack is not realistic in the given timeframe. With Envio, you get:

• 143x faster backfills on HyperIndex

• Multichain indexing supported out of the box

• 2 months free hosting for all Alchemy users

• White-glove migration support tailored for Alchemy Subgraphs

• Support for your existing schema

• A migration flow that avoids a full rebuild

• Efficient access to real-time and historical data

• A seamless cutover to production-ready endpoints

• The option to run locally or fully hosted

And much more!

Most importantly, Envio lets you bring your current indexing logic across and run it on a much faster setup.

Before you Migrate​

Make sure you have:

• Your current Alchemy Subgraph

• Your ABI or contract addresses

• Node.js and pnpm installed

• Docker Desktop if you want to test locally (Windows Users:

WSL Windows Subsystem for Linux)

Envio supports both HyperIndex and HyperSync. For migrations, you will be using HyperIndex.

How to Migrate from Alchemy to Envio: A Step-by-step Guide​

Here is the exact workflow to migrate an Alchemy Subgraph to Envio:

1. Generate a new HyperIndex project​

Run:

pnpx envio init template --name alchemy-migration --directory alchemy-migration --template greeter --api-token "YOUR_ENVIO_API_KEY"

2. Bring over your schema​

Take your existing Alchemy Subgraph schema and drop it into your new Envio project under the schema directory. If you need help mapping fields, our migration team can do this for you.

3. Move over your mapping logic​

Copy your Subgraph mappings into Envio mapping files. The structure is familiar if you have used The Graph or Alchemy Subgraphs before. Events and handlers work the same way, so this step should feel straightforward.

4. Use migration cursors​

Envio has a dedicated migration cursor flow so you do not have to replay your entire chain from block zero. This saves hours for larger projects.

After this, you can run the indexer locally with Docker or deploy directly to Envio’s hosted service. Once deployed, your indexer will sync with HyperSync-level speed.

If you prefer hands-on help, or would like our team to check your setup, you can book a free migration call here. Alternatively, feel free to reach out to us in our Discord.

What changes when you leave Alchemy?​

Most of your stack stays the same. Here is what changes:

• You are no longer tied to a provider that is ending support

• You get faster indexing with real-time data

• You get an active team supporting your indexers

• You get a future-proof path that consistently scales with you

Your application code stays untouched. Queries stay close to what you already use. And you get more reliability as soon as you deploy.

Conclusion​

Migrate faster, not harder. Alchemy stepping away from Subgraphs does not mean your project has to stop. Migrating to Envio is fast, stable and gives you a more reliable long-term foundation for your data.

Book a migration call, move your Subgraphs and keep shipping without interruption.

About Envio​

Envio is a fast, developer-friendly blockchain indexer that makes real-time data accessible for builders migrating their Subgraphs across from Alchemy and Web3.

With Envio, developers can query and stream blockchain data efficiently without the complexity of running their own infrastructure. Envio’s blockchain indexing solution supports any EVM network and is trusted by many teams building everything from DeFi platforms to analytics dashboards and production applications.

If you’re a blockchain developer or analyst looking to enhance your workflow, look no further. Join our growing community of Web3 builders and explore our docs.

Website | X | Discord | Farcaster | GitHub

November was a big month of product updates, mainnet support and ecosystem activity. We shipped v2.32.0 with new Effect API controls, rolled out full indexing support for Monad Mainnet, and published guidance for teams affected by the Alchemy Subgraphs shutdown to help them migrate their subgraphs to Envio. HyperSync delivered strong benchmarking results on Sonic, and we wrapped up multiple hackathons across MetaMask, Monad and Encode. We also spent time with builders across Edge City in Patagonia and Devconnect in Buenos Aires. Let’s dive in.

🚨 Exciting Release: Version 2.32.0 🚨​

🧪Effect API: Goodbye Experimental Prefix​

We’ve officially removed the experimental_ prefix from the Effect API and introduced some major improvements to indexing visibility and query flexibility.

This update comes with two new features:

• RateLimit option lets you control how often Effects are called, with support for custom durations

• Disable cache for specific Effect calls using context.cache = false

Effect API, released on May 8, served us well, and we officially removed the experimental_ prefix from createEffect.

export const getMetadata = createEffect(
  {
    name: "getMetadata",
    input: S.string,
    output: S.optional(S.schema({
      description: S.string,
      value: S.bigint,
    })),
    // Protect your API from burst Effect calls
    rateLimit: {
      calls: 5,
      per: "second"
    },
    cache: true,
  },
  async ({ input, context }) => {
    try {
      const response = await fetch(`https://api.example.com/metadata/${input}`);
      const data = await response.json();
      return {
        description: data.description,
        value: data.value,
      };
    } catch(_) {
      // Don't cache failed response
      context.cache = false
      return undefined;
    }
  }
);

📺 Development Console Insights​

The Development Console now shows detailed performance metrics for every Effect API execution. You can see execution time, rate limits, and caching behaviour at a glance, making it much easier to debug and fine tune performance. A simple way to get more visibility and improve your indexer.

🔎 New getWhere.lt Query​

You can now use context.<Entity>.getWhere.<FieldName>.lt to filter entities where field values are lower than a given value. This adds more flexibility for granular queries and custom data filtering directly within your indexers.

👉 See full release notes

👉 Star us on GitHub ⭐

Monad Mainnet Is Live: Learn How to Index Data on Monad​

Envio is live on Monad Mainnet. Get easy access to real-time and historical data on Monad through performant syncing and a smooth, high performance indexing experience from day one. We supported teams throughout testnet and continue to provide the same fast, reliable indexing setup for a growing ecosystem on Mainnet.

If you are live or going live on Monad and need help getting set up, chat to us about your data needs in Discord. For more on how to index data on Monad, read our blog article.

How to Migrate Alchemy Subgraphs to Envio​

Alchemy Subgraphs are officially sunsetting on December 8, 2025. Many teams relying on their subgraph service will need a new solution before that date to avoid downtime.

Envio is supporting affected teams with 2 months of free hosting, faster backfills, multichain indexing, and full white-glove migration support to help you move over smoothly. HyperIndex gives you a modern indexing setup with real-time syncing and production ready deployments, making the transition quick and reliable.

If your subgraphs are affected and you need to migrate, chat to our team or check out this page for more information and we will help you get set up.

For a full walkthrough on how to migrate, read our guide on How to Migrate Alchemy Subgraphs to Envio.

MetaMask x Envio Advanced Permissions Hackathon is Live​

We have partnered with MetaMask for the Advanced Permissions Dev Cook-Off hackathon, inviting developers to build with ERC-7715 and ship new agent and automation ideas. The hack is now live with $10,000 in total prizes available.

For full details and registration, check the event page on HackQuest.

Stable Radar: Monitoring USDC Transactions in Real-Time​

Stable Radar is a new live visualisation that tracks USDC transfers per second across multiple chains including Ethereum, Base, Monad, Sonic, HyperEVM, Worldchain, XDC and many more. It gives a clear view of stablecoin activity as it happens and makes it easy to watch real usage and adoption play out in real-time across different networks. Be sure to check out our showcase for more examples of Envio in action.

Check the original post on X.

How to Monetize HyperSync Queries using x402​

A new demo went live this month showing how analysts and builders can monetize their HyperSync queries using x402. The project combines HyperSync’s fast querying and filtering across multiple networks with x402’s pay per request model to create simple monetizable blockchain APIs. The example lets users fetch token transfer history for any address across all HyperSync supported networks, with optional filtering by token.

Explore the demo or try it yourself on GitHub.

Devconnect and Edge City | Argentina​

The team recently attended Edge City in Patagonia, spending time with builders and getting a closer look at what teams are working on across the ecosystem. It was a good mix of conversations, working sessions and meeting new faces.

From there we headed to Buenos Aires for Devconnect, catching up with teams throughout the week. We also partnered with Sonic, Pyth and Gelato for an evening event in the city that brought all of our communities together in one venue.

We wrapped up the month at Devconnect Buenos Aires, taking part in the sessions and connecting with builders across the ecosystem. Big thanks to all the partners, organisers and teams we met along the way. Next stop? Stay tuned.

Encode Hackathon: Envio’s Winners​

Envio partnered with Encode Club at Encode London 2025 and awarded $3,000 in bounties for builders using HyperIndex and HyperSync. The winners included:

• Best Use of HyperIndex ($1,000) → VeriLoan

• Best Use of HyperSync ($1,000) → Sniffer

• HyperIndex Runner-Up ($500) → TradeTrackr

Congratulations to all the builders who took part and big thanks to the Encode team. For the full breakdown of winners and what they built, check our blog post.

High Performance Indexing on Sonic with HyperSync​

Building on Sonic? Envio keeps up.

Compare Nodes recently benchmarked Envio’s HyperSync on Sonic Mainnet and shared the results publicly. HyperSync provides one of the strongest high performance indexing solutions for Sonic data, backed by real benchmarking results. Their tests scaled from 0 to 1,000 RPC requests per second with full success, and later pushed up to 5,000 requests per second across ten methods. Across two runs they processed around 3.3 million requests in just over thirty minutes!

For the full performance benchmark and breakdown, check Compare Nodes’ original post on X

Tutorial: How to Index Rootstock Data with Envio​

Rootstock released a new tutorial walking developers through how to use Envio to capture and organize on-chain events from smart contracts deployed on Rootstock. The session covers everything from setting up a local environment to writing mappings, generating entities and querying indexed data. It is part of the Hacktivator program and gives builders a full walkthrough of how to index Rootstock data using Envio.

See Rootstock’s original post on X.

MetaMask Smart Accounts x Monad x Envio Hackathon Winners​

We partnered with MetaMask and Monad for the Smart Accounts hackathon, which featured a total prize pool of $15,000. This hackathon focused on the next generation of wallet and smart account experiences. Builders explored account abstraction, modular execution, AI driven automation and real-time blockchain indexing using Envio.

For the full list of winners and a detailed breakdown of their projects, read our blog.

🗓️ Current & Upcoming Events​

• MetaMask x Envio: Advanced Permissions Dev Cook-Off Hackathon: 18th Nov → 31st Dec 2025
• Solana Breakpoint: 11th → 13th Dec 2025

🧑‍💻 Featured Developer: Kevin Lin​

This month’s featured dev is Kevin Lin, a Web3 engineer from Taiwan who has been building dashboards and analytics tools across identity, x402 community activity and prediction markets. Kevin uses Envio as the indexing layer across several of his projects.

For Self Protocol, he indexes real-time registration and disclosure actions to help the team track user growth and protocol health. In the x402 ecosystem, he built this epic PING dashboard, which tracks community engagement around the first major x402-era meme, including new addresses, interaction patterns and Uniswap V3 and V4 liquidity pools.

His latest project, PolyPilot, is a Polymarket analytics tool that pulls candlestick charts from on-chain trades and includes a Market Explorer and Trader Explorer, with more smart money analysis on the way.

Big thanks to Kevin for all his amazing contributions, for being an outstanding member of our community and for everything he continues to build with Envio.

“What I really like about Envio is that the DX is super smooth. The documentation is excellent, with solid templates and multiple examples, so it’s very friendly for vibe coders working on side projects. It also scales nicely from internal dashboards to public products, and lets me focus on what the user sees instead of worrying about indexing infra.” – Kevin Lin, Integration Engineer at Self Protocol

Be sure to follow them on X and check out their work on GitHub to stay up to date with what they are building.

🎧️ Playlist of the Month​

▶️ Open Spotify

🚢 Ship With Us​

Envio is a multi-chain EVM blockchain indexer for querying real-time and historical data. If you’re working on a Web3 project and want a smoother development process, Envio’s got your back(end). Check out our docs, join the community, and let’s talk about your data needs.

Stay tuned for more monthly updates by subscribing to our newsletter, following us on X, or hopping into our Discord for more up-to-date information.

Subscribe to our newsletter 💌

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

Envio joined MetaMask Developers and Monad for the MetaMask Smart Accounts Dev Cook-Off, a global hackathon focused on the next generation of wallet and smart account experiences. Over three weeks, builders explored account abstraction, modular execution, AI driven automation, and real-time blockchain data indexing using Envio.

The projects below stood out across innovation, execution quality, and use of Envio’s indexing stack. Let’s take a look at our winners.

Best use of Envio ($2,000): Last Monad​

Last Monad built a live network dashboard that showcases activity across Monad in real-time. Using Envio to index contract events with high speed and accuracy, the team delivered an always up to date view of the chain.

The project shows how real-time blockchain indexers like Envio unlock transparent analytics for high performance networks, giving developers a clear way to explore and understand on-chain behaviour as it happens.

Best Onchain Automation ($1,000): TradeClub​

TradeClub introduced automated on-chain execution powered by smart accounts. The project used Envio to index their data to power intent based triggers and automated flows, allowing users to run actions without managing complex backend logic.

It highlights how real-time data from Envio’s blockchain indexing solution can support consumer friendly automation and smarter on-chain behaviour.

Best AI Agent ($1,000): ShieldAI​

ShieldAI built an on-chain monitoring agent that reacts to blockchain events on Monad in real-time. With Envio providing reliable, indexed data, the agent could track contract interactions, detect anomalies, and surface insights efficiently.

It shows how AI agents become significantly more powerful when they can rely on clean, real-time blockchain data from indexing solutions like Envio.

Best Consumer App ($1,000): Smart Account Explorer​

Smart Account Explorer created a clear interface for viewing and understanding smart account activity. With Envio’s real-time blockchain indexing layer handling the heavy lifting, the app delivered fast lookups of permissions, transactions, and account behaviour without any lag. It made smart accounts feel accessible and transparent for everyday users.

The project shows how consumer apps can improve usability by pairing smart accounts with fast, structured on-chain data from indexing solutions like Envio.

Conclusion​

The MetaMask Smart Accounts x Monad Dev Cook Off highlighted what happens when wallet innovation meets real-time data performance. From onboarding to gaming and DeFi UX, each project showed what’s possible when you mix smart accounts and efficient blockchain tools like Envio.

Envio’s multichain blockchain indexer remains a cornerstone for teams indexing Monad data. Developers can use it to access efficient, real-time data on Monad and any other EVM chain. It gives them a simple way to query and understand Monad activity in real-time without dealing with the overhead of running or scaling their own indexing infrastructure.

About Envio​

Envio is a fast, developer friendly blockchain indexer that makes real-time data accessible for builders on Monad and across Web3.

With Envio, developers can query and stream blockchain data efficiently without the complexity of running their own infrastructure. Envio’s blockchain indexing tools support Monad and any EVM network and are trusted by many teams building everything from DeFi platforms to analytics dashboards and production applications.

If you’re a blockchain developer or analyst looking to enhance your workflow, look no further. Join our growing community of Web3 builders and explore our docs.

Website | X | Discord | Farcaster | GitHub | Medium

Envio proudly partnered with Encode Club at the London 2025 hackathon, offering $3,000 in bounties for builders using HyperIndex and HyperSync. Over one weekend, developers explored how Envio’s fast blockchain indexing stack helps power real-time applications in Web3.

The results spoke for themselves.

Best use of HyperIndex ($1,000): VeriLoan​

Team: Myo Myat

GitHub: LuLuKar05/VeriLoan

Demo: YouTube

VeriLoan solves one of DeFi’s biggest problems, trust. It connects Concordium’s privacy preserving identity proofs with EVM wallets to enable verified borrower profiles. Using Envio HyperIndex, the team aggregated lending data from Aave, Compound, and Spark to generate real-time DeFi credit reports. The project shows how Envio’s blockchain indexer can power private, compliant, and capital efficient lending systems built on trust rather than collateral.

Best use of HyperSync ($1,000): Sniffer​

Team: Abdul Aaqib Ali

GitHub: Junaid2005/encode-hack-nov

Demo: YouTube

Sniffer uses Envio HyperSync and GPT 5 to make blockchain forensics conversational. Investigators can ask natural language questions and receive instant fraud reports with charts, alerts, and insights. HyperSync’s real-time data access, up to 2000 times faster than RPC, allows Sniffer to detect suspicious patterns almost immediately in real-time. It is a perfect example of how powerful blockchain indexing tools like Envio can bring AI and on-chain analytics together.

Best use of HyperIndex Runner Up ($500): TradeTrackr​

Team: Xferno GT

GitHub: Cozkou/portfi

Demo: YouTube

TradeTrackr turns crypto trading into a social experience. Users can track their portfolios, join groups, and compete in trading leagues with real-time data indexed by Envio HyperIndex. Built with React, Tailwind, and shadcn UI, it supports Ethereum, Polygon, Base, and Arbitrum. The app uses Concordium for optional identity verification, creating fair competitions and trusted leaderboards. It shows how modern blockchain indexers like Envio make multichain analytics accessible for any Web3 project.

Conclusion​

From AI powered fraud detection to privacy aware lending and social trading apps, these teams proved that real-time data is the foundation of the next generation of decentralized applications.

Envio continues to push the boundaries of performance and reliability for developers who need a fast, scalable, and developer friendly Web3 indexer. Big thanks to the Encode team for having us, all the organizers and partners. Congratulations to all the winners and to every builder who participated.

About Encode London​

Encode London is part of the global Encode Club hackathon series, which brings together developers, founders, and students to build new Web3 applications and infrastructure. The event connects builders with technical partners like Envio, helping them explore blockchain indexing, data analytics, and real-time Web3 tools.

Each Encode Club hackathon fosters collaboration, education, and growth within the Web3 community, showcasing how open innovation continues to push blockchain development forward.

About Envio​

Envio is a fast, developer friendly blockchain indexer that makes real-time data accessible for builders across Web3.

With HyperIndex and HyperSync, developers can query and stream blockchain data efficiently without the complexity of running their own infrastructure. Envio’s blockchain indexing tools support any EVM network and are trusted by teams building everything from DeFi platforms to analytics dashboards and production applications.

If you’re a blockchain developer or analyst looking to enhance your workflow, look no further. Join our growing community of Web3 builders and explore our docs.

Website | X | Discord | Farcaster | GitHub | Medium | YouTube

Reliability and performance were the big themes this month, with a focus on making indexing even smoother across the board. We rolled out v2.31.0, shipped key upgrades to rollback handling and database performance, and saw some great contributions from the community.

We dive into how a Uniswap alert system uncovered a MEV bot making millions, introduced a new Scaffold ETH 2 extension for faster indexer setup, and shared a look at the team’s involvement across ETHOnline, Encode London and much more. Let’s dive in!

⚡ MAJOR Releases: v2.30.0 → v2.31.0​

V2.30.0: Speed, consistency, and migration-friendly improvements​

Version 2.30.0 introduced key performance and compatibility updates focused on reliability at scale.

Address Format Configuration​

You can now choose between checksum (default) and lowercase addresses directly in your config.yaml. The lowercase option makes it easier to migrate existing SubGraphs and can improve performance in some cases.

# config.yaml
address_format: lowercase

Faster Event Decoder for RPC Source​

The RPC source now uses the HyperSync event decoder, offering a significant speed boost compared to the previous Viem decoder.

Fixes:

• Resolved a regression in 2.29 that affected indexing at the head Prometheus metric.
• Fixed a race condition during Hasura configuration that occasionally prevented certain GraphQL entities from having read permissions.

Internal Improvements:

• Ensured all events from a single block are processed together for stronger data consistency.
• Optimized JS batch creation logic, improving handling for high-volume indexers (100k+ events/sec).
• Adjusted dynamic address persistence to only store processed events.

These updates laid the groundwork for the reorg refactoring work and further system optimizations in 2.31.0 and upcoming releases.

V2.31.0: Big Reliability Release​

Rollback On Reorg Refactoring​

We completely rebuilt our rollback on reorg logic to make indexing more robust, predictable, and faster. This update introduces a range of performance and stability improvements across indexing and database handling.

Highlights​

• Fixed all known indexing and rollback on reorg issues
• Optimised database writing logic to reduce latency by dozens of milliseconds
• Reduced internal table size for managing reorg and rollback
• Improved Events Processed counter accuracy for verifying data consistency

Nice Additions​

• Added subgraph migration cursor rule initialisation support
• Exposed chain readiness status through context.chains
• Expanded supported entity name length up to 63 characters

👉 See full release notes

👉 Star us on GitHub ⭐

The Uniswap Alert System That Uncovered a MEV Bot Making Millions​

While testing a Uniswap alert system, the team accidentally uncovered an active MEV bot that has been making millions every week on mainnet!

The Telegram bot was meant to ping whenever a Uniswap v4 pool hit $1M TVL. The goal was simple: catch hot new tokens early. Instead, the alerts started firing on pools that barely held any TVL at all.

A closer look revealed flash liquidity spikes driven by an MEV bot executing sandwich attacks across v3 and v4 pools. With over 11 million transactions on mainnet, the on-chain data paints a wild picture of just how active these bots are.

Read the original thread on X and join the Telegram group to see the alerts in action.

Getting Started with Envio’s Scaffold ETH 2 Extension​

You can now build Scaffold ETH 2 apps that stream real-time data into your frontend without writing any code.

Our curated Envio extension adds automatic indexer generation to your project, making it simple to index all deployed contracts and query their data through a GraphQL API. Your frontend can subscribe to events as they happen, power live dashboards, and stay in sync with the chain with minimal setup.

Check out the full tutorial in our documentation.

ETHGlobal’s ETHOnline Hackathon​

ETHGlobal’s ETHOnline returned this month, bringing together builders from around the world for one of the largest virtual hackathons of the year.

Envio joined as a proud partner with $5K in bounties up for grabs. If you’re participating, check out our ETHOnline workshop for an introduction to HyperIndex and HyperSync, how to scaffold, deploy, and stream real-time data, plus past winning hacks, tips, and starter repos to help you ship faster. We look forward to seeing what everyone builds!

P.S. Our bounties can double as a bonus on top of whatever you’re already building, since our tooling plugs right in if you’re deploying contracts or working with on-chain data. 😎

Understanding Stablecoin Flows in Real-time​

Stablecoins move faster than ever, and understanding that flow in real-time opens up new layers of insight, from transaction velocity to how close we are to Visa or Mastercard throughput.

Co-Founder Jonjon Clark shared an early look at a live dashboard powered by Envio, which tracks stablecoin transfers across chains in real-time. It highlights what’s possible when real-time data meets transparent on-chain finance.

Check out the original post on X.

Scaling Indexing for the Next Generation of Blockchains | Pragma New Delhi Workshop​

Blockchain throughput has grown from 15 TPS in early networks to over 400K TPS on chains like Monad, Sonic, and MegaETH. As networks scale execution, Envio focuses on scaling indexing so developers can keep up with real-time data at that speed.

Co-Founder, Denham Preen, led a workshop at ETHGlobal Pragma New Delhi, sharing how Envio approaches modern blockchain indexing at scale and what it takes to stay in sync with high-performance chains.

Envio Showcase​

We launched a new showcase page highlighting live demos built with HyperIndex and HyperSync. From real-time dashboards to on-chain visualizations, it’s a growing collection of projects built by the community and team to show what’s possible with Envio.

Explore the Showcase in our documentation.

Empowering Builders with Real-Time Indexing | Encode London 2025​

Envio joined Encode London 2025 as a partner, offering $3K in bounties to support builders throughout the weekend hackathon.

The event brought together developers, founders, and innovators from across the ecosystem for a full weekend of hacking, talks, and late nights at the Hub.

Our Co-Founder, Jonjon Clark, hosted a workshop on real-time blockchain indexing, sharing how developers can move from indexing to streaming data in real-time using Envio’s suite of tools.

Well done to all the builders and a big shoutout to the Encode team and organizers for an incredible event!

🗓️ Current/Upcoming Conferences, Events & Hackathons​

• EthOnline Hackathon: 10th → 31st October 2025
• Edge City Patagonia: 18th October → 15th November, 2025
• Devconnect Buenos Aires: 17th → 22nd November 2025

🧑‍💻 Featured Developer​

This month’s featured developer is Enguerrand, a builder with a strong focus on low level tech and decentralized solutions to real world problems.

As CTO at LONG(), he’s building plug and play monetization rails for platforms. With a few API calls, LONG() lets teams integrate markets for crowdfunding, fair launches, and rewards, powered by transparent and open market mechanics that make Web3 monetization seamless.

Before LONG(), Enguerrand operated one of Ethereum’s earliest mining setups and led engineering at Lum Network, contributing to multiple Cosmos based stacks. He’s also worked with Ubisoft on community made multiplayer mods for Watch Dogs Legion and created mods for the Mafia series.

He recently contributed to our latest release by adding the ability to access chain readiness status through context.chains, helping improve transparency and reliability across indexing operations.

Always great seeing developers like Enguerrand push performance and developer experience even further with Envio.

“What I really appreciated at Envio is 1. the DX is great and super easy to move to, 2. it works flawlessly, 3. its SUPER performant compared to competitors and 4. The team is great, super professional and easy to reach.” - Enguerrand CTO at LONG()

Be sure to follow them on X and check out their work on GitHub to stay up to date with what they’re building.

🎧️ Playlist of the Month​

▶️ Open Spotify

🚢 Ship With Us​

Envio is a multichain EVM blockchain indexing solution for querying real-time and historical data. If you’re working on a Web3 project and want a smoother development process, Envio’s got your back(end). Check out our docs, join the community, and let’s talk about your data needs.

Stay tuned for more monthly updates by subscribing to our newsletter, following us on X, or hopping into our Discord for more up-to-date information.

Subscribe to our newsletter 💌

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

Welcome to our September Developer Update.

This month, we shipped major new features in v2.28.0 and v2.29.0, introduced Block Handlers and the new _meta query, and rolled out significant performance improvements that make indexing even faster and more efficient. We were on the ground at Pragma, ETHGlobal New Delhi, and Sonic Summit in Singapore, explored how AI is shaping blockchain data, and showcased Envio’s indexing support for MegaETH along with how we power tools like Liqo, a liquidations leaderboard.

We also kicked off new hackathons with MetaMask and Monad and confirmed our partnership for Encode London next month. Let’s dive in!

⚡ Big Releases: v2.28.0 → v2.29.0​

V2.28.0​

For a visual walkthrough, check out our Shipper Log v2.28.0 on YouTube.

Official _meta query​

HyperIndex now exposes an official _meta query that returns indexing metadata per chain, making it simple to monitor progress and track sync status.

2× faster and cheaper historical sync​

Block range selection for log queries has been improved, cutting the number of required requests for some RPC providers in half, making historical sync up to 2x faster. HyperSync responses are now smaller, faster, and simpler, reducing ingress costs while improving performance.

Big performance boost for large factories​

Indexers handling large numbers of addresses now sync significantly faster. In testing, an indexer with over 2 million addresses synced in about two days instead of four.

Subgraph migration Cursor rules cheatsheet​

A new Cursor rule example in our repo helps you quickly migrate existing Subgraphs to HyperIndex.

⚠️Potential breaking change​

We’ve refactored internal tables to focus on a single public entry point: _meta. Internal tables such as chain_metadata, event_sync_state, persisted_state, end_of_block_range_scanned_data, and dynamic_contract_registry are now hidden from Hasura, and their internal representations have changed.

If this impacts your setup, reach out, and we’ll help you migrate smoothly.

V2.29.0​

View Shipper Log on YouTube

🆕Block Handlers​

You can now run logic on every block or at defined intervals, unlocking new use cases like aggregations, time-series data, and bulk updates using raw SQL.

Example:

import { onBlock } from "generated";

onBlock(
  {
    name: "MyBlockHandler",
    chain: 1,
    interval: 10,
    startBlock: 10_000_000,
  },
  async ({ block, context }) => {
    context.log.info(`Processing block ${block.number}`);
  }
);

Read our docs to learn more about block handlers and the powerful use cases they enable, like:

• Time intervals
• Preset handlers
• Multichain mode
• Different intervals for historical vs. real-time sync

Be sure to check out our Example Indexer to see Block Handlers combined with Preload Optimization, Effect API queries, and Traces indexing to track all contracts deployed on Mainnet.

👉 See full release notes

👉 Star us on GitHub ⭐

Liqo Brings Real-Time Liquidation Insights Across Major DeFi Protocols​

Track major real-time liquidations in style with Liqo, a powerful liquidation leaderboard tool powered by Envio. The new leaderboard gives you a clear view of the most active liquidators across top protocols like Aave, Morpho, and Euler, with support for Twyne coming soon.

It makes exploring liquidation activity across multiple chains and protocols easier than ever, all from one place.

Shoutout to Saurav for their contributions to the sleek UI upgrade.

Check out the original post on X.

MetaMask Smart Accounts Hackathon with Monad and Envio​

The MetaMask Smart Accounts Hackathon, in collaboration with Monad and Envio, is now live and will run from September 19 to October 20. Builders are invited to create next-level applications on Monad with a focus on account abstraction and user experience.

Envio is putting up $5,000 for builders:

• $2,000 for Best Use of Envio

• $3,000 in bonuses

In total, $15,000 in prizes are up for grabs.

More details on Hackquest.

Missed our kickoff call and want to learn more? Check out the broadcast on X.

Envio at Pragma and ETHGlobal New Delhi​

The team was in New Delhi for Pragma and ETHGlobal, spending the week with builders, founders, and partners across the ecosystem. Every dapp relies on indexing, but most existing solutions are slow, siloed, and unreliable.

We shared how HyperIndex and HyperSync change that, bringing high performance, multi-chain infrastructure that scales with the modular ecosystem. The result is faster dapps, richer analytics, and a reliable data backbone developers can build on with confidence.

Big thanks to ETHGlobal, the organisers, partners, and everyone who stopped by to chat with us in New Delhi.

Envio Supports MegaETH Builders with Lightning-Fast On-Chain Data Access​

100k+ TPS, 10+ ggas p/s & <10ms blocks? Envio is built for it. Our indexing framework supports developers building on MegaETH with efficient access to both real-time and historical data.

With Envio, you can sync millions of events up to 2000x faster than RPC, making data access easy, fast, and fully customizable even at massive scale. Our performance and mainnet readiness make Envio the ideal choice for builders looking to ship real-time and performant applications on MegaETH.

The State of AI in Blockchain Data: Neon x Envio​

Blockchain generates endless streams of data, and powerful indexers like Envio make it usable. But what happens when AI steps into the picture?

We joined Neon and Subsquid for a live panel to dig into how AI is reshaping the way data is accessed, organized, and understood in Web3. The conversation explored how intelligence layers can boost indexing workflows, change how developers build with on-chain data, and what the future looks like as AI becomes part of the core data stack.

Missed it live? Catch the full recording of the broadcast on X.

Join Envio at Encode London This October​

We’re excited to be partners at the Encode London Hackathon and Conference, taking place from 24–26 October at the Encode Hub in Shoreditch, London. This three-day event brings together builders, researchers, and industry leaders for hands-on hacking, talks, and workshops focused on AI and Web3. Our team will be on the ground all weekend supporting builders, so keep an eye out for us throughout the event.

Plus, we’ll be hosting a speaking slot and putting up a couple of bounties with prizes, more details coming soon!

See full event details and get tickets in Luma.

Developer Workshop Series: Exploring Aave with Envio​

We’ve kicked off a 16-part developer workshop series, starting with a session focused on exploring Aave data using Envio. The series is designed to help developers get hands-on with real on-chain data, showing how to query, index, and build with Aave using Envio.

More workshops are on the way, so be sure to subscribe this YouTube channel

to follow along and catch every session.

🗓️ Upcoming Events​

• Encode London: 24th → 26th October 2025
• Devconnect Buenos Aires: 17th → 22nd November 2025

🧑‍💻 Featured Developer​

This month’s featured developer is Ryan Holanda, Co-founder and CTO of Zup Protocol. A software engineer since the age of 16, Ryan brings advanced expertise across front-end, mobile, blockchain, and design. Driven by a deep passion for DeFi and the Web3 ecosystem, he has dedicated his career to building innovative solutions that empower users and promote financial freedom.

At just 20 years old, Ryan has already won multiple hackathons, contributed to several open source projects, and founded Zup Protocol. He is known for his quick problem-solving skills across a wide range of domains, from Figma design to complex blockchain engineering.

“Envio is by far the best indexer on the market today. Their innovative approach to indexing blockchain data helped Zup Protocol reduce the sync time for historical liquidity pools data from 3 months with Subgraphs to just 2 days using their hosted service. The Envio team is amazing and always ready to help whenever you need support. If you like great products and cool teams, you should definitely give it a try (pro tip: the migration from Subgraphs is veeeery easy ).” - Ryan Holanda, Co-Founder & CTO of Zup Protocol

Be sure to follow them on X and check out their work on GitHub to stay up to date with what they are building.

🎧️ Playlist of the Month​

▶️ Open Spotify

🚢 Ship With Us​

Envio is a multichain EVM blockchain indexing solution for querying real-time and historical data. If you’re working on a Web3 project and want a smoother development process, Envio’s got your back(end). Check out our docs, join the community, and let’s talk about your data needs.

Stay tuned for more monthly updates by subscribing to our newsletter, following us on X, or hopping into our Discord for more up-to-date information.

Subscribe to our newsletter 💌

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

Welcome to our August Developer Update.

This month, we shipped preload optimization in v2.27.0, added contract-specific start blocks, and rolled out improved contributing guidelines with built-in Cursor rules. HyperSync also went global, we joined the Mobil3 hackathon in Mexico City, and we built a Telegram-to-Notion sync utility to make CRM management easier. Let’s dive in!

⚡ BIG Releases: v2.27.0​

Preload Optimization​

HyperIndex now preloads entities used by handlers via batched database queries, maintaining the original order of event processing. Paired with the Effect API for external calls, this gives big performance gains over other indexing solutions.

Set a single line in your config and make your handlers run multiple times faster without changing a single line of code:

preload_handlers: true

⚠️ Note: Preload optimization runs your handlers twice. From envio@2.27, all new indexers include it by default.

Contract-specific start block​

HyperIndex now supports indexing with start blocks on a per-contract basis (previously, start blocks were only per-network), a highly requested feature contributed by one of our community members, Rangel Stoilov.

Example: register NFT contracts from a factory but start processing Transfers only from block 30,000,000:

name: nft-indexer
description: NFT Factory
networks:
  - id: 1337
    start_block: 0
    contracts:
      - name: NftFactory
        address: 0x4675a6B115329294e0518A2B7cC12B70987895C4
        handler: src/EventHandlers.ts
        events:
          - event: SimpleNftCreated(string name, string symbol, uint256 maxSupply, address contractAddress)

      - name: Nft
        # No address field - we'll discover these addresses from SimpleNftCreated events
        start_block: 
        handler: src/EventHandlers.ts
        start_block: 30000000 # Overwrite the network start block
        events:
          - event: Transfer(address from, address to, uint256 tokenId)

👷‍♀️👷‍♂️ Contributing Improvements​

We’ve updated our CONTRIBUTING.md with a detailed guide to navigating the HyperIndex codebase and examples of changes in action. We’ve also added .cursor rules to make developing new HyperIndex features easier.

Embrace Vibe-Coding​

All new projects now include initial .cursor rules to help you build indexers with agent support. Got ideas? Send a PR with rule suggestions to improve the experience for everyone. 😉

👉 See full release notes

👉 Star us on GitHub ⭐

Introducing Shipper Logs​

Our new YouTube series covers release updates, new features, and optimizations. Episode 1 covers preload optimization in the v2.27.0 release and how it speeds up indexing.

Introducing Chain Pulse​

A simple yet powerful tool to quickly check the pulse of multiple blockchains in real time.

With a single command, you can instantly see:

• 📊 Throughput
• 🔄 Transaction activity
• 👥 Address activity
• 📑 Logs & other key metrics

Chains already cooking include: BNB, MegaETH, Taraxa, Monad, Base, Unichain (Sepolia), and Polygon, with more on the way.

Just run:

npx chainpulse

👉 Check out the original post on X.

Envio Powers Zup Protocol​

Easily search millions of pools across multiple DEXs and chains for the best yield per pair. Really cool tech.

Zup Protocol now connects you to 1M+ pools and 16 protocols across 5 blockchains.

Powered by Envio, you can compare 1,000+ combos in just 10 seconds.

👉 Check out Zup Protocol: app.zupprotocol.xyz

HyperSync is now Globally Distributed​

We’ve joined the official list of K8GB adopters. HyperSync is now served from multiple regions, giving builders faster and more reliable access wherever they are.

🇲🇽 Mobil3 Hackathon - Mexico City​

We had a great time at the Mobil3 Hackathon in CDMX!

Envio put up a $2,000 USD bounty for the best real-time payments or consumer fintech dashboards built using Envio.

Co-founder Denham Preen was on-site, leading a workshop on HyperIndex + HyperSync and offering 1:1 mentoring to teams throughout the hackathon.

Big thanks to the Mobil3 organizers, the Monaa Foundation, and all the builders who made it an incredible event!

💸 $943M Frozen​

Say hello to the only list you don’t want to be on → The Banned List

This dashboard tracks funds frozen across USDT and USDC on Ethereum mainnet. Right now, over $943M is locked in blacklisted wallets. USDT accounts for $833.78M and USDC makes up $109.73M.

Some of the top wallets hold tens of millions, with one blocked from moving $50.25M. New addresses continue to be blacklisted, including one with $1.37M that keeps trying to move funds out. It’s still not clear why these wallets have been targeted, but the dashboard makes it easy to explore and investigate what’s happening in real time.

👉 Check out the original post on X.

💧 Introducing Liquidator​

Say hello to Liquidator, a new tool that lets you watch liquidation events unfold live in your terminal.

Powered by Envio, it can cut through more than 10 chains in seconds and surface hundreds of thousands of liquidation events, raw, unfiltered, and in real time.

Liquidator is currently live for Aave, with more protocols coming soon. Which one should we add next? 👀

👉 See the original post on X.

📦 Telegram to Notion Sync CRM Tool​

Managing endless Telegram groups is a hassle, so we built an open-source CLI tool that syncs your Telegram chats into a Notion database.

It finds all chats with a specific substring, adds new ones automatically, and lets you manage them with Kanban, labels, and reminders.

Credits to Kenau Vith

👉 Check it out on GitHub

🗓️ Upcoming Events​

• Encode London: 24th → 26th October 2025
• Devconnect Buenos Aires: 17th → 22nd November 2025

🧑‍💻 Featured Developer​

This month’s featured developer is Mikko Ohtamaa, CEO and Co-Founder of Trading Strategy, a Web3 algorithmic trading protocol. Over the past decade, Mikko has served as CTO at leading blockchain companies like LocalBitcoins (one of the first Bitcoin exchanges) and TokenMarket (one of the first ICO platforms), where he helped build infrastructure for more than $1B in digital assets. He’s also an active voice in digital rights and open-source communities.

Thanks for being an awesome member of our community, Mikko!

“We use Envio because it's the first indexer that works. Envio is easy to integrate with modern data research and trading pipelines based in Python. This allows us to integrate more chains, faster, go deeper in data, and finally have a developer experience blockchain programmers have craved for.” - Mikko Ohtamaa, CEO & Co-Founder at Trading Strategy

Be sure to follow them on X and check out their work on GitHub to stay up to date with what they are building.

🎧️ Playlist of the Month​

▶️ Open Spotify

🚢 Ship With Us​

Envio is a multichain EVM blockchain indexing solution for querying real-time and historical data. If you’re working on a Web3 project and want a smoother development process, Envio’s got your back(end). Check out our docs, join the community, and let’s talk about your data needs.

Stay tuned for more monthly updates by subscribing to our newsletter, following us on X, or hopping into our Discord for more up-to-date information.

Subscribe to our newsletter 💌

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

Welcome to our July Developer Update.

This month, we embraced built-in cache for effect calls, improved loaders, added new testing utilities, and introduced more control over output configuration. We also launched a one-click indexer generator, shipped fresh hacks from our internal hackathon, and kept refining the overall developer experience.

We made stops at EthCC and Pragma Cannes too, catching up with builders from across the space. Let’s dive in!

Latest Releases: v2.23.0 → v2.26.0​

⚠️Note: Current Release is v2.26.0

Built-in Cache for Effect Calls​

import { experimental_createEffect, S } from "envio";

export const getMetadata = experimental_createEffect(
  {
    name: "getMetadata",
    input: S.string,
    output: {
      description: S.string,
      value: S.bigint,
    },
    cache: true, // Simply set cache to true
  },
  async ({ input, context }) => {}
})

Learn more in our docs about how to persist the cache on reruns and share it with Hosted Service (alpha).

V2.23.0​

Embracing loaders​

In v2.23.0, we added context.set, context.unsafeDelete, and context.getOrCreate to loaders.

Add context.isPreload to distinguish between the first and second loader run. If you are a power user, from now on we recommend going all-in with loaders and keeping your handlers empty.

Learn more in our dedicated loaders guide.

For a full list of changes and more information about current and past releases, view the release notes on our GitHub.

Love what we’re building as much as we do and want to stay updated on our latest releases and developments? Give us a star on GitHub! Your support means the world to us! ⭐

New Feature: Instantly Generate an Indexer from Your Contract Address​

We’ve refreshed our landing page with a handy new tool. Simply paste your contract address to:

• Get an estimated indexing time
• Receive one command to autogenerate your indexer
• No config files. No guesswork. Just paste and go.

Try it out now by visiting our landing page.

Envio Supports Base with Lightning Fast Data Retrieval​

Base is booming. Your data should too. Envio’s HyperSync supports Base with the most advanced indexing on the market. Sync historical data in minutes, access it up to 2000x faster than RPC, and query structured logs, traces, events, and functions.

Learn how to index millions of events in Seconds on Base using Envio in this thread.

Internal Hackathon July 2025​

We wrapped up another successful internal hackathon during our team offsite this month. The goal? Build tools that push Envio forward. Some are already live.

We run these every last Thursday of the month, so keep an eye out for more builds. Let us know which one’s your favourite.

Check out this thread to see what we built in under 24 hours.

Supercharge Your Ethereum Data With Envio’s HyperSync​

Ethereum is on fire. ETF inflows are climbing, regulatory clarity is coming, and price action is picking up. The network’s heating up, but can your infrastructure keep up? Envio’s HyperSync lets you index millions of events on Ethereum in seconds. No delays. Just fast, structured access to the data that matters.

Learn how in this thread.

EthCC & Pragma Cannes 2025 Recap​

Yes, we Cannes!

Big shoutout to the EthCC team for an incredible event, and to ETHGlobal for hosting a packed Pragma. Non-stop energy, great convos, and a stacked builder crowd.

We’re proud to be building alongside some of the sharpest devs and innovators in the space. Huge thanks to everyone who made it happen. Until next time.

Missed our workshop on lightning-fast multi-chain indexing? Catch the replay on YouTube.

Upcoming Events 🗓️​

• Ethereum 10th Anniversary Cape Town: → 30th July 2025
• Devconnect Buenos Aires: 17th → 22nd November 2025
• Mobil3 Hackathon Mexico: 20th → 24th August 2025

Featured Developer 🧑‍💻​

This month’s featured developer is Nikhil, a software developer and technical content creator who’s been sharing practical insights with Web3 devs for years. He’s worked with teams like Figment, Celo, and Bitquery, crafting developer-facing content. Nikhil has also contributed as a Solidity developer on smaller DeFi projects and is now focusing on personal projects while exploring new opportunities.

He recently got hands-on with Envio, using our tools live on stream to build a custom database for Across Protocol. His clear walkthroughs on his YouTube channel and detailed feedback have helped surface valuable insights and made our tooling more accessible to the wider community.

“I came across Envio through some of the content Jonjon had shared, his projects like Logtui and V4, really caught my attention and pushed me to try it out. What I was looking for was a framework that gave me full control and flexibility, and Envio delivers exactly that.

I’m currently working on a personal project to build an explorer and analytics platform for Across Protocol, so it felt like a good time to dive into Envio. So far, the experience has exceeded expectations. The documentation is solid, it answers almost every question I’ve had while working with it.” - Nikhil, Developer & Web3 Educator

Be sure to follow Nikhil on X and check out their work on GitHub to see what they’re building next.

Playlist of the Month 🎧️​

▶️ Open Spotify

Ship With Us 🚢​

Envio is a multichain EVM blockchain indexing solution for querying real-time and historical data. If you’re working on a Web3 project and want a smoother development process, Envio’s got your back(end). Check out our docs, join the community, and let’s talk about your data needs.

Stay tuned for more monthly updates by subscribing to our newsletter, following us on X, or hopping into our Discord for more up-to-date information.

Subscribe to our newsletter 💌

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

As part of Mission 4 from the Monad Developers community, we challenged builders to create the most innovative real-time dashboards and visualizers on Monad using Envio. The results were exceptional. The developers delivered powerful tools that showcased not only creative visualizers and dashboards but also the power of Envio’s indexing stack.

Monad’s rapid growth has created a strong need for scalable, real-time data infrastructure. Whether tracking protocol activity, analyzing transaction flows, or building live analytics dashboards, a high-performance indexer is critical.

Envio is helping developers meet this demand with a robust suite of indexing tools that are purpose-built for high-throughput chains like Monad. These submissions highlight how Envio simplifies data indexing on Monad, enabling rich, real-time applications with speed, accuracy, and ease.

Let’s dive into some of the submissions built during Mission 4.

Monad Super Visualizer​

By @monadicoo

This immersive dashboard allows users to explore live activity across the entire Monad chain. It provides deep visibility into data from specific protocols, contracts, or addresses. Envio powers two core functionalities: streaming live, chain-wide activity to the homepage, and offering a filtered data feed for targeted protocol analysis.

Check it out here

Monad Genki Dama​

By @sifu_lam

A unique Dragon Ball Z-inspired visual experience that depicts each Monad testnet block as energy contributing to a Genki Dama. Monanimals generate power balls representing transaction types, visually charging the Monad mainnet. Envio’s HyperSync ensures real-time accuracy and high throughput with minimal latency.

Check it out here

LendHub Stats Page​

By @bossonormal1

LendHub’s dashboard presents real-time analytics for a peer-to-peer NFT lending protocol. It tracks metrics such as loans listed, funded, repaid, claimed, and withdrawn. Custom-built with Envio’s config.yaml, schema.graphql, and event handlers, this tool uses a GraphQL endpoint to update dynamically based on key smart contract events.

Check it out here

Miris​

By @velkan_gst

Miris is a fully featured chain visualizer offering insights into blocks, transactions, and overall network health. Envio handles the indexing of core protocols like Wormhole and Apr Labs, and the Explorer page also uncovers activity from additional Monad projects. Built using Apollo Client and Next.js.

Check it out here

Monad Frens​

By @WagmiArc

Monad Frens delivers real-time and historical chain insights in a visually engaging format, including a pizza-themed chain status display. Envio’s HyperSync feeds accurate block and transaction data, while a custom API calculates cumulative transactions since Block 0. The dashboard filters transactions by timestamp, ensuring comprehensive tracking.

Check it out here

MonLake​

By @YOUZYPOOR

An aquarium-themed visualization of the Monad testnet, where Monanimals represent blocks and treasure chests symbolize various transaction types. Failed transactions appear as jellyfish. Real-time metrics like gas price and transaction distribution are updated using Envio, which indexes all relevant data without stressing RPC endpoints.

Check it out here

Animonad​

By @Samruddhi_Krnr

Animonad tracks live transactions per second across Monad-based dApps like Magma, PancakeSwap, and Narwhal Finance. Each transaction is categorized by address and function signature. Envio’s HyperSync facilitates rapid data retrieval to update the UI every second, powering dynamic graphs and protocol rankings.

Check it out here

NadMetrics​

By @yomax75

Built with React, TypeScript, Node.js, and WebSockets, NadMetrics is a robust analytics platform offering real-time and historical data for Monad. The dashboard is ideal for developers and analysts monitoring chain volume, transaction flow, and usage trends. Envio serves as the foundation for its high-speed data ingestion.

Check it out here

Monalytics​

By @gabriell_santi

An interactive dashboard for real-time visualization of activity on the Monad testnet. It leverages Envio for continuous on-chain event streaming and HyperRPC for fast, low-latency data access. The platform delivers both a global view of the network, including metrics like TPS, gas usage, and block entropy, and protocol-specific panels for apps like MonTools, Castora, Ambient, and more.

Check it out here

Monanimals Blast Mayhem​

By @Pradeeppilot2k5 & @vidit_0

A gamified dashboard transforming real-time blockchain stats into interactive graphics. Monanimals symbolize block numbers, and animated graphs display key metrics such as gas usage, TPS, and block peers. Envio’s HyperRPC ensures seamless data delivery for a high-performance user experience.

Check it out here

Indexing Monad Data Using Envio​

Envio offers a modular indexing solution for developers and analysts seeking to build scalable, real-time applications on Monad. Whether you’re building visual dashboards or analytics platforms, Envio’s indexing stack provides the essential building blocks to transform raw blockchain data into accessible, actionable insights. Here's how each component supports efficient and high-speed indexing on Monad:

HyperIndex​

A full-featured blockchain indexing framework that transforms on-chain events into structured, queryable databases with GraphQL APIs. It offers Monad developers a complete indexing solution with schema management and event handling, making data on Monad easily accessible and developer-friendly.

Learn more

HyperSync​

A high-performance data retrieval layer that gives developers unprecedented access to data on Monad. It directly replaces traditional RPC endpoints, delivering up to 10,000x faster data access. HyperSync enables rapid and cost-effective retrieval of both real-time and historical blockchain data and can be used directly for custom data pipelines and specialized applications.

Learn more

HyperRPC​

A local RPC proxy that supercharges blockchain data access by mapping standard RPC requests to HyperSync’s ultra-fast data engine. HyperRPC accepts typical RPC calls and translates them into HyperSync queries, dramatically reducing latency and eliminating the bottlenecks of traditional RPC endpoints.

Learn more

Envio makes it easy to define events, build handlers, and deploy powerful indexers that power dashboards, data tools, analytics platforms, and more at scale.

Getting Support​

Data indexing can be challenging, especially for complex use cases. Our engineers are always ready to assist you with your data availability needs. Join our growing community of elite builders and experience peace of mind with Envio. Feel free to reach out to us on Discord or email us at hello@envio.dev.

About Envio​

Envio is a modern, multichain EVM blockchain indexer designed for real-time and historical data access. If you’re building on Monad or any other EVM-compatible network, Envio is here to make your development process faster and more efficient. Explore our documentation, join the community, and let’s connect about your data needs.

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

From refining core DX with new helpers and project structure improvements to smarter multichain batching and smoother loader behavior, we shipped updates that made indexing with Envio faster, cleaner, and easier to work with.

We also wrapped up Mission 4 with the Monad community, ran another internal hackathon, hit DappCon Berlin, and plenty more. Let’s jump in.

Latest Releases: v2.22.0 → v2.24.0​

⚠️Note: Current Release is v2.24.0

V2.220​

Added context.Entity.getOrCreate and context.Entity.getOrThrow API

// Before:
// let pool = await context.Pool.get(poolId);
// if (!pool) {
//  pool = {
//    id: poolId,
//    totalValueLockedETH: 0n
//  }
//  context.Pool.set(pool);
// }
const pool = await context.Pool.getOrCreate({
  id: poolId,
  totalValueLockedETH: 0n
})

// Before:
// const pool = await context.Pool.get(poolId);
// if (!pool) {
//  throw new Error(`Pool with ID ${poolId} is expected.`)
// }
const pool = await context.Pool.getOrThrow(poolId)
// Will throw: Entity 'Pool' with ID '...' is expected to exist.
// Or you can pass a custom message as a second argument:
const pool = await context.Pool.getOrThrow(poolId, `Pool with ID ${poolId} is expected.`)

These are additional helpers for DX improvements. Accessible from both handlers and loaders.

Loaders Consistency​

Loaders optimize indexer performance by running twice: first in parallel for all events in the batch, and then just before handler execution to fetch the latest data. While this process remains unchanged, we've made a few improvements:

• If the loader fails on the first run, the error is silently ignored. This can happen if the entity is only available on the second run, so we continue indexing without interruption.

• The HyperIndex test framework now runs the loaders twice to match the actual indexer logic.

Learn more about optimizing database access with loaders in our docs.

Clever Batch Creation for Unordered Multichain Mode​

In previous versions, events for Unordered Multichain Mode were batched based on their order on-chain, pulling from all available chains. While this approach worked, it's more efficient for larger indexers relying on loader optimization to batch events from a single chain. This increases the chances of deduplication and batch optimization.

In the latest version, we now prioritize creating processing batches with events from one chain, and only rotate to another chain for the next batch.

Learn more about multi-chain event ordering in our docs.

Flexible Project Structure​

Previously, to get HyperIndex running, we had a few requirements that limited flexibility and could be confusing:

• It required pnpm-workspaces.yaml file
• It required .npmrc file with shamefully hoisting dependencies
• It required to have the start script in your package.json with ts-node generated/src/Index.bs.js

With the latest update, none of these are necessary. Feel free to remove them, and instead of using ts-node generated/src/Index.bs.js, simply replace it with envio start.

For more information, view all past and current release notes on our GitHub.

If you love what we’re building as much as we do and want to stay updated on our latest releases and developments, give us a star on GitHub! Your support means the world to us! ⭐

Mission 4: Building Visualizers & Dashboards on Monad​

As part of Mission 4 with the Monad Developer community, we invited builders to push the limits of real-time dashboards and visualizers on Monad, powered by Envio. The outcome? A wave of standout projects that combined sharp design with serious indexing performance.

Catch the highlights in our blog.

Exploring Cross-Chain Arbitrage on Uniswap V4​

Curious how much prices diverge across the same Uniswap V4 pools deployed on different chains? One builder tracked ETH/USDC across Ethereum, Base, Arbitrum, and Unichain, building a real-time dashboard that surfaces price discrepancies, trade sizes, and cross-chain spread opportunities as they appear.

V4 digs into how often mispricings occur, how significant they get, and how quickly they're arbitraged, highlighting the unique challenges of cross-chain arbitrage.

Read more on X.

Internal Hackathon​

This month, we wrapped up another internal hackathon. 24 hours, 7 hackers, and a stack of ideas. The goal? Build fast, test new concepts, and push Envio’s tech in new directions.

Take a look at what we shipped by reading this thread.

How to Index Data on MegaEth Using Envio​

When speed is the baseline, precision becomes the edge. Envio proudly supports developers and data analysts building on MegaEth with the most performant real-time indexing stack designed for high-throughput environments. Get fast, reliable access to both real-time and historical data without the usual bottlenecks.

Learn more about how to efficiently index data on MegaEth in our blog.

Join Us at Pragma Cannes​

We’re heading to EthGlobal’s Pragma in Cannes and running a hands-on workshop built for developers. Learn how to easily access, index, and query multi-chain data with Envio.

Still need a ticket? Grab $70 off with our referral link.

Analyzing Safe Data in Real-time Using HyperIndex​

Missed our speaking slot at DappCon? We got you boo! Learn how Envio’s HyperIndex unlocks instant visibility into Safe transactions, from multisig behavior to governance and fund flows in our developer workshop.

How to Index Data on Monad Using Envio​

Envio is proud to support developers and data analysts building on Monad by providing the most efficient and reliable access to real-time and historical data on the Monad network through our modular indexing stack.

Learn more about how to efficiently index data on Monad in our blog.

Upcoming Events 🗓️​

• WAGMI Sponsors at EthCC Cannes: 30th June → 3rd July 2025
• Pragma Cannes: July 3rd, 2025
• Devconnect Buenos Aires: 17th → 22nd November 2025

Featured Developer 🧑‍💻​

This month’s featured developer is Thalles Passos. He’s a full-stack developer from Brazil who started building professionally at just 17. Thalles began his journey with Notus Labs and is now working on Notus API, where the team is creating a complete suite for account abstraction.

He’s also been an active part of the Envio community, giving thoughtful feedback and pushing our indexing tools in real use cases.

“Initially, I found Envio's developer experience a bit unusual and wasn't convinced it was the right fit. However, once I gave it a real try, I was absolutely blown away by its speed. What other indexers might take weeks to accomplish, Envio completed in mere days, and that instantly hooked me.

Their support also truly impressed me. As anyone in web3 knows, getting effective support can be an impossible feat, but Envio completely changed that for me, guiding me through various issues. And as a Brazilian company, where the dollar exchange rate is always a consideration, their pricing structure was incredibly appealing and genuinely surprised us.” - Thalles Passos Full-stack Developer At Notus Labs

Be sure to follow Thalles on X and check out his work on GitHub to see what he’s building next.

Playlist of the Month 🎧️​

▶️ Open Spotify

Ship With Us 🚢​

Envio is a multichain EVM blockchain indexing solution for querying real-time and historical data. If you’re working on a Web3 project and want a smoother development process, Envio’s got your back(end). Check out our docs, join the community, and let’s talk about your data needs.

Stay tuned for more monthly updates by subscribing to our newsletter, following us on X, or hopping into our Discord for more up-to-date information.

Subscribe to our newsletter 💌

Website | X | Discord | Telegram | GitHub | YouTube | Reddit

When speed is the baseline, precision becomes the edge. Envio proudly supports developers and data analysts building on MegaEth with the most performant real-time indexing stack designed for high-throughput environments. Get fast, reliable access to both real-time and historical data without the usual bottlenecks.

MegaEth is reshaping what real-time looks like on the EVM. With sub-millisecond block times and support for over 100,000 transactions per second, built for next-gen applications that demand scale, speed, and reliability.

In this blog, we’ll walk through how to easily index, sync, and query millions of events on MegaEth in minutes using Envio. From setup to production, learn how to get the most out of one of the fastest chains in the ecosystem.

What is MegaEth?​

MegaEth is a high-performance EVM chain purpose-built for real-time applications. It combines sub-millisecond block times with over 100,000 transactions per second, giving developers a foundation to build real-time, responsive, production-grade apps.

Unlike other chains that trade off EVM compatibility for speed, MegaEth keeps your Solidity code, dev tools, and mental models intact. You get Ethereum’s programming experience with none of the latency. Whether you’re powering data analytics, an on-chain game, or a reactive dashboard, MegaEth makes sure your stack never lags behind your users.

Key Features:​

• Mini Blocks + EVM Blocks: Fast mini-blocks (~10 ms) combined with full EVM block finality offer real-time latency and standard blockchain guarantees.

• High-Throughput Sequencing + Parallel Execution: MegaEth achieves high TPS through a centralized sequencer architecture and parallel execution across node types.

• Realtime API Access: The Realtime API surfaces mini-block data via standard JSON-RPC methods, allowing near-instant visibility into state and transaction outcomes.

• EigenDA-Powered Data Availability: By integrating EigenDA, MegaEth enables scalable, secure data access without burdening Ethereum’s on-chain storage.

• Full EVM Support: MegaEth supports Solidity, EIP‑1559, EIP‑7702, large contract sizes, and existing Ethereum tooling out of the box.

These core building blocks make MegaEth a robust environment for building everything from real-time DeFi and high-frequency trading bots to streaming on-chain gaming and on-demand NFT mints, all at warp speed.

How to Index Data on MegaEth​

HyperIndex​

A full-featured blockchain indexing framework that transforms on-chain events into structured, queryable databases with GraphQL APIs. It offers MegaEth developers a complete indexing solution with schema management and event handling, making data on MegaEth easily accessible and developer-friendly.

Learn more

HyperSync​

A high-performance data retrieval layer that gives developers unprecedented access to data on MegaEth. It directly replaces traditional RPC endpoints for raw block data, delivering up to 10,000x faster data access. HyperSync enables rapid and cost-effective retrieval of both real-time and historical blockchain data and can be used directly for custom data pipelines and specialized applications.

Learn more

HyperRPC​

A local RPC proxy that supercharges blockchain data access by mapping standard RPC requests to HyperSync’s ultra-fast data engine. HyperRPC accepts typical RPC calls and translates them into HyperSync queries, dramatically reducing query time and eliminating the bottlenecks of traditional RPC endpoints.

Learn more

MegaEth moves fast, and your indexing stack should too. Envio gives you the infrastructure to match that speed, so you can build applications that are responsive, reliable, and ready for scale.

Additional Features for MegaEth Indexers Built Using Envio​

Envio offers a range of advanced capabilities that make it easy to build rich, flexible data pipelines on MegaEth:

• Flexible Language Support: Configure your event handling in familiar and widely supported languages such as JavaScript, TypeScript, or ReScript.
• No-Code Quickstart: Autogenerate the key boilerplate for an entire indexer project based on single or multiple smart contracts. Deploy within minutes.
• Multichain Support: Aggregate data across multiple networks into a single database and query everything through a unified GraphQL API.
• Join On-Chain and Off-Chain Data: Connect indexed blockchain data with off-chain data to create a flexible API that goes beyond simple on-chain event logs, such as integrating external NFT metadata.
• Factory Contracts: Automatically register and process events emitted by all child contracts created by a specified factory or dynamic contract.
• Hosted Service: The simplest way to deploy production-ready indexers on MegaEth. A managed service platform for building, hosting, and querying Envio's Indexers with guaranteed uptime and performance service level agreements.

These additional features make Envio the ideal choice for building next-generation data-driven applications on MegaEth and beyond.

Existing Use Cases on MegaEth Utilizing Envio​

Oracle Wars​

Oracle Wars is an experimental dashboard built with Envio’s HyperIndex that visualizes real-time oracle behavior on MegaEth. It showcases how push-based oracles like RedStone Bolt behave under live market conditions by tracking heartbeat intervals, deviation thresholds, and latency patterns. The project helps developers understand how oracles operate in volatile environments and the potential risks of delayed or unexpected updates. Built in under two hours, Oracle Wars demonstrates how Envio enables rapid development of real-time monitoring tools on high-throughput chains like MegaEth.

Take a deeper dive in our full Oracle Wars blog.

This is just one of many great examples of what Envio is powering in the MegaEth ecosystem. For more, explore our Envio Explorer and see what developers are building.

Relevant Resources​

• Getting Started
• Envio’s HyperSync
• Envio’s Hosted Service
• Indexing MegaEth Data with Envio
• Indexers on MegaEth

Getting Support​

Data indexing can be challenging, especially for complex use cases. Our engineers are always ready to assist you with your data needs. Join our growing community of elite builders and experience peace of mind with Envio. Feel free to reach out to us on Discord or email us at hello@envio.dev.

About Envio​

Envio is a modern, multichain EVM blockchain indexing toolkit designed for real-time and historical data access. If you’re building on MegaEth or any other EVM-compatible network, Envio is here to make your development process faster and more efficient. Explore our documentation, join the community, and let’s connect about your data needs.

Website | X | Discord | Telegram | GitHub | YouTube | Reddit