Chain Abstraction and growing Web3

Continuing the posts around Crypto UX, today I wanted to write about Chain Abstraction.

To start with a simple explanation, chain abstraction is basically about unifying the experience across blockchains in a way that the chain itself, doesn't matter.

The reality of Web3 is pretty messy. Like I’ve said in a different post, we can’t expect regular users to just understand the complex steps we currently go through to interact with crypto. But that’s not the only problem we’re dealing with.

Another big one is user fragmentation and liquidity fragmentation, and how this messes with the kind of dApps we want to build.

When building anything in Web3, we’re usually hit with the first big decision:
"Which blockchain are we going to build on?"

This decision can be based on a bunch of different things. Sometimes it’s financial, like when a blockchain sponsors your project. But most of the time, it’s about liquidity and the number of users.

Right from the start, this decision already cuts off a lot of potential users from your dApp. If you go with EVM, you lose on chains like Solana, where users are genuinely passionate about everything related to it. On the flip side, choosing Solana means missing out on Ethereum, which, for a lot of things, is just the core of the space. Either way, it feels like a lose-lose situation where both companies and users end up losing something.

Chain abstraction is a step in the right direction. And I'm going to be completely honest, without it, we’re not going to scale this space...

Now that we have an idea of why this is so important, let’s break it down.

There are a lot of pieces involved in getting real chain abstraction. Some of them aren’t really my area of expertise, but here are a few key ones:

Cross-chain liquidity
Universal wallet address
Cross-chain communication
Account abstraction
(you know what?! there are many more)

My focus is more on the UX side and how I see this playing out.

If we solve the user problem, we’re probably solving the developer problem too. If users don’t need to know which chain they’re on, we likely have the tools for developers to not have to pick a chain either (though this will probably look different depending on the chain).

Building a Better UX

Here’s what I think we need to focus on to make the UX better:

The more it feels like Web2, the better.
The closer it is to a tradfi flow, the better (at least for now)
Integrating tradfi is key! Most users will only get into this space when they can just use their debit and credit cards to add funds.
Transaction details should be crystal clear. Explorer pages should make sense at a glance, and should not be as scary as they are right now.
Gas payments should be either covered by the dApp or super flexible (but ideally, the dApp should just cover it).
Investments shouldn’t be tied to a single chain. Users shouldn’t have to know where their token lives, like having to know if the desired token is available on Solana or Arbitrum for example.
No per-chain balances! It doesn’t make sense to split tokens by chain. If I have 1000 USDC on Base and 500 on Arbitrum, I should just see that I have 1500 USDC.

These are just starting points, but they can help us move towards a simple UX with cross-chain execution. We’re not even close to being there yet, but I think it’s clear how important it is, and a lot of projects are already working towards it.

The Role of Aggregators and Middleware

One of the biggest things pushing chain abstraction forward are aggregators and middleware. These tools bridge the gap between blockchains, letting dApps work without being stuck to a single network.

In the long run, these middleware solutions might become the foundation for chain-agnostic apps. They give developers a unified interface to work with, making the ecosystem more modular, scalable, and user-friendly.

Honestly, trying to achieve chain abstraction without middleware is just unrealistic, because each chain would have to focus on it too. These technologies are the glue that makes the idea possible, helping both users and developers get past the limitations of each blockchain.

What’s Next

The next steps are going to define how we actually make this work. Developers who are die-hard fans of one chain or hate another probably won’t be the ones pushing this change, but that’s okay. We need to cross that bridge anyway, and the easiest way is to not have too many opinions around the chains themselves. But even if you do, don't turn this into something it doesn't need to be.

I think the building process will be modular, just like how we use different libraries to handle specific features. Different projects will start to open up chains to this kind of abstraction, while bigger projects will likely work on setting standards, like global address conventions, for example.

Either way, I’m pretty excited about what’s coming next and how frontend development is going to be a huge part of making it happen. I honestly think a lot about it these days as we are building Glider and reaching these puzzles.

Thanks for reading!