What is NOT Chain Abstraction?

Chain abstraction is not what you think.

It isn't your fault.

It's easy to form wrong mental models in web3.

Every new narrative brings along waves of new tweets, podcasts, articles, and typical CT debates that shape your understanding.

The current hot narrative is Chain Abstraction.

You think you get it. But, most likely, you have a wrong idea of what it truly is.

This article is not about what chain abstraction means, it's glorification or vilification, or super technical deep dives. There are enough of those already.

Instead, I aim to try and eliminate a few common misconceptions around Chain Abstraction that I encountered during my research.

Chain Abstraction in < 100 words

Chain Abstraction is a combined effort to simplify the complexity of using decentralized apps, to the extent that users shouldn't be required to perform unnecessary tasks or understand the underlying chain to accomplish any on-chain action.

Additionally, for developers, chain abstraction aims to reduce the difficulties of dealing with multi-chain infrastructure complexities like interoperability, and cross-chain communication and instead focus on building real-world consumer applications.

Essentially, it strives to improve both user experience (UX) and developer experience (DevX) in the current ecosystem to enable simplified development as well as the use of decentralized applications.

That's it.

Count it. It's less than 100.

Now, What is Not Chain Abstraction?

Now, let's clearly understand and eliminate the misconceptions around chain abstraction.

1. No, Chain Abstraction does not resolve all on-chain complexities.

One of the most common misconceptions about ChA is that it aims to simplify every single on-chain complexity.

Well, it does NOT.

It's understandable where this misunderstanding comes from.

As previously mentioned, Chain Abstraction is a combined effort to improve the overall UX and DevX of on-chain apps - a significant goal. It's an ambitious goal. This ambitious vision can be misinterpreted to suggest that ChA will fix all on-chain complexities, leading to a perfectly streamlined web3 ecosystem. And we live happily ever after.

This, however, is not true.

Chain Abstraction aims to resolve multi-chain complexity rather than all on-chain complexities.

To begin with, It's important to recognize that these scopes are quite different:

• Multi-chain complexity is a narrow scope that indicates the challenges a user or developer faces when interacting with multiple chains, each with its protocols, transaction formats, native tokens, etc.
• All On-Chain Complexities, on the other hand, have a much broader scope that encompasses all the inherent technical challenges within a single blockchain, including consensus algorithms, scalability (transaction throughput, latency), security models, economic incentives, etc.

Solving all on-chain complexities is beyond the current scope of ChA as these complexities require solutions specific to each blockchain's architecture.

Instead, ChA is more targeted at improving multi-chain interaction as it operates at the application layer and abstracts the complexity at the user interface and application protocol level.

And now, just in case you think ChA is just another name for cross-chain bridging ( interop solutions )

Think again and read the next point.

2. Chain Abstraction is not just Cross-Chain Communication

If ChA solutions resolve multi-chain complexities, then it's just another name for Interoperability or Cross Chain Communication - right?

That's a misconception.

Although both of these aim to resolve the complexities of fragmented multi-chain ecosystems, they aren't necessarily similar.

ChA represents the evolution of Interoperability/cross-chain solutions, sure.

But it's more than just communication between chains.

Mentioned below are a few reasons why:

2.a There is little to no "Abstraction" in Interop Solutions

A typical interoperability (Interop) solution provides one key factor - the ability to interact/communicate between chains. Value transfers, arbitrary message transfers, programmable token transfers, etc.

With an interop solution:

• users select a bridge,
• construct the payload (message/action) that they wish to relay,
• provide the destination chain ID for the payload
• manages & provides gas tokens on the source chain
• switches between chains
• achieves the desired outcome on the destination chain

The important aspect is that a user must perform all these steps themselves to achieve their desired outcome. All of them.
( some aren't even mentioned above).

While interoperability solutions resolve the interactions between chains, the overall UX remains complex.

Why?

Well, there is no abstraction in Interop Solutions. A typical bridge doesn't necessarily abstract away the complications for a user, at all. Users still need to learn, understand, and navigate through multiple chains, and perform a set of on-chain tasks themselves to achieve simple desired outcomes. In the process, they might even expose themselves to many security risks that can lead to unwanted losses. More on security in point 2.c below.

Now, this is where ChA differs.

The idea of ChA is to abstract way complex on-chain actions as much as possible from users and only let them do the bare minimum to get the desired outcome.

A similar action ( as mentioned above with an interop solution ) could be as simple as:

• A user defines the desired outcome ( the intent or userOps).
• Off-chain actors ( solvers, relayers, executors, etc) in the ChA protocol can then do the heavy lifting of :
  • what chain to select,
  • how to efficiently execute the intent,
  • managing the gas fees across chains, etc.
• Once completed, the user simply achieves the desired outcome. Without ever having to navigate between chains & perform complicated on-chain tasks

This abstraction significantly improves the UX for an average Joe, who may not be interested in the underlying chains but simply wants to achieve their goals seamlessly.

ChA allows Joe to achieve this, with abstractions.

2.b Interop Solutions don't adequately address Fragmentation

The previous point indicates how interoperability solutions do not equate to user-level abstraction.

It also doesn't adequately address the fragmented ecosystem.

Users are still required to manage multiple wallets on different chains, possess the native gas token of different chains, and understand the varying interfaces of apps built on multiple chains.

A user Bob with 3 different assets on 3 different chains can't use them to perform one single action on one specific chain ( despite having funds ).

Bob's assets are siloed on their respective chains. He can't seamlessly utilize his chainA or chainB tokens to invest in the chainC protocol without manually bridging assets.

Interoperability doesn't consolidate his fragmented assets into a usable form on the target chain.

This is where ChA differs.

Chain Abstraction addresses this fragmentation by unifying the user experience across all blockchains

With ChA solutions:

• Users have a unified account that operates seamlessly across all chains - no more multiple wallet management.
• They can view and manage all their assets in one place, regardless of which chains those assets reside on.
• They get abstracted UX for gas payment for transactions. Users might pay transaction fees in a single currency or have them handled entirely by the protocol.

To get a glimpse of how such accounts function, check MagicSpend++

By focusing on the UX, ChA removes barriers that hinder the mainstream adoption of web3 and dApps.

It leverages interoperability as a foundational component but extends far beyond it to solve the fragmentation problem at the user level.

2.c Security Models aren't the same anymore

An additional note is to compare the security models between the two solutions.

Note: This argument doesn't indicate that ChA solutions are more secure than interop solutions. Its too early to make such statements.

Its to simply show how both of these are different.

A typical interop solution, for instance, facilitates value or data transfers between chains by utilizing validators or relayers to verify transactions. This process, however, introduces multiple points of security failures such as breaches of centralized validators or relayers, inadequate multi-sig schemes, heavy reliance on complex smart contracts, unsafe external calls, etc.

These vulnerabilities have led to significant security incidents resulting in substantial financial losses, as we have seen in the past.

On the other hand, ChA solutions minimize the security risk by shrinking down that attack area.

The idea of reducing users' direct and redundant interaction with chains - and, instead, delegating them to expert on-chain actors such as intent handlers or solvers, helps in reducing the attack surface and providing enhanced security for users.

However, it shouldn't be overlooked that ChA solutions introduce new points of security failure.

Introducing new abstracted layers and off-chain components like handlers or solvers means we will have to rethink the security of the new abstracted ecosystem.

Security audits of involved smart contracts and the individual components in the process will still be imperative. However, these will be different from the ones we saw in interop solutions in the past.

Here is one more interesting reason why ChA and Interop is different.

That said, we should now have better mental models to distinguish Interop solutions from ChA.

While both aim to simplify the UX in the multi-chain web3 ecosystem, ChA stands out as the evolved and enhanced solution

Chain abstraction is, in essence,
the Version 2.0 of the Interoperability solutions.

3. ChA Abstracts Chains, Not Eradicate Them

If you believe:

• ChA introduces a new universal interface that renders every blockchain identical,
• ChA removes the necessity of considering individual chains,
• or ChA will lead to chains completely vanishing...

then, you are expecting way too much from ChA.

Every chain has unique architecture, finality, transaction throughput, incentive mechanisms, governance structure, etc.

To think that there will be a single universal protocol that all chains will adhere to - is overestimating the scope of chain abstraction.

This again goes back to the multi-chain complexity vs all on-chain complexity debate that we covered in first point.

ChA aims to abstract, not eradicate chains.

ChA leads to a web3 ecosystem where users won't be forced to do unnecessary tasks to achieve simple outcomes. Instead, most of those redundant & complex tasks will be abstracted away or delegated to specialized on-chain actors.

This doesn't mean the underlying chains just vanish completely.

They will still exist and function as per their protocol.

There will still be users ( advanced users, devs, etc ) who will care about the underlying chains.

There will still be chain vibes. That isn't going anywhere. 😎

However, the imperative part is users will no longer be forced to understand the underlying chains.

And that's because all unimportant details will be abstracted away.

Chain-Abstraction allows you to focus on properties that matter because all the unnecessary complexity is taken care of and condensed into some high level properties you as a developer/users can control/optimise
- Vaibhav, Socket.

4. Chain Abstraction does not lead to Centralization

This misconception arises from the previous one, i.e., that every on-chain action will go through one specific unified layer or protocol.

We have now understood that it's not true.

However, there is one more point to counter this argument.

The core idea of ChA is to use decentralized components & specialized on-chain actors to remove unnecessary actions from users during any on-chain interactions. Decentralized Components.

That's the key here.

Ideally, every ChA solution should use decentralized architecture and mechanisms that distribute trust and operations across multiple independent entities.

For instance, the recently released Socket's whitepaper says:

Socket Protocol consists of 4 major components: Plugs, Switchboards, Gateway and Socket which is the center-point and where everything is plugged into. The goal of the entire protocol is to create, execute and finalise chain-abstracted-packet.
...
Transmitters are off-chain smart-actors that are responsible to execute user-requests onchain, anyone can become a transmitter and submit responses to user-requests. App-Gateway is able to select the right transmitters for the userrequest ultimately.
...
Given applications/plugs can choose any switchboard AND registering new switchboards is permissionless, applications have full control on how they want to validate actions across networks as well as interactions between gateway and the onchain application.
...
Key points around Watchers: Anyone can run a watcher-service and listen to as many or as few chains as they want to participate in the Socket protocol

These are a few good instances that I picked from the whitepaper.

The aim is to indicate how some of the main components of Socket, such as Watchers or Transmitters are designed to be permissionless, thus, making the entire architecture decentralized.

A similar permissionless and decentralized approach can be found in other popular ChA solutions like Particle Network, Okto, etc.

I must add, however, that the fear around centralization isn't completely invalid. It's a tricky one. Just like any other new solution in web3.

Currently, ChA solutions are in their nascent stages. We are yet to see complete implementations and adoptions of these solutions.

Therefore, it's somewhat premature to definitively confirm or deny whether all ChA solutions will fully embody the ethos of decentralization.

It's also worth noting that ChA protocols may inherently involve a centralization trade-off because the overall decentralization of the stack is constrained by its least decentralized component. That's one of the criticisms of the centralization aspect of ChA solutions.

Nevertheless, I believe in the long run, ChA solutions that are fairly decentralized and effectively abstract unnecessary on-chain actions while improving the overall Web3 user experience will ultimately succeed.

Everything else will fade away.

5. Chain Abstraction is NOT the Final Frontier of Web3

If you believe ChA is the final frontier of web3...you are spending too much time on crypto twitter. ( with no time for in-depth research).

Crypto Twitter is notoriously good at forming strong narratives.

Some are legit. Most are noise.

Every new solution, infra, or idea in web3 somehow becomes the "final frontier". The endgame. The ultimate savior. The gateway to the "next billion users".

Recall the previous "final frontiers" of web3:

• Rollup-centric roadmap to scale Ethereum - scalability era.
• Creation of bridges & interop solutions - cross-chain era
• Fixing onboarding by abstracting EOAs - account abstraction era
• Simplifying UX with user's intents - intent-centric revolution
• Abstracting chain to further simplify the UX & DevX - Chain Abstraction

Do you see the pattern now?

Every new solution appears to be the end game. But none of them are.

The final frontier, the true end game for web3 is when we build & ship consumer-centric applications powered by blockchain technology that an average Joe can use, just like any other app. Period.

That's the end goal; everything else is our preparation to reach this goal.

If we don't reach this end goal, all these preparations won't matter.

That being said, so far we have solved scalability, block space, cross-chain communication, and account abstraction ( sort of ).

I believe ChA is the next logical problem to solve in web3. An important issue to solve.

However, it isn't the final frontier.

Users don't care about our preparations, all they want are truly useful apps.

And here, I leave you with the popular Y-Combinator slogan.

Cheers 🍷