The new interpretation of Movement's public chain, "Can introducing Move to EVM reshape Ethereum and Move?"

Written by: LFG Labs

Imagine if any Solidity developer could build/migrate safer and more efficient DApps on Move with almost zero barriers. Wouldn't that be really cool?

In 2019, the Libra project, which stirred the entire tech industry and quickly withered, probably did not expect that after its failure, Aptos, Sui, Linera, and Movement would successively take up the mantle, pushing the Move ecosystem's new public chains to a small climax.

Interestingly, unlike Aptos, Sui, and Linera, which are all L1 public chains based on the Move language, the new generation Movement has turned its attention to L2—launching the first Ethereum L2 based on the Move language, aiming to leverage the underlying execution performance and security advantages of Move while further integrating the ecological advantages of EVM, allowing developers to launch Solidity projects on M2 without writing Move code.

As the first integration solution among the new public chains in the Move ecosystem to shift from "Ethereum killer" to "joining Ethereum," Movement's mechanism design, which applies high-performance architecture at the L2 layer and final state security based on the Ethereum mainnet, also secured a significant funding of $38 million in April.

So what exactly does Movement aim to do, and what kind of magic does it possess to attract top investment institutions like Polychain Capital, Binance Labs, OKX Ventures, and Hack VC?

Movement: Bringing Move into the EVM Ecosystem

Since programming languages reflect the core tone of a blockchain project, it is necessary to review the intrinsic characteristics of the Move language before delving into what Movement aims to achieve.

As we know, Move, a new smart contract language developed by Facebook, was initially applied in Facebook's Libra (Diem) project. Currently, the Web3 products publicly adopting the Move language are mainly concentrated in the new public chain ecosystems like Aptos and Sui.

From the perspective of public chains, the Move language can be said to be born for digital assets—compared to blockchain programming languages like Solidity, Move emphasizes "asset security" and "native high performance" in its core logic:

• On one hand, it is based on Rust and designed as an object-oriented language for writing smart contracts with secure resource management, reinforcing the status of digital assets, allowing developers to define and manage digital assets on-chain more flexibly and securely;
• On the other hand, the source code of the Move language, Move IR, can decouple transaction scripts and modules, splitting transaction logic and smart contracts, which often allows Move-based public chains to achieve TPS in the tens of thousands or even hundreds of thousands, significantly surpassing the performance of EVM-based public chains;

In short, blockchain networks built on Move inherently possess security and high-performance advantages superior to those of Solidity-based public chains, providing a better entry point for new developers to build on-chain applications.

However, for public chains, technical narratives are often not the main battlefield for competition; attracting enough users and capital 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 to the endless application layer innovations on Ethereum, most new public chains suffer from the "ghost town effect," with user engagement and liquidity being quite bleak.

For this reason, Movement has chosen a different path, aiming to bridge the security and high-performance advantages of Move-based smart contracts with the liquidity and user base advantages of EVM, combining their respective strengths by "bringing Move into Ethereum."

For instance, the M1 and M2 public chain architectures under Movement naturally possess the advantages of efficient transaction processing while specifically integrating the Ethereum Virtual Machine (EVM), allowing developers to launch and introduce mature DApps from the EVM ecosystem on M2 without writing Move code.

In other words, Movement can automatically convert Solidity scripts into operation codes understandable by Move, enabling Move to achieve interoperability with Ethereum and other EVM networks.

Thus, rather than saying Movement is bringing Move into the EVM ecosystem, it is more accurate to say it is incorporating EVM's funds and users into the Movement Labs stack and the broader Move ecosystem, ultimately siphoning traffic from the EVM ecosystem to build a more secure and efficient blockchain system.

Modular Development Suite Movement SDK

The main development tool to realize the core vision of "bringing Move into Ethereum" is the Movement SDK.

As a modular development suite, it mainly includes three core components: MoveVM, Fractal, and custom adapters for the sequencer network and DA services.

MoveVM: A Secure and Efficient Runtime Environment

First, as the core of the Movement SDK, MoveVM primarily provides a secure, efficient, resource-oriented runtime environment for smart contracts.

This enables the Movement SDK to execute complex smart contracts and manage digital assets, making it an indispensable part of the M2 network (as detailed below). Therefore, MoveVM is also the key support for achieving ultra-high transaction throughput and extremely fast response speeds in the M2 network, with main features including:

• Resource-oriented programming: MoveVM treats assets as tangible, non-replicable resources, ensuring a higher degree of security and integrity in asset management;
  Strict security guarantees: By adopting a bytecode verification process, MoveVM ensures that all running code adheres 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 precise management of digital assets, ensuring transactions are executed with the highest fidelity and reliability.
• Type safety and formal verification: MoveVM emphasizes type safety, using a strict type system to catch errors at compile time, combined with formal verification methods to ensure smart contracts comply with specified properties and security standards, reducing the risk of errors and vulnerabilities;
• Isolation and encapsulation: Assets and code in MoveVM are encapsulated in modules, implementing strict access control and isolation, preventing unauthorized access and interactions, ensuring each module operates within its defined parameter range, thereby enhancing the overall security and integrity of the system;
• Bytecode verification: MoveVM employs a comprehensive bytecode verification process to carefully check smart contracts before execution, ensuring all contracts meet the platform's security and correctness standards, significantly reducing the risk of executing malicious or defective code;

Notably, Movement's MoveVM utilizes parallel processing technology and a modular architecture. The former optimizes the order and priority of transactions in the memory pool through algorithms, reducing congestion and latency in transaction processing.

The latter can extend the original MoveVM's functionality to external environments (such as EVM), essentially building a multifunctional virtual machine aimed at encompassing a broader interoperable blockchain ecosystem.

Just a few days ago, senior Move engineer @artoriatech publicly tweeted "bombarding" the fragmentation issues faced by the current Move ecosystem, stating that "developers face significant 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 unique VM and toolkit, with significant differences that continue to grow as protocols release new features, to the point where they are almost different languages, and there are no projects attempting to reduce these differences.

Movement's modular MoveVM, as a multifunctional virtual machine, aims to be fully compatible with EVM and other Move ecosystems—currently supporting the deployment of Aptos and EVM code, and soon to cover the Sui ecosystem.

This means that DApps from EVM ecosystems like Aptos and Ethereum can be deployed within 10 minutes—developers do not need to learn Move additionally; they can keep their code within the original language frameworks like Solidity and achieve parallel deployment.

Fractal: Bridging Solidity and MoveVM

Fractal is essentially a compiler that enables Solidity smart contracts to execute in the MoveVM environment, thus becoming a secure framework that seamlessly connects Solidity and Move, allowing developers to deploy their Solidity contracts on MoveVM (M2 network).

The benefits of this are self-evident; developers enjoy the flexibility of Solidity while leveraging the security and high-performance advantages of Move to address some inherent issues in Solidity.

The compilation process of Fractal mainly consists of the following five steps:

1. Lexical analysis and parsing. This process first breaks down 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 syntax structure of the Solidity code and organizing the elements into an abstract syntax tree (AST) that describes the logic and organization flow of the code;
2. Abstract Syntax Tree (AST). The AST is a tree representation of the syntax structure of the Solidity code, detailing the hierarchy of operations and the relationships between different code segments;
3. Intermediate Language (IL). After constructing the AST, the code is converted into an intermediate language (IL) to bridge the gap between high-level Solidity code and the low-level instructions required for execution;
4. MoveVM operation codes. The IL is then compiled into MoveVM operation codes, which are the basic instructions understood and executed by the virtual machine, indicating specific operations that MoveVM should perform;
5. MoveVM bytecode. In the final stage, the operation codes are converted into MoveVM bytecode, which is the executable binary representation of the program, fully compiled based on the original Solidity script and ready to run in the secure and resource-oriented environment of MoveVM;

According to disclosures from the official blog, Fractal is still in the development phase, undergoing thorough testing and enhancements to extend its functionality beyond existing capabilities.

Custom Adapters

Custom adapters are the last core component of the Movement SDK (essentially the M1 architecture discussed below), aimed at providing seamless integration with the sequencer network and data availability (DA) services:

• Data Availability Services (DA). The Movement SDK integrates with DA services, allowing them to run directly on L1 or as standalone dedicated DA services, ensuring reliable access to transaction data;
• Support for Danksharding. To align with Ethereum's roadmap, the Movement SDK reserves the capability to collaborate with exclusive DA service providers, including Celestia and EigenDA—providing guaranteed data availability;
• Validator node management and sequencer integration services. The custom adapters of the Movement SDK are also responsible for the strategic management and reconfiguration of validator nodes, while enhancing the blockchain's defense against Sybil attacks by interfacing with consensus mechanisms like Snowman and Proof of Stake (PoS);
• Inclusivity across DA layers. This custom adapter can also support various DA layers, including Ethereum-4844 and several sovereign DA solutions like Celestia, EigenDA, and Avail, ensuring users can choose the DA layer that best meets their application needs;

Overall, the Movement SDK provides a comprehensive development suite that includes a runtime environment for deploying and testing smart contracts, compilers, and adapters, aimed at simplifying the development process, enabling developers, especially Solidity developers, to more easily build, test, and optimize DApps based on the Move language.

"M1+M2" Public Chain Architecture

Based on the Movement SDK, Movement Labs has developed a public chain architecture that includes M1 and M2.

M1 is designed as a community-first network capable of achieving extremely high transaction throughput and instant finality, providing a decentralized sequencer network and consensus layer; while M2 is a ZK-Rollup L2 solution based on M1 and Ethereum (supporting both Sui Move and Aptos Move), which integrates EVM to allow Ethereum-compatible DApps to run on M2.

M1: Decentralized Sequencer Network and Consensus Layer

M1 is officially defined as a Move-based "community-first blockchain," capable of providing as high TPS as possible through instant finality, modular customization, and other architectures. Its core goal is to support complex transactions and smart contract functionalities through the high security and customizability of the Move language while ensuring the platform's reliability and user-friendliness.

However, according to current public information, it is gradually transitioning into a decentralized sequencer network, playing the role of a "shared sequencer" and "consensus layer" component within the entire Movement Labs ecosystem and any blockchain network, to achieve interoperability between Move and other networks, supporting various applications and services.

Notably, since M1 employs an improved Snowman consensus mechanism, it allows nodes to reach consensus by mimicking social interactions (i.e., "chitchatting" between nodes), naturally supporting larger-scale node participation and faster consensus speeds to achieve high throughput and efficient transaction ordering.

On this basis, M1 serves as the PoS sequencer network and consensus layer for M2, ensuring the security of the M2 network's operation through staking while providing M2 with an efficient consensus mechanism—becoming a sequencer in the M1 network requires staking MOVE tokens and utilizing a Slash mechanism to prevent malicious activities, enhancing the network's security and reliability.

As the PoS sequencer network for M2, M1 ensures the correctness, accessibility, and verifiability of transactions through data availability (DA) services and Prover Marketplace.

M2: ZK-Rollup L2 Based on M1 and Ethereum

M2 can be viewed as the "mainnet" of the Movement ecosystem, introducing a ZK-Rollup architecture based on Move, composed of MoveVM, Fractal, and M1, responsible for deploying specific DApp applications.

The reason it is referred to as "ZK-Rollup architecture based on Move" is that M2 plans to use zero-knowledge proofs to enhance privacy and security (i.e., zk-Move technology), which will give M2 advantages not only in processing speed and cost-effectiveness but also in privacy protection.

With MoveVM and Fractal, it can execute standard EVM smart contracts while also supporting smart contracts written in the Move language (Aptos Move, Sui Move); at the same time, by leveraging the Move language and Sui's parallelization model, it can provide high throughput and low latency services for EVM transactions.

This means that developers using languages like Solidity can easily launch secure, high-performance, and high-throughput MoveVM Rollup applications, directly utilizing the native advantages of the Move language.

Finally, all transactions executed on M2 will be sorted by the M1 sequencer network, packaging transaction data back to Ethereum, where the zk-provers network of Prover Marketplace will provide validity proof finality, and the results of the ZK proof will be placed on the Ethereum mainnet, with detailed transaction data published to Celestia, achieving data state synchronization between the two:

With Blobstream technology, the modular data availability layer of Celestia can be transmitted to Ethereum, and developers can create high-throughput Ethereum L2 applications by integrating Blobstream just like developing smart contracts.

In simple terms, M1 is responsible for the consensus layer and transaction ordering, M2 handles the conversion and execution of Solidity-Move transactions, 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 and security with the user and traffic advantages of EVM.

Conclusion

Beyond technical narratives, the ability to quickly build a large and thriving ecosystem from scratch is crucial.

Currently, the tools developed by Movement Labs, including the Movement SDK, messaging infrastructure Hyperlane, and Movement shared sequencer (M1), are all aimed at providing developers with the necessary resources to easily build and deploy applications based on Move.

Moreover, according to official disclosures, the Movement runtime environment Move Stack will begin testing this summer, as an execution layer framework, it plans to be compatible with many Rollup frameworks from companies like Optimism, Polygon, and Arbitrum.

From this perspective, the combination of M1, M2, and Move Stack may give rise to a broader MoveVM universe encompassing the Solidity ecosystem and the Aptos Move and Sui Move ecosystems, thereby enabling protocols not based on the Move language to utilize Move functionalities and expand the influence of the Move language.

This way, any developer can meet the future high-performance DApp operational needs under the premise of decentralization and security, solving scalability and performance issues in asset transfer and exchange processes, thus reaching a commercially viable level.

Although Movement is still in its early stages, top VC firms have undoubtedly recognized the potential opportunities in this Move-Solidity integration and have begun to position themselves early to seek new solutions that end the "scalability bottleneck" and "high-performance ghost town" dichotomy.

If all goes well, this set of combined efforts may lay the foundation for a new wave of scenario use cases, new users, and ultimately the growth of the broader Move-Solidity ecosystem. Let's wait and see.