This article focuses on Aptos, taking a deep dive into the features of Move/MoveVM it uses, and comparing it to mature programming languages and state machines such as Solidity/EVM and Rust/WASM.
Written by DongHyun Kang, Xangle
Compiled by Peng SUN, the Chinese version of Foresight News is exclusively authorized to compile and publish
I. Introduction
In Web3, a seamless user experience is extremely important. In a way, ensuring that users experience smooth interoperability between different blockchains is much more important than the blockchain on which DApps are built. In 2021 and 2022, the industry has been engaged in a heated debate around single blockchains and multi-chains. It is worth noting that Solana and Luna once rose to fame, but then gradually declined, paving the way for Aptos and Sui to attract market attention.
Aptos and Sui both originated from the Meta blockchain project Diem (formerly Libra), and they have one thing in common - they both use the Move programming language. This article will focus on Aptos, and explore the characteristics of the Move language and MoveVM state machine it uses, as well as its comparison with mature programming languages and state machines such as Solidity/EVM and Rust/WASM.
2. What is Move?
1. Where does Move come from?
The Diem team at Facebook (now Meta) discovered two limitations in the Solidity programming language widely adopted by the blockchain industry. First, Solidity has vulnerabilities such as reentrancy attacks and double-spending attacks. Although blockchain networks that use Solidity (such as Ethereum) mitigate these attacks through consensus algorithms, it is undeniable that the language itself has potential attack vectors.
Secondly, Solidity cannot process transactions in parallel, and thus faces a bottleneck. In order to prevent double spending, Solidity requires transactions such as smart contracts to be executed sequentially. This limits the speed of transaction processing, which in turn hinders the scalability of the blockchain.
Based on this, the Diem team developed the Move language influenced by Rust to solve the above problems. The Rust programming language is highly praised, but it may result in lengthy code when used to write smart contracts. Subsequently, Aptos retained the original Move language while incorporating an object-oriented programming model, evolving it into Aptos Move. At the same time, Sui adopted an object-oriented language, Sui Move.
2. What are the functions of Aptos Move/MoveVM?
Aptos' Move/MoveVM has been carefully designed with a primary focus on security. In addition, Aptos has simplified the Move contract code and enabled parallel processing, which minimizes the possibility of blockchain attacks and improves scalability. In this section, we will take a deep dive into how Move achieves these features.
Enhance security with Move Prover and Resource Model
Formal verification involves mathematically proving that software code conforms to specific rules or properties. Aptos uses formal verification to verify the security of its smart contracts through the Move Prover tool. Move Prover can protect against potential attack vectors in smart contracts, such as double-spending and reentrancy attacks, by applying formal verification, while also identifying other code errors and ensuring stability. Unlike other blockchains that rely on consensus algorithms to prevent double-spending and reentrancy attacks, Move's language and its tools address these issues directly.
In addition, MoveVM uses static scheduling to call functions to prevent reentrancy attacks on function calls. In contrast, traditional EVM uses dynamic scheduling. The two methods differ in the timing of function calls in the program execution sequence, which is usually in the order of: Compile → Link → Load → Run → Terminate. Static scheduling involves calling functions at compile time, at which stage the smart contract can be initially checked for errors. Therefore, in MoveVM, smart contracts enter the verification stage in advance, effectively preventing reentrancy attacks from the source.
Parallel transaction processing
Aptos MoveVM enhances scalability through transaction parallel processing. To achieve this goal, MoveVM uses Block-STM (block-level software transaction memory) to distribute database transactions to multiple threads for parallel execution. A closer look at Block-STM reveals the following key features:
Block-STM uses optimistic concurrency control (OCC) to execute transactions in parallel, which are then verified and re-executed if conflicts arise.
Block-STM uses a multi-version data structure to prevent write-write conflicts. All writes are stored in the same location along with the transaction ID and the number of re-executions. This ensures that even if transactions are re-executed, they can be processed in the predetermined order.
Block-STM introduces a collaborative scheduler to prioritize the execution and verification of sub-transactions, thereby specifying the processing order between transaction threads. Move uses this collaborative scheduler to prevent conflicts between transactions and prevent them from failing.
Finally, dynamic dependency estimation groups transactions by estimating their dependencies and identifying related transactions.
Through Block-STM, Aptos can achieve parallel transaction processing in the following ways. In addition, although the verification between validators is unified, the execution between each validator is parallel, which further improves scalability. Aptos' transaction parallel processing is summarized as follows:
Users generate transactions and send them to the network.
Validators verify transactions.
Validated transactions are grouped based on dynamic dependency estimates, and each transaction group is processed in parallel by validators.
Processed transactions are compiled into blocks and propagated throughout the network.
Leveraging the Aptos Token Standard to Enhance Developer and User Convenience
Aptos also uses Move to establish its own token standard, Aptos Coin Standard, which improves the limitations associated with traditional EVM. MoveVM does not need to publish a separate smart contract for token issuance, and only needs to pay a small gas fee to issue coins. However, since non-EVM blockchains such as Solana and Algorand also have their own token standards, this feature is not particularly prominent.
However, in August 2023, Aptos launched two new standards, FT and NFT. It is worth noting that the new FT standard allows developers to choose and issue one of the following depending on their development goals: regular token assets, tokenized RWA, or in-game tokens. This seems to coincide with Aptos' strategy to enter the growing RWA-related market. Specifically, Web 2.0 companies typically seek control over assets when tokenizing RWA, but this is not easy to achieve on Ethereum, so many companies have begun to build their own blockchains. In contrast, Aptos can achieve this at the protocol layer through token standard settings.
3. Comparison with other languages and VMs
（一）Move vs Solidity
Move/MoveVM was created to address the limitations of Solidity, so it is more secure and more scalable than Solidity. As mentioned above, the features of Move/MoveVM enhance the security and scalability of Aptos. MoveVM prevents reentrancy and double-spending attacks at the language stage, while Solidity/EVM has seen multiple reentrancy attacks. The 2016 Ethereum The DAO attack is the best example, and although the Ethereum Foundation has done a lot of prevention, there are still a lot of reentrancy attacks in DeFi. Hackers never stop, hoping to deploy faulty contracts in DeFi in the EVM ecosystem.
<EVM ecosystem still suffer from reentrancy attacks, Source: Google>
As mentioned above, Move/MoveVM also has strong scalability. Since it can process transactions in parallel, it can theoretically reach up to 160,000 TPS, which means that the transaction processing efficiency is not limited. At the same time, due to the risk of double spending and reentry attacks, EVM must process transactions in sequence. Therefore, the EVM chain is greatly restricted by this. When a large number of transactions are submitted at the same time, the gas cost rises rapidly, and the transactions have to queue and stagnate.
In terms of flexibility, Solidity/EVM has an advantage over Move/MoveVM. Solidity/EVM uses dynamic scheduling, while Move/MoveVM uses static scheduling. Compared with Solidity, Move uses static scheduling to enhance the security of smart contracts, but limits its functionality. In addition, Solidity allows the protocol and contract code to be upgraded at any time, while Move is somewhat limited in this regard. In terms of interoperability between blockchains, Solidity is more flexible and scalable than Move, mainly because EVM teams such as Ethereum tend to prefer modular blockchains, while the Move team tends to prefer monolithic blockchains.
（二）Move vs Rust
Move is derived from Rust and has many similarities with Rust in terms of performance and functionality, such as efficiency and security. The key difference lies in its intended purpose: Rust is a general-purpose programming language, while Move focuses on smart contract development. Rust is designed for a wider range of applications and is widely used in various development environments, including those that are not related to blockchain. Therefore, writing smart contract code in Rust may result in longer and more complex code. In contrast, Move is a blockchain-specific language customized specifically for smart contracts. While this limits its use in blockchain development, it can result in relatively concise and less complex code when writing smart contracts.
<Move vs. Rust: Smart Contract Comparison, Source: Krešimir Klas>
Above is the code length token for Solana and Sui when developing the same smart contract. Obviously, longer code means that the smart contract is more likely to be attacked, and the developer is more likely to make mistakes, which may be overlooked during the code review process. In contrast, the advantage of Move is that code development is simpler, which can reduce the probability of developer errors, and code review will be more effective.
（三）Aptos Move vs Sui Move
Both Aptos Move and Sui Move come from the Diem team, so they have many similarities. They were originally based on Rust, so they have similar syntax and functions. In addition, both projects use Move Prover to verify smart contracts.
However, while Aptos Move retains the original Diem blockchain and adopts an object-oriented programming model, Sui Move launches the object-oriented Sui blockchain as an evolution of Diem. Sui's transition to an object-oriented blockchain is to support parallelism, which depends on understanding the data to be read and written. Therefore, Aptos adopts a resource model that divides application building blocks into three different units: unique identifiers, properties, and methods. Sui, on the other hand, adopts an object-oriented model that divides application components into states and behaviors. This results in Aptos Move providing developers with considerable flexibility, which Sui Move does not have.
Aptos Move and Sui Move also differ in how they operate on the blockchain. First, both blockchains support parallel processing, albeit in different ways. As mentioned earlier, Aptos implements parallel transaction processing through Block-STM, while Sui uses a directed acyclic graph (DAG) structure to store transactions. The DAG structure cuts off the interconnections between transactions, thereby enabling parallel transaction processing.
Another difference is how to prevent reentrancy attacks. As mentioned above, Aptos prevents reentrancy attacks by using static dispatch to verify the state of the smart contract before execution. In contrast, Sui prevents reentrancy attacks by updating the state of the smart contract only once during the transaction execution, ensuring that the state will not change even if the attacker interrupts the transaction. In addition, because Sui's DAG structure does not depend on the transaction order, the interruption of one transaction will not affect the independent processing of other transactions, providing additional protection against reentrancy attacks.
4. Next Step: Building a Strong Developer Ecosystem and Killer DApps
Move/MoveVM is a promising blockchain development platform, but it faces two major challenges. (1) Move does not yet have a mature developer ecosystem, unlike Solidity. Aptos has been around for nearly a year, while Sui has only recently launched its mainnet. Therefore, compared to Solidity, which has a mature developer community, Move still has a long way to go. Solidity has an eight-year history and provides a large number of development tools and dedicated training programs. It is crucial for developers to have a supportive community to provide feedback on their work, and Solidity already has a large developer community and hosts hackathons around the world. Turing estimates that the Solidity developer community is about 200,000 people.
In contrast, Move has been in development since Facebook launched it, but most of it is internal work of the Diem team. As a result, Move's developer ecosystem is neither as mature nor as widespread as Solidity. While there is now an Aptos developer community, including the Aptos Forum, it lacks the structured training programs, developer tools, and open feedback mechanisms of the Solidity ecosystem. Sui development company Mysten Labs estimates that the number of Move developers is 10,000, but Aptos does not provide official statistics.
Secondly, (2) Move lacks a killer DApp. Many EVM chains (such as Ethereum and Arbitrum) have a large number of DApps, and users are widely using them. However, the Move ecosystem has not yet produced similar applications. As of September 26, the TVL of the Aptos network was US$43.5 million, which is significantly lower than the mainstream Layer2.
<Aptos Move Tutorial created by the Aptos Foundation, Source: Aptos Move Github>
The Aptos Foundation recognizes the challenges we are facing and is taking proactive steps to overcome them. First, the Aptos Foundation places a high priority on developer tools to foster a thriving developer ecosystem. They have launched the Aptos Tutorial to help early developers get started, and are creating educational programs such as Move Spider. In addition, the Aptos Foundation is also further strengthening the developer ecosystem by organizing Meetups around the world, including in the United States, South Korea, and China, to promote the development of developer communities.
In terms of business, Aptos is actively establishing partnerships with well-known companies and companies with a large number of distribution channels in various industries, such as BBCUniversal, Microsoft, Google, Netmarble (Marblex), Neowiz and Chingari. On the other hand, Aptos is implementing on-chain randomness through AIP-41 to facilitate the integration of game companies. Aptos uses AIP-41 to provide game companies with a cost-effective middleware alternative, such as replacing Chainlink VRF, which ensures the randomness of EVM projects, and attracting more projects to build products on Aptos.
V. Conclusion
<An illustration comparing blockchain development languages to evolution, Source: Krešimir Klas>
This article focuses on Aptos' Move/MoveVM and compares its features with existing blockchain development languages. The results show that Move is designed specifically for developing blockchain smart contracts and has significant technical advantages over existing languages. However, Move is still in its early stages in terms of developers and DApp ecosystem. Currently, Solidity has about 20 times the number of developers as Move, and its position is more secure in terms of TVL and killer DApps. However, Move is only one year old and is one of the few programming languages specifically designed for blockchain development, which shows that it has huge untapped potential.
In addition, Move was developed by Facebook's Diem team, which also adds a lot to the development prospects of the Move ecosystem. Therefore, as shown in the figure above, as a comprehensive blockchain programming language, whether Move can compete with Solidity in the future is worth our attention.