Revise the section smart contracts

Author: AlvinHon

docs/for_developers/smart_contracts/getting_started.md

@@ -9,13 +9,13 @@ tags:
 Before we dive deep into the structure of a contract and the SDK's semantics, we require some background information about the semantics enforced by ParallelChain Mainnet. The full capabilities of ParallelChain Mainnet continue to grow with active developers 
 and a growing community. Let's see how smart contracts are called and processed by a node in the form of transactions.
 
-First, the ParallelChain Client (`pchain_client`) will submit a transaction when making a smart contract call to the validating node using a serialization crate [pchain-types](https://github.com/parallelchain-io/pchain-types-rust). The node's RPC service and mempool will process the list of transactions and check for validity and correctness. 
+First, the ParallelChain Client (`pchain_client`) will submit a transaction when making a smart contract call to the validating node using a serialization crate [pchain-types](https://crates.io/crates/pchain-types). The node's RPC service and mempool will process the list of transactions and check for validity and correctness. 
 
-Transactions that fail the validation check may not be included in a block. The transactions are then packed in a block and sent to the execution engine in the node to execute the transactions. 
+[Transactions](../../fundamentals/transactions.md#how-transaction-works) that fail the validation check may not be included in a [block](../../fundamentals/blocks.md#how-block-works). The transactions are then packed in a block and sent to the execution engine in the node to execute the transactions. 
 
-The executor will call `wasmer` (Web Assembly Engine) which provides an isolated context to perform the execution. This enables the smart contract code to read the current state of the blockchain and interact with it. However, the execution results are temporarily stored and subject to further checks before the block may be committed or rolled back on error. 
+The executor will call [wasmer](https://crates.io/crates/wasmer) (Web Assembly Engine) which provides an isolated context to perform the execution. This enables the smart contract code to read the current state of the blockchain and interact with it. However, the execution results are temporarily stored and subject to further checks before the block may be committed or rolled back on error. 
 
-`wasmer` also computes the gas fees through a metering module, which is responsible for limiting the execution to the amount of gas paid. Each transaction returns a result in the form of receipts along with logs. The receipts (with or without log), transactions and block itself will contain its hash (or Merkle proof) and will be all included in the same block.
+`wasmer` also computes the [gas](../../fundamentals/gas.md) fees through a metering module, which is responsible for limiting the execution to the amount of gas paid. Each transaction returns a result in the form of receipts along with logs. The receipts (with or without log), transactions and block itself will contain its hash (or Merkle proof) and will be all included in the same block.
 
 
 ## Smart Contract Development Kit
@@ -36,20 +36,52 @@ For more information on Rust's crate system, see [Rust Book Chapter 7: Packages
 Please specify the dependency in `Cargo.toml` for using SDK by fetching from [crates.io](https://crates.io/) or repository in Github.
 
 === "Crates.io"
-    ```rust
+    ```toml
+    [lib]
+    crate-type = ["cdylib"]
+
     [dependencies]
     pchain-sdk = "0.4"
     ```
 
 === "Github"
-    ```rust
+    ```toml
+    [lib]
+    crate-type = ["cdylib"]
+
     [dependencies]
     pchain-sdk = { git = "https://github.com/parallelchain-io/pchain-sdk" }
     ```
 
-## Building the Contract with pchain_compile
+### Implement Smart Contract
+
+Let's start with a sample smart contract for illustration in this guide. The smart contract code is written in the file `lib.rs`.
+
+```rust
+use pchain_sdk::{call, contract, contract_methods};
+
+#[contract]
+struct MyContract { }
+
+#[contract_methods]
+impl MyContract {
+
+    #[call]
+    fn hello_from(name :String) -> u32 {
+        pchain_sdk::log(
+            "topic: Hello From".as_bytes(), 
+            format!("Hello, Contract. From: {}", name).as_bytes()
+        );
+        name.len() as u32
+    }
+}
+```
+
+The details about the macros (e.g. `contract`, `contract_methods`, `call`) used in the code can be found in later sections [Contract Methods](./advanced/contract_methods.md) and [Contract Storage](./advanced/contract_storage.md). Let's skip knowing them first, and continue reading about building and deploying the contract in following sections.
 
-**pchain_compile** is a CLI build tool for smart contract developers to build their source code to WASM binaries for deployment on 
+## Building The Contract With `pchain_compile`
+
+[pchain_compile](https://github.com/parallelchain-io/pchain-compile) is a CLI build tool for smart contract developers to build their source code to WASM binaries for deployment on 
 ParallelChain Mainnet. 
 
 The WASM binary generated from a generic cargo build process has the following disadvantages: 
@@ -63,10 +95,10 @@ The WASM binary generated from a generic cargo build process has the following d
 
   - Executing the build process in a docker environment with pre-defined toolchain versioning.
 
-  - Optimizing and compressing the size of the WASM binary with the help of `wasm-snip` and `wasm-opt` packages.
+  - Optimizing and compressing the size of the WASM binary with the help of [wasm-snip](https://crates.io/crates/wasm-snip) and [wasm-opt](https://crates.io/crates/wasm-opt) packages.
 
 
-### Downloading **pchain_compile**
+### Download **pchain_compile**
 
 `pchain_compile` supports Linux, macOS and Windows. Depending on the operating system, they can be downloaded from Assets of ParallelChain Lab's Git Hub [release page](https://github.com/parallelchain-io/pchain-compile/releases).
 
@@ -80,7 +112,7 @@ cargo install pchain_compile
 
 
 
-### Building WASM Binary
+### Build WASM Binary
 
 In order to build a `WASM` binary of the smart contract, run the following command:
 
@@ -103,7 +135,7 @@ A `.wasm` file will be generated in the current directory.
 
 ## Deploying a Smart Contract
 
-You can deploy the contract using the pchain_client command line tool. You should make sure to obtain your latest account nonce before submitting the transaction.
+You can deploy the contract using the pchain_client command line tool. You should make sure to [know your latest account nonce](../../for_users/pchain_client_cli/query.md#check-account-related-information) before submitting the transaction.
 
 === "Linux / macOS"
     ```bash
@@ -130,7 +162,7 @@ You can deploy the contract using the pchain_client command line tool. You shoul
 
 You can follow the instruction in [Create Transaction](../../for_users/pchain_client_cli/transaction.md) about submiting a transaction through `pchain-client`.
 
-## Checking Contract in State
+## Checking Contract In State
 
 To verify that the smart contract is deployed correctly, you can run the command `query` with the flag `contract`. It queries the state of the blockchain and saves the wasm code as `code.wasm` in the current directory.
 If you want to store the contract file in your preferred location, you need to provide the flag `destination` to specify the path with your preferred file extension:
@@ -146,20 +178,15 @@ If you want to store the contract file in your preferred location, you need to p
 
 ## Calling Contract
 
-Suppose you have already deployed a contract that contains a `call` method as follows:
+Suppose you have already deployed a contract that contains a `call` method named `hello_from` as mentioned in previous section [Implement Smart Contract](#implement-smart-contract):
 
+> 
 ```rust
-    #[call]
-    fn hello_from(name: String) -> u32 {
-        pchain_sdk::log(
-            "topic: Hello From".as_bytes(), 
-            format!("Hello, Contract. From: {}", name).as_bytes()
-        );
-        name.len() as u32
-    }
+#[call]
+fn hello_from(name :String) -> u32
 ```
 
-To invoke this contract in the blockchain by using `pchain_client`, you can prepare a JSON file that contains a list of arguments and matches with the `call` method. For example, this `call` method takes a string argument. Then, the content of the JSON file should be as follows:
+To invoke this contract by using `pchain_client`, you can prepare a JSON file that contains a list of arguments and matches with the `call` method. For example, this `call` method takes a string argument. Then, the content of the JSON file should be as follows:
 
 ```json
 {
@@ -169,9 +196,9 @@ To invoke this contract in the blockchain by using `pchain_client`, you can prep
 }
 ```
 
-This JSON file will be used in the subcommand `call` as mentioned in the subsequent sections on this page.
+This JSON file will be used in creating a transaction with [Call Command](../../fundamentals/transactions.md#account-commands).
 
-### Submitting Transaction with Call Command
+### Submit Transaction With Call Command
 
 To call a smart contract, submit a transaction with your account nonce and contract address using the `pchain_client`.
 
@@ -204,6 +231,10 @@ Here is the command to call a contract:
     --amount <AMOUNT_TO_CONTRACT>
     ```
 
+The command argument `method` is the name of the method with macro `#[call]` in the code. Take the contract in [Implement Smart Contract](#implement-smart-contract) as example, "hello_from" should be set as the value of the command argument `method`.
+
+The command argument `arguments` is the JSON file that contains the method arguments to the method being called in the contract. The way to create this JSON file is described in previous section [Calling Contract](#calling-contract).
+
 The gas limit required for the transaction depends on the complexity of the smart contract. For safety reasons, you can always set a higher gas limit. You can also test contract calls on testnet to reassure.
 
 You can follow the instruction in [Create Transaction](../../for_users/pchain_client_cli/transaction.md) about submiting a transaction through `pchain-client`.
@@ -221,7 +252,7 @@ To query the resulting receipt of the transaction,
 
 The commands stored in `transaction` and command receipts in `receipt` are following the same order. That means you can always find the corresponding transaction from a command receipt.
 
-### Parsing Call Result
+### Parse Call Result
 
 To parse the response from the contract method, represented in the field named `return value` , which is in `CallResult` format, you can use the `parse call-result` command in ParallelChain Client.
 

docs/for_developers/smart_contracts/installing_sdk.md

@@ -7,15 +7,15 @@ tags:
 
 ## Installing Rust
 
-To install the required toolkits, the standard method is by `rustup`, which maintains dependencies and is a version manager for `cargo` and `rustc` (the rust compiler). Detailed installation instructions can be found on the [official website](https://www.rust-lang.org/tools/install)
+To install the required toolkits, the standard method is by `rustup`, which maintains dependencies and is a version manager for `cargo` and `rustc` (the rust compiler). Detailed installation instructions can be found on the [official website](https://www.rust-lang.org/tools/install).
 
 ## Setting up a Development Environment
 
 A recommended Integrated Development Environment (IDE) is [VSCode](https://code.visualstudio.com/), which allows the addition of the plugin [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=matklad.rust-analyzer) to type-check all of your code on save. This feature allows you to locate errors in the code easily, and the error messages displayed in the IDE are the same as when executing the `cargo build` command. However, any other editor that is comfortable for you can be used. However, any other editor that is comfortable for you can be used.
 
 ## Installing Wasm Toolchain (Optional)
 
-ParallelChain Mainnet also provides a smart contract compilation tool called `pchain-compile` to compile your Rust smart contract into WASM bytecode. While not necessary, the Installation of Wasm Toolchain can help check if your code is compilable before using the time-consuming process in the use of `pchain-compile`.
+ParallelChain Mainnet also provides a smart contract compilation tool called [pchain-compile](getting_started.md#building-the-contract-with-pchain_compile) to compile your Rust smart contract into WASM bytecode. While not necessary, the Installation of Wasm Toolchain can help check if your code is compilable before using the time-consuming process in the use of `pchain-compile`.
 
 The `wasm32-unknown-unknown` toolchain is required for smart contracts to compile as WASM. To add the wasm toolchain in Rust, type the command below:
 ```bash