Move programming language is a relatively new programming language that was developed so to provide a secure programmable foundation for the Libra blockchain. It was initially used to build the Diem blockchain. It was created by Diem Association, which was a tech consortium backed by Meta. Even though the blockchain was eventually abandoned, Move is still actively utilized to this day.
Move programming language is an executable bytecode language. It implements smart contracts and custom transactions. The intention behind this move is to address issues that arise from using other blockchain programming languages, such as Solidity. Nonetheless, the fundamental objectives of attaining digital scarcity and exercising control over digital assets remain unchanged
Key Features:
1. Safety and Security: Move is designed with safety and security in mind. It enforces strict rules to prevent common vulnerabilities found in smart contracts, such as reentrancy attacks and state manipulation issues.
2. Resource-Oriented: One of the defining characteristics of Move is its resource-oriented approach. Data in Move is treated as resources that can be moved between program storage locations. This ensures that resources are not accidentally duplicated or leaked, preventing bugs related to ownership and memory management.
3. Deterministic Execution: Move enforces deterministic execution of smart contracts. Given the same inputs, a Move smart contract will always produce the same output. This predictability is essential for maintaining the integrity and stability of the Libra/Diem blockchain.
4. Move IR (Intermediate Representation): Move has an intermediate representation (IR), which allows for formal verification of smart contracts. Formal verification is a technique used to mathematically prove the correctness of code, enhancing the security and reliability of the contracts.
5. Limited Native Data Types: Move has a small set of native data types, which helps in making the language simpler and safer. The native types include integers, booleans, addresses, byte arrays, and references to resources.
6. Module System: Move supports a module system that enables the organization of code into logical units. This allows for code reusability and enhances maintainability.
7. Transactions and Modules Separation: Move differentiates between transactions and modules. Transactions represent executable scripts, while modules contain the code for resources and functions. This separation allows for better clarity and compartmentalization of code functionality.
How to install Move?
Ways for you to install move
1.Open your terminal and clone the repository
git clone https://github.com/move-language/move.git2. Change to the move directory and run the dev_setup.sh script
Cd move
./scripts/dev_setup.sh -ypt3. Follow script prompts to install all Move’s dependencies
4. The script will add environment variable definition to your ~/.profile Include them by running.
~/.profile5.Next, install Move’s command line by the commands (install cargo first)
Cargo install –path language/tools/move-cli6. Verify it by running the command
–help
Key features of Move programming language
-
Resource-Oriented: Move introduces a resource-oriented programming model where resources are first-class citizens, representing digital assets on the blockchain. Resources can be created, destroyed, and transferred between accounts.
-
Safety and Security: Move has strict static analysis to prevent common vulnerabilities, such as reentrancy, resource leakage, and integer overflow/underflow.
-
Move Semantics: The language enforces unique ownership of resources, ensuring that only one account can own and control a resource at any given time.
-
Native Support for Blockchain Operations: Move provides built-in features to handle blockchain-specific operations like transactions, event handling, and querying account states.
-
Custom Transaction Logic: Developers can define their custom transactions with specific rules and conditions for the movement of resources, enabling flexible and customizable smart contracts.
Advantages of using Move for smart contact
The main advantages of using Move for smart contracts include:
-
Security: Move's design aims to prevent common programming errors that can lead to vulnerabilities and security breaches in smart contracts, making it a safer choice for managing digital assets and transactions.
-
Resource-Oriented Model: The resource-oriented programming model in Move allows for more efficient and expressive management of digital assets, enabling the creation of complex financial transactions and contracts.
-
Custom Transactions: Move's flexibility enables developers to define custom transactions with specific conditions and rules, providing more control over the movement of resources.
-
Built-in Support for Blockchain Operations: Move natively supports essential blockchain operations, simplifying the development of smart contracts for blockchain applications.
Hello-world in Move
script HelloWorld {
fun main() {
let greeting: &signer Str;
greeting = &signer "Hello, World!";
// Print the greeting
assert(copy(greeting) == "Hello, World!", 1);
}
}Explanation:
-
The script is named HelloWorld, which means it represents a standalone script that can be executed on the Diem blockchain.
-
The main function is the entry point of the script, and it will be executed when the script is called.
-
We define a variable greeting of the resource type Str, which is a string.
-
The &signer annotation indicates that the greeting resource is owned by the sender of the transaction.
-
We assign the value "Hello, World!" to the greeting resource.
-
The assert statement checks whether the value of the greeting is equal to "Hello, World!". If it's not, it will raise an error with the error code 1.
How to run the code:
-
Toggle VSCode's command palette by pressing ⌘+Shift+P (on Mac) or Ctrl+Shift+P (on Linux/Windows)
-
Type: >Move: Run Script and then press enter or click when you see the appropriate option.
Explanation:
-
Observe the execution result, wherein a log message displaying '5' is printed in debug mode. In case this window is not visible, please revisit this section once more.
Sample simple smart contract for reference:
// Define a resource type for the cryptocurrency
resource struct Currency {
coin_id: u8,
value: u64,
}
// Create a function to transfer the currency from one account to another
public fun transfer_currency(sender: &signer, recipient: address, coin_id: u8, amount: u64) {
let sender_balance: &mut Currency;
let recipient_balance: &mut Currency;
// Get the sender's currency and recipient's currency references
sender_balance = &mut borrow_global<Currency>(sender, coin_id);
recipient_balance = &mut borrow_global<Currency>(&recipient, coin_id);
// Ensure the sender must have enough balance for the transfer to be done
assert(sender_balance.value >= amount, 101);
// Perform the transfer
move_to(sender_balance, Currency { coin_id, value: sender_balance.value - amount });
move_to(recipient_balance, Currency { coin_id, value: recipient_balance.value + amount });
}In this example, the smart contract defines a resource-type Currency representing a cryptocurrency with a coin_id and a value. The transfer_currency function allows users to transfer a specified amount of cryptocurrency from their account to another account on the blockchain. The function checks if the sender has sufficient balance and performs the transfer accordingly.
Additional Reference
Here are some other referential videos that would help you to go forward with the Move:
More about move programming language
Frequently Asked Questions
Q1. What is the main purpose of Move programming language?
The main purpose of the Move programming language is to facilitate the creation of smart contracts and custom transactions on the Diem blockchain. Move is specifically designed to support digital asset management and safety, aiming to prevent common programming errors that can lead to vulnerabilities and security breaches.
Q2. Which blockchain uses the Move programming language?
Move programming language was initially developed for the Libra (now Diem) blockchain. Diem is a permissioned blockchain designed for fast and secure transactions, primarily focusing on financial services and digital currency use cases.
Q3. Can I use Move for projects outside of Diem blockchain?
The move was primarily built for the Diem blockchain, and its design is closely tied to the blockchain's architecture. However, in theory, it is possible to adapt Move for other blockchain platforms with some modifications and adjustments. Nevertheless, it might not be the most suitable choice for blockchains with different design principles or requirements.
Q4. Is Move only suitable for financial applications?
While Move was initially designed for financial applications on the Diem blockchain, it can be adapted and used for various other purposes. Its safety and security features make it well-suited for any use case that requires smart contracts and digital asset management with a strong emphasis on safety.
Q5. Can Move smart contracts be updated or modified after deployment?
In its initial design, Move smart contracts on the Diem blockchain were immutable, meaning they could not be directly modified after deployment. This approach ensures that the smart contract behavior remains predictable and secure, preventing unintended changes that could lead to potential vulnerabilities.
However, it is possible to implement upgradeable smart contracts on top of the Diem blockchain using proxy contracts or similar mechanisms. These upgradeable contracts can allow developers to introduce changes or updates to the contract's logic by deploying a new version of the contract while maintaining the existing state and data.