Do you understand the Plasma framework? It’s all here.

Plasma is a framework for building a scaled application, not a project. There are many projects that use the tools provided by Plasma. If you are learning Plasma for the first time, you will often get confused (but it doesn't matter!).

The framework features of Plasma are difficult to interpret. Without an example of how to use Plasma, it is difficult to accurately describe what Plasma is. At the same time, it is important that these examples represent only some of the possibilities of Plasma.

Therefore, before introducing the application examples within the framework, it is necessary to introduce the role of Plasma as a framework. If you are used to seeing Plasma as a specific project, then you will be confused when you look at this chapter! Don't worry, we'll cover some of these applications in detail later.

Why do we need Plasma?

Before explaining what is Plasma, first understand why Plasma exists. Basically, it comes down to the fact that modern blockchain systems run slowly under modern standards. To handle simple payments of any wide capacity, the blockchain needs to process thousands of transactions per second. According to network conditions, Ethereum currently supports a maximum of 20-30 transactions per second.

Identifying the difference between 'transaction already exists' and 'transaction needs to be proven to exist' is often referred to as "blockchain scalability". We want to extend the blockchain system while preserving security and decentralization. This is why we built the blockchain.

Plasma is trying to solve scalability problems in different ways. Some of these projects attempt to expand by upgrading the blockchain, which we often call "Layer 1" expansion because we are also modifying the base layer. Other projects try to build things on top of existing systems, which we usually refer to as "Layer 2" expansion, because we are currently adding new layers without changing the underlying system.

Plasma belongs to the second category of "Layer 2" expansion projects. It is important to understand how the two-tier projects work and what they do. Many Layer 2 designs are designed to monitor, that is, everyone does not have to know every transaction that takes place on the network. Imagine that you buy a cup of coffee from a local coffee shop every morning. In addition to choosing one of the many coffees, you may find it more convenient to use the merchant's prepaid mobile wallet. Simply import the money into your mobile wallet at once, so you don't have to take out your wallet every time you make a payment. It's also faster and cheaper for merchants because they don't have to pay through the payment processor every time. This is a mutually beneficial approach.

The essence is actually putting money into the local “book” of the coffee shop you hold, just like a prepaid card. We try to simplify this process because there is no need to go through the complicated process to let everyone know that you have paid for the coffee shop. As long as the store and the store agree on the use of the balance in the wallet, all processes will be easier. So this is the core of most Tier 2 projects. The above is a very simple example – it only involves two participants (you and the coffee shop). However, what people want to know is whether we can extend this idea to the entire blockchain.

Is it possible to temporarily transfer funds from the blockchain to a smaller (and cheaper) blockchain and then transfer the funds transferred from the second chain back? The answer is – yes! This is the evolution of the "sidechain". Our basic idea is to take assets from one chain and transfer them to another chain by locking them in the main chain (or "root chain") and "create" it again on the side chain. When you want to turn assets back, you only need to "destroy" the assets on the sidechain and unlock them on the root chain. It sounds simple, but there is a big problem – someone must agree to "create" these assets on the sidechain. So who can “create” assets? – Consensus mechanism. The basic idea is that if the sidechain consensus mechanism works properly, then your assets are safe. Unfortunately, the safety of side chains is usually not as good as the root chain. If someone creates money that “appears out of the air” that does not correspond to the assets locked in the root chain, they can “destroy” these fake assets and steal a lot of wealth.

Obviously this is not an idealized model, but as long as the sidechain is safe, your assets are safe. But if the sidechain fails, the asset is at risk of being stolen! That's why we want to introduce Plasma (this is why we want to introduce Plasma). Plasma was first developed to improve the convenience of sidechains while ensuring asset security stored on the sidechain (as long as the rootchain is secure). Although we don't get the same side chain, we retain some of the most important things (such as making the deal cheap) while keeping it safe. The fundamental principle of Plasma is that all user assets can "return" to the root chain even if the sidechain loses security.

Plasma building block

Blockchains are slow and expensive, so we want the blockchain to operate quickly and cheaply while still being secure. This is why we need Plasma. What exactly is Plasma? Plasma is a way to build a decentralized application that scales up, while speeding up without sacrificing security. Let's explore its components.

Execute trading under the chain

The Plasma application needs a lot of work outside of its "root chain" (for example, Ethereum). The root chain runs slowly and is expensive because it is safe to do so. If an application can do all the tasks except the root chain, then it is a good way. For example, in the Plasma MVP, almost all transactions, except Ethereum. You can only access funds, that is, you need to use smart contracts to process and log in. It is a standardized workflow for Plasma applications that does not require any assets to move in and out, and can be handled with smart contracts under the chain.

State commitment

When we deal with so many tasks under the chain, we need some way to ensure the finality of the change. This is why we use the “state commitment”. State Commitment is a cryptographic way to store a compressed version of an application.

However, everything on the storage application can severely break the Plasma, and we usually use the Merkle tree instead, so that these promises become storage points similar to the application.

drop out

The Plasma application uses these promises when a user leaves the Plasma chain. We usually refer to it as an "exit" application. Let's imagine a web payment application to clarify this! The state commitment on the application may contain some information about the user's current deposit. If the user wants to withdraw ("exit") the balance from the application, they need to submit a smart contract to prove that they have so many balances to withdraw. To do this, the user can use a technique called Merkel proof.

These are the basic ways in which most Plasma applications build blocks. Next we will introduce you to Plasma MVP, the first official application to be designated by Plasma. The next part will explore how to apply these modules to create a true Plasma payment network, so stay tuned.

Original source: https://www.learnplasma.org/docs/plasma-framework.html

This article is translated from the first class. For more information on blockchain projects, please add the author go-first-one , or click on the source of this article to find out more~