Original author: Pavel Paramonov

Original translation: Alex Liu, Foresight News

Is everything really moving towards AppChains?

Yes and no.

The main reason dApps are turning to building their own sovereign chains is that they believe they are being exploited. This is not far from the truth, as most dApps do not make money.

You can consider the recent example of @zkxprotocol ceasing operations, and many other applications in the past such as @utopialabs_, @yield, @FujiFinance, etc.

But is this because their business model is bad, or are the protocols truly exploitative?

The main (and often only) source of revenue for a dApp is fees. Users pay the fees because they directly benefit from them.

However, users are not the only beneficiaries of the rise in dApp usage.

There are several roles that can profit from the transaction supply chain, the most important of which are the block proposers, even though they are the last to see the transaction. In the L2 case, it is the sequencer.

MEV (maximum extractable value) is being extracted in large quantities, which is not always a bad thing, but the value created by dApps is being taken away, so they are not getting the full value they provide.

There are currently three ways to solve this problem:

  • Become an Appchain.

  • Choose an L1/L2 that returns value.

  • Implement app-specific sequencing.

Like everything in cryptocurrency, every solution has its trade-offs.

1. Becoming an appchain: High cost + high value

There are countless advantages: you can extract the value you want, control your own network (if you are L2), it is easier to scale, avoid competition for block space... and so on.

The downside is: it’s really expensive. Really expensive. And it’s harder to do because you have to build both the chain and the application at the same time.

Even if you want to build an L2 and use a solution like Alt Layer.

The idea that every application will eventually become an Appchain is fundamentally wrong for three reasons:

  • Not every dApp is large enough to require migration to Appchain.

  • Some dApps directly benefit from the architecture of the underlying chain.

  • Many dApps have grown quite comfortably on other chains.

2. L1/L2 of Return Value: Low Cost + Medium Value

It is much cheaper to deploy an application on a Rollup or L1 because you don’t need to implement new rules for validation, inclusion, consensus, transaction flow, etc.

In the case of Rollups: It is very easy to migrate your application from Ethereum to Rollup (in most cases) because Rollup is either EVM-compatible (e.g. Arbitrum) or EVM-equivalent (e.g. Taiko).

You still need to consider the architecture of the underlying chain, but you don’t have to build it from scratch.

Maybe in the future we’ll have true chain abstraction and developers will only have to worry about their dApps, but that’s another story…

The rewards that developers receive are medium in that it is not very high (you don’t own the chain’s economy), but not very low (you get some rewards in addition to the fees).

There is almost no implementation of this at the moment because sharing MEV with dApps is still a complex process and we need to do more R&D.

3. Application-specific ranking: moderate cost + uncertain value

The concept of application-specific ordering is fairly new and people often confuse it with Appchain, but the difference is simple:

  • Appchain takes care of sequencing and execution.

  • Self-sorting dApps only care about sorting and "outsource" the execution to L1/L2.

The cost is moderate because in addition to building a dApp you have to consider the ordering of transactions, and the value is uncertain because the concept is fairly new and has different concerns.

First, you are still dependent on the proposer because of the inclusion game: you can send any bundle you want, but the decision to include your bundle is up to the proposer.

If you take all MEV, then there is no clear incentive for the proposer to include your bundle in a block.

This actually opens up another incentive market for proposers. They (dApp + proposer) should cooperate, otherwise none of them has value or power.

Its value is also uncertain, as we are not sure whether the shared value from L1/L2 will exceed the value the dApp creates for itself by ordering transactions.

Any chain is a dark forest (not just Ethereum!). So back to the original question:

Is everything really moving towards AppChains?

  • Well, yes (some dApps benefit more from having their own chain rather than staying on an existing one).

  • Well, no (there are other solutions that fit dApp needs).

This forest is so large that all options can be explored.

There is diversity in every field in the world, including crypto. So choose the one that best suits your needs, or build your own solution!