Written by: LFG Labs
Imagine if any Solidity developer could build/migrate a safer and more efficient DApp directly on Move with almost zero threshold, wouldn’t it be very cool?
In 2019, Libra, which stirred up the entire technology industry and then quickly withered, might not have thought that after its failure, Aptos, Sui, Linera, and Movement would successively take over the mantle and push the new public chain of the Move system to a small climax.
However, what’s interesting is that unlike Aptos, Sui, and Linera, which are all L1 public chains based on the Move language, the new generation of Movement has set its sights on L2 - launching the first Ethereum L2 based on the Move language , aiming to leverage the underlying execution performance and security advantages of Move, and further integrate the ecological advantages of EVM, so that developers can start Solidity projects on M2 without writing Move code.
As the first integrated solution in the new public chain of Move that has transformed from "Ethereum killer" to "joining Ethereum", Movement, which applies high-performance architecture at the L2 layer and the final state security mechanism design based on the Ethereum mainnet , also won a large amount of financing of US$38 million in April.
So what exactly does Movement want to do, and what kind of magic does it have to attract top investment institutions such as Polychain Capital, Binance Labs, OKX Ventures, and Hack VC to place bets?
Movement: Bringing Move to the EVM Ecosystem
Since the programming language reflects the core tone of a blockchain project, before we understand in detail what Movement is going to do, it is necessary for us to review the inherent characteristics of the Move language.
As we all know, Move is a new smart contract language developed and designed by Facebook. In addition to being first applied to Facebook's Libra (Diem) project, the Web3 products on the market that publicly use the Move language are mainly concentrated in new public chain ecosystems such as Aptos and Sui.
From the perspective of the public chain, the Move language can be said to be born specifically for digital assets . Compared with blockchain programming languages such as Solidity, Move specifically highlights the two keywords of "asset security" and "native high performance" in its core logic:
- On the one hand, it is based on Rust and is designed as an object-oriented language for writing smart contracts with secure resource management. It focuses on strengthening the status of digital assets, allowing developers to define and manage digital assets on the chain more flexibly and securely.
- On the other hand, Move IR, the source code based on the Move language, can decouple transaction scripts and modules, split transaction logic and smart contracts, which also makes the TPS of Move-based public chains often reach tens of thousands or even 100,000, which is much higher than the performance of EVM-based public chains.
In short, the blockchain network built on Move naturally has security and high performance advantages over the Solidity public chain , which also provides a better entry point for new developers to build on-chain applications.
However, for public chains, technological narratives are often not the main battlefield of competition. Whether they can attract enough users and funds to enter is the key to the competition among public chains. This is also the core reason why few people have mentioned "Ethereum killers" in recent years. Compared with Ethereum's endless application layer innovations, most new public chains have been criticized for the "ghost town effect", and the number of users and liquidity of most networks are very bleak.
For this reason, Movement chose to take a different approach and is committed to integrating the security and high performance advantages of the Move smart contract with the liquidity and user base advantages of the EVM system, that is, combining the respective advantages of the two by using the idea of "introducing Move into Ethereum".
For example, the M1 and M2 public chain architectures under Movement have the natural advantage of efficient transaction processing, and at the same time they are specially integrated with the Ethereum Virtual Machine (EVM), allowing developers to start and introduce mature DApps on the EVM system on M2 without writing Move code.
That is to say, Movement can automatically convert Solidity scripts into opcodes that Move can understand, allowing Move to gain interoperability with Ethereum and other EVM networks.
So rather than saying that Movement is introducing Move into the EVM ecosystem, it is better to say that it is incorporating EVM's funds and users into the Movement Labs stack and the pan-Move ecosystem , ultimately siphoning traffic from the EVM ecosystem and building a safer and more efficient blockchain system.
Modular Development Kit Movement SDK
The main development tool to realize the core vision of "introducing Move to Ethereum" is the Movement SDK.
As a modular development kit, it mainly includes three core components: MoveVM, Fractal, and custom adapters for sorter networks and DA services.
MoveVM: A safe and efficient operating environment
First of all, as the core of Movement SDK, MoveVM mainly provides a safe, efficient, resource-oriented operating environment for smart contracts.
This also enables the Movement SDK to execute complex smart contracts and manage digital assets, making it an indispensable part of the M2 network (see below for details). Therefore, MoveVM is also the key support for the M2 network to achieve ultra-high transaction throughput and extremely fast response speed. Its main features include:
- Resource-oriented programming : MoveVM treats assets as tangible, non-replicable resources, thus ensuring a higher degree of security and integrity in asset management;
Strict security assurance: By adopting a bytecode verification process, MoveVM ensures that all running codes adhere to strict security protocols, minimizing vulnerabilities and enhancing the overall robustness of the blockchain system; - Efficient Asset Management : It provides a controlled environment that allows for precise management of digital assets, ensuring that transactions are executed with the highest fidelity and reliability.
- Type safety and formal verification: MoveVM emphasizes type safety and uses a strict type system to capture errors at compile time. Combined with formal verification methods, it ensures that smart contracts comply with specified properties and safety standards, reducing the risk of errors and vulnerabilities.
- Isolation and encapsulation : Assets and code in MoveVM are encapsulated in modules, which implements strict access control and isolation. This encapsulation prevents unauthorized access and interaction, ensuring that each module operates within its defined parameters, thereby enhancing the overall security and integrity of the system.
- Bytecode Verification : MoveVM uses a comprehensive bytecode verification process to carefully check smart contracts before execution. This step ensures that all contracts meet the platform's security and correctness standards, significantly reducing the risk of executing malicious or defective code;
It is worth noting that Movement's MoveVM uses parallel processing technology and modular architecture. The former optimizes the transaction order and priority in the memory pool through algorithms, and reduces congestion and delays in transaction processing through parallel processing.
The latter is able to extend the functionality of the original MoveVM to external environments (such as EVM), that is, to build a multi-functional virtual machine designed to encompass a wider interoperable blockchain ecosystem.
Just two days ago, senior Move engineer @artoriatech publicly criticized the fragmentation problem currently faced by the Move ecosystem, saying that "developers face great resistance when transitioning from one Move chain to another":
Taking Sui Move and Aptos Move as examples, each chain is an isolated ecosystem with its own unique VM and toolkit that are so divergent and continue to grow as the protocols release new features that they are almost different languages, with no projects trying to reduce this divergence.
Movement's modular MoveVM, a multi-functional virtual machine, is designed to be fully compatible with the EVM and other Move ecosystems - currently it supports the deployment of Aptos and EVM code, and will soon cover the Sui ecosystem.
This means that DApps in EVM ecosystems such as Aptos and Ethereum can be deployed within 10 minutes - developers do not need to learn Move separately, they only need to keep the code in the original language architecture such as Solidity to achieve parallel deployment.
Fractal: Bridging Solidity and MoveVM
The essence of Fractal is a compiler that enables Solidity smart contracts to be executed in the MoveVM environment, thus becoming a secure framework that seamlessly connects the two languages Solidity and Move, allowing developers to deploy their Solidity contracts on MoveVM (M2 network).
The benefits of this are self-evident. Developers can enjoy the flexibility of Solidity while taking advantage of the security and high performance of Move to solve some inherent problems of Solidity.
The compilation process of Fractal is mainly divided into the following five steps:
- Tokenization and parsing . The process first decomposes the Solidity script into tokens representing the basic elements of the script (such as variables, functions, and control structures). Parsing these tokens involves analyzing the grammatical structure of the Solidity code and organizing the elements into an abstract syntax tree (AST), which describes the logic and organizational flow of the code;
- Abstract Syntax Tree (AST) . The AST is a tree representation of the grammatical structure of Solidity code, which details the hierarchy of operations and the interrelationships between different code segments;
- Intermediate Language (IL) . After building the AST, the code is converted to an intermediate language (IL) to bridge the gap between high-level Solidity code and the low-level instructions required for execution;
- MoveVM opcodes . The IL is then compiled into MoveVM operation codes (opcodes), which are basic instructions that the virtual machine understands and executes, indicating the specific operations that MoveVM should perform;
- MoveVM bytecode . In the final stage, the opcodes are converted into MoveVM bytecode, which is an executable binary representation of the program, compiled entirely from the original Solidity script and ready to run in MoveVM's secure and resource-oriented environment;
According to the official blog, Fractal is still in the development stage and is undergoing thorough testing and enhancements to expand its functionality beyond existing features.
Custom Adapter
Custom Adaptors are the last core component of the Movement SDK (essentially the M1 architecture below), designed to provide seamless integration with the sorter network and data availability (DA) service:
- Data Availability Service (DA) . The Movement SDK integrates with the DA service, enabling the DA service to run directly on L1 or as a standalone dedicated DA service, ensuring reliable access to transaction data;
- Support for Danksharding . In order to match the development roadmap of Ethereum, Movement SDK reserves the ability to cooperate with exclusive DA service providers, including Celestia and EigenDA, which provide guaranteed data availability;
- Validator node management and sequencer integration services . The Movement SDK’s custom adapter is also responsible for the strategic management and reconfiguration of validator nodes. By connecting to consensus mechanisms such as Snowman and Proof of Stake (PoS), the SDK strengthens the blockchain’s defense against Sybil attacks.
- Inclusiveness across DA layers . The custom adapter is also able to support a variety of DA layers, including Ethereum-4844 and several sovereign DA solutions such as Celestia, EigenDA, and Avail, ensuring that users can choose the DA layer that best meets their application needs;
In general, the Movement SDK provides a comprehensive development kit including an operating environment, compiler, and adapter for deploying and testing smart contracts. It aims to simplify the development process and enable developers, especially Solidity developers, to more easily build, test, and optimize DApps based on the Move language.
“M1+M2” public chain architecture
It is also based on the Movement SDK that Movement Labs has developed public chain architectures including M1 and M2.
M1 is designed as a community-first network that can achieve extremely high transaction throughput and instant finality to provide a decentralized sorter network and consensus layer; M2 is a ZK-Rollup L2 solution based on M1 and Ethereum (supporting both Sui Move and Aptos Move). By integrating EVM, DApps compatible with Ethereum can run on M2.
M1: Decentralized sorter network and consensus layer
The official definition of M1 is a "community-first blockchain" based on Move, which can provide the highest possible TPS through architectures such as instant finality and modular customization. The core goal is to support complex transactions and smart contract functions through the high security and customizability of the Move language, while ensuring the reliability of the platform and ease of use for users.
But according to current public information, it is currently gradually transitioning to a decentralized sorter network, that is, playing the role of "shared sorter" and "consensus layer" components in the entire Movement Labs ecosystem and any blockchain network , so as to achieve interoperability between Move and other networks and support various applications and services.
It is worth noting that since M1 adopts an improved Snowman consensus mechanism, it allows nodes to reach consensus by imitating social communication (i.e. "chatting" between nodes), so it naturally supports larger-scale node participation and faster consensus speed to achieve high throughput and efficient transaction sorting.
On this basis, M1 acts as the PoS sorter network and consensus layer of M2. On the one hand, it ensures the security of the M2 network operation through staking, and on the other hand, it enables M2 to have an efficient consensus mechanism - to become a sorter in the M1 network, you need to stake MOVE tokens, and use the Slash mechanism to prevent malicious activities and enhance the security and reliability of the network.
As the PoS sorter network for M2, M1 ensures the correctness, accessibility, and verifiability of transactions with the help of Data Availability (DA) service and Prover Marketplace.
M2: ZK-Rollup L2 based on M1 and Ethereum
M2 can be regarded as the "mainnet" of the Movement ecosystem. It introduces the ZK-Rollup architecture based on Move, which consists of MoveVM, Fractal and M1, and is responsible for deploying specific DApp applications.
The reason why it is called "ZK-Rollup architecture based on Move" is because M2 plans to use zero-knowledge proof to enhance privacy and security (ie zk-Move technology), which will enable M2 to have advantages not only in processing speed and cost-effectiveness, but also in privacy protection. Unique advantages.
MoveVM and Fractal enable it to execute standard EVM smart contracts as well as support smart contracts written in the Move language (Aptos Move, Sui Move); at the same time, by utilizing the Move language and Sui parallelization model, it can provide high throughput and low latency services for EVM transactions.
This means that developers of languages such as Solidity can easily launch secure, high-performance, and high-throughput MoveVM Rollup applications, directly leveraging the native advantages of the Move language.
Finally, all transactions executed on M2 will be packaged and sent back to Ethereum through the M1 sorter network, and the finality of the validity proof will be carried out through the zk-provers network of the Prover Marketplace. The results of the ZK proof will be placed on the Ethereum mainnet, and the detailed transaction data will be published to Celestia, thereby achieving data status synchronization between the two:
With Blobstream technology, Celestia's modular data availability layer can be transferred to Ethereum, and developers can create a high-throughput Ethereum L2 by integrating Blobstream just like developing smart contracts.
To put it simply, M1 is responsible for the consensus layer and transaction sorting, M2 is responsible for Solidity-Move conversion and transaction execution, and Celestia/Ethereum is responsible for the final data availability and state security . This modular architecture undoubtedly maximizes the integration of Move's high performance, security and EVM's user and traffic advantages.
summary
In addition to the technical narrative, the ability to quickly build a large and prosperous ecosystem from scratch is crucial.
The tool suites currently developed by Movement Labs, such as the Movement SDK, messaging infrastructure Hyperlane, and Movement shared sequencer (M1), are also intended to provide developers with the necessary resources to enable them to easily build and deploy applications based on Move.
According to official disclosure, Movement Labs' operating environment Move Stack will also begin testing this summer. As an execution layer framework, it plans to be compatible with many Rollup frameworks from companies such as Optimism, Polygon and Arbitrum.
From this perspective, the combination of M1, M2, Move Stack and other suites may give birth to a pan-MoveVM universe covering the Solidity ecosystem and the Aptos Move and Sui Move ecosystems, thereby enabling other non-Move language-based protocols to utilize Move functions and expand the influence of the Move language.
In this way, any developer can meet the needs of future high-performance DApp operation under the premise of decentralization and security, solve the scalability and performance problems in the process of asset transfer and exchange, and thus reach a commercial level.
Although it is still in its early stages of development, top VC institutions have undoubtedly seen the potential opportunities of this Move-Solidity fusion and have begun to take the lead in seeking a new solution to end the two opposing extremes of "scalability bottleneck" and "high-performance ghost town".
If all goes well, this combination of measures may lay the foundation for a new wave of use cases, new users, and ultimately the growth of the pan-Move-Solidity ecosystem. Let’s wait and see.
