Partnered With:

AltLayer: Rollups temporary execution layer solution that can replace the application chain

Read this article in 15 Minutes

Is the application chain necessarily good?

Original source: AltLayer

Original title: "The Case for AltLayer"

Original compilation: FYJ, BlockBeats

This article provides a relatively complete case for AltLayer. The content in this article is the full version of the recent Thread on AltLayer's official Twitter account, and explains the basic principles of the project party building AltLayer in the current trend of popular dApps migrating from general-purpose chains to specific application chains.

We are excited to build on popular dApps as they start to outgrow native platforms. DefiKingdoms is the first project to transition from a dApp on Layer 1 to have its own application chain as an Avalanche subnet.

Yuga Labs (the entity behind CryptoPunks) followed suit, announcing that after the highly anticipated NFT sale faced scalability issues, it would shut down the contract on Ethereum and seek to migrate the project to its own chain to scale performance. Although the Apecoin community rejected the proposal to leave Ethereum, about 47% of the community voted for ApeChain.

Recently, dYdX, the largest decentralized derivatives trading platform on Ethereum, announced that their version 4 update will be built on a self-customized application chain and have its own set of verification nodes using the Cosmos SDK.

Each of the above dApps are very popular among users, traders and crypto enthusiasts. We believe that the trend of transitioning from general purpose chains like Ethereum to specific application chains will become the norm for mainstream dApps looking to ultimately provide a better experience for their users.

One of the main reasons for building an application chain is performance issues. Ethereum has a shared block space, which causes a popular dApp to consume a disproportionate amount of block space for itself, while users of other dApps due to increased Gas and settlement time And the experience is not good.

dApps such as DefiKingdoms, dYdX, Yuga Labs, etc. demonstrate the necessity of having separate on-chain spaces owned by applications. Today, these dApps can use solutions such as Polkadot, Avalanche, and the Cosmos SDK. However, these options have trade-offs.

For example, while some of these are completely permissionless, i.e. the Cosmos SDK; others are not, such as Avalanche's subnetwork, which follows a shared security model where each chain is secured by a common set of validators (i.e. Avalanche and Polkadot) .

Although the ecological chains of the Cosmos SDK do not share security themselves, each chain has its own set of validators. Imagine a Cosmos-style application chain secured by only a handful of validators, with an attacker controlling 1/3 of them to halt the network.

Controlling 2/3 of them would make the network produce invalid blocks. Therefore, if the security of the application chain is not tied to a larger, more secure network (such as layer 1 such as Ethereum), the security of the application may be seriously affected.

Additionally, AppChains may waste resources (physical or economical) if the dApp does not gain enough usage. For example, in the case of Avalanche, the dApp chain is in the form of a subnet, which needs to mortgage the main chain Token, namely AVAX, to ensure economic security.

As a result, dApps that can barely consume block space end up taking up scarce economic resources that could be used to secure more used subnets.

On the one hand, in the case of general-purpose chains (such as Ethereum), more used dApps compete for block space with a large number of less used dApps. On the other hand, each dApp with its own chain wastes resources.

Since existing approaches and solutions present two opposite extremes, there is a need to design an architecture that provides the best of both worlds.

Another key point to note is that some popular dApps do not require permanent dedicated block space, but only for short periods of time in anticipation of a surge in demand. For example, the Yuga Labs case involving NFT minting was a short-term event.

In fact, most NFT minting events are over within a few days (usually hours or even minutes), only during this period user activity is very high, requiring elastic scaling solutions.

Once the minting event is over, user activity will slow down to a point where it can be easily handled.

Building an appchain that won't see much activity after the hot event is over is also a waste. In addition, once the application chain is established, the project will also be isolated from other NFT projects such as the market and lending, thereby breaking composability.

The ideal solution is a temporary execution layer protected by Layer1. Developers can start before the minting event and mint coins on the execution layer. Once the minting is over, the assets will be settled at Layer1, and the execution layer will be dissolved.

The key here is that this transient execution layer must be scalable and must be connected to a secure Layer1. At AltLayer, we are building a transient execution layer system powered by optimistic rollups (a state-of-the-art scaling technique pioneered by Arbitrum and Optimism).

AltLayer can be viewed as a separate system of optimistic rollups that derive security from the underlying Layer1 (e.g., Ethereum) or Layer 2 (e.g., Arbitrum and Optimism), each rollups tailored for a specific application custom made.

AltLayer brings the new idea of one-shot execution layers. With AltLayer, dApp developers expect increased demand:

1) Start fast and scalable rollups;

2) Use it as needed;

3) Settle and dispose of it at Layer1 through "end of life".

This makes the whole system highly resource optimized. The execution layer and its resources are invoked only when the dApp is expected to be unable to handle a large demand at Layer1, and once the demand tapers off, the dApp can return to Layer1.

Appchains also break composability, resulting in isolated dApps being unable to connect with users of other dApps, thus limiting the set of functionality a dApp can provide. AltLayer allows developers to regain composability after Layer1 has settled.

AltLayer also improves existing rollups such as Arbitrum and Optimism, making the sorter (the node that executes the transaction) more decentralized; in addition, it is designed for the multi-chain and multi-VM world and will support EVM and WASM.

We believe that an application-specific execution layer provides a modular and customizable solution to the scalability challenge. Therefore, we are excited to build on this vision and bring a unique "rollups-as-a-service" scaling solution to dApp developers across the blockchain ecosystem.

At AltLayer, we will work with other Layer1 and Layer2 (i.e. Arbitrum, Polygon, Optimism, etc.) to bring WASM to Ethereum and enable application-specific execution layers for dApp developers on these networks.

We are particularly looking forward to Arbitrum’s upcoming Nitro upgrade, which is designed for fraud proofs via WASM. This opens up new possibilities where developers will be able to execute WASM contracts on AltLayer and any fraud proofs can be handled by Arbitrum.

A visual comparison:

- Bitcoin - shared block space, limited functionality

- Ethereum - Limited execution environment with shared block space

- application chain - dedicated block space, closed execution environment

< br>

- AltLayer - On-Demand Scalable and Fully Open Execution Environment with Dedicated Block Space