Movement Labs is developing a framework for building modular blockchains powered by the Move programming language. This framework aims to address scalability, security, and interoperability challenges in the blockchain industry. Through this approach, Movement focuses on creating a network of Move-based rollups rather than a single high-performance chain. Movement aims to capture value across the ecosystem and position itself as the standard for building Move-based rollups.
Move language, originally created for the Diem(Libra) project, introduces resource-oriented programming and first-class assets. Enhanced security features and formal verification tools like the Move Prover make Move well-suited for blockchain development
MoveVM, the runtime environment for Move-based rollups, incorporates Block STM for parallel transaction processing, enabling significantly higher throughput. MoveVM also features a modular design for seamless integration of blockchain components, native bridging capabilities for cross-chain interactions, and efficient mempool synchronization and block building processes
The Movement framework consists of the Move Stack, a collection of tools and components for creating customizable Move rollups. Key elements include the Move Executor for processing both MoveVM and EVM bytecode, configurable sequencing options (like the M1 shared sequencer), flexible data availability solutions, and various settlement mechanisms such as Optimistic, ZK, and Fast-finality approaches
M1, a decentralized shared sequencer L1 network, facilitates cross-chain interoperability within the Movement ecosystem, supporting multiple Move-based rollups and enabling seamless communication between different chains
M2 is presented as the first ZK Move-EVM L2, combining Move's strengths with Ethereum's infrastructure. The core features of M2 includes high throughput (over 30,000 TPS) while maintaining EVM compatibility
Fractal, an interpreter within the Movement SDK, enables the execution of Solidity smart contracts in the MoveVM environment. Fractal bridges Solidity and Move, to facilitate easier migration of existing Ethereum projects to Move-based platforms and vice-versa
Movement's ecosystem is expanding with various projects across infrastructure, interoperability, wallets, DeFi, gaming, and social sectors. Leveraging Movement's framework, these projects build diverse applications and services
In the last two years, the blockchain industry has witnessed its most vibrant phase of development, which have addressed some of the most pressing challenges especially in the infrastructural design. Users no longer have to suffer from prohibitively high transaction fees, and the time to finalization on high-throughput chains like L2s, Sui or Solana is now quite comparable with Web2 equivalents.
Given these advancements, one might question the necessity for yet another fast blockchain. However, Movement Labs' vision extends far beyond merely creating a high-speed chain. To regard Movement solely as a fast chain would be to understand it in a very limited sense.
At its core, Movement’s framework leverages the superiority of the Move language and virtual machine (VM) to tackle several critical areas. It addresses the design of shared sequencers, overcomes the limitations of the Ethereum Virtual Machine (EVM) in terms of scalability and security, facilitates interoperability between multiple rollups, and enhances the developer experience to accelerate adoption.
Ultimately, Movement Labs proposes a novel framework for building modular blockchains powered by Move. By harnessing the scalability and security advantages of the Move language, this framework offers a holistic solution to the challenges facing contemporary blockchain architecture.
1.1.1 Security Risks Driven by Programming Languages
Source: Hack3d: The Web3 Security Quarterly Report - Q2 + H1 2024
The blockchain industry continues to grapple with persistent security challenges that threaten its stability and growth. Hacks and exploits have become alarmingly frequent, occurring almost monthly and resulting in substantial financial losses. According to Certik's report for the first half of 2024, over $1 billion was lost across more than 400 onchain security incidents. The magnitude of these losses underscores the critical need for robust security measures in developing applications on the blockchain.
Many of the vulnerabilities plaguing the industry stem from fundamental issues in language design and virtual machine limitations. These problems are particularly challenging because they are often beyond the control of individual developers, who may struggle to address them effectively within the constraints of existing platforms.
An analysis of common security flaws in smart contracts reveals the following vulnerabilities and their origins:
This table illustrates that many security issues arise from a combination of language design flaws, contract bugs, and virtual machine limitations. Notably, some of the most severe vulnerabilities, such as reentrancy and delegatecall injection, stem from both language design issues and contract bugs.
Source: DefiLlama
Currently, Solidity and Rust dominate the landscape of blockchain programming languages. However, both languages have apparent limitations that contribute to the ongoing security challenges faced by the industry.
Solidity, developed specifically for smart contracts on Ethereum and other EVM compatible platforms, has been the primary language for blockchain development since its launch in 2015. While Solidity has enabled the creation of numerous decentralized applications and smart contracts, it has also been plagued by vulnerabilities that have led to significant financial losses.
One of the most notorious examples is the reentrancy exploit, which has been responsible for millions of dollars in losses on Ethereum and EVM-compatible chains. The reentrancy vulnerability arises from Solidity's design, which allows a contract to make external calls before updating its internal state. Reentrancy flaw has been exploited in high-profile incidents such as the DAO hack in 2016, which resulted in the loss of approximately $50 million worth of ETH at the time.
Additionally, the underlying virtual machines, particularly the EVM, also contribute to security vulnerabilities. The EVM's design choices, such as its use of 256-bit words and a stack-based approach, can lead to inefficiencies and potential security issues. These architectural decisions can make it difficult to implement certain security features or optimizations that might be more readily available in purpose-built systems.
Source: Move: The Next Step in Smart Contract Programming
Rust, on the other hand, is a multi-paradigm, general-purpose, low-level programming language first created by Mozilla. While Rust has gained popularity for blockchain development, particularly on platforms like Solana and NEAR, it was not originally designed with blockchain-specific use cases in mind. Rust's development began in 2006, predating even the Bitcoin whitepaper, which means it lacks inherent optimizations for the unique requirements of blockchain systems.
The industry's continued reliance on these languages raises important questions about their suitability for a sector that has grown to encompass trillions of dollars in value. Solidity was launched at a time when the true potential of smart contracts and decentralized applications was not yet fully understood. As a result, many of its design decisions may not be optimal for the complex and high-stakes environment of modern blockchain systems.
Similarly, Rust's adoption in blockchain development, while beneficial in many ways due to its focus on safety and performance, still requires significant adaptation to fully address the specific needs of decentralized systems.
While Solidity, Rust, and the EVM have played crucial roles in the development of the blockchain industry, the persistent security challenges indicate that it may be time to explore new paradigms. By developing languages and virtual machines specifically tailored to the needs of blockchain systems, the industry may be able to create a more secure foundation for the next generation of decentralized applications and financial systems.
1.1.2 Limited Scalability In The Execution Layer
The blockchain industry continues to grapple with scalability issues, despite considerable advancements and efforts. These limitations are particularly evident in the context of broad adoption and the development of more sophisticated decentralized applications. Among blockchain components, scalability constraints are primarily linked to the execution layer's processing capabilities.
Source: Ethereum’s Scalability Crisis: The Execution Layer
The execution layer involves computations necessary for processing transactions and implementing state changes on the blockchain. These computations typically encompass transaction validation through signature and balance checks, as well as executing on-chain logic to update the network state. State changes are reflected when full nodes update their ledger copies to account for new token transfers, smart contract code modifications, and data storage alterations.
“We will either solve the scalability and consensus problems in Ethereum or die trying.”
Vitalik Buterin
Ethereum's mainnet, the foundation for a diverse ecosystem of decentralized applications, continues to encounter significant scalability hurdles. Despite its groundbreaking role in smart contract implementation, Ethereum's existing architecture finds it challenging to keep pace with its growing user base's demands. High network activity periods often result in exorbitant transaction fees and prolonged confirmation times, negatively impacting user experience and limiting the network's effectiveness.
To address these challenges, the blockchain sector has witnessed the rise of numerous Layer 2 solutions. These Layer 2 approaches aim to reduce main chain congestion by conducting off-chain transaction processing and only recording final states on the main chain.
However, the mere proliferation of chains does not resolve the fundamental blockchain scalability issue, as individual chains still impose considerable constraints on their hosted dApps. The table below illustrates the target gas per second and block time for major EVM chains currently in operation.
Source: Rollup.wtf
Even the most efficient blockchain solutions struggle to rival the throughput of centralized systems. For instance, opBNB, one of the fastest EVM-compatible chains, can process around 3,700 ERC-20 transfers per second. While this represents a substantial improvement over Ethereum's main chain, it still falls short when compared to modern centralized database systems, which can handle millions of transactions per second.
Source: X(@WestieCapital)
In early 2024, during a period of increased activity, Base experienced relatively high fees despite the implementation of EIP-4844, which was intended to reduce data posting costs. This indicates that execution remains a bottleneck even with optimizations in place. In response to these fee spikes, Base gradually increased the gas limit of their L2 blocks. While such measures can temporarily cope with the increased demand, they are not sustainable long-term solutions. Given that the industry has not yet achieved its desired adoption level, the current scalability limitations will likely hinder further user integration into the ecosystem.
Addressing scalability limitations proves challenging due to their inherent nature within the EVM. Some of the structural constraints include:
Single-Threaded Execution: The EVM processes transactions in a sequential manner, unable to utilize the parallel processing capabilities of modern hardware. This significantly restricts the number of operations that can be performed within a given time frame.
Inefficient Resource Usage: The EVM's utilization of 256-bit words as its fundamental computational unit and a stack-based approach instead of registers. This results in inefficient use of computational resources for many common operations.
Complex State Management: Ethereum's account-based model, featuring a deeply nested state tree, necessitates multiple database updates for each state change. This complexity decelerates transaction processing and increases the resources needed to maintain the network state
Gas Metering Overhead: While essential for preventing spam and infinite loops, the gas metering system introduces substantial computational overhead to every operation executed on the EVM
State Growth: As transaction volume increases, so does the blockchain's state. This expansion requires additional storage and makes state verification and access more time-consuming, further impeding network performance
As a result of these limitations, during periods of high demand, network congestion can lead to skyrocketing transaction fees, pricing out many users and making micro-transactions economically unfeasible. Moreover, high latency and unpredictable transaction times lead to poor user experiences, restricting the widespreaed adoption of onchain applications. Users accustomed to the instant responsiveness of traditional web applications may find blockchain interactions frustratingly slow and unreliable.
The landscape of blockchain development has undergone a significant transformation in recent years, with the advent of rollups marking a paradigm shift in how blockchain networks are deployed and scaled. The process of launching rollups has been simplified to such an extent that it now rivals the ease of deploying a website. With just a few clicks, developers can initiate their own rollup, dramatically simplifying the process to such an extent that can be compared to the ease of deploying a website. Rollups represent an effective solution that transforms blockchain development into a SaaS-like model, enabling it by paying fees to the underlying network.
Source: Optimism Collective
By offloading security and censorship resistance concerns to established base layers like Ethereum and other data availability solutions, Layer 2 networks can explore a vast design space for implementing aggressive performance optimizations. This approach allows for rapid iteration and experimentation without compromising on the fundamental principles of decentralization and security.
Widely used rollup stack solutions like OP Stack and Arbitrum Orbit are designed as generalized frameworks capable of supporting multiple implementation and execution environments. Solutions like Arbitrum Stylus has further expanded this flexibility by enabling developers to write smart contracts in languages beyond Solidity.
Source: Arbitrum Stylus vs. Solidity: Performance Benchmark
However, despite the rapid adoption of rollup technology, the available development and execution environment remain limited in scope. While these frameworks theoretically allow for the implementation of various virtual machines, the reality is that developing and integrating a new VM requires substantial upfront costs, time, and specialized expertise. For most projects, particularly those aiming to minimize development overhead and accelerate time-to-market, creating a custom VM or execution environment remains impractical.
As a result, the vast majority of rollups built on these frameworks default to using the EVM as their execution environment. This choice is driven by the EVM's established ecosystem, extensive tooling, and developer familiarity. While the flexibility to implement alternative VMs exists, the economic and practical constraints often lead projects back to the EVM, inheriting both its strengths and limitations.
Alternatives to EVM-based chains do exist, such as Sui and Aptos, which utilize the Move programming language. Additionally, projects like Eclipse have implemented the Solana Virtual Machine (SVM) on top of Ethereum. However, these solutions operate in isolation, allowing deployment on their respective chains but not offering the ability to replicate their environments for custom chain development.
"Build whatever..., but only use the EVM” To me, this is like customizing your sportscar with decked out wheels, a great chassis, expensive breaks, and then using an engine from the 1970s that barely works. We're fixing that. We're building the universal high-throughput engine for all rollups.
Rushi Manche, Co-Founder of Movement
Movement Labs aims to fill this gap by creating a framework that extends the Move programming language to various blockchains, establishing a network of Move-based blockchains and rollups. Rather than representing a single fast chain, Movement is developing a framework for building modular blockchains that harness the superiority of the Move language and virtual machine.
Recognizing the inevitable proliferation of rollups, Movement's approach focuses on creating a framework with broader potential to capture value across the ecosystem. Drawing parallels to how OP Stack has become an industry standard for building rollups, Movement is positioning itself to occupy a similar role in the Move ecosystem.
Source: Movement Whitepaper
Movement's design incorporates an M1 shared sequencer and Move-based modular framework, proposing a modern framework for building a network of rollups while maintaining incentive alignment and interoperability. Movement’s approach creates an ecosystem where the interests of developers, users, and the network itself are more closely aligned.
The vision of Movement extends beyond the merely individual fast chain, encompassing a broader goal of constructing entire networks based on Move. By prioritizing the development of the fastest and most secure Ethereum L2 environment while simultaneously introducing the Move language to Ethereum and other VM chains, Movement is strategically positioning itself at the vanguard of blockchain building framework. The framework proposed by Movement not only fosters interoperability across various blockchain architectures, but also ensures that Move-based solutions can adapt and flourish in an ever-evolving landscape, catering to a wide spectrum of use cases and network configurations.
Source: The Evolution of Smart Contract Development
The genesis of Move stems from a critical observation made by Sam Blackshear and his team at Meta (formerly Facebook) during the development of the Diem (previously Libra) blockchain project. They identified a fundamental gap in existing programming languages when it came to blockchain development:
"On a computer, everything is just bits and bytes and can be freely copied. You want a language that gives you the necessary abstractions around ownership and scarcity, just like in the physical world. You want those basic safety guarantages. That's what Move does and why we created a new language"
Sam Blackshear, the Creator of Move.
The team realized that conventional programming languages, including those used for smart contracts like Solidity, lacked a native concept or vocabulary to describe digital assets accurately. This absence led to complex workarounds, often resulting in vulnerabilities. Furthermore, they recognized that adopting existing languages would inherently import their limitations, potentially constraining the project's future growth and adaptability.
These insights led to the creation of Move, a language designed from the ground up to be minimal, platform-agnostic, and centered around the concept of programming with scarcity. Move aimed to provide a structured representation of assets in a safe environment, offering developers the flexibility to experiment across different blockchain platforms.
Source: The language of money, Part one: Why build Move?
Move has evolved into a platform-agnostic language that prioritizes three key principles:
2.1.1 Resource-Oriented Architecture (ROA)
At the core of Move's innovation is its resource-oriented approach, embodying the concept of "programming with scarcity." This design addresses a fundamental challenge in blockchain technology: representing and managing digital assets with the same precision and care as physical assets in the real world.
Move introduces resources as first-class citizens in the language. Move’s resources are customizable types inspired by linear logic, providing inherent scarcity protections. Unlike conventional data types, resources in Move can only be moved between program storage locations, never copied or implicitly discarded. Imagine them as physical objects you can move between different locations.
The resource-oriented design extends to Move's module-based architecture. Each resource's fields are encapsulated in a corresponding module, similar to smart contracts in other blockchain systems. These modules contain the types and procedures for creating, updating, and destroying resources, providing critical data abstraction and protecting resource operations from untrusted code. This encapsulation allows developers to define custom resource types while benefiting from Move's built-in safety measures.
2.1.2 Safety and Verifiability
Source: The Move Prover
Move's architecture is built with security at its core, providing robust protection against common vulnerabilities. The language employs a dual approach to enforcing safety properties. Universal properties like type, memory, and resource safety are verified on-chain via the bytecode verifier. For program-specific properties, Move supports off-chain verification using the Move Prover, a formal verification tool.
Move's bytecode-first approach sets it apart from many other blockchain languages. The executable format of Move is bytecode, with all necessary protections encoded after compilation. This design removes the compiler from the trusted computing base, eliminating a potential point of vulnerability in the system. The combination of on-chain bytecode verification and off-chain formal proving tools enhances the overall reliability of Move programs.
2.1.3 Flexibility and Cross-Platform Compatibility
Move is designed with flexibility and platform agnosticism in mind. Its intentionally minimal design, lacking built-in concepts like accounts or specific cryptography, allows it to be used across different blockchain platforms. Developers can tailor Move to specific blockchain architectures, customizing it to their unique needs.
Source: Sui
The flexibility of Move is exemplified by the different implementations of Move in projects like Aptos and Sui. Both initiated by ex-members of the Diem team, these projects have further refined Move to suit their specific requirements. Aptos focused on enhancing security features and improving asset handling capabilities, aiming for a more user-friendly blockchain ecosystem. Sui, on the other hand, modified Move to support new consensus mechanisms and state management systems, boosting speed and flexibility.
The adoption and adaptation of Move by Aptos and Sui demonstrate a versatility the language possess. Also, there are other initiatives such as Starcoin, Celo and Solana which have employed Move for their smart contracts development. This illustrates how Move can be tailored to the specific needs of different projects while maintaining its core principles.
Move's combination of resource-oriented design, strong safety and verifiability features, and flexibility make it a powerful tool for blockchain development. Its innovative approach to asset management, combined with robust security guarantees and cross-platform compatibility, positions Move as a compelling choice for developers looking to build secure, scalable, and flexible blockchain applications.
Move's design philosophy places security at its core, addressing many of the vulnerabilities that have plagued other blockchain programming languages. This security-first approach is evident in several key features that set Move apart from its predecessors:
First-class Assets
Source: Move Github
Move introduces the concept of first-class assets, analogous to first-class functions in programming. The first-class assets principle allows assets to be treated as fundamental elements of the language, similar to how Ethereum treats ETH. First-class assets in Move cannot be arbitrarily issued or deleted, providing a higher level of security compared to token standards like ERC-20 on Ethereum.
In Move, developers can define custom first-class assets that inherit these security properties. These assets can only be moved between storage locations, not copied or implicitly deleted, unless explicitly specified by a module. This approach solves many security flaws such as reentracy at the language level, reducing the risk of bugs related to asset management.
Flexibility
Move's module system offers a flexible yet secure way to manage resources. Modules, similar to smart contracts, define how resources are created, modified, and destroyed. This encapsulation ensures that critical operations on resources are performed only within their defining module, providing a strong foundation for security. Developers can implement fine-grained access control policies, restricting who can interact with specific resources and how.
Move enhances flexibility through its use of transaction scripts. Each transaction includes a transaction script, which serves as the main procedure of the transaction. These scripts can call any procedure from any module on the blockchain, allowing transaction creators to customize their transactions by combining different modules. This design gives developers significant flexibility in programming, as they can create complex transactions by composing simpler, well-verified components.
The module system and transaction script approach enable the creation of versatile applications while maintaining security. Developers can build on existing, secure modules, reducing the risk of introducing vulnerabilities in new code.
Bytecode-level Safety
Move takes a unique approach to safety by implementing checks at the bytecode level. This design choice offers several advantages:
Onchain Verification: The Move VM includes a bytecode verifier that checks for type, memory, and resource safety before execution. This ensures that even maliciously crafted bytecode cannot violate the language's safety guarantees.
Gas Metering: The bytecode verifier includes gas metering, ensuring that all Move programs terminate and preventing potential denial-of-service attacks.
Limited Mutability: Move restricts the mutability of values, allowing changes only through references within a single transaction. This design simplifies reasoning about program behavior and enhances security.
No Dynamic Dispatch: Move does not support dynamic dispatch, meaning that the compiler knows which methods are being called at compile time. The static dispatching makes it easier for verification tools to analyze and verify transactions, as the program's behavior is more predictable and easier to reason about.
2.2.1 Move Prover
Source: Move: Innovations and Opportunities
One of Move's most powerful security features is the Move Prover, an advanced formal verification tool designed specifically for Move code. The Move Prover helps developers ensure the correctness and security of their smart contracts by mathematically proving that the code behaves as intended. Here are the key features of the Move Prover:
Formal Verification: The Move Prover uses mathematical techniques to prove code correctness, providing stronger guarantees than traditional testing methods. Additionally, despite its thorough analysis, the Move Prover is remarkably efficient. It can verify even large modules in seconds, making it practical for regular use during development.
Specification Language: Developers can write formal specifications directly alongside their Move code. These specifications define expected behaviors, invariants, and pre/post-conditions, which the Prover then verifies against the actual code.
Fine-grained Invariant Checking: The Prover ensures that important properties of the code (invariants) hold true throughout execution, unless explicitly declared as mutable. This helps catch subtle bugs that might be missed by traditional testing.
Alias-free Memory Model: For verification purposes, the Prover uses a simplified memory model that eliminates complex references. This approach significantly speeds up the verification process without sacrificing accuracy.
Source: Formal Verification, the Move Language, and the Move Prover
By providing mathematical certainty about code behavior, The Move Prover significantly reduces the risk of vulnerabilities in production systems. This is particularly crucial in blockchain applications, where bugs can have severe financial implications.
The combination of Move's inherent safety features and the powerful Move Prover creates a robust framework for developing secure blockchain applications. It enables developers to write code with a high degree of confidence in its correctness and security, setting a new standard for smart contract development.
As a throughput requirements of blockchain expand to accommodate increasingly complex applications, the limitations of sequential transaction processing have become apparent. This leads to network congestion, extended transaction confirmation times, and scalability issues, which all hinder the broader adoption.
Parallelization has emerged as a promising solution to these challenges. This approach fundamentally changes how blockchain networks process transactions by enabling concurrent execution. Instead of processing transactions one after another, parallelization allows multiple transactions to be handled simultaneously.
Source: Blockchain & Technology Enabling Parallel Execution
By leveraging the capabilities of modern multi-core processors, parallelization can potentially reduce latency, increase overall network scalability and fully utilize the hardware capacities. The key to effective parallelization lies in managing transaction dependencies and conflicts, ensuring that the final state of the blockchain remains consistent and secure.
2.3.1 Block STM
At the heart of Move VM's scalability solution lies Block STM, a sophisticated parallel execution engine that is used by Aptos. Developed as part of the Diem project, Block STM addresses one of the most pressing challenges in the blockchain technology: how to handle a large number of transactions quickly without compromising security or accuracy.
At its core, Block STM is about parallel processing of transactions. Traditional blockchain systems process transactions one at a time, which can be slow when dealing with a high volume of operations. Block STM, on the other hand, attempts to process multiple transactions simultaneously. This is akin to having multiple cashiers in a store instead of just one, significantly speeding up the checkout process.
However, processing transactions in parallel is not straightforward in a blockchain environment. Transactions often depend on each other, and processing them out of order could lead to errors. Block STM solves this problem through a clever system of ordering and verifying.
Source: Block-STM: Accelerating Smart-Contract Processing
Imagine a block of ten transactions with specific dependencies on each other. Block-STM would organize processing across multiple threads in a way that respects these dependencies, allowing non-dependent transactions to process in parallel while ensuring that any dependent transactions wait for the required data.
The core mechanism of Block STM operates as follows:
Block pre-order:
In parallel processing, Block-STM ensures that all transactions within a block lead to the same results as if they were processed one at a time. It uses the set order to handle dependencies between transactions to ensure everything matches up.
Optimistic Scheduling
When dependencies aren’t known in advance, Block-STM uses a "speculate-validate-redo" method. It first tries to run transactions in parallel optimistically, then checks if the transactions read the right data. If not, transactions are redone correctly.
Strawman (S-1) Algorithm
The initial approach by Block-STM involves two phases: first, all transactions are processed in parallel; then, transactions that fail validation are processed again. This continues until all transactions are validated successfully.
The Block-STM Algorithm
The full version of Block-STM improves upon the strawman by allowing threads to dynamically take on tasks of validating or re-executing transactions as needed. It uses a simple form of tracking dependencies to reduce the number of times transactions need to be redone. This is done through a mix of preemptive execution and on-the-spot revalidation.
Correctness
First, whenever a transaction needs information, it always retrieves the most current data available. This is similar to always checking the latest update in a conversation before responding. Second, if any details are updated, the following transactions double-check to make sure nothing has changed since they last looked.
Source: Block-STM
The efficiency of Block STM stems from its ability to leverage the preset order of transactions in a block. This order allows the system to make intelligent decisions about execution and validation, reducing conflicts and maximizing parallel processing. By combining optimistic execution with careful conflict management and a collaborative scheduling approach, Block STM achieves high throughput while maintaining the consistency guarantees required for blockchain operations.
2.3.2 Move VM
MoveVM is a runtime environment for move-based rollups developed by Movement Labs. In addition to the parallelization enabled by Block STM, MoveVM is designed to enhance scalability, modularity, and interoperability where traditional models have faced challenges.
Modularity
Conventional VMs often encounter integration challenges, leading to inefficiencies in areas such as mempools, APIs, and block processing mechanisms. These inefficiencies can limit a blockchain's capacity for parallel processing, constraining system scalability and responsiveness. MoveVM's modular design aims to address these barriers, facilitating seamless integration of blockchain components. Furthermore, the modular design of MoveVM allows for dynamic updates or modifications to the network without disrupting the system, ensuring continuous operation and evolution.
Interoperability
Through the deployment of SDKs with native bridging capabilities, MoveVM aims to reduce reliance on third-party technologies, enabling direct transaction flow across Movement rollups. Movement employs a specialized Ethereum JSON RPC endpoint, which processes EVM RPC requests and converts them into MoveVM-compatible calls, enabling a seamless integration between Solidity smart contracts and the underlying Move blockchain. By doing so, Movement handles the risks associated with third-party bridges, such as centralized validator dependencies, asset reserve imbalances and potential errors in code, enhancing the overall security and reliability of cross-chain transactions.
Source: X(@movementlabsxyz)
MoveVM introduces several modifications to enhance its compatibility with multiple VMs:
Mempool Sync: Optimizes transaction ordering and prioritization in the mempool for efficient parallel processing. It enables synchronization with various application consensus mechanisms and notifies the consensus layer when new transactions enter the mempool. Block-building can be initiated based on time intervals or transaction reception.
Block Building: Utilizes live transaction data to accelerate block assembly. When prompted by the consensus layer, the execution layer evaluates and prioritizes mempool transactions based on parameters such as fees and age.
Block Committing: Secures and validates assembled blocks, ensuring accurate transaction recording on the blockchain. After block construction in the execution layer, the block is transferred to the consensus layer. Upon agreement, the execution layer updates the storage.
Through additional improvements to the existing Block STM approach, MoveVM (Move + EVM) has been able to implement a systematic and efficient workflow. The step-by-step approach from the mempool to block consensus enhances transaction processing efficiency and ensures smooth interaction between each layer. As a result, MoveVM has been able to achieve not only the high throughput provided by Block STM, but also the benefits of modularity and interoperability simultaneously.
Source: Movement Docs
The Move Stack is a collection of tools, components, and adapters that enable the creation of customizable Move rollups. It includes essential elements such as sequencing, data availability, and settlement mechanisms. The modular architecture of the Move Stack allows developers to select the most suitable components for their specific applications, ensuring optimal performance and security.
The Move rollup architecture is designed with flexibility to accommodate a wide range of requirements. It consists of two main components: fixed elements that form the core structure, and customizable elements that developers can tailor to their specific needs. The fixed elements include crucial components such as the Move Executor and bridge contracts, which handle asset transfers between Layer 1 and rollups. On the customizable side, developers have the freedom to choose and implement their preferred sequencer, data availability (DA) service, and settlement mechanism. Ultimately, this flexibility enables developers to create rollups that are optimally designed for their specific applications or projects.
3.1.1 Move Executor
Source: Movement
The Move Executor is a core component of the Movement-SDK, supporting both MoveVM and EVM bytecode. This dual compatibility provides a robust execution environment, enabling developers to leverage the advanced features of the Move language while maintaining compatibility with existing Ethereum applications. The Move Executor integrates the parallel execution capabilities of MoveVM with existing EVM interpreters, ensuring compatibility and scalability. This module is at the heart of movement architecture and not configurable.
The Move Executor processes transactions differently depending on their type (Move or EVM). For Move transactions, the MoveVM executes them and generates data representing changes to the blockchain's state. EVM transactions are processed using Geth, which can either directly modify the blockchain's state or generate state change data similar to Move transactions. This approach ensures that regardless of the transaction type, the blockchain's state is ultimately modified in the same format, allowing both Move and Ethereum transactions to update the blockchain's state in a consistent manner.
3.1.2 Configurable Components of Move Stack
Source: Movement Whitepaper
The Move Stack provides comprehensive support for creating and deploying Move rollups. It empowers developers to rapidly launch new Move Rollups by selecting from a range of pre-configured components. This modular approach allows for diverse rollup configurations tailored to specific needs. For example, M2, designed for general purposes, utilizes the M1 shared sequencer and Celestia for data availability, coupled with a ZK proof mechanism. Other configurations can be optimized for specific applications like gaming or DeFi.
The configurable components of the Move Stack include:
Sequencer: Rollups can opt for the default M1 decentralized shared sequencing service or use a self-reliant sequencing mechanism.
Data Availability: Options include Ethereum or alternative solutions like Celestia or Near.
Settlement mechanisms: Choices encompass Optimistic (Fraud Proof), ZK (Validity Proof), and Fast-finality (Staked Rollup) approaches.
3.1.3 Fast-Finality Rollup (Staked Rollup)
Movement introduces the concept of fast-finality rollups secured by its own Proof of Stake consensus. In a staked rollup, validators stake native L2 tokens to participate in the consensus process, attesting to the validity of state transitions. This mechanism incentivizes honest behavior, as validators risk having their stakes slashed for dishonest actions, while honest participation is rewarded.
The fast-finality mechanism employs a network of validators to achieve rapid transaction finality. Validators are tasked with confirming the correctness of transaction batch executions. A transaction is considered final and irreversible when a sufficient number of validators (typically more than two-thirds of the total stake) have confirmed the state transition's correctness.
The verification process of a fast-finality Move Rollup involves several key steps:
Validators stake assets in a trusted Layer 1 contract
Upon a state transition, validators broadcast signed attestations and collect attestations from other validators
When attestations representing over two-thirds of the total stake are collected, they are submitted to the Layer 1 contract
The Layer 1 contract verifies the validity, uniqueness, and sufficiency of the attestations, finalizing the state transition
The security level of a fast-finality rollup is directly tied to the total stake of validators. The staking, verification, and reward/slashing processes occur on Layer 1 through the trusted contract. This approach aims to provide a balance of speed and security, offering faster finality than traditional rollup models while maintaining a high level of trust and integrity in the system.
3.1.4 Movement SDK
Source: Movement SDK: Unifying the Blockchain Universe
Essentially, the Movement SDK is a comprehensive, modular development kit designed for the M2 rollup structure, providing an execution environment in MoveVM. Movement SDK provides modular execution environment which allows for the tailored configuration and deployment of blockchain, ensuring compatibility and efficiency across different blockchain. The SDK is designed to be modular and extensible, allowing developers to build custom tools and libraries on top of the core components as well as to interact with Movement Labs' own networks
Movement SDK provides a comprehensive tool that facilitates modularity and interoperability between multiple blockchain environments, combining the core stacks of movement framework:
MoveVM: MoveVM serves as the secure and efficient execution engine, providing a resource-oriented and tightly controlled environment for running smart contracts, which aligns with Move’s principles of safety and efficiency.
Fractal: Fractal acts as the bridge for Solidity, allowing developers to deploy existing Solidity contracts onto MoveVM. Fractal integrateds Solidity’s developer-friendly interface with MoveVM’s secure, performance-oriented runtime.
Custom Adaptors for Sequencer and DA Services: Customizable adaptors of Movement SDK facilitate seamless integration with multiple sequencer options and DA solutions such as Celestia or Eigen DA. Developers can flexibly configure the chain’s tech stack according to their special needs and use cases.
M1 functions as a decentralized shared sequencer within the Movement ecosystem, serving as a critical component in the Movement framework. It manages transaction ordering and consensus across multiple Move-based rollups, with the goals of enhancing network security, promoting fair transaction ordering, and enabling cross-rollup interoperability.
The architecture of M1 is built on a decentralized design, diverging from the centralized sequencers commonly used in many rollup solutions. M1 integrates closely with the Movement SDK and leverages the capabilities of the MoveVM. A key aspect of M1's architecture is its use of a highly scalable Snowman mechanism for achieving consensus on transaction ordering. If a sequencer fails to post transaction data to the designated DA layer chosen by each rollup, they may face penalties.
Source: X(@movementlabsxyz)
A key feature of M1 is its role in facilitating cross-chain interoperability. As a shared sequencer for multiple Move-based rollups, M1 enables seamless communication and interaction between different chains in the Movement ecosystem. M1’s shared architecture supports cross-chain atomic swaps and pooled liquidity across Move Rollups, contributing to a more interconnected and efficient network where assets and liquidity can flow freely between different rollups.
M1's design leverages the Move Stack to simultaneously support Aptos, Sui, and EVM projects for the Parthenon testnet, showcasing its modularity and versatility. This capability allows M1 to cater to a wide range of blockchain applications and ecosystems.
Source: The Shared Sequencer; An SoK on Shared Sequencing, Aggregation Theory and Vertical Integrations
The integration of M1 with Move Rollups is a central feature of the Movement ecosystem. The shared sequencer approach provides connectivity across all Move Rollups within the network, facilitating cross-rollup transactions and liquidity sharing. This integration allows for optimizations in transaction processing and state management that may not be possible with external sequencing solutions.
M1 offers customizable transaction ordering, with templates for various approaches such as fair transaction ordering to mitigate front-running attacks and enhance censorship resistance. Importantly, the M1 sequencer module allows fees to be collected by the rollup rather than by an external service, potentially increasing the utility of native tokens in the Movement Network.
Source: Introducing M1: Redefining L1 Blockchains with the Movement SDK
A notable aspect of M1 is its ability to facilitate the deployment of custom VMs. This flexibility allows developers to create blockchain applications tailored to their specific requirements, moving beyond one-size-fits-all solutions. Developers can optimize the efficiency and performance of their applications by designing VMs that align with their particular needs.
Furthermore, M1 offers out-of-the-box integration capabilities. VMs and technologies deployed on the M1 platform are automatically incorporated, reducing the need for developers to manage complex integration processes. This streamlined approach allows creators to focus on developing innovative applications without being hindered by integration challenges.
By providing a unified sequencing layer, M1 aims to reduce the infrastructure requirements for individual rollups. It creates an ecosystem where assets and liquidity can move between different Move Rollups, potentially enhancing the user experience and overall network utility.
3.3.1 Architecture
Source: Movement Labs announces M2, the first Move VM-based L2 for Ethereum with Celestia underneath
Movement Labs has introduced M2, a ZK rollup based on the Move language, positioned as the cornerstone of the Movement ecosystem. M2 represents an effort to combine the strengths of Move programming with Ethereum's established infrastructure, aiming to provide developers with a platform for building scalable and secure blockchain applications. However, it should be noted that currently Movement rollups use fraud proof as their settlement mechanism, and will be upgraded to ZK rollups in the future.
The architecture of M2 is built around several core components:
MoveVM: Runtime environment to execute Move and EVM smart contracts
Fractal: Allows M2 to run standard EVM smart contracts alongside Move contracts
M1: A Proof of Stake L1 sequencer network that ensures transaction order, correctness and verifiability within the Movement network
3.4.2 Key Features
A distinguishing feature of M2 is its dual language support. The architecture accommodates both Move language variants (Aptos Move, Sui Move) and Solidity contracts. This approach allows developers to utilize the perceived advantages of both ecosystems, potentially broadening the range of applications that can be built on the platform.
In terms of scalability, M2 targets significant improvements over traditional Ethereum transactions. The architecture aims to achieve over 30,000 transactions per second while maintaining EVM compatibility. To reach these throughput levels, M2 utilizes the Move VM's design, which Movement Labs claims is more conducive to parallelization.
M2 incorporates formal verification through the Move Prover, a tool designed to enhance smart contract security. Additionally, M2 employs a Move-EVM bytecode interpreter which can prevent certain vulnerabilities, such as reentrancy, at runtime.
By combining elements of Move with EVM compatibility, M2 attempts to offer a platform that balances the perceived security and performance benefits of Move with the established ecosystem of Ethereum. Movement Labs presents M2 as a solution for developers seeking to build blockchain applications that require high throughput and enhanced security measures.
3.4.3 Transaction Lifecycle
Source: Parallelization: A Fresh Perspective on Blockchain Transactions
The lifecycle of a transaction within a Move Rollup is as follows:
Transaction submission: A transaction is added to the mempool by a client.
Sequencing: The sequencer selects and orders a batch of transactions from the mempool. It then publishes the transaction data to the chosen DA service. For M2, transactions are published to Ethereum
Execution: The executor processes the transactions, generating a new L2 state. A concise representation of this state, known as the state root, is published to the L1 bridge contract
Settlement: The transaction is finalized when the L1 validating bridge contract verifies the new state. For M2, validity proofs are generated through a network of zk-provers, referred to as the Prover Marketplace. However, this verification can also occur through successful completion of the challenge period in optimistic rollups, or validation of the quorum certificate in fast-finality rollups.
M2 maintains a close connection with Ethereum, leveraging its security and liquidity while aiming to offer improved performance. Transaction data and state changes are ultimately anchored back to Ethereum, ensuring overall security.
Source: X(@movementlabsxyz)
Fractal serves as an interpreter within the Movement SDK, enabling the execution of Solidity smart contracts in the MoveVM environment. Fractal aims to bridge the gap between Ethereum's ecosystem and the Move-based platform, allowing developers to leverage existing Solidity contracts while utilizing MoveVM's resource-oriented framework.
Source: X(@movementlabsxyz)
The interpretation process in Fractal involves several steps:
Tokenization and Parsing: Fractal breaks down Solidity scripts into basic elements such as variables, functions, and control structures. It then analyzes the syntactical structure of the code to create an Abstract Syntax Tree
Abstract Syntax Tree(AST): The AST represents the hierarchical structure of the Solidity code, depicting the relationships between different code segments
Intermediate Language(IL): The AST is translated into an Intermediate Language, which serves as a bridge between high-level Solidity code and lower-level instructions
MoveVM Opcodes: The IL is interpreted into operation codes (opcodes) that MoveVM can understand and execute
MoveVM Bytecode: Finally, the opcodes are converted into MoveVM bytecode, ready for execution in the MoveVM environment
Source: X(@movementlabsxyz)
Fractal extends beyond its interpretation process, offering features that facilitate integration between Move and EVM environments. Two key functions enable seamless interaction between these environments:
register_move_contract: This function allows for the integration of Move contracts within the EVM environment. It potentially expands the smart contract ecosystem by enabling Move contracts to operate alongside EVM-based contracts
call_evm_from_move: This function enables Move contracts to interact with EVM-based contracts
These functions aim to simplify the process of integrating Move and EVM-based contracts. With a single function call, Move contracts can potentially interact with contracts deployed on the EVM, broadening the range of possible integrations within each ecosystem. This approach may allow developers to leverage the attributes of both platforms in building dApps.
Through this process, Fractal aims to enable Ethereum developers to migrate their existing contracts to Move-based platforms without rewriting them. Converting existing Solidity codebases to Move can be a time-consuming process that requires learning a new language. Fractal attempts to simplify this process, potentially enabling resources and liquidity to move more freely across different chains.
It's worth noting that Fractal is currently in development, undergoing testing and refinement to expand its capabilities. The long-term goal of Fractal appears to be facilitating greater interoperability between different blockchain ecosystems, particularly between Ethereum and Move-based platforms.
Movement has laid the groundwork for developers to easily build customized solutions and dApps using the Move language, enabling users to seamlessly integrate into the ecosystem. As a result, the Movement ecosystem is continuously expanding and evolving.
In this chapter, we will explore how the expanding and developing Movement ecosystem is structured and examine some interesting concepts of dApps that have established themselves and are thriving within it.
Source: Movement Labs
First, let's look at the infrastructure. Although grouped under the same term, the projects included here vary in their respective fields. From data availability (DA) to the Decentralized Mobile Infrastructure Network (DeMIN), we will take a closer look at the infrastructure projects that bolster the Movement blockchain.
4.1.1 Celestia
Celestia is a modular blockchain designed to efficiently manage data and securely share it across a decentralized network. By using data availability proofs, Celestia enhances network security, allowing blockchains or dApps to operate more efficiently. In the Movement ecosystem, Celestia plays a critical role in data availability, establishing itself as a key infrastructure component that ensures the ecosystem's stability.
4.1.2 Covalent
Covalent provides a blockchain data API solution, offering services to efficiently collect, process, and deliver data across various blockchain networks. Within the Movement ecosystem, Covalent assists dApp developers by facilitating easy access to and use of blockchain data. This significantly increases development efficiency by eliminating the need for developers to build complex data infrastructure.
4.1.3 Superchain
Superchain is a multi-chain indexer that allows for quick and easy access to customized data, enabling developers to build more efficient and secure dApps. This project provides consistent data across both EVM and Move VM, enhancing decentralization and transparency of blockchain data. Using Superchain, dApp development within Movement becomes easier and faster.
4.1.4 SupraOracles
SupraOracles is a project that delivers fast and secure real-time price data or external data to developers building dApps within Movement. It provides reliable decentralized oracle feeds and a verifiable random function (VRF), offering the necessary fairness for games and NFTs.
4.1.5 Hyacinth
Hyacinth specializes in blockchain and smart contract security audits, analyzing various smart contract codes within Movement to identify vulnerabilities and offer recommendations for improvement. Hyacinth supports dApp developers and project teams in creating safer and more trustworthy services.
4.1.6 Up Network
Source: Up Network X
Up Network introduced the concept of DeMIN, aiming to build a decentralized mobile infrastructure that facilitates seamless access to blockchain services in mobile environments. This project significantly enhances the accessibility of blockchain services, particularly in regions with a high number of mobile users, thereby encouraging greater participation in the Movement ecosystem.
Movement is not the only entity in the blockchain industry. With the rise of various mainnets, each with its philosophy and concept, the industry has seen increased fragmentation. However, interoperability projects aim to connect these fragmented mainnets. Within Movement, such efforts have materialized in the following projects.
Union provides a sovereign layer that supports interoperability across various blockchains, utilizing trustless bridges with zero-knowledge proofs to connect application chains, L1s, and L2s. This opens up possibilities for interchain connections.
Noble is a project within the Cosmos ecosystem focused on asset issuance, ensuring security, liquidity, regulatory compliance, standardization, and neutrality to enable seamless access to digital assets within the Cosmos ecosystem.
Movement Labs collaborates with these two projects to maximize interoperability within the blockchain ecosystem, enhance user experience, and integrate technology and liquidity. Notably, this collaboration enables the transfer of native USDC from Celestia to Movement, facilitating more widespread financial access.
4.2.2 OmniBTC
Movement joins Omni's Open Liquidity Network to provide the security and speed of Move to Ethereum rollup users. Omni aggregates data on users, liquidity, and activities across rollups, enabling developers to build dApps usable across all rollups. By entering Omni's ecosystem, Movement allows users to access a wide range of rollup dApps and liquidity.
4.2.3 Dappad+
Source: dappad+ X
Dappad+ is a multi-chain launchpad that connects L2 projects, which may struggle to secure funding, with early investors, supporting fundraising and token launches within Movement. Additionally, it uses the Fractal EVM-to-Move interpreter, allowing EVM developers to deploy directly within Movement without rewriting code. Dappad+ offers an easy onboarding process and innovative features such as using native tokens for fees.
When users attempt to use dApps, the first service they encounter is the wallet service. While existing wallet services can be adopted as they are, Movement-specific wallets that are more optimized for the Movement environment and more user-friendly exist. These wallets strengthen the connection between dApp projects and users within the Movement ecosystem, enabling convenient user experiences. Let's take a look at some of the wallet projects.
4.3.1 Razor Wallet
Source: Razor DAO X
Razor Wallet is a wallet service optimized for the Movement ecosystem, helping users safely and easily access various dApps. With a user-friendly interface and robust security features, it is designed for ease of use by both beginners and experts. Currently supporting all networks within Movement, with MEVM support soon to be added, Razor Wallet Kit makes it highly convenient to develop new Movement dApps, and using Razor Wallet is recommended.
4.3.2 Tailwind
Tailwind is developing a one-click Cosmos smart wallet that allows users to pay gas fees with IBC tokens, which can now connect Move and EVM users and liquidity in Movement. Through this ecosystem collaboration, it improves user experience (UX) and provides an environment where transactions can be executed without considering the type of tokens to be used for fees across various chains.
Despite the progress in blockchain history, DeFi remains a sector that attracts significant funds and users. Movement, with its Move language, offers a tool that enables the creation of safer and more efficient smart contracts with ease. Additionally, Movement supports the Fractal feature, an EVM-to-Move compiler, allowing services implemented on other EVM chains to be brought directly to Movement. These features have been sufficient reasons for many DeFi project developers to enter, leading to the fastest and most explosive growth within the Movement ecosystem. Let's explore the active DeFi projects and their features.
4.4.1 Ethena
Source: Movement X
Ethena is a protocol offering fully collateralized USDe, backed by a combination of yields from staked ETH and derivative market earnings. Ethena plans to introduce USDe-based native yield products within the Movement ecosystem. Using Movement's Fractal EVM-to-Move compiler, EVM protocols can operate in Movement without rewriting their code, allowing dApp developers within Movement to access USDe liquidity without needing to write additional Move code.
4.4.2 Lexer Market
Lexer Market is a DEX built on Arbitrum that offers short, long, and perpetual futures trading based on cryptocurrency. Soon to support synthetic asset and NFT trading, Lexer Market can seamlessly integrate into the Movement ecosystem using the Fractal EVM-to-Move compiler. Leveraging Move's built-in Prover system, Lexer can protect user assets from reentrancy attacks, enabling users to participate in derivative trading with Move and ERC-20 tokens, and soon NFTs. Lexer’s Smart Router processes transactions using an oracle-based payment system, and the fast processing speed and strong oracle support of the Movement Stack make this possible.
4.4.3 Thala
Source: Movement X
Thala Labs is the largest DeFi platform on M2 as of March 2024, offering an all-in-one DeFi hyper-app with fast, secure Ethereum L2 accessibility, 100% Move compatibility, and EVM liquidity support. Thala's DeFi platform, which recorded $200 million TVL on Aptos, provides an all-in-one DeFi hub, including Thala Swap DEX, Move Dollar (MOD), sthAPT for APT staking, and an active token launch platform. MOD, the stablecoin powering the Thala ecosystem, is backed by a diversified asset portfolio and operates via a collateralized debt position (CDP) system, allowing users to deposit collateral and issue $MOD accordingly.
4.4.4 VCRED
VCRED is an AI-based liquidity management service positioned on top of DEXs, offering liquidity providers (LPs) single-sided staking strategies using AI and machine learning to significantly improve capital efficiency. VCRED’s liquidity management strategy is expected to greatly benefit LPs, traders, and the entire Movement DeFi ecosystem, providing an optimal user experience through Movement's security, speed, and performance features, and enabling access to non-EVM DEXs. Notably, VCRED, originally written in Solidity, was easily deployed within Movement with the support of Movement's Fractal technology.
4.4.5 Xebra Trade
Source: xebra.trade X
Xebra Trade is a non-custodial derivatives exchange with a platform that offers 100% transparency under the motto "No grey areas." All trading processes occur on-chain, providing a speed and user experience comparable to CeFi. Xebra’s infrastructure is built on an on-chain CLOB system and includes Auto Market Maker (AMM), locked LP staking, and a price-based margin system. Additionally, it features cross-margin, 0% fees for order creation, a GLP-like vault, and an off-order book block trading mechanism.
4.4.6 Stream Finance
Stream Finance uses a Decentralized Market Maker (DMM) to enable users to earn profits without being affected by price fluctuations of underlying assets. This mechanism allows users to earn profits not only in USDC but also in ETH and BTC. By joining Movement, Stream Finance gains access to Move DeFi users and liquidity, paving the way for the future launch of a liquidity-optimized decentralized perpetual exchange.
4.4.7 Milky Way
Milky Way introduces its liquid staking token $milkTIA to M2, allowing M2 users to stake $TIA while maintaining liquidity and utilizing $milkTIA in DeFi. Milky Way is designed as a liquid staking protocol tailored for a modular ecosystem, allowing users to receive staking rewards without locking up tokens for a specific period. M2 is a modular L2 that connects the MoveVM and other blockchain components, leveraging Celestia’s data availability. Additionally, with IBC support, $milkTIA can move seamlessly between M2 and other IBC chains.
4.4.8 Stakestone
StakeStone is a one-stop staking protocol connecting liquidity across blockchains. STONE Ether brings yield-generating ETH liquidity to L2, enabling its use in DeFi for trading, lending, and stablecoin issuance. With STONE-Fi available in Movement, users can maintain ETH liquidity while earning staking rewards within Movement using STONE liquid staking tokens.
4.4.9 Avitus
Source: Avitus X
Avitus is a decentralized derivatives trading platform that allows various on-chain assets to be used as collateral, making it an attractive place for existing protocols to add new assets and expand liquidity. Avitus aims to expand the DeFi derivatives market by enabling users to create markets without permission and manage on-chain risks, facilitating the trading of various assets. To address security issues arising from Solidity-based DeFi, Avitus leverages Movement’s security and speed, offering excellent UX and fast transaction speeds, with Movement's MoveVM providing over 180,000 TPS, deep liquidity, and high security.
Similar to DeFi, the ease and efficiency of developing smart contracts with the Move language have made it an incredibly attractive point in the gaming sector. The savings in development resources from the project company's perspective have led to creative and fun game planning, resulting in the emergence of several gaming projects discussed below.
4.5.1 BRKT(Bracket)
Source: BRKT X
BRKT is a decentralized tournament management protocol that launched privately to bring sports GambleFi to Movement. This platform allows users to create customized tournaments, experience betting, and prize distribution directly. BRKT offers tournaments in various sports, including soccer, American football, tennis, and golf, accommodating up to 256 teams, with users able to participate in teams or bet to win prizes. It also allows betting on fun topics like election results. Within Movement, BRKT delivers a smooth user experience thanks to the parallel execution and efficient fee market characteristic of Movement.
4.5.2 Gaimin
Gaimin is a Web3 gaming platform aiming to revolutionize gaming experiences and popularize Web3. Gaimin envisions its role as helping millions of gamers easily participate in Web3, positioning itself as the next-generation gaming platform at the intersection of Web3 gaming, cloud computing, and gaming. Gaimin continues its efforts to return most of its revenue to gamers, striving to build a sustainable and gamer-friendly environment. Gaimin is working with BNB Chain to build the fastest and most secure game-focused L2 blockchain using the Move Stack framework. This collaboration allows Gaimin to leverage Move's performance and security as the execution layer when developing a custom modular L2 solution on BNB Chain. This entry into the Movement ecosystem is expected to pave the way for more Move-based L2 launches within the BNB ecosystem in the future.
In the broader blockchain industry, the social sector has yet to see much hype. However, it is likely to be the field where mass adoption will occur first, given its accessibility to light users. Movement also has social projects that are interesting due to their innovative concepts.
4.6.1 Henry Social
Source: HENRY X
Henry Social is an integrated social commerce service combining applications with an on-chain layer, offering a smooth and scalable commerce solution through its dedicated rollup. Current commerce dApps face challenges related to user experience, scalability, and costs. Henry’s dedicated rollup app chain allows users to conduct P2P transactions with no additional costs in a fully abstracted environment, promoting mass adoption of blockchain technology. Henry Social, in collaboration with Movement, provides fast and affordable transactions, interoperability between EVM and Move chains, and compatibility with Ethereum tools, enabling the creation of an innovative on-chain commerce ecosystem. Henry Social aims to redefine commerce within the Movement ecosystem, supporting companies in growing within an innovative and accessible environment.
4.6.2 MoveWifFrens
MoveWifFrens is a SocialFi platform built with Move Aptos smart contracts, set to be deployed on the Aptos Move-based chain. This project aims to revolutionize how people interact with and communicate with content creators in the digital world. Notably, it features a social-like UI/UX that supports content discovery, management, and transactions in one place. The process also uses AI to provide personalized suggestions for content.
4.6.3 Gilder
Gilder is a community platform for gaming and animation fans, built with the Move language on Sui, offering secure messaging, forums, and reputation systems. Now, through the Movement Network, Gilder can reach EVM users with the same Move codebase, utilizing Celestia’s data availability and Snowman’s sequencing to ensure that Gilder's Move app works smoothly on Ethereum. Gilder's reputation engine is open source, allowing game developers and animation site operators to integrate Gilder’s community and user profiles.
Source: Movement Labs
Movement Labs has introduced a novel approach that aims to democratize the Move language for wider ecosystem. Movement addresses challenges in building a blockchain and applications, particularly in terms of security, scalability, and interoperability. By leveraging Move's strengths, Movement aims to create a robust and efficient ecosystem for developing smart contract applications. The vision of Movement extends beyond individual fast chains, encompassing a goal of constructing entire networks based on Move.
The Move programming language offers advantages that make it suitable for blockchain applications. Move's resource-oriented architecture provides scarcity protections, treating digital assets with precision similar to physical assets. The language's bytecode-level safety and formal verification capabilities through the Move Prover offer security features that address vulnerabilities common in the industry. Move's virtual machine also facilitates parallel execution, allowing for improvements in transaction processing speed and network scalability. These features of enhanced security and parallel execution capabilities make Move a potentially effective tool for developing high-performance, secure blockchain applications.
As Movement continues to develop, its impact on the blockchain landscape may become more pronounced. The project's focus on democratizing Move for L2s could lead to a proliferation of Move-based rollups, potentially shifting the industry's focus towards more secure and efficient blockchain architectures. The success of M1, M2 and its ecosystem will be crucial in demonstrating the viability of Move-based solutions at scale. If successful, Movement's approach could encourage more developers to adopt Move, potentially leading to a broader ecosystem of Move-compatible tools and applications.
The integration of Move with Ethereum's infrastructure through projects like M2 may serve as a model for future blockchain interoperability efforts. This could lead to a more interconnected blockchain ecosystem where the strengths of different languages and platforms are combined. The emphasis on modular design in the Movement Framework may influence future blockchain development practices, encouraging more flexible and adaptable blockchain architectures.
Sui
Story
Injective
Taiko
