Web 开发工具包：现代化 Web 应用程序开发工具包旨在帮助开发人员更快地构建现代化的 Web 应用程序

# Move CLI The Move command-line interface (Move CLI) is a tool that provides an easy way to interact with Move, to experiment with writing and running Move code, and to experiment with developing new tools useful for Move development. To reflect this, the Move CLI commands are grouped into three main subcommands: * **package commands**: are commands to create, compile, and test Move packages, as well as perform other operations related to packages. These do not rely on a Move Adapter implementation nor an implementation of storage. * **sandbox commands**: are commands that allow you to write Move modules and scripts, write and run scripts and tests, and view the resulting state of execution in a local sandboxed environment. * **experimental commands**: are experimental commands that are currently in development. Every Move CLI command, with the exception of `package create`, is expected to be run within the context of a [Move package](https://move-language.github.io/move/packages.html). ## Installation ```shell $ cargo install --path move/language/tools/move-cli ``` or ```shell $ cargo install --git https://github.com/move-language/move move-cli --branch main ``` This will install the `move` binary in your Cargo binary directory. On macOS and Linux this is usually `~/.cargo/bin`. You'll want to make sure this location is in your `PATH` environment variable. Now you should be able to run the Move CLI: ```shell $ move Move 0.1.0 CLI frontend for Move compiler and VM USAGE: move [FLAGS] [OPTIONS] <SUBCOMMAND> ... ``` We'll go through the most common Move CLI commands and flags here, however you can find the complete list of commands available by calling `move --help`. Additionally, the complete list of flags and options available for each Move CLI command can be found by passing the `--help` flag to it, i.e., `move <command> --help`. ## Package Commands Package commands provide wrappers with sane defaults around other commands that are provided either by various Move tools, compiler, or prover. The `move new` command will create a new empty Move package: ```shell $ move new <package_name> # Create a Move package <package_name> under the current dir $ move new <package_name> -p <path> # Create a Move package <package_name> under path <path> ``` From within a package's root directory, you can build the modules and/or scripts that you have written in the package with: ```shell $ move build # Builds the Move package you are currently in $ move build -p <path> # Builds the Move package at <path> ``` The compiled artifacts will by default be stored in the `build` directory. You can change where the build artifacts are saved by passing the optional `--build-dir` flag: ```shell $ move build --build-dir <path_to_save_to> # Build current Move package and save artifacts under <path_to_save_to> ``` You can verify the specifications in a Move package using the Move Prover with the `prove` command: ```shell $ move prove # Verify the specifications in the current package $ move prove -p <path> # Verify the specifications in the package at <path> ``` In order to run the Move Prover [additional tools need to be installed](https://github.com/move-language/move/blob/main/language/move-prover/doc/user/install.md). Information on the Move Prover and its configuration options can be found [here](https://github.com/move-language/move/blob/main/language/move-prover/doc/user/prover-guide.md) and [here](https://github.com/move-language/move/blob/main/language/move-prover/doc/user/spec-lang.md). You can also run unit tests in a package using the `test` command ```shell $ move test # Run Move unit tests in the current package $ move test -p <path> # Run Move unit tests in the package at <path> ``` ## Sandbox Commands The sandbox allows you to experiment with writing and running Move code without validators, a blockchain, or transactions. Persistent data is stored on-disk in a directory structure that mimics the Move memory model ### Project structure Each sandbox command is run in the context of a Move package. So let's create a Move package that we'll use for the code in this README and `cd` into it: ```shell $ move new readme $ cd readme ``` ### Compiling and running scripts Let's first start out with a simple script that prints its [`signer`](https://move-language.github.io/move/signer.html). Create a file named `sources/debug_script.move` and type the following into it: ```rust // sources/debug_script.move script { use std::debug; fun debug_script(account: signer) { debug::print(&account) } } ``` Before we can run this however, we need to import the Move standard library nursery in order to have access to the `Debug` module and `Std` [named address](https://move-language.github.io/move/address.html#named-addresses). You can specify dependencies locally, or using a Git URL. Here, we will specify it using Git, so add the following to the `Move.toml` file in the `readme` directory: ```toml [addresses] std = "0x1" # Specify and assign 0x1 to the named address "std" [dependencies] MoveNursery = { git = "https://github.com/move-language/move.git", subdir = "language/move-stdlib/nursery", rev = "main" } # ^ ^ ^ ^ # Git dependency Git clone URL Subdir under git repo (optional) Git revision to use ``` Now let's try running the script -- the very first time may take some time since the package command will clone the repository at the given URL, but subsequent calls should be fast: ```shell $ move sandbox run sources/debug_script.move --signers 0xf [debug] (&) { 0000000000000000000000000000000f } ``` The `--signers 0xf` argument indicates which account address(es) have signed off on the script. Omitting `--signers` or passing multiple signers to this single-`signer` script will trigger a type error. ### Passing arguments The CLI supports passing non-`signer` arguments to `move sandbox run` via `--args`. The following argument types are supported: * `bool` literals (`true`, `false`) * `u64` literals (e.g., `10`, `58`) * `address` literals (e.g., `0x12`, `0x0000000000000000000000000000000f`) * hexadecimal strings (e.g., `'x"0012"'` will parse as the `vector<u8>` value `[00, 12]`) * ASCII strings (e.g., `'b"hi"'` will parse as the `vector<u8>` value `[68, 69]`) ### Publishing new modules When executing a transaction script you'll often want to call into different Move modules, like in the example above with the `Debug` module. New modules can be added to the `sources` directory in the package where the CLI is being invoked. You can also add dependencies on other packages to have access to the modules that they define (just like we did with the `Debug` module above). The `move sandbox run` command will compile and publish each module in the package, and in each of the package's transitive dependencies, before running the given script. Try saving this code in `sources/Test.move`: ```rust // sources/Test.move module 0x2::Test { use std::signer; struct Resource has key { i: u64 } public fun publish(account: &signer) { move_to(account, Resource { i: 10 }) } public fun write(account: &signer, i: u64) acquires Resource { borrow_global_mut<Resource>(signer::address_of(account)).i = i; } public fun unpublish(account: &signer) acquires Resource { let Resource { i: _ } = move_from(signer::address_of(account)); } } ``` Now, try ```shell $ move build ``` This will cause the CLI to compile and typecheck the modules under `sources`, but it won't publish the module bytecode under `storage`. You can compile and publish the module by running the `move sandbox publish` command (here we pass the `-v` or verbose flag to get a better understanding of what's happening): ```shell $ move sandbox publish -v Found 1 modules Publishing a new module 000000000000000000000000000