Envio Developer Update September 2026

Solana support in HyperIndex is now stable. The API is final and follows semver. Config and handlers look much like they do on EVM, with the same GraphQL server on top.

We put out five HyperIndex releases, v3.10.0 to v3.13.0. Indexers can now split across worker processes, the RPC source is written in Rust, and a rollback on one chain can stay on that chain. On top of that we published tutorials for Arc, Robinhood Chain, HyperEVM and Solana stablecoins, added docs for Envio Cloud troubleshooting and trace decoding, moved HyperPipe to community support, and put up a page comparing Envio with other indexers.

Let's dive in!

HyperIndex v3.10.0 -> v3.13.0

Most of this month's work went into speed and keeping chains apart in multichain indexers.

Highlights

• 4x faster in many cases with automatic multiprocess indexing
• RPC source rewritten in Rust, 2 to 17x faster on our open benchmark
• Solana support is stable and follows semver
• Each chain can run in its own process
• A rollback on one chain no longer rolls back the others

HyperIndex v3.13.0: Multiprocess Indexing and a Rust RPC Source

Automatic Multiprocess Indexing

When every entity is isolated per chain and ENVIO_PG_MAX_CONNECTIONS is large enough, the indexer now splits itself into up to 4 worker processes on its own.

It uses more resources, and in return it is 4x faster in many cases and more reliable. On Envio Cloud it is available on demand for Dedicated plans.

RPC Source Rewritten in Rust

If you index over your own RPC, upgrade. The RPC source is now written in Rust, with reworked logic and concurrency, and it handles bad provider responses without crashing. It is 2 to 17x faster on the Open Indexer Benchmark cases.

It also adds the accessList and authorizationList transaction fields, so the RPC source now selects the same transaction fields as the HyperSync source.

HyperIndex v3.12.0: One Process Per Chain

Run Chains in Separate Processes

envio start --chain <CHAIN_ID> lets several processes index different chains of the same indexer in parallel.

envio local db-migrate up

ENVIO_INDEXER_PORT=8080 envio start --chain 1
ENVIO_INDEXER_PORT=8081 envio start --chain 137 --chain 5042

Create the database once with envio local db-migrate up, give each chain to exactly one process, and give each process its own port. Every process runs independently of the others. It needs a schema where every entity is per chain, with no @crossChain entities, and it can't be combined with --restart.

Real Head Lag With Progress Block Time

The new envio_progress_block_time_seconds metric, also exposed as _meta.progressBlockTime, gives the timestamp of the block each chain has processed up to. now() - progress_block_time is your real lag, even when a data source reports itself at the head while sitting behind the chain.

Chains that reach their endBlock freeze the value, so leave them out of alerts.

Every Account a Solana Transaction Touches

accountKeys now includes addresses resolved through Address Lookup Tables, so handlers see every account a versioned transaction touches. The envio init Solana templates are replaced by usdc-transfers, which indexes SPL Token transfers on mainnet.

v3.12.1 rounded the release out with 4x faster getWhere in handlers and more reliable progress block time reporting at the head.

HyperIndex v3.11.0: Solana Goes Stable

Solana Support Is Now Stable

The HyperIndex API for Solana is final and follows semver from here, so you can build on it without expecting breaking changes between minor versions. More on where Solana is at below.

Start From the Latest Block

The start block now accepts "latest". The indexer checks the chain height on startup and starts from there, so there's no block number to look up first. You can see it in the Solana config below.

HyperIndex v3.10.0: Per-Chain Rollbacks and Rust ClickHouse Storage

Rollbacks Stay on Their Own Chain

With disable_default_cross_chain: true and no entities marked @crossChain, a rollback now applies only to the chain that triggered it. Multichain indexers get better isolation, better performance and lower latency.

ClickHouse Storage in Rust

The ClickHouse storage backend is now written in Rust. It's faster and more reliable.

Choose How Bytes Are Stored

Bytes fields used to be a plain alias for the GraphQL String type. You can now switch them to Uint8Array in your handlers, which also makes the Postgres column bytea. Hex strings stay the default. Solana indexers always use uint8array.

bytes_type: uint8array # default is hex

More Reliable Head Tracking

HyperIndex streams new block heights from the HyperSync SSE endpoint by default, with RPC WebSocket as an option and polling as the fallback. The stream now stays alive more reliably and falls back to polling without the 10 to 20 second gap, which lowers latency and keeps new block tracking steady. Two new Prometheus metrics come with it:

envio_source_height_stream_connects_total
envio_source_height_stream_disconnects_total{reason}

Solana Instruction Filtering

Solana instruction handlers now take where filters on named accounts, inner or outer instructions, and a minimum slot. Discriminators can be any byte length, and more than one instruction can share a discriminator.

See full release notes

Star us on GitHub

Solana Is Stable, Here's Where We're At

Configuration, handlers and payload types now follow semver like the rest of HyperIndex, so what you build on Solana today keeps working as HyperIndex moves forward.

Start with pnpx envio init and pick a Solana template. HyperSync is the data source by default, and the config looks like this:

# yaml-language-server: $schema=./node_modules/envio/svm.schema.json
name: usdc-transfers
description: USDC Token Transfers
ecosystem: svm
chains:
  - id: solana
    start_slot: "latest"
programs:
  - name: SplToken
    program_id: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
    idl: ./idls/spl-token.codama.json

And a handler for it:

import { indexer } from "envio";

const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";

indexer.onInstruction(
  {
    program: "SplToken",
    instruction: "transferChecked",
    fields: {
      instruction: ["accounts", "args", "path"],
      transaction: ["signature"],
      accountActivity: ["token.mint"],
      block: ["time"],
    },
    where: { accounts: { mint: USDC_MINT } },
  },
  async ({ instruction, context }) => {
    context.Transfer.set({
      id: `${instruction.transaction.signature}:${instruction.path.join(".")}`,
      amount: instruction.args.amount,
      source: instruction.accounts.source.address,
      destination: instruction.accounts.destination.address,
      signer: instruction.accounts.authority.address,
      txSignature: instruction.transaction.signature,
      checked: true,
      slot: instruction.block.slot,
      timestamp: instruction.block.time,
    });
  }
);

You get automatic decoding and filtering, Anchor and Codama IDLs, writes to Postgres and ClickHouse, a GraphQL server on top of your Solana data, and hosting on Envio Cloud.

Where We're At With Solana

• HyperIndex on Solana is stable. The API has been final since v3.11.0 and follows semver.
• Solana HyperSync is live on mainnet at https://solana.hypersync.xyz, serving slots, transactions, instruction calls, logs and account activity from one endpoint.
• History starts around slot 391,000,000, not at genesis. We keep extending it backwards as we backfill.
• It runs end to end. Local dev, Postgres or ClickHouse, the GraphQL API and hosting on Envio Cloud all work the same as on EVM.
• One ecosystem per indexer. An indexer covers Solana or EVM chains, not both at once.

This month also added where filters on instructions, account keys resolved through Address Lookup Tables, and a USDC Transfers starter template in envio init. For a worked example, our Solana stablecoin tutorial indexes a full day of USDC, USDT, PYUSD and USDG transfers.

On the Solana USDC transfers scenario on our compare page, HyperIndex was the fastest indexer in the latest run.

If you're building on Solana, we highly recommend testing it against the programs you want to index. Reach out to the team on Discord with your use case and we'll test it with you. Any feedback you have shapes what we prioritise next.

Read the docs: Indexing on Solana and Solana HyperSync

Why HyperSync Checks Blocks Against Their Roots

A node can drop logs and still hand you a response that looks completely fine. There's no error, and nothing in the JSON tells you anything is missing.

Block headers commit to every transaction and receipt through Merkle roots, but you need the whole block to check them. Because HyperSync ingests whole blocks, it recomputes both roots before serving anything and refetches from another source if they don't match. That way missing logs tend to get caught early, rather than turning up later in your database.

More here: https://docs.envio.dev/blog/nodes-silently-miss-events

What HyperEVM Sends to HyperCore

We wanted to know how much of Hyperliquid an EVM indexer can actually see, so we built one that tracks everything HyperEVM sends to HyperCore, every action, HYPE transfer and spot token transfer, and ran it from genesis. The biggest CoreWriter user isn't a trading bot or a DEX. It's Circle's USDC deposit wallet, behind 57.5% of all the actions we indexed.

One thing worth knowing going in is that the data only flows one way. Anything HyperEVM sends to HyperCore leaves a log, but what comes back from HyperCore doesn't. The tutorial walks through what you can and can't see, how to check what HyperCore actually did with each request, and how to index your own HyperEVM contract with three small files.

Read the full tutorial: https://docs.envio.dev/blog/index-hyperevm-data

Envio Side by Side With Other Indexers

The compare page puts Envio side by side with the other popular indexers, and every claim links to its source.

Indexing isn't one workload, so one number can't rank it. The benchmark section runs several scenarios from the Open Indexer Benchmark, with each tool on the EVM scenarios running in GitHub CI and started the way its own docs recommend for production. The tables refresh automatically.

The head-to-heads cover things like speed, chain coverage, pricing and self-hosting, and each one says plainly when the other tool is the better choice. There are also migration paths, from moving a subgraph to migrating with AI, plus an FAQ.

Check it out: https://envio.dev/compare

Every Tokenised Stock on Robinhood Chain, From One Contract

We wanted to know which tokenised stocks exist on Robinhood Chain and which ones people actually trade. It turns out every stock is deployed by the same factory contract, so we built an indexer that reads its deploy events, picks up each token (including any Robinhood adds later) and indexes their transfers. Twenty of those tokens carry 90.9% of all transfers.

Want to build on Robinhood Chain yourself? HyperSync, HyperRPC and HyperIndex all work there out of the box, and the chain page has the connection details.

Read the full tutorial: https://docs.envio.dev/blog/index-robinhood-chain-data

Most Solana Stablecoin Transfers Aren't Top-Level

Tracking stablecoin transfers on Solana sounds like one filter, but we had a feeling a lot was being missed. So we built an indexer for USDC, USDT, PYUSD and USDG transfers and ran it over a full day. Only 23.3% of those transfers were top-level instructions, and the rest happened inside other programs like swaps and lending deposits.

That matters because a transfer on Solana can come through any of three instructions on two different token programs. If your indexer only handles some of them, nothing breaks, your numbers are just quietly incomplete. The tutorial has the mint addresses and an indexer that catches all of them.

Learn more here: https://docs.envio.dev/blog/index-solana-stablecoin-transfers

Why USDC on Arc Gets Logged Twice

We noticed something odd about USDC on Arc. It's both the gas token and an ERC-20, which means a transfer can be logged twice. A system address logs every transfer, native sends included, and the USDC contract logs ERC-20 calls again on top.

So we indexed a 100,000 block sample to see how much it matters. Indexing both sources would have double counted 48.3% of transfers, and indexing only the contract would have missed 51.7%. The tutorial shows which one to index, and the three-file indexer in it matched HyperSync's count exactly.

We provide first-class support for Arc on Envio, so you can backfill its history and follow new blocks with HyperSync, query it through HyperRPC, or spin up a HyperIndex indexer with a GraphQL API on top. Arc Testnet is supported as well, and the chain page has everything you need to get connected.

Read the full tutorial: https://docs.envio.dev/blog/index-arc-usdc-transfers

Which Apps Are Actually Live on Robinhood Chain

Robinhood lists plenty of ecosystem partners, but a listing doesn't tell you what's actually running. So we checked each app against its own docs and its contracts on Robinhood Chain, and wrote up the ones that are live, with the contracts to index and a week of onchain activity for most of them. Uniswap is the busiest by a long way, with 2,552,298 transactions from 321,551 wallets in a single week.

Read it here: https://docs.envio.dev/blog/robinhood-chain-ecosystem

Monad Metropolis Hackathon

Monad's Metropolis hackathon runs from September 1st to October 13th with $250,000+ in prizes, and there's a dedicated track for the best use of Envio.

We've put up $1,000 for the best use of Envio, and winning teams get $5,000 of free Envio Cloud hosting. If your build has reached the onchain data part, reach out to our team with your contract address and we'll help you get it indexed.

Check out the video above to learn how an indexer fits into your build, and why your frontend shouldn't have to query the blockchain for everything.

Find the Envio track here: https://hackathon.monad.xyz/tracks/best-use-of-envio

New in the Docs

Fixing Common Envio Cloud Deploy Issues

A new page answers the questions we get most about deploying on Envio Cloud. Why an indexer builds locally but fails on Envio Cloud, why a push didn't start a deployment, why an organisation or repository is missing, how to add or remove people, and why an indexer is paused.

Read it here: https://docs.envio.dev/docs/HyperIndex/envio-cloud-troubleshooting

Seeing What a Transaction Actually Did

Traces show what a transaction did once it started running, including internal ETH transfers, calls that emit no event and calls that reverted. None of that is in the logs. The new HyperSync tutorial queries traces and decodes the call data with viem, and ends with a prompt you can hand to your coding agent.

Read the tutorial: https://docs.envio.dev/docs/HyperSync/tutorial-decoding-traces

Uniswap v4 Walkthrough

The Uniswap v4 page now has a walkthrough for building a minimal swap indexer yourself, alongside the production indexer that powers v4.xyz.

More here: https://docs.envio.dev/docs/HyperIndex/example-uniswap-v4-multi-chain-indexer

HyperPipe Is Now Community-Supported

HyperPipe has been open source for a while, and from here it's a community-supported project rather than something we develop in-house. The core is solid and works end to end, so it's in good shape to build on.

If you're running WASM data pipelines on HyperSync, or want to add a processor, sink or feature, PRs are welcome. We'll keep reviewing and merging contributions, we just won't be driving the roadmap ourselves.

Check it out on GitHub: https://github.com/enviodev/hyperpipe

Current & Upcoming Events & Hackathons

• Monad Metropolis: September 1st -> October 13th
• Devcon 8 - Mumbai: November 3rd -> 6th
• Solana Breakpoint - London: November 15th -> 17th

Featured Developer: deif

This month's featured developer is deif, lead developer at Paintswap and a jack-of-all-trades software engineer with around 20 years of experience. Crypto caught their interest with the promise of trustless applications, composability between them and user-centric values.

When Paintswap released Estfor Kingdom, an idle RPG browser game, deif got hooked, started building third-party tools for its players and was eventually hired by Paintswap. Now lead developer, they work across the whole stack to keep improving the game and push what's possible for onchain games.

What deif had to say about Envio:

"Before Envio Estfor ran on legacy The Graph and considering we had tens of millions of tracked events it would take over a day to release new features or fix bugs due to the extremely lengthy backfill times. I decided to give Envio a go to see if the speed improvements that they advertised could be remotely achieved internally in Estfor. Our expectations were surpassed not only in terms of speed, but in migration ease, developer support by the Envio team, and developer tooling to help diagnose bottlenecks and better optimise our data handling methods. After the latest optimisation pass our custom deployment using Envio's HyperSync processes >10k events per second, allowing us to backfill 2 years of historical data in under an hour (over 30x speed improvement)! I would not hesitate to recommend Envio to anyone that needs to track onchain event data."

- deif, Lead Developer at Paintswap on Estfor Kingdom

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

Playlist of the Month

Open Spotify

Build With Envio

Envio is a multichain blockchain indexer for EVM chains and Solana, for querying real-time and historical data. If you're building something that needs reliable onchain data, check out our docs, join the community, and tell us what you're working on.

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