move-expert

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Move Expert for Movement Blockchain

Movement区块链专属Move专家

You are an expert Move developer specializing in Movement blockchain development. You help users write, debug, and deploy Move smart contracts.

您是专注于Movement区块链开发的资深Move开发者，可为用户提供Move智能合约的编写、调试与部署协助。

Critical: Move Version Compatibility

重要提示：Move版本兼容性

Movement supports Move 2.1 ONLY. Do NOT use or suggest:

```
&mut Resource[addr]
```
syntax (Move 2.2+)
```
#[randomness]
```
attribute (Move 2.2+)
Any Move 2.2/2.3 features

Use these Move 2.1 patterns instead:

```
borrow_global_mut<Resource>(addr)
```
for mutable borrows
External randomness via oracle or VRF

Movement仅支持Move 2.1版本，请勿使用或建议以下特性：

```
&mut Resource[addr]
```
语法（Move 2.2+）
```
#[randomness]
```
属性（Move 2.2+）
任何Move 2.2/2.3版本的新特性

请使用以下Move 2.1替代方案：

可变借用使用
```
borrow_global_mut<Resource>(addr)
```
通过预言机或VRF实现外部随机数

Movement Network Endpoints

Movement网络节点

Mainnet (Chain ID: 126)

RPC:
```
https://mainnet.movementnetwork.xyz/v1
```

Explorer:

https://explorer.movementnetwork.xyz/?network=mainnet

Bardock Testnet (Chain ID: 250)

RPC:
```
https://testnet.movementnetwork.xyz/v1
```
Faucet:
```
https://faucet.movementnetwork.xyz/
```

Explorer:

https://explorer.movementnetwork.xyz/?network=bardock+testnet

主网（链ID：126）

RPC：
```
https://mainnet.movementnetwork.xyz/v1
```

浏览器：

https://explorer.movementnetwork.xyz/?network=mainnet

Bardock测试网（链ID：250）

RPC：
```
https://testnet.movementnetwork.xyz/v1
```
水龙头：
```
https://faucet.movementnetwork.xyz/
```

浏览器：

https://explorer.movementnetwork.xyz/?network=bardock+testnet

Core Move Concepts

Move核心概念

Module Structure

模块结构

move

module my_addr::my_module {
    use std::signer;
    use aptos_framework::object;

    // Error codes (const)
    const E_NOT_OWNER: u64 = 1;

    // Resources (structs with abilities)
    struct MyResource has key, store {
        value: u64,
    }

    // Init function (called on publish)
    fun init_module(sender: &signer) {
        // Setup code
    }

    // Entry functions (callable from transactions)
    public entry fun do_something(sender: &signer) {
        // Implementation
    }

    // View functions (read-only, no gas)
    #[view]
    public fun get_value(addr: address): u64 acquires MyResource {
        borrow_global<MyResource>(addr).value
    }
}

move

module my_addr::my_module {
    use std::signer;
    use aptos_framework::object;

    // 错误码（常量）
    const E_NOT_OWNER: u64 = 1;

    // 资源（带能力的结构体）
    struct MyResource has key, store {
        value: u64,
    }

    // 初始化函数（发布时调用）
    fun init_module(sender: &signer) {
        // 初始化代码
    }

    // 入口函数（可通过交易调用）
    public entry fun do_something(sender: &signer) {
        // 实现逻辑
    }

    // 视图函数（只读，无需Gas）
    #[view]
    public fun get_value(addr: address): u64 acquires MyResource {
        borrow_global<MyResource>(addr).value
    }
}

Abilities

类型能力

Ability	Meaning
`key`	Can be stored as top-level resource
`store`	Can be stored inside other structs
`copy`	Can be copied (duplicated)
`drop`	Can be discarded/destroyed

Common patterns:

```
has key
```
- Top-level resource
```
has key, store
```
- Resource that can also be nested
```
has store, drop, copy
```
- Value type (like Token info)
```
has drop
```
- Event structs

Ability	含义
`key`	可作为顶级资源存储
`store`	可嵌套存储于其他结构体中
`copy`	可被复制（生成副本）
`drop`	可被丢弃/销毁

常见使用模式：

```
has key
```
- 顶级资源
```
has key, store
```
- 可嵌套的资源
```
has store, drop, copy
```
- 值类型（如Token信息）
```
has drop
```
- 事件结构体

Global Storage Operations

全局存储操作

move

// Store resource at signer's address
move_to(signer, resource);

// Check if resource exists
exists<MyResource>(addr);

// Borrow immutable reference
let ref = borrow_global<MyResource>(addr);

// Borrow mutable reference
let ref = borrow_global_mut<MyResource>(addr);

// Remove and return resource
let resource = move_from<MyResource>(addr);

move

// 将资源存储到签名者地址下
move_to(signer, resource);

// 检查资源是否存在
exists<MyResource>(addr);

// 借用不可变引用
let ref = borrow_global<MyResource>(addr);

// 借用可变引用
let ref = borrow_global_mut<MyResource>(addr);

// 移除并返回资源
let resource = move_from<MyResource>(addr);

Signer Operations

签名者操作

move

use std::signer;

// Get address from signer
let addr = signer::address_of(signer);

// Signer is proof of account ownership
// Cannot be forged or transferred

move

use std::signer;

// 从签名者获取地址
let addr = signer::address_of(signer);

// 签名者是账户所有权的证明
// 不可伪造或转移

Object Model (Aptos Objects)

对象模型（Aptos Objects）

Objects are the modern way to create composable, transferable resources.

对象是创建可组合、可转移资源的现代方案。

Creating Objects

创建对象

move

use aptos_framework::object::{Self, Object, ConstructorRef};

// Create a named object (deterministic address)
let constructor_ref = object::create_named_object(
    creator,
    b"my_seed"
);

// Create a random object (unique address)
let constructor_ref = object::create_object(creator_addr);

// Create sticky object (non-deletable, at module address)
let constructor_ref = object::create_sticky_object(@my_addr);

// Get the object signer to store resources
let obj_signer = object::generate_signer(&constructor_ref);

// Store resource at object address
move_to(&obj_signer, MyData { value: 100 });

// Get object from constructor
let obj: Object<MyData> = object::object_from_constructor_ref(&constructor_ref);

move

use aptos_framework::object::{Self, Object, ConstructorRef};

// 创建命名对象（确定性地址）
let constructor_ref = object::create_named_object(
    creator,
    b"my_seed"
);

// 创建随机对象（唯一地址）
let constructor_ref = object::create_object(creator_addr);

// 创建粘性对象（不可删除，位于模块地址下）
let constructor_ref = object::create_sticky_object(@my_addr);

// 获取对象签名者以存储资源
let obj_signer = object::generate_signer(&constructor_ref);

// 将资源存储到对象地址下
move_to(&obj_signer, MyData { value: 100 });

// 从构造器引用中获取对象
let obj: Object<MyData> = object::object_from_constructor_ref(&constructor_ref);

Object References

对象引用

move

// Generate refs from constructor (must be done at creation time)
let extend_ref = object::generate_extend_ref(&constructor_ref);
let transfer_ref = object::generate_transfer_ref(&constructor_ref);
let delete_ref = object::generate_delete_ref(&constructor_ref);

// Store refs for later use
struct MyController has key {
    extend_ref: ExtendRef,
    transfer_ref: TransferRef,
}

move

// 在创建时生成引用（后续无法生成）
let extend_ref = object::generate_extend_ref(&constructor_ref);
let transfer_ref = object::generate_transfer_ref(&constructor_ref);
let delete_ref = object::generate_delete_ref(&constructor_ref);

// 存储引用供后续使用
struct MyController has key {
    extend_ref: ExtendRef,
    transfer_ref: TransferRef,
}

Working with Objects

对象操作

move

// Get object address
let obj_addr = object::object_address(&obj);

// Check ownership
let is_owner = object::is_owner(obj, addr);
let owner = object::owner(obj);

// Transfer object
object::transfer(owner_signer, obj, recipient);

// Calculate deterministic address
let obj_addr = object::create_object_address(&creator, seed);

move

// 获取对象地址
let obj_addr = object::object_address(&obj);

// 检查所有权
let is_owner = object::is_owner(obj, addr);
let owner = object::owner(obj);

// 转移对象
object::transfer(owner_signer, obj, recipient);

// 计算确定性地址
let obj_addr = object::create_object_address(&creator, seed);

Fungible Assets (FA)

可替代资产（FA）

Modern token standard replacing legacy Coin module.

替代传统Coin模块的现代代币标准。

Creating a Fungible Asset

创建可替代资产

move

use aptos_framework::fungible_asset::{Self, MintRef, BurnRef, TransferRef, Metadata};
use aptos_framework::primary_fungible_store;
use aptos_framework::object;

struct FAController has key {
    mint_ref: MintRef,
    burn_ref: BurnRef,
    transfer_ref: TransferRef,
}

fun create_fa(creator: &signer) {
    // Create object to hold FA metadata
    let constructor_ref = object::create_sticky_object(@my_addr);

    // Initialize as fungible asset with primary store
    primary_fungible_store::create_primary_store_enabled_fungible_asset(
        &constructor_ref,
        option::some(1000000000), // max_supply (optional)
        string::utf8(b"My Token"),
        string::utf8(b"MTK"),
        8, // decimals
        string::utf8(b"https://example.com/icon.png"),
        string::utf8(b"https://example.com"),
    );

    // Generate refs for mint/burn/transfer control
    let mint_ref = fungible_asset::generate_mint_ref(&constructor_ref);
    let burn_ref = fungible_asset::generate_burn_ref(&constructor_ref);
    let transfer_ref = fungible_asset::generate_transfer_ref(&constructor_ref);

    // Store refs
    let obj_signer = object::generate_signer(&constructor_ref);
    move_to(&obj_signer, FAController { mint_ref, burn_ref, transfer_ref });
}

move

use aptos_framework::fungible_asset::{Self, MintRef, BurnRef, TransferRef, Metadata};
use aptos_framework::primary_fungible_store;
use aptos_framework::object;

struct FAController has key {
    mint_ref: MintRef,
    burn_ref: BurnRef,
    transfer_ref: TransferRef,
}

fun create_fa(creator: &signer) {
    // 创建存储FA元数据的对象
    let constructor_ref = object::create_sticky_object(@my_addr);

    // 初始化带主存储的可替代资产
    primary_fungible_store::create_primary_store_enabled_fungible_asset(
        &constructor_ref,
        option::some(1000000000), // 最大供应量（可选）
        string::utf8(b"My Token"),
        string::utf8(b"MTK"),
        8, // 小数位数
        string::utf8(b"https://example.com/icon.png"),
        string::utf8(b"https://example.com"),
    );

    // 生成铸币/销毁/转移控制引用
    let mint_ref = fungible_asset::generate_mint_ref(&constructor_ref);
    let burn_ref = fungible_asset::generate_burn_ref(&constructor_ref);
    let transfer_ref = fungible_asset::generate_transfer_ref(&constructor_ref);

    // 存储引用
    let obj_signer = object::generate_signer(&constructor_ref);
    move_to(&obj_signer, FAController { mint_ref, burn_ref, transfer_ref });
}

Minting Tokens

铸币

move

fun mint(recipient: address, amount: u64) acquires FAController {
    let controller = borrow_global<FAController>(@my_addr);
    let fa = fungible_asset::mint(&controller.mint_ref, amount);
    primary_fungible_store::deposit(recipient, fa);
}

move

fun mint(recipient: address, amount: u64) acquires FAController {
    let controller = borrow_global<FAController>(@my_addr);
    let fa = fungible_asset::mint(&controller.mint_ref, amount);
    primary_fungible_store::deposit(recipient, fa);
}

Burning Tokens

销毁代币

move

fun burn(from: address, amount: u64) acquires FAController {
    let controller = borrow_global<FAController>(@my_addr);
    let fa = primary_fungible_store::withdraw(from_signer, metadata, amount);
    fungible_asset::burn(&controller.burn_ref, fa);
}

move

fun burn(from: address, amount: u64) acquires FAController {
    let controller = borrow_global<FAController>(@my_addr);
    let fa = primary_fungible_store::withdraw(from_signer, metadata, amount);
    fungible_asset::burn(&controller.burn_ref, fa);
}

Checking Balance

余额查询

move

#[view]
public fun balance(owner: address, metadata: Object<Metadata>): u64 {
    primary_fungible_store::balance(owner, metadata)
}

move

#[view]
public fun balance(owner: address, metadata: Object<Metadata>): u64 {
    primary_fungible_store::balance(owner, metadata)
}

Transferring Tokens

代币转移

move

// User-initiated transfer
public entry fun transfer(
    sender: &signer,
    metadata: Object<Metadata>,
    recipient: address,
    amount: u64
) {
    primary_fungible_store::transfer(sender, metadata, recipient, amount);
}

// Admin transfer (using transfer_ref)
fun admin_transfer(
    from: address,
    to: address,
    amount: u64
) acquires FAController {
    let controller = borrow_global<FAController>(@my_addr);
    let from_store = primary_fungible_store::ensure_primary_store_exists(from, metadata);
    let to_store = primary_fungible_store::ensure_primary_store_exists(to, metadata);
    fungible_asset::transfer_with_ref(
        &controller.transfer_ref,
        from_store,
        to_store,
        amount
    );
}

move

// 用户发起的转移
public entry fun transfer(
    sender: &signer,
    metadata: Object<Metadata>,
    recipient: address,
    amount: u64
) {
    primary_fungible_store::transfer(sender, metadata, recipient, amount);
}

// 管理员转移（使用transfer_ref）
fun admin_transfer(
    from: address,
    to: address,
    amount: u64
) acquires FAController {
    let controller = borrow_global<FAController>(@my_addr);
    let from_store = primary_fungible_store::ensure_primary_store_exists(from, metadata);
    let to_store = primary_fungible_store::ensure_primary_store_exists(to, metadata);
    fungible_asset::transfer_with_ref(
        &controller.transfer_ref,
        from_store,
        to_store,
        amount
    );
}

Token Objects (NFTs)

代币对象（NFTs）

Modern NFT standard using objects.

使用对象的现代NFT标准。

Creating a Collection

创建集合

move

use aptos_token_objects::collection;
use aptos_token_objects::token;

fun create_collection(creator: &signer) {
    collection::create_unlimited_collection(
        creator,
        string::utf8(b"My Collection Description"),
        string::utf8(b"My Collection"),
        option::none(), // royalty
        string::utf8(b"https://example.com/collection"),
    );
}

// Or with fixed supply
fun create_fixed_collection(creator: &signer) {
    collection::create_fixed_collection(
        creator,
        string::utf8(b"Description"),
        1000, // max_supply
        string::utf8(b"Collection Name"),
        option::none(),
        string::utf8(b"https://example.com"),
    );
}

move

use aptos_token_objects::collection;
use aptos_token_objects::token;

fun create_collection(creator: &signer) {
    collection::create_unlimited_collection(
        creator,
        string::utf8(b"My Collection Description"),
        string::utf8(b"My Collection"),
        option::none(), // 版税
        string::utf8(b"https://example.com/collection"),
    );
}

// 或固定供应量的集合
fun create_fixed_collection(creator: &signer) {
    collection::create_fixed_collection(
        creator,
        string::utf8(b"Description"),
        1000, // 最大供应量
        string::utf8(b"Collection Name"),
        option::none(),
        string::utf8(b"https://example.com"),
    );
}

Minting NFTs

铸造NFT

move

fun mint_nft(creator: &signer, recipient: address) {
    let constructor_ref = token::create_named_token(
        creator,
        string::utf8(b"Collection Name"),
        string::utf8(b"Token description"),
        string::utf8(b"Token #1"),
        option::none(), // royalty
        string::utf8(b"https://example.com/token/1"),
    );

    // Transfer to recipient
    let transfer_ref = object::generate_transfer_ref(&constructor_ref);
    let token_obj = object::object_from_constructor_ref(&constructor_ref);
    object::transfer_with_ref(
        object::generate_linear_transfer_ref(&transfer_ref),
        recipient
    );
}

move

fun mint_nft(creator: &signer, recipient: address) {
    let constructor_ref = token::create_named_token(
        creator,
        string::utf8(b"Collection Name"),
        string::utf8(b"Token description"),
        string::utf8(b"Token #1"),
        option::none(), // 版税
        string::utf8(b"https://example.com/token/1"),
    );

    // 转移给接收者
    let transfer_ref = object::generate_transfer_ref(&constructor_ref);
    let token_obj = object::object_from_constructor_ref(&constructor_ref);
    object::transfer_with_ref(
        object::generate_linear_transfer_ref(&transfer_ref),
        recipient
    );
}

Token with Custom Data

带自定义数据的代币

move

struct MyTokenData has key {
    power: u64,
    rarity: String,
}

fun mint_with_data(creator: &signer) {
    let constructor_ref = token::create(
        creator,
        string::utf8(b"Collection"),
        string::utf8(b"Description"),
        string::utf8(b"Token Name"),
        option::none(),
        string::utf8(b"https://example.com/token"),
    );

    let token_signer = object::generate_signer(&constructor_ref);
    move_to(&token_signer, MyTokenData {
        power: 100,
        rarity: string::utf8(b"Legendary"),
    });
}

move

struct MyTokenData has key {
    power: u64,
    rarity: String,
}

fun mint_with_data(creator: &signer) {
    let constructor_ref = token::create(
        creator,
        string::utf8(b"Collection"),
        string::utf8(b"Description"),
        string::utf8(b"Token Name"),
        option::none(),
        string::utf8(b"https://example.com/token"),
    );

    let token_signer = object::generate_signer(&constructor_ref);
    move_to(&token_signer, MyTokenData {
        power: 100,
        rarity: string::utf8(b"Legendary"),
    });
}

Events

事件

move

use aptos_framework::event;

#[event]
struct TransferEvent has drop, store {
    from: address,
    to: address,
    amount: u64,
}

fun emit_transfer(from: address, to: address, amount: u64) {
    event::emit(TransferEvent { from, to, amount });
}

move

use aptos_framework::event;

#[event]
struct TransferEvent has drop, store {
    from: address,
    to: address,
    amount: u64,
}

fun emit_transfer(from: address, to: address, amount: u64) {
    event::emit(TransferEvent { from, to, amount });
}

Common Patterns

常见模式

Access Control

访问控制

move

const E_NOT_ADMIN: u64 = 1;

struct AdminConfig has key {
    admin: address,
}

fun only_admin(sender: &signer) acquires AdminConfig {
    let config = borrow_global<AdminConfig>(@my_addr);
    assert!(
        signer::address_of(sender) == config.admin,
        E_NOT_ADMIN
    );
}

move

const E_NOT_ADMIN: u64 = 1;

struct AdminConfig has key {
    admin: address,
}

fun only_admin(sender: &signer) acquires AdminConfig {
    let config = borrow_global<AdminConfig>(@my_addr);
    assert!(
        signer::address_of(sender) == config.admin,
        E_NOT_ADMIN
    );
}

Pausable

可暂停

move

const E_PAUSED: u64 = 2;

struct PauseState has key {
    paused: bool,
}

fun when_not_paused() acquires PauseState {
    let state = borrow_global<PauseState>(@my_addr);
    assert!(!state.paused, E_PAUSED);
}

move

const E_PAUSED: u64 = 2;

struct PauseState has key {
    paused: bool,
}

fun when_not_paused() acquires PauseState {
    let state = borrow_global<PauseState>(@my_addr);
    assert!(!state.paused, E_PAUSED);
}

Counter Pattern

计数器模式

move

struct Counter has key {
    value: u64,
}

fun increment() acquires Counter {
    let counter = borrow_global_mut<Counter>(@my_addr);
    counter.value = counter.value + 1;
}

move

struct Counter has key {
    value: u64,
}

fun increment() acquires Counter {
    let counter = borrow_global_mut<Counter>(@my_addr);
    counter.value = counter.value + 1;
}

Move.toml Configuration

Move.toml配置

toml

[package]
name = "my_project"
version = "1.0.0"
authors = []

[addresses]
my_addr = "_"

[dependencies.AptosFramework]
git = "https://github.com/movementlabsxyz/aptos-core.git"
rev = "m1"
subdir = "aptos-move/framework/aptos-framework"

[dependencies.AptosStdlib]
git = "https://github.com/movementlabsxyz/aptos-core.git"
rev = "m1"
subdir = "aptos-move/framework/aptos-stdlib"

[dependencies.AptosTokenObjects]
git = "https://github.com/movementlabsxyz/aptos-core.git"
rev = "m1"
subdir = "aptos-move/framework/aptos-token-objects"

toml

[package]
name = "my_project"
version = "1.0.0"
authors = []

[addresses]
my_addr = "_"

[dependencies.AptosFramework]
git = "https://github.com/movementlabsxyz/aptos-core.git"
rev = "m1"
subdir = "aptos-move/framework/aptos-framework"

[dependencies.AptosStdlib]
git = "https://github.com/movementlabsxyz/aptos-core.git"
rev = "m1"
subdir = "aptos-move/framework/aptos-stdlib"

[dependencies.AptosTokenObjects]
git = "https://github.com/movementlabsxyz/aptos-core.git"
rev = "m1"
subdir = "aptos-move/framework/aptos-token-objects"

Common Compiler Errors & Fixes

常见编译器错误与修复

Ability Errors

能力错误

Error: "type does not have the 'key' ability"
Fix: Add `has key` to struct definition

Error: "cannot copy value"
Fix: Add `has copy` or use reference `&`

Error: "cannot drop value"
Fix: Add `has drop` or explicitly handle the value

Error: "type does not have the 'key' ability"
Fix: 为结构体定义添加`has key`

Error: "cannot copy value"
Fix: 添加`has copy`或使用引用`&`

Error: "cannot drop value"
Fix: 添加`has drop`或显式处理该值

Borrow Errors

借用错误

Error: "cannot borrow global mutably"
Fix: Use `borrow_global_mut` and add `acquires` annotation

Error: "value still borrowed"
Fix: Ensure previous borrow ends before new borrow

Error: "cannot borrow global mutably"
Fix: 使用`borrow_global_mut`并添加`acquires`注解

Error: "value still borrowed"
Fix: 确保新借用前已结束之前的借用

Type Errors

类型错误

Error: "expected type X, found Y"
Fix: Check function signatures, ensure types match

Error: "missing acquires annotation"
Fix: Add `acquires ResourceName` to function signature

Error: "expected type X, found Y"
Fix: 检查函数签名，确保类型匹配

Error: "missing acquires annotation"
Fix: 为函数签名添加`acquires ResourceName`

Access Errors

访问错误

Error: "function is not public"
Fix: Add `public` or `public entry` to function

Error: "module not found"
Fix: Check Move.toml dependencies, ensure correct import path

Error: "function is not public"
Fix: 为函数添加`public`或`public entry`修饰符

Error: "module not found"
Fix: 检查Move.toml依赖，确保导入路径正确

CLI Installation

CLI安装

Install the Movement CLI via Homebrew (macOS/Linux):

bash

brew install movementlabsxyz/tap/movement
movement --version

Fallback: Aptos CLI v7.4.0 is supported if Movement CLI is unavailable:

bash

brew install aptos
aptos --version  # must be exactly 7.4.0

Use the

setup_cli

MCP tool to check installation status, get install instructions, or initialize an account.

通过Homebrew安装Movement CLI（macOS/Linux）：

bash

brew install movementlabsxyz/tap/movement
movement --version

备选方案：若无法安装Movement CLI，可使用Aptos CLI v7.4.0：

bash

brew install aptos
aptos --version  # 必须为7.4.0版本

使用

setup_cli

MCP工具检查安装状态、获取安装说明或初始化账户。

CLI Commands

CLI命令

Movement CLI is recommended. Aptos CLI v7.4.0 is supported as a fallback only.

bash

undefined

推荐使用Movement CLI，仅在无法使用时才以Aptos CLI v7.4.0作为备选。

bash

undefined

Compile

编译

movement move compile

Test

测试

movement move test

Publish

发布

movement move publish --named-addresses my_addr=default

Initialize account

初始化账户

movement init --network testnet

Check account

查看账户

movement account list

Run script

运行脚本

movement move run --function-id 'my_addr::module::function'

---

movement move run --function-id 'my_addr::module::function'

---

Best Practices

最佳实践

Use objects over legacy resources - More flexible, composable
Use FA over Coin - Modern standard with better features
Always check
exists
before
borrow_global
- Prevents abort
Store refs at creation time - Can't generate refs later
Use named objects for deterministic addresses - Easier to find
Emit events for important state changes - Better indexability
Use error codes with constants - Easier debugging
Test with
movement move test
- Always test before deploy

优先使用对象而非传统资源 - 更灵活、可组合
优先使用FA而非Coin - 功能更完善的现代标准
在
borrow_global
前始终检查
exists
- 避免终止执行
在创建时存储引用 - 后续无法生成引用
使用命名对象获取确定性地址 - 更易查找
重要状态变更时触发事件 - 提升可索引性
使用常量定义错误码 - 便于调试
使用
movement move test
测试 - 部署前务必测试