Envio Blog

Envio Developer Update February 2026

Wed, 25 Feb 2026 00:00:00 GMT

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 💌

Blockchain Indexer For Application Backends

Wed, 28 Jan 2026 00:00:00 GMT

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

Envio Developer Update January 2026

Wed, 28 Jan 2026 00:00:00 GMT

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

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 💌

Envio Developer Update December 2025

Tue, 16 Dec 2025 00:00:00 GMT

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

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 💌

How to Migrate Alchemy Subgraphs to Envio

Wed, 03 Dec 2025 00:00:00 GMT

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

Envio Developer Update November 2025

Wed, 26 Nov 2025 00:00:00 GMT

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..getWhere..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

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 💌

MetaMask Smart Accounts x Monad Hackathon Winners

Thu, 13 Nov 2025 00:00:00 GMT

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.

Encode London 2025: Envio Hackathon Winners

Wed, 12 Nov 2025 00:00:00 GMT

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.

Envio Developer Update October 2025

Tue, 28 Oct 2025 00:00:00 GMT

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 💌

Envio Developer Update September 2025

Tue, 30 Sep 2025 00:00:00 GMT

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

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 💌

Envio Developer Update August 2025

Fri, 29 Aug 2025 00:00:00 GMT

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.

👉 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

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 💌

Envio Developer Update July 2025

Wed, 30 Jul 2025 00:00:00 GMT

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 🚢

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 💌

Building Visualizers & Dashboards on Monad using Envio

Tue, 24 Jun 2025 00:00:00 GMT

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.

Envio Developer Update June 2025

Tue, 24 Jun 2025 00:00:00 GMT

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.

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 🚢

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 💌

How to Index MegaEth Data Using Envio

Tue, 17 Jun 2025 00:00:00 GMT

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 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.

How to Index Monad Data Using Envio

Thu, 12 Jun 2025 00:00:00 GMT

Name a better duo? We’ll start. 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. By combining Monad’s exceptional speed with Envio’s powerful blockchain indexing solution, developers can easily build highly performant applications that thrive on fast, reliable, and comprehensive data.

Monad has emerged as a promising new chapter in blockchain performance, delivering unmatched throughput of up to 10,000 transactions per second for developers and users alike. As a fully EVM-compatible Layer 1, Monad combines one-second block times, optimistic parallel execution, and single-slot finality to redefine what is possible on-chain.

In this blog, we will explore why Envio is the best blockchain indexer on Monad and how our indexing stack empowers you to seamlessly sync, query, and leverage data, unlocking everything from analytics dashboards to advanced applications and user-facing experiences.

What is Monad?

Monad is a high-performance Layer 1 blockchain built to bring scalability to the EVM without compromising composability. With Monad’s parallel execution engine and focus on low-latency performance, developers can build highly efficient applications that offer higher throughput and lower fees without needing to rewrite existing EVM code.

Monad features:

One-second block times that reduce transaction finality delays.
Parallel execution through Monad’s superscalar architecture for efficient transaction processing.
Single-slot finality powered by MonadBFT consensus, ensuring fast and secure state updates.
A highly optimized storage layer called MonadDB for efficient state access and management.
RaptorCast for efficient block transmission and network performance.
Asynchronous execution to pipeline consensus and execution, extending the execution time budget.

These features make Monad an ideal foundation for data-rich decentralized applications that demand speed, reliability, and seamless composability.

How to Index Data on Monad

A high-throughput chain deserves infrastructure that can keep up. By utilizing Envio, you can harness the full potential of Monad’s high-throughput environment and build unstoppable applications.

Additional Features for Monad Indexers Built Using Envio

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

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 Monad. 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 Monad and beyond.

Existing Use Cases on Monad Utilizing Envio

These are just a few great examples of Envio in the wild, powering awesome applications in the Monad ecosystem. Feel free to check out this thread for even more examples or dive into our Explorer.

Relevant Resources

Getting Support

About Envio

Envio Developer Update May 2025

Thu, 29 May 2025 00:00:00 GMT

May was a big month at Envio.

We shipped major versions with powerful new features, which gave indexing performance a serious upgrade, and made the CLI even smoother for automation.

We also landed some exciting integrations, improved tooling across the board, locked in our DappCon 2025 sponsorship and speaking slot, and much more. Let’s dive in!

Latest Releases: v2.19.0 → v2.21.3

Fixed Invalid Rollback on Reorg Bug

In v2.21.3, we addressed an issue with invalid rollbacks during reorgs. We highly recommend upgrading to this version to ensure smoother contract indexing and enhanced system stability.

Async Contract Registration

You can now register contracts asynchronously using external logic. Perfect for dynamic deployments where the contract address depends on an external source.

NftFactory.SimpleNftCreated.contractRegister(async ({ event, context }) => {
  const version = await getContractVersion(event.params.contractAddress);
  if (version === "v2") {
    context.addSimpleNftV2(event.params.contractAddress);
  } else {
    context.addSimpleNft(event.params.contractAddress);
  }
});

New EVM Fields

Added accessList and authorizationList (EIP-7702) to transactions for expanded chain compatibility.

JSON Field Support in Schema

You can now define flexible JSON fields in your GraphQL schema, ideal for storing dynamic metadata.

type User {
  id: ID!
  metadata: Json!
}

Effect API for Efficient External Calls

The new Effect API lets you batch, memoize, and deduplicate external calls directly from your handlers.

Paired with loaders, it prevents overfetching and speeds up processing across large batches.

Check out the walkthrough on Loom or dive into our Loaders guide to learn more.

Contract Registration Boost

Dynamic contract indexing is now dramatically faster. We’ve deprecated preRegisterDynamicContracts option, it’s no longer needed.

Improved RPC Error Handling

We added support for 9 more RPC error types to improve retry logic and block range fallback.

Non-Interactive CLI Setup

You can now initialize an indexer entirely through the CLI, no prompts, ideal for scripting and automation.

This comes as part of early experimentation with Envio MCP.

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! ⭐

Envio Rolls Out Major Upgrade to Contract Indexing

Our latest performance upgrade unlocks dramatically faster dynamic indexing, especially for contracts deployed by factories. What previously took hours can now be done in minutes, with indexing speeds reaching nearly 30,000 events per second, even while dynamically registering new contracts.

No more two-pass preregistration flows. As of V2.19.0, contract registration happens in real-time, and the preregistration option has been deprecated. HyperIndex supports nested factory contracts, so if your contracts deploy other contracts (even more factories), we’ll handle it automatically.

Big shoutout to one of our leading devs, Dmitry Zakharov, for leading the work to streamline contract registration.

Here’s a look at the local dev console, a useful way to track indexing speed and progress in real time. In this example, it’s tearing through Uniswap V3 data.

Envio Sponsors DappCon 2025

We’re excited to announce that Envio is one of the many proud sponsors of DappCon 2025, joining an incredible lineup of projects pushing Web3 forward.

Be sure to also catch our speaking slot, Envio Co-founder Denham Preen will be sharing insights on real-time blockchain indexing and building open access to on-chain data.

See you in Berlin! 🇩🇪🥨

Exciting DeFi Integration With Nad.fun

We’re excited to share that Envio has been integrated with Nad.fun, an on-chain trading game built on Monad. We recently developed geographic request visualizations as we began serving HyperSync requests from multiple regions. Check out the awesome graphs showcasing where traffic is coming from.

Learn more in this post on X.

Envio Powers Real-Time Analytics on Monorail

Another solid example of Envio in the wild, Monorail is now serving up real-time blockchain analytics, powered by our indexing infrastructure on Monad.

From live data to actionable insights, it’s all running smoothly under the hood. Big props to Monorail for the slick integration.

Learn more in this post on X.

Sonic Summit Keynote

Learn how to index millions of events on Sonic—in seconds.

Watch our keynote from Sonic Summit and see what real-time indexing looks like on a chain built for speed.⚡️

Watch on YouTube.

Integration Spotlight: Forever Moments

Forever Moments just rolled out a robust new indexing setup using Envio. The result? Faster performance, cleaner data feeds, and expanded features. Even better, they’ll be open-sourcing their version soon so others can build on it too.

Shout out to the Forever Moments team for pushing on-chain media forward.

Learn more in this post on X.

Monad Evm/Accathon Winners

Congratulations to the winners of the first-ever Monad hackathon (evm/accathon). It brought some serious builder energy, and we were proud to support teams with the fastest and most performant data indexing on Monad.

Learn more about the winning projects in our blog.

Upcoming Events 🗓️

DappCon: 16th → 18th June 2025
WAGMI Sponsors at EthCC Cannes: 30th June → 3rd July 2025
Pragama Cannes: July 3rd, 2025

Featured Developer 🧑‍💻

This month, we’re proud to spotlight Paul Berg, co-founder and CEO of Sablier Labs, and a long-time contributor to the open-source Ethereum ecosystem. Known for building tools like Sablier and PRBMath, Paul continues to push the space forward with thoughtful, developer-first projects.

“Envio is the best indexer for EVM chains. Blazing fast indexing and native multi-chain support make it a game-changer.” - Paul Berg, Co-Founder & CEO at Sablier Labs

We’re especially thankful for Paul’s ongoing support of Envio and for being such an engaged developer and community member.

We highly recommend exploring Paul’s contributions and projects in the space. He’s also an active voice on X and Farcaster, where he shares insights that go beyond crypto, diving into topics like longevity, epistemology, and physics. Give him a follow and check out his GitHub to stay in the loop!

Playlist of the Month 🎧️

▶️ Open Spotify

Ship With Us 🚢

Envio is a modern, 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 💌

Announcing the Monad Envio Hackathon Winners

Fri, 16 May 2025 00:00:00 GMT

The first-ever Monad hackathon (evm/accathon) brought some serious builder energy. We were proud to support teams with the fastest and most performant data indexing on Monad.

Huge shoutout to the Monad team and every dev who participated, especially those who built with us. Here’s a look at the two standout winning submissions that used Envio’s open indexing infrastructure to power their projects on Monad.

Gorillionaire

By luduvigo, sammino, and CKobril

Gorillionaire is an AI-powered crypto trading platform delivering real-time Buy/Sell signals by analyzing on-chain data, whale activity, token listings, and price feeds. It uses Envio to index data on Monad, giving users and bots fast access to high-signal, real-time insights.

With Privy for authentication and the 0x API for execution, users can act on signals instantly and compete on a gamified leaderboard. The platform also features AI-generated token analytics and gated access to private signals via Nillion’s Secret Vault.

Backed by Monad’s performance and Envio’s real-time indexing infrastructure, Gorillionaire shows what’s possible when AI meets production-grade indexing built for scale. Big congrats to the team on this stellar submission!

Watch the demo.

MonFundMe

By defilova1 and hillary_jayden

MonFundMe is a decentralized fundraising platform built on Monad, offering fast, transparent donations without the friction of Web2. Inspired by GoFundMe but reimagined for Web3, it cuts out high platform fees and removes all-or-nothing fundraising limits.

Powered by Envio, MonFundMe tracks donations in real time, offering complete transparency and faster access to funds. It’s an ideal fit for urgent causes or ongoing community campaigns alike.

Big ups and congrats to the team for an outstanding submission!

How to Index Data on Monad

These projects highlight what’s possible when you combine a high-performance chain like Monad with high-performance infrastructure like Envio.

Whether you’re building real-time analytics, AI agents, NFTs, or dashboards, indexing data on Monad with Envio is fast, flexible, and fully customizable.

→ Start indexing Monad data

Big thanks to the builders

Huge thanks to the Monad team for pulling together an incredible hackathon. The quality of submissions was seriously impressive, and picking winners wasn’t easy. We’re grateful to every dev who took the time to build, experiment, and ship using Envio.

We’re looking forward to seeing these projects grow and to the next hackathon. Keep shipping.

About Monad

Monad is a high-performance L1 built to bring scalability to the EVM without compromising composability. With Monad’s parallel execution engine and focus on low-latency performance, it enables devs to build next-gen applications with higher throughput and lower fees, without rewriting existing EVM code.

About Envio

Envio is a fast, developer-friendly blockchain indexer and the fastest, most flexible way to get on-chain data, making real-time data accessible for developers across the Web3 ecosystem.

With Envio, developers can query and stream blockchain data efficiently without the complexity of running their own infrastructure. Envio’s blockchain indexing tools 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.

Envio Developer Update April 2025

Fri, 25 Apr 2025 00:00:00 GMT

Welcome to Our April 2025 Developer Update!

This month, we launched v2.16.0 & v2.17.0, introducing Topic Filters by Contract Addresses for more precise indexing and a new development console to track indexer progress. We've also expanded indexing support for Monad and released tools like Snubb for token approval scanning and Loggregate for real-time EVM event data aggregation and much more. Let's jump in!

🚀 HyperIndex Version 2.16.0 & 2.17.0 are now available 🚀

Please note: Current release 2.17.1

Topic Filters by Contract Addresses

Besides chainId added in the previous release, you can now also access contract addresses to filter by.

For example, index your users' USDC transfers as easily as:

import { FactoryContract, UserContract } from "generated";

const USDC_ADDRESS = {
  84532: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
  11155111: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
};

FactoryContract.UserCreted.contractRegister(async ({ event, context }) => {
  context.addUserContract(event.params.userContractAddress);
});

UserContract.Transfer.handler(async ({ event, context }) => {
  // Filter and store only the USDC transfers that involve a Safe address
  if (event.srcAddress === USDC_ADDRESS[event.chainId]) {
    context.Transfer.set({
      id: `${event.chainId}_${event.block.number}_${event.logIndex}`,
      from: event.params.from,
      to: event.params.to,
    });
  }
}, {
  wildcard: true,
  eventFilters: ({ addresses }) => [{ from: addresses }, { to: addresses }],
});

New Development Console!

V2.17.0 also went live, allowing you to track indexer progress, access the GraphQL Playground, and level up your local dev experience, with plenty more features on the way! 👇

Logger improvements 📝

Added the ability to pass params on a log call:

context.log.info("Sucessfully handled Transfer()", { from: event.params.from, to: event.params.to })

These params will be displayed in the logs in your terminal as well as in Hosted Service.

You can also pass an error:
} catch (error) {
  context.log.error("Failed ipfs call", error)
}

For more information, you can 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! ⭐

Envio Delivers Modular, Real-Time Indexing for Monad Builders

We’re excited to announce that Envio’s open indexing framework now supports developers building on Monad. Monad is pushing the boundaries of performance at the execution layer, and Envio ensures your data pipeline keeps up seamlessly. Instantly index real-time and historical data on Monad using Envio, fast, reliable, and fully customizable. Track complex state changes, power prediction markets, or build whatever you’re working on with full control over how your data flows.

We’re proud to support Monad developers with the fastest blockchain indexing solution available.

Introducing Snubb: A Multichain Token Approval Scanner for Your Terminal

Inspired by Revoke, Snubb is an incredibly fast and efficient CLI tool to scan for outstanding token approvals for your address across as many as 70 chains simultaneously.

Try it out now with one terminal command:

npx snubb --address  --chains 1,10,130

For example:

npx snubb --address 0x7C25a8C86A04f40F2Db0434ab3A24b051FB3cA58 --chains many-networks

Check out this video to see it in action.

It’s lightning fast, able to scan multiple chains and return results in seconds. Under the hood, it uses HyperSync to scan entire chains quickly, with specific filters for approval and transfer events related to the given address.

If you're curious, feel free to check out the original background post on X that kicked this all off.

Introducing Loggregate: A Terminal-Native Tool for Real-Time EVM Event Data Aggregation

We’re excited to introduce Loggregate, inspired by LogTUI. It’s a terminal-native tool that lets developers aggregate and analyze EVM event data in real-time. Whether it’s token transfers, swaps, or deposits, Loggregate makes it easy to pull meaningful data from Ethereum and other networks.

With Loggregate, you can quickly calculate key statistics like counts, sums, and averages, all within your terminal. For example, we aggregated live transfer data to reveal 127 million transfers with an average value of $111,727 per transaction.

Built for developers and powered by HyperSync, Loggregate is fully open-source and extensible.

Try it out now:

npx loggregate -e "event Transfer(address indexed from, address indexed to, uint256 value)" -n eth -p "value" -c 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 -d 6

Explore it on npm and check out the open-source repo.

Feel free to check out the original background post on X.

Oracle Wars: Exploring Real-Time Oracle Behavior and Push-Based Feeds

Who watches the watchers? We do, in real time. Powered by HyperIndex, Oracle Wars visualizes how oracle feeds behave on-chain, highlighting deviations and helping you design more reliable smart contracts.

Learn more about it in our latest blog.

Envio's HyperSync Powers Trading Strategy with Multichain Data Collection

Another great example of HyperSync in action! Check out how Trading Strategy leveraged Envio to collect on-chain data across multiple chains and dive into their epic data & research notebook analyzing the performance of 7,000 ERC-4626 vaults across 10 blockchains!

Learn more in this post.

HyperSync Now Supports 70+ EVM Networks, Enhancing Real-time Data Access Across Web3

We’re excited to share that HyperSync now supports 70+ EVM networks, with many more on the way! Developers and analysts can now access real-time and historical data across various EVM networks with ease. Whether you're tracking activity, analyzing trends, or powering apps, HyperSync makes querying fast, reliable, and effortless.

To learn more about the networks we support, check out our latest blog.

Developer Workshop: Indexing Real-Time Data on the XDC Network with Envio

Missed our XDC Developer Workshop? We got you. Check out this step-by-step walkthrough on how to instantly index real-time and historical data on the XDC Network using Envio.

Upcoming Events 🗓️

Sonic Summit: 6th → 8th May 2025
ETHPrague: 27th → 29th May 2025
DappCon: 16th → 18th June 2025
WAGMI Sponsors at EthCC** Cannes:** 30th June → 3rd July 2025
Pragama Cannes: July 3rd 2025

Featured Developer 🧑‍💻

This month, we’re excited to feature Manu Soman, a talented developer who transitioned from UX design to mastering backend programming in Rust and JavaScript. Manu’s work primarily revolves around systems programming and crypto, with a special focus on Solana. Recently, he’s been expanding his skill set by exploring Go.

Manu has been actively building out the UniV3 Indexer (coming soon) using Envio, a custom-built multi-chain indexer for Uniswap V3 powered by HyperIndex. This project tracks top swaps, pools, and trends in real-time, providing invaluable insights into liquidity, trading volumes, fees, and more!

His passion for exploring new technologies and creating robust solutions makes him a standout developer and member of our community.

“Though my prior experience with blockchain indexers is limited to a small project using Subgraph, I was amazed at how quickly HyperIndex was able to index high-traffic smart contracts like Uniswap. Not only is it fast, it’s also easy to set up and fully syncs with chains. Subgraph fell short in all of those areas. Envio's tech support on Discord is also active, responsive, and super helpful. Choosing Envio for indexing is a no-brainer.” - Manu Soman

We’re excited to see where Manu’s journey takes him next and appreciate his contributions to our community.

Be sure to follow Manu and his work on X for the latest updates and insights!

Playlist of the Month 🎧️

▶️ Open Spotify

Ship with us. 🚢

Envio is a modern, 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 |

Exploring Real-time Oracle Behavior and Push Based Feeds

Tue, 15 Apr 2025 00:00:00 GMT

Oracles are the unsung heroes of DeFi. They connect blockchains to real-world data, enabling smart contracts to interact with off-chain events like asset prices (USDC, ETH), market rates, or even real-time sports scores. But while the concept of oracles is often discussed in theoretical terms, visualizing how they behave in practice can offer a new level of clarity, especially for developers building apps on-chain.

Enter Oracle Wars, a live feed of on-chain oracle data that compares how different providers behave in real-time. It helps developers visualize and gain a better understanding of how oracles actually function under different market conditions, so they can design more reliable and secure smart contracts.

⭐ Please note: The dashboard shown above is no longer live on the site. Oracle Wars is currently displaying live ETH/USD price oracle updates from the Redstone Bolt oracle feed on MegaETH, rather than the multi-oracle comparison dashboard featured above. Oracle Wars remains an educational and experimental tool for surfacing real-time data from various oracle providers, helping developers better understand oracle behavior as the data and tooling continues to evolve.

What is a Blockchain Oracle?

If you're building in the decentralized space, you’ve more than likely heard about oracles. In simple terms, they allow smart contracts to react to external data sources. Whether it's the latest price of an asset or the outcome of a sporting event, oracles are how the blockchain sees the world.

Over time, oracle architectures have evolved. From the early days of Truffle and Ganache to today’s production-grade protocols, we've seen the rise of push-based oracles, pull-based oracles, and many more. Each design has trade-offs. For now, let’s zero in on push oracles and how they behave from a data perspective.

Push Oracles in Practice

A push oracle works exactly as the name implies: it periodically pushes data onto the blockchain. Your contract can then read that data and respond accordingly, whether it's executing a trade, adjusting a loan-to-value ratio, or minting some ridiculous meme coin.

Most push oracles use two primary mechanisms:

Heartbeat intervals – Regular updates (e.g., every 24 hours)
Deviation thresholds – Immediate updates when data shifts significantly (e.g., 0.5% price movement)

Visualizing Real-Time Oracle Activity with Oracle Wars

Wonder what happens in live conditions, during periods of high volatility? That’s where Oracle Wars comes in. It can show a live comparison between price feeds from different oracle providers, such as Chainlink and RedStone.

You’ll notice that updates aren’t always evenly spaced. That’s the deviation threshold kicking in when markets get volatile, updates come in fast. When things are calm, fewer updates appear. It’s a valuable pattern to observe, especially if you’re designing a protocol that depends on accurate and real-time data.

For example, this volatility spike, between Chainlink and RedStone posted frequent updates to reflect price changes, an essential feature for platforms like Aave, which depend on real-time data for liquidation logic and capital safety.

Understanding the Limitations of Deviation Thresholds in Push Oracles

Oracle Wars also allows you to see the maximum deviation between any two consecutive price points over 24 hours. Why does this matter? Every DeFi protocol relies on timely and accurate price data, and large shifts between updates can lead to exploit risk, broken assumptions, or cascading failures. This metric gives developers a real-world view of how much price movement can actually occur between updates, even when using well-known oracle providers.

This brings us to a common misunderstanding: deviation thresholds are not strict limits.

Take Chainlink and RedStone, for instance. Both use a 0.5% deviation threshold for price feeds. That should mean the oracle updates whenever the price moves more than 0.5%. But here’s the catch:

A 0.5% deviation threshold does not mean consecutive on-chain prices will only differ by 0.5%.

In practice, you might see larger deviations. Over 24 hours alone, Oracle Wars recorded deviations of around 0.67% for both providers. This doesn’t mean the oracles were broken, it means they’re working as designed. The threshold is more of a trigger condition than a strict upper bound.

So if you're competing in security audits on platforms like Sherlock, Code4rena, or CodeHawks, it's worth thinking through these edge cases. Your protocol logic needs to account for these potentially higher-than-expected changes, especially in volatile markets.

Is a Super-Fast Push Oracle Now Better Than a Pull Oracle?

With the advent of high-speed chains like MegaETH and Monad, we’re starting to see the rise of ultra-fast push oracles that update data with each block. This near-instantaneous data feed challenges traditional push oracles, offering freshness comparable to pull oracles, provided transaction costs remain manageable.

On Oracle Wars, you can now observe how these super-fast push oracles behave in real-time, with feeds like the ETH/USD price on MegaETH. The data is continuously updated, providing a new level of insight into how push oracles might evolve to rival the responsiveness of pull models.

However, one aspect that remains intriguing is the frequent occurrence of multiple price updates at the same timestamp. This raises questions about whether these oracles are pushing multiple updates within the same block, and the rationale behind this granularity.

While Redstone's "Bolt" push oracle is an exciting development, it’s still early days. It will be interesting to see how other oracle providers and chains approach the super-fast push model. The key question remains: Can these ultra-fast push oracles maintain the freshness and reliability of pull oracles without significant cost overhead?

Oracle Wars: Powered by Envio’s HyperIndex

To pull this off and index this level of data, we used HyperIndex, our open blockchain indexing framework which seamlessly queried this data effortlessly. The entire Oracle Wars platform was built in under two hours using Envio’s HyperIndex, which made indexing real-time oracle data smooth and easy.

If you're building dashboards, simulations, or monitoring tools, it’s worth checking out. Need help getting started? Feel free to reach out to us in our Discord or on Telegram, we’re always happy to walk you through it!

Helpful Resources

Thanks for reading, and if you're curious, feel free to check out the original background posts on X that kicked this all off:

About Envio

Envio is a fast, developer friendly blockchain indexer and the fastest, most flexible way to get on-chain data, making real-time data accessible for developers across the Web3 ecosystem.

With Envio, developers can query and stream blockchain data efficiently without the complexity of running their own infrastructure. Envio’s blockchain indexing tools 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.

Envio Blog

Envio Developer Update February 2026

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

Alpha.14​

🚨 Breaking: New getWhere API​

🔄 Breaking: Removed Ordered Multichain Mode Support​

🤖 Big Cursor/Claude Skills Update​

⛓️ Chain Info for Test Indexer​

Alpha.13​

🏎️ 3x Historical Backfill Performance​

📉 Support for DESC Indices​

⛽ Improved RPC Source Support​

🔌 WebSocket Support for RPC (Experimental)​

🚨Breaking: rpc_config Removed​

Indexing Data on MegaEth Mainnet​

Building Indexers with HyperIndex​

Tyde Terminal Tide Visualiser​

Index Data on Sei​

Envio Alerts: Uniswap v4 Alert Bots​

🗓️ Current & Upcoming Events & Hackathons​

🎧️ Playlist of the Month​

Build with Envio​

Blockchain Indexer For Application Backends

What is a blockchain indexer​

How blockchain indexers work​

The backend problem blockchain apps run into​

What role a blockchain indexer plays​

Where the indexed data gets used​

When a blockchain indexer becomes necessary​

Building a blockchain indexer with Envio​

Getting started​

Conclusion​

About Envio​

Envio Developer Update January 2026

HyperIndex V3 (alpha): Exciting Feature Updates​

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

Vitest - Recommended Testing Framework​

Envio Init Improvements​

Expose Indexer Config & State​

Automatic Contract Configuration​

Conditional Event Handlers​

TUI Love​

Envio API Token Required​

Indexing Data on Injective​

Migrating Production Subgraphs: Polymarket Indexer​

Blockchain Indexer For Application Backends​

Envio Powers Funnel with Efficient Data Indexing​

🗓️ Current & Upcoming Events & Hackathons​

🧑‍💻 Featured Developer: Zod​

🎧️ Playlist of the Month​

🚢 Ship With Us​

Envio Developer Update December 2025

🚨 HyperIndex v3.0.0 is Coming​

CommonJS → ESM​

Top-level await​

src/handlers auto registration​

Block handler indexers​

Flexible entity fields​

HyperSync source improvements​

Experimental ClickHouse Sink support​

Experimental additions: Solana Support​

Cleanups and defaults​

Envio Supports Developers Building on Sonic​

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

Envio at Solana Breakpoint 2025 in Abu Dhabi​

Envio Developer Workshops: Decypted Bytes Is Back​

Recent streams include:​

Envio Adds Support for Tempo​

How to Index Cross-Chain USDT0 Transfers with Envio​

Envio Powers Slab.cash with Efficient Data Indexing​

Getting Started with Envio for the MetaMask Advanced Permissions Hackathon​

🗓️ Current & Upcoming Events​

🧑‍💻 Featured Developer: Port​

Merry Xmas from the Envio Team​

🎧️ Playlist of the Month​

🚢 Ship With Us​

How to Migrate Alchemy Subgraphs to Envio

Why Teams are Migrating their Alchemy Subgraphs to Envio:​

Before you Migrate​

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

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

Alpha.14

🚨 Breaking: New getWhere API

🔄 Breaking: Removed Ordered Multichain Mode Support

🤖 Big Cursor/Claude Skills Update

⛓️ Chain Info for Test Indexer

Alpha.13

🏎️ 3x Historical Backfill Performance

📉 Support for DESC Indices

⛽ Improved RPC Source Support

🔌 WebSocket Support for RPC (Experimental)

🚨Breaking: rpc_config Removed

Indexing Data on MegaEth Mainnet

Building Indexers with HyperIndex

Tyde Terminal Tide Visualiser

Index Data on Sei

Envio Alerts: Uniswap v4 Alert Bots

🗓️ Current & Upcoming Events & Hackathons

🎧️ Playlist of the Month

Build with Envio

What is a blockchain indexer

How blockchain indexers work

The backend problem blockchain apps run into

What role a blockchain indexer plays

Where the indexed data gets used

When a blockchain indexer becomes necessary

Building a blockchain indexer with Envio

Getting started

Conclusion

About Envio

HyperIndex V3 (alpha): Exciting Feature Updates

🚨BIG feature alert: New Testing Framework (experimental)

Vitest - Recommended Testing Framework

Envio Init Improvements

Expose Indexer Config & State

Automatic Contract Configuration

Conditional Event Handlers

TUI Love

Envio API Token Required

Indexing Data on Injective

Migrating Production Subgraphs: Polymarket Indexer

Blockchain Indexer For Application Backends

Envio Powers Funnel with Efficient Data Indexing

🗓️ Current & Upcoming Events & Hackathons

🧑‍💻 Featured Developer: Zod

🎧️ Playlist of the Month

🚢 Ship With Us

🚨 HyperIndex v3.0.0 is Coming

CommonJS → ESM

Top-level await

src/handlers auto registration

Block handler indexers

Flexible entity fields

HyperSync source improvements

Experimental ClickHouse Sink support

Experimental additions: Solana Support

Cleanups and defaults

Envio Supports Developers Building on Sonic

Monad Testnet Re-Genesis: Reindex Required for Envio Users

Envio at Solana Breakpoint 2025 in Abu Dhabi

Envio Developer Workshops: Decypted Bytes Is Back

Recent streams include:

Envio Adds Support for Tempo

How to Index Cross-Chain USDT0 Transfers with Envio

Envio Powers Slab.cash with Efficient Data Indexing

Getting Started with Envio for the MetaMask Advanced Permissions Hackathon

🗓️ Current & Upcoming Events

🧑‍💻 Featured Developer: Port

Merry Xmas from the Envio Team

🎧️ Playlist of the Month

🚢 Ship With Us

Why Teams are Migrating their Alchemy Subgraphs to Envio:

Before you Migrate

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

1. Generate a new HyperIndex project

2. Bring over your schema

3. Move over your mapping logic

4. Use migration cursors

What changes when you leave Alchemy?

Conclusion