Imagine if any Solidity developer could effortlessly build or migrate more secure and efficient DApps on Move with nearly zero barriers. Wouldn’t that be cool?

In 2019, Libra, which stirred the entire tech industry and quickly faded away, might not have anticipated that after its downfall, projects like Aptos, Sui, Linera, and Movement would emerge to carry the torch. Instead of succumbing to defeat, these projects have propelled the Move-based new public chains to a modest resurgence.

Interestingly, unlike Aptos, Sui, and Linera, which are all Layer 1 chains based on the Move language, the new generation Movement has set its sights on Layer 2. It has launched the first Move-based Ethereum Layer 2 solution—aiming to leverage the underlying performance and security advantages of Move while integrating with the ecosystem strengths of EVM. This allows developers to launch Solidity projects on M2 without needing to write Move code.

As the first fusion solution in the Move-based new public chain ecosystem to transition from being an “Ethereum killer” to joining Ethereum, Movement’s architecture applies high performance at the L2 level and ensures finality security based on Ethereum mainnet mechanisms. This approach attracted significant investment, including a substantial $38 million funding round in April from top-tier investors such as Polychain Capital, Binance Labs, OKX Ventures, Hack VC, and others.

What exactly is Movement aiming to achieve, and what magic does it possess to attract such prominent investments?

Movement: Introducing Move into the EVM ecosystem

Due to the fact that programming languages portray the core tone of a blockchain project, it’s essential to review the intrinsic characteristics of Move language before delving into what Movement aims to achieve.

Move, developed by Facebook, is a novel smart contract language primarily known for its application in projects like Libra (now Diem) within the Web3 ecosystem, notably adopted by new public chains such as Aptos and Sui. From a blockchain perspective, Move is specifically tailored for digital assets. In contrast to blockchain languages like Solidity, Move emphasizes two critical aspects at its core: asset security and native high performance.

On one hand, based on Rust, Move is designed as an object-oriented language for writing smart contracts with secure resource management, enhancing the flexibility and security of defining and managing digital assets on-chain.

On the other hand, Move IR, the source code of Move language, decouples transaction scripts and modules, splitting transaction logic and smart contracts. This often allows Move-based public chains to achieve transaction per second (TPS) rates ranging from tens of thousands to 100,000, significantly higher than EVM-based public chains’ performance.

In summary, blockchain networks built on Move inherently offer superior security and high-performance advantages over Solidity-based public chains, providing a better entry point for developers to build on-chain applications.

However, for public chains, technical narratives are not typically the main battleground for competition. The key to competing in the public chain arena lies in whether they can attract enough users and funds. This is also why “Ethereum killers” have rarely been mentioned in recent years—compared to Ethereum’s continuous application layer innovations, most new public chains suffer from a “ghost town effect,” with minimal user activity and liquidity.

It is precisely because of this challenge that Movement has chosen a different path, focusing on integrating the security and high-performance advantages of Move-based smart contracts with the liquidity and user advantages of the EVM ecosystem. By leveraging the approach of “bringing Move into Ethereum,” Movement aims to combine the strengths of both, exemplified by its M1 and M2 blockchain architectures. These architectures not only naturally excel in efficient transaction processing but also integrate Ethereum Virtual Machine (EVM), allowing developers to launch and introduce mature DApps from the EVM ecosystem on M2 without needing to write Move code.

In essence, Movement automates the conversion of Solidity scripts into Move-understandable opcodes, enabling Move to achieve interoperability with Ethereum and other EVM networks. Therefore, rather than merely introducing Move into the EVM ecosystem, Movement is effectively integrating EVM’s capital and users into the Movement Labs stack and broader Move ecosystem, ultimately attracting traffic from the EVM ecosystem to construct a safer and more efficient blockchain system.

Modular Development Kit Movement SDK

The primary development tool to achieve the core vision of “bringing Move into Ethereum” is the Movement SDK. As a modular development kit, it mainly comprises three core components: MoveVM, Fractal, and custom adaptors for sorter networks and DA services.

MoveVM: a safe and efficient operating environment

1. Firstly, as the core of the Movement SDK, MoveVM primarily provides a secure and efficient resource-oriented execution environment for smart contracts. This capability empowers the Movement SDK to execute complex smart contracts and manage digital assets, making it an indispensable component of the M2 network (as detailed below). Therefore, MoveVM is crucial to achieving ultra-high transaction throughput and extremely fast response times on the M2 network. Its key features include:
2. Resource-oriented programming: MoveVM treats assets as tangible, non-replicable resources, ensuring a higher level of security and integrity in asset management.
3. Strict security guarantees: Through bytecode verification, MoveVM ensures all executed code adheres to rigorous security protocols, minimizing vulnerabilities and enhancing the overall robustness of the blockchain system.
4. Efficient asset management: It provides a controlled environment for the precise management of digital assets, ensuring transactions are executed with maximum fidelity and reliability.
5. 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, it ensures smart contracts adhere to specified properties and security standards, reducing risks of errors and vulnerabilities.
6. Isolation and encapsulation: Assets and code in MoveVM are encapsulated within modules, enforcing strict access control and isolation. This encapsulation prevents unauthorized access and interactions, ensuring each module operates within its defined parameter range, thereby enhancing overall system security and integrity.
7. Bytecode verification: MoveVM employs comprehensive bytecode verification processes to thoroughly inspect smart contracts before execution. This step ensures all contracts meet the platform’s security and correctness standards, significantly reducing the risk of executing malicious or faulty code.

It’s worth noting that Movement’s MoveVM incorporates parallel processing techniques and modular architecture. The former optimizes transaction order and priority in the memory pool through algorithms, reducing congestion and latency issues by processing transactions in parallel. The latter extends the capabilities of the original MoveVM to external environments like EVM, creating a versatile virtual machine aimed at encompassing a broader interoperable blockchain ecosystem.

Just a few days ago, senior Move engineer @artoriatech publicly criticized the fragmentation issues currently facing the Move ecosystem, bluntly stating that “developers face significant resistance when transitioning from one Move chain to another”:

For example, with Sui Move and Aptos Move, each chain operates as an isolated ecosystem with its unique VM and toolkits, leading to significant differences. As these protocols continue to release new features, these differences grow to the point where they are almost like different languages, with no projects attempting to mitigate these disparities.

In contrast, Movement’s modular MoveVM, serving as a versatile virtual machine, aims to fully support EVM and other Move ecosystems. Currently, it supports deploying Aptos and EVM code and will soon cover the Sui ecosystem as well.

This means that DApps from EVM ecosystems like Aptos and Ethereum can be deployed within 10 minutes. Developers don’t need to learn Move separately; they can keep their code in existing languages like Solidity and achieve parallel deployment.

Fractal: bridging Solidity and MoveVM

Fractal essentially acts as a compiler enabling Solidity smart contracts to execute within the MoveVM environment. This creates a seamless bridge between the Solidity and Move languages, providing developers the capability to deploy their Solidity contracts on MoveVM (M2 network) securely.

The benefits are self-evident: developers can leverage the flexibility of Solidity while harnessing Move’s security and high-performance advantages to address inherent limitations in Solidity.

Fractal’s compilation process involves 5 key stages:

Tokenization and Parsing: The Solidity script is initially broken down into tokens representing basic elements such as variables, functions, and control structures. Parsing these tokens involves analyzing the syntax of Solidity code and organizing these elements into an Abstract Syntax Tree (AST) that describes the logic and organizational flow of the code.

Abstract Syntax Tree (AST): The AST represents the hierarchical structure of Solidity code syntax, detailing the levels of operations and the relationships between different code segments.

Intermediate Language (IL): Once the AST is built, the code is translated into an Intermediate Language (IL). This step bridges the gap between high-level Solidity code and the low-level instructions required for execution.

MoveVM Opcode: The IL is then compiled into MoveVM opcodes, which are fundamental instructions that the virtual machine understands and executes. These opcodes specify the specific operations MoveVM should perform.

MoveVM Bytecode: In the final stage, the opcodes are translated into MoveVM bytecode. This bytecode represents the executable binary form of the program, compiled directly from the original Solidity script and prepared to run within MoveVM’s secure and resource-oriented environment.

According to the official blog disclosures, Fractal is currently in development and undergoing thorough testing and enhancement to extend its functionality beyond existing capabilities.

Custom adapter

Custom Adaptors are the final core component of the Movement SDK (essentially the M1 architecture mentioned below), aimed at seamless integration with Sorter Networks and Data Availability (DA) services:

Data Availability (DA) Service Integration: Movement SDK integrates with DA services, enabling DA services to operate directly on L1 or as standalone dedicated DA services, ensuring reliable access to transaction data.

Support for Danksharding: To align with Ethereum’s roadmap, Movement SDK reserves the capability to collaborate with exclusive DA service providers, including Celestia and EigenDA, to provide guaranteed data availability.

Validator Node Management and Sorter Integration Services: Custom Adaptors of Movement SDK are also responsible for strategic management and reconfiguration of validator nodes, while enhancing blockchain resilience against attacks like Snowman and Proof of Stake (PoS) consensus mechanisms.

Cross-DA Layer Compatibility: These custom adaptors also support various DA layers, including Ethereum-4844 and several sovereign DA solutions such as Celestia, EigenDA, and Avail, ensuring users can choose the DA layer that best suits their application needs.

Overall, Movement SDK provides a comprehensive development suite that includes environments for deploying and testing smart contracts, compilers, and adaptors, designed to simplify the development process. This enables developers, especially Solidity developers, to more easily build, test, and optimize DApps based on the Move language.

“M1+M2” public chain architecture

Based on Movement SDK, Movement Labs has developed a public chain architecture including M1 and M2. M1 is designed as a community-first network, capable of achieving high transaction throughput and instant finality, to provide decentralized sorter networks and consensus layers. M2, on the other hand, is based on M1 and Ethereum’s ZK-Rollup L2 solution (supporting both Sui Move and Aptos Move), integrating EVM to enable Ethereum-compatible DApps to run on M2.

M1: Decentralized Orderer Network and Consensus Layer

M1 is officially defined as a “community-first blockchain” based on Move, designed to provide high TPS through instant finality and modular customization. Its core objective is to support complex transactions and smart contract functionalities with high security and customizability using the Move language, ensuring platform reliability and user usability.

Currently, according to publicly available information, M1 is gradually transitioning into a decentralized sorter network within the Movement Labs ecosystem and other blockchain networks. It serves as a shared sorter and consensus layer component, facilitating interoperability between Move and other networks to support various applications and services.

Notably, M1 adopts an enhanced Snowman consensus mechanism, allowing nodes to achieve consensus through social communication (referred to as “chatter” among nodes). This naturally supports greater scalability of node participation and faster consensus speeds, enabling high throughput and efficient transaction sorting.

Furthermore, M1 acts as the PoS sorter network and consensus layer for M2. It ensures the security of the M2 network through staking mechanisms while providing an efficient consensus mechanism. Nodes aspiring to become sorters in the M1 network must stake MOVE tokens and adhere to slash mechanisms to prevent malicious activities, thereby enhancing network security and reliability.

As the PoS sorter network for M2, M1 leverages Data Availability (DA) services and the Prover Marketplace to ensure the correctness, accessibility, and verifiability of transactions.

M2: ZK-Rollup L2 based on M1 and Ethereum

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

The term “based on Move ZK-Rollup architecture” refers to M2’s plan to enhance privacy and security using zero-knowledge proofs (zk-Move technology). This not only provides advantages in processing speed and cost-efficiency but also uniquely enhances privacy protection.

MoveVM and Fractal enable M2 to execute both standard EVM smart contracts and smart contracts written in Move language (Aptos Move, Sui Move). Utilizing the parallelization model of Move language and Sui, it offers high throughput and low-latency services for EVM transactions.

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

Ultimately, all transactions executed on M2 are routed through the M1 sorter network, where transaction data is packaged and sent back to Ethereum. Through the Prover Marketplace’s zk-provers network, validity proofs are finalized, and the results of ZK proofs are posted to the Ethereum mainnet. Transaction details are also published to Celestia, ensuring synchronization of data states between the two platforms.

Utilizing Blobstream technology, Celestia’s modular data availability layer can transmit to Ethereum, allowing developers to integrate Blobstream similar to developing smart contracts, thus creating high-throughput Ethereum L2 solutions.

In essence, M1 handles consensus and transaction sorting, while M2 manages Solidity-Move conversion and transaction execution. Celestia/Ethereum ensures final data availability and state security. This modular architecture maximizes the integration of Move’s high performance and security with the user and traffic advantages of EVM.

Summary

Beyond technical narratives, the ability to rapidly build a large and thriving ecosystem from scratch is crucial. Currently, tools like Movement SDK, messaging infrastructure Hyperlane, and Movement Shared Sorter (M1) developed by Movement Labs aim to provide developers with essential resources to easily build and deploy applications based on Move.

According to official disclosures, Movement Labs’ 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 integration of suites like M1, M2, and Move Stack may foster a broad MoveVM universe encompassing the Solidity ecosystem and Aptos Move, Sui Move ecosystems. This could enable protocols not based on Move to leverage Move functionalities, thus expanding the influence of Move language.

This integration empowers any developer to meet future high-performance DApp requirements under decentralized and secure conditions, addressing scalability and performance issues in asset transfer and exchange processes to achieve commercial viability.

While Movement’s development is still in its early stages, top VC firms undoubtedly recognize the potential of Move-Solidity integration and are actively positioning themselves to seek new solutions to end the dichotomy between “scalability bottlenecks” and “high-performance ghost towns.”

If successful, this combination could lay the foundation for a new wave of use cases, attract new users, and ultimately foster the growth of a comprehensive Move-Solidity ecosystem. The future holds promising prospects.

Statement:

1. This article is reproduced from [foresightnews], the copyright belongs to the original author [LFG Labs], if you have any objection to the reprint, please contact Gate Learn Team, the team will handle it as soon as possible according to relevant procedures.

2. Disclaimer: The views and opinions expressed in this article represent only the author’s personal views and do not constitute any investment advice.

3. Other language versions of the article are translated by the Gate Learn team and are not mentioned in Gate.io, the translated article may not be reproduced, distributed or plagiarized.