Nervos Xie Hanjian: Understanding the ultimate form of blockchain from blockchain abstraction and interoperability 2.0

0

 707 total views

Will Ethereum be the ultimate form of blockchain?

Original title: “Blockchain Abstraction and Interoperability 2.0”
Written by: Xie Hanjian (Jan Xie), Chief Architect of Nervos, CEO of Secret Ape Technology, former member of the Ethereum core R&D team

After Bitcoin was born in 2009, we soon ushered in the so-called “altcoin” era. People have derived many ideas on the basis of Bitcoin and put them into experiments. Thousands of cryptocurrencies have emerged at a time. Some new cryptocurrencies survived, and others quickly disappeared from our sight. One of the most successful is Ethereum. Why is Ethereum?

Before Ethereum, whenever someone launched a new blockchain application, a new “altcoin” would be created to realize the application. Ethereum puts an end to this cumbersome innovative way, by introducing a common programming model so that developers can build any decentralized applications on it. With Ethereum, developers can offload the burden of writing consensus code and building peer-to-peer networks, and devote more precious time to business logic. Ethereum is to other “altcoins” what the iPhone is to its feature phone[1] predecessors, which opened the Cambrian explosion of dApps for us.

Looking back on this history, we can easily understand the reason why Ethereum can develop into the most valuable blockchain-when other projects are still solving one problem at a time, it is solved in one fell swoop through a systematic method. Thousands of questions. The way Ethereum provides a systematic solution is to solve the problem at a different level: not satisfied with answering how to build the next application, but to answer how to build the next 10,000 applications more conveniently—— Is there a better way than “one application, one chain”? Such a dimensionality reduction attack on other “altcoins”[2] opened a new era belonging to Ethereum. Due to the drastic reduction in development costs, dApps have flourished. Today, almost all dApps run on Ethereum, which makes Ethereum a leader in cryptocurrency.

People often ask: Will Ethereum be the ultimate form of blockchain? Or is there a new blockchain in the future, which is to Ethereum what Ethereum is to Bitcoin? What will the next era look like?

Blockchain abstraction

The main breakthrough of Ethereum is the general programming model (also known as smart contract model, interchangeable in this article) composed of EVM and account model , on which developers can implement various application logic. The smart contract model is an intermediate layer that isolates developers from the underlying details of the blockchain that do not need to be concerned about the development of applications, while at the same time providing developers with excellent programming flexibility. What Ethereum does is abstraction, as the definition of abstraction on Wikipedia [3] said:

In software engineering and computer science, abstraction refers to:

  • When studying certain objects or systems, they ignore their physical, spatial or temporal details or attributes, and only focus on the process of more important details. Its essence is similar to the generalization process;

  • Create abstract conceptual objects by replicating the common characteristics or attributes of various non-abstract objects or systems (the result of the abstract process).

From this perspective, Ethereum is an abstraction of Bitcoin and the so-called “altcoin” . Abstraction is the eternal theme of system evolution, which has happened many times in history. In the early stage of programming technology, we could only write assembly code to directly deal with the machine. Later, people created high-level programming languages ​​and compilers, which freed us from the tedious details of the machine and only needed to focus on more important issues. .

At first, we managed hardware resources directly in our own programs. Later, we built an operating system as an intermediate layer to handle those heavy tasks on our behalf. Later, we realized hardware virtualization, so the application can run in the cloud. In the early days of the Internet, there were only a few layers of protocols, such as TCP/IP, and then the application layer was developed, so there were HTTP, FTP, and SMTP. As you can see, abstract examples abound.

Therefore, what I want to say is that the new abstraction is a sign of evolution, and the next generation of blockchain must be more abstract than the previous generation. The leap from Bitcoin to Ethereum is the first generation of blockchain abstraction, and I believe that the process of abstraction will not stop there. If we want to know what the post-Ethereum era will look like, the first thing we should think about is what can be further abstracted from Ethereum.

New abstraction

Compared with Bitcoin, Ethereum’s general smart contract model is a big improvement. To further abstract, one direction is to create a more abstract model based on the Ethereum smart contract model . If we dig deeper into the Ethereum model, we will find that the model incorporates many specific design choices, among which the main ones are:

1. Account address. Users need to initiate transactions through EOA (external account). The EOA address is the Keccak256 (a specific hash algorithm) hash value of the public key.
2. The sender’s identity verification. Ethereum uses two specific cryptographic algorithms, Secp256k1 and Keccak256, to authenticate the transaction sender. To create a valid Ethereum transaction, the client (such as a wallet) must implement the Secp256k1 and Keccak256 algorithms to sign the transaction. This also causes the client to need a secure method to manage the Secp256k1 key pair.
3. Cryptographic primitives (a type of algorithm used as a basic component). In order to provide developers with convenience, some pre-selected specific cryptographic primitives are hard-coded into EVM (Ethereum Virtual Machine) as pre-compiled contracts, for example, ECDSA signature verification and SHA256 hash function. The same algorithm, hard-coded into EVM is much more efficient than using Solidity, and the former gains practicality.
4. World state structure. The world state of Ethereum is a huge Merkle Patricia Tree (MPT), and accounts are leaf nodes. Each account also maintains its own internal key-value database in the form of MPT. MPT is one of many options for verifiable data structures.

For users with non-technical backgrounds, these design choices may seem unclear, but their importance is no less than the choice of consensus algorithms or economic model parameters. These choices affect all aspects of Ethereum, just as fine-tuning the Planck constant [4] will also bring about earth-shaking changes to our universe [5]. Building a new decentralized ecology is like creating a new universe, and these design choices are like physical laws set in this universe.

These design choices at the time were to help Ethereum achieve its initial goals, and in hindsight they were not the best choice. For example, the sender authentication algorithm Secp256k1 may be a convenient choice for designers, but in an environment that does not support secp256k1 [6] it brings unnecessary obstacles; through a small whitelist embedded pre- The practice of compiling contracts makes most of the widely used cryptographic primitives excluded from the application; the MPT used in the state data structure has also proved to be very inefficient [7], which not only exacerbated the state explosion [8] The problem has also led to the difficulty of pricing the EVM opcode [9] related to IO, and improper pricing may cause security issues such as DoS attacks.

The Ethereum community and other new protocols have also noticed these problems and tried different solutions. For example, Ethereum added more useful pre-compiled contracts through a series of hard forks, and re-priced opcodes; Tezos added Secp256r1 as a new sender authentication algorithm, and so on.

The problem is that this is no different from the way people solved application needs in the era of “altcoins”. To make matters worse, these design choices can be more complex and difficult to understand than the application, and there is often no best solution. Faced with different situations, there may be different optimal solutions. Even if there are very few cases where there is a general optimal solution, we cannot guarantee that the best choice at the moment will remain the same in the future. Therefore, a better way is to think again from a new level: instead of continuing to add new features through hard forks that require coordination by the core team, can we create new abstractions and give smart contract developers full freedom?

Nervos CKB answered this question and created a new level of abstraction. For example, CKB transactions are abstract because users and developers are not limited to using the default Blake2b-Secp256k1 verification algorithm, anyone can replace it with [10] such as Blake2b-Secp256r1, Keccak256-ED25519 or Blake2b-SHA3-Schnorr Other methods; CKB-VM is abstract and does not contain any pre-compiled contracts. Even the default cryptographic primitives like the hash function Blake2b and the signature verification algorithm Secp256k1 are just smart contracts running in the virtual machine. In other words, These cryptographic primitives and smart contracts created by application developers run in the same environment without any privileges; the cell model is abstract, in which each cell is just a pure data storage space without any internal structure, and its layout depends entirely on For developers, as we saw in sUDT[11] and xUDT[12].

Since CKB is abstract in many ways, developers are given more freedom and new capabilities. CKB is an abstraction of Ethereum, just as Ethereum is an abstraction of Bitcoin. Abstraction makes CKB a simple but powerful blockchain and transfers a lot of work off-chain (including Layer 2). The result of Ethereum’s abstraction of Bitcoin is to divide developers into two parts: one is blockchain developers who focus on the underlying blockchain, and the other is smart contract developers who build applications. It is foreseeable that CKB’s abstraction of Ethereum will also divide smart contract developers into system contract developers and application contract developers. The former focuses on system-level smart contracts, such as cryptographic primitives, lock scripts, and even memory management modules.

Recently, the Ethereum community has recognized the importance of blockchain abstraction and proposed some related improvements [13]. If these improvements are realized, I think it will make Ethereum more abstract than it is now, and further distance itself from other projects that cannot do this. However, I don’t think that these proposals for blockchain abstraction will enable Ethereum to achieve the same level of abstraction as CKB, because it is extremely difficult to make such a low-level change to a running ecosystem, just like we can’t do it without destroying it. In the case of the universe, the Planck constant is changed like that. For example, account abstraction will introduce new security complexity to important modules such as transaction pools. At this time, whenever a new transaction is signed, the verification node needs to process arbitrary calculations instead of fixed signature verification.

Abstraction can also start from scalability. Both sharding and Layer 2 solutions have the same problem, that is, changing the way the application is developed in some ways. For example, cross-shard calls [14] or cross-Layer 2 transactions may be handled completely differently from contract calls on Layer 1. Layer 2 application developers may also encounter different smart contract models on different layers (for example, Layer 1 uses the account model, but Layer 2 uses the UTXO model, or vice versa). How can we shield these details and provide application developers with a smooth development experience that is no different from Layer 1? This issue is still inconclusive, and this is one of the issues we are actively challenging.

The first channel design on CKB, Generic Payment Channel (GPC), was built following this idea. GPC aims to provide a “transparent” performance extension layer for UDT (User Defined Token) on Layer 1, so that any UDT can be “channelized” from birth without the UDT developer doing anything else. In GPC, we abstract away the details of the payment channel protocol for UDT developers. Godwoken and Polyjuice are our other attempts. These two solutions can be considered as scalability and computational abstraction on CKB, respectively .

Interoperability 2.0

Each abstraction level of the blockchain will bring us something new, something we have never seen before at the abstraction level. The first blockchain abstraction brought us universal programmability and interconnected decentralized applications. What will the next blockchain abstraction bring us?

Interoperability 2.0 (I mentioned this concept for the first time at the 2020 Wanxiang Blockchain Conference) is bound to be one of the fruits of the new level of abstraction. Our vision for the future of the digital economy is that public chains, permission chains and centralized systems will all coexist. With interoperability, we can transfer assets and call smart contracts between systems that are independent of each other. In recent years, people have conducted [15] a lot of research on interoperability [16] [17] and attempts [18], and believe that this problem can be solved through a series of basic interoperability primitives, such as multi-signature notarization, Chinese Following and hash lock.

Although blockchain interoperability is currently technically feasible, there is still a missing link between the digital economy with seamless interoperability.

First, current interoperability attempts will only lead to more severe network fragmentation. Projects such as Polkadot [19] and Cosmos [20] have defined their own standards and tried to build a multi-chain network around their own “Hub”. In addition, there are projects that strive to build direct bridges, such as realizing a direct cross-chain between Bitcoin and Ethereum. It is hard to imagine that the core teams and communities of these independent networks will one day sit down and agree on an interoperability standard that everyone abides by.

Second, and more importantly, even if these blockchain networks have perfect technical interoperability, users will still be dissuaded by the poor interoperability experience. From the user’s point of view, if I am a Bitcoin user and want to transfer my Bitcoin to Ethereum to participate in DeFi applications, I must first run my Bitcoin wallet, initiate a cross-chain transaction, and then Use another Ethereum wallet. In order to complete a cross-chain operation, I must install two wallet applications, keep two sets of mnemonics, and use two addresses. The process itself is very complicated, and only applies to the case of two blockchains. If users want to interact with more blockchains, they must manage more mnemonic/address/key pairs. User experience issues not only hinder the widespread deployment of dApps, but also undermine decentralization-the core value of blockchain-because users have to and will choose centralized services to avoid all these troubles.

To solve the above two problems, we need a new kind of interoperability, which we call Interoperability 2.0 . The blockchain with this new type of interoperability is like a “Wanwei Exchange Port”, which can achieve interoperability with other blockchains without the need for the other’s awareness. To achieve this, the “Wanwei Exchange Port” must be able to understand and implement other blockchain protocols, rather than creating their own protocols and requiring other chains to learn. It is like a “language proficiency” that can actively learn and speak other people’s languages, so that they can communicate with people who speak different languages, and other people are more willing to communicate with him.

In the cryptocurrency world, all protocols (that is, the language used by the blockchain) are constructed by cryptography. This also means that the “Wanwei Exchange Port” must broadly support various cryptographic primitives, regardless of whether they are used in current or future blockchains. In addition, the “One World Exchange Port” must be able to understand the transactions signed by various wallets, so that users can use all applications running on this “One World Exchange Port” using any wallet (only one wallet is needed).

These requirements of Interoperability 2.0 can be met by the new abstractions, cryptographic primitives and authentication mentioned above. This is why Ethereum users can use the MetaMask wallet to control assets and dApps on Nervos CKB[21] without any manual settings, or even realize that they are using the Nervos application. Not only users of Ethereum, users of EOS, Tron, and other blockchains can also manipulate assets or dApps on Nervos CKB[22]. If your favorite blockchain is not in the current support list, don’t worry, you can add support yourself by creating and deploying a smart contract (or waiting/hiring a smart contract developer to do this for you). All of this can be done by writing smart contracts without requesting the core development team and/or implementing a hard fork.

Applications running on Nervos can get the benefits of Interoperability 2.0 for free. Every Nervos application can be accessed by all blockchain user groups. We call this application a Universal Application .

  • As a developer, you can gain a wider user base than any other blockchain platform can provide by learning how to build applications on Nervos.

  • As a user, you only need to use your current wallet and account to access the Wanwei application on Nervos, without installing new applications or adapting to a new learning curve.

You may feel like you are using a dApp on Ethereum or EOS, but in fact the underlying pipeline and infrastructure are provided by Nervos. I believe this is how life should be, just like when an Internet user visits a website, he doesn’t care whether the website is written in PHP or JAVA, and whether it uses MySQL or PostgreSQL. Users don’t care about these at all, and this is right.

As developers, we have the responsibility to create abstractions and hide implementation details from users, so that we can continue to replace existing implementations with better software, so as to continuously provide a better user experience. Interoperability 2.0 can make the world of cryptocurrency like the Internet today, and this needs to be achieved through a new blockchain abstraction.

Even better, in addition to blockchain users, Wanwei applications can even reach a much larger group than blockchain users. The cryptocurrency world is still a small circle, and we can “break the circle”. Blockchain wallets and accounts are just another account/identity system, and the Internet world has established a variety of identity/account systems and verification standards, such as OpenID, face recognition, and fingerprint recognition. Through the abstraction of cryptographic primitives and authentication, Nervos CKB can also understand widely used Internet protocols. In this way, users can use browsers and mobile phones to access Wanwei applications without installing any blockchain wallets, generating key pairs, or even keeping any mnemonic words. In this way, we can proactively adapt to the existing Internet ecology, rather than creating a brand new ecology. Our grandparents can enjoy the convenience of technology without having to work hard to learn something that looks like magic. The barriers that prevent Internet users from entering the world of cryptocurrency no longer exist here.

Nervos Xie Hanjian: Understanding the ultimate form of blockchain from blockchain abstraction and interoperability 2.0

New metropolis

Many modern metropolises developed from trading hubs or ports. Venice, New York, Hong Kong, Shanghai and Singapore have all become highly commercialized cities by virtue of their own port advantages. In the industrial age, we use interoperable technologies such as GPS, cargo ships and containers to transfer assets between different cities. Today, we have encrypted assets, blockchain, and interoperability 2.0. Better interoperability will bring more migration, trade and vitality to cities. Tall buildings will stand, goods will flow endlessly, assets will live here, people will gather here, and a new metropolis will be born.

Ref:

[1] https://en.wikipedia.org/wiki/Feature_phone

[2] https://en.wikipedia.org/wiki/Death%27s_End

[3] https://en.wikipedia.org/wiki/Abstraction_(computer_science )

[4] https://en.wikipedia.org/wiki/Planck_constant

[5] https://iopscience.iop.org/article/10.1088/0143-0807/37/5/055406/meta

[6] https://crypto.stackexchange.com/questions/85831/what-ec-curve-is-used-by-apple-ios-platform

[7] https://hackernoon.com/getting-deep-into-geth-why-syncing-ethereum-node-is-slow-1edb04f9dc5

[8] https://blog.ethereum.org/2021/03/03/geth-v1-10-0/

[9] https://eips.ethereum.org/EIPS/eip-1884

[10] https://talk.nervos.org/t/lay2-pw-sdk-build-dapps-on-ckb-and-run-them-everywhere/4289

[11] https://talk.nervos.org/t/rfc-simple-udt-draft-spec/4333

[12] https://talk.nervos.org/t/rfc-extensible-udt/5337

[13] https://hackmd.io/@SamWilsn/ryhxoGp4D

[14] https://ethresear.ch/t/cross-shard-defi-composability/6268

[15] https://docs.zkproof.org/pages/standards/accepted-workshop3/proposal-plumo_celolightclient.pdf

[16] https://docs.keep.network/tbtc/index.pdf

[17] https://www.r3.com/wp-content/uploads/2017/06/chain_interoperability_r3.pdf

[18] https://www.weforum.org/whitepapers/inclusive-deployment-of-blockchain-for-supply-chains-part-6-a-framework-for-blockchain-interoperability

[19] https://polkadot.network/

[20] https://cosmos.network/

[21] https://talk.nervos.org/t/2-0-nervos-unidapp-dapp/5332

[22] https://pay.lay2.dev/#/

Let’s block ads! (Why?)

Disclaimer:

Blockcast.cc does not endorse any content or product on this page. While we aim at providing you all important information that we could obtain, readers should do their own research before taking any actions related to the company and carry full responsibility for their decisions, nor can this article be considered as investment advice or recommendations. Every investment and trading move involves risk, you should conduct your own research when making a decision.