update

Author: chenzhitong

docs/n3/develop/tool/sdk/rpc.md

@@ -27,6 +27,7 @@ RpcClient client = new RpcClient(new Uri("http://localhost:20332"), null, null,
 ## Blockchain data
 
 ### GetBestBlockHashAsync
+
 Gets the hash of the highest block in the blockchain:
 
 ```cs
@@ -36,6 +37,7 @@ UInt256 hash256 = UInt256.Parse(hexString);
 ```
 
 ### GetBlockAsync
+
 Gets the detailed block information by the block hash or block index.
 
 ```cs

docs/n3/develop/write/difference.md

@@ -38,6 +38,7 @@ using Neo.SmartContract.Framework;
 using Neo.SmartContract.Framework.Services.Neo;
 using System;
 ```
+
 Neo N3：
 
 ```cs
@@ -114,6 +115,7 @@ Neo N3 adds a new security method. You can execute the contract in a read-only m
 Neo N3 introduces a large number of native contracts, moving massive interoperable services from Neo Legacy to native contracts. The major changes are as follows.
 
 - Upgraded the Blockchain class to a Ledger native contract, e.g. `Blockchain.GetBlock()` changed to `Ledger.GetBlock()`.
+
 - Added the ContractManagement native contract to query contracts and manage their updating and destruction.
 
 - Moved the contract part of the Blockchain class to the ContractManagement native contract, e.g. `Blockchain.GetContract()` changed to `ContractManagement .GetContract()`.
@@ -133,8 +135,8 @@ Neo N3 introduces a large number of native contracts, moving massive interoperab
 - The Transaction class has been extensively updated to fit the data structure of Neo N3 transactions.
 - Added a new Crypto class and moved some of the methods provided by the SmartContract class to this class.
 - Moved a number of classes:
-  -  Account
-  -  Asset
+  - Account
+  - Asset
   - Header
   - InvocationTransaction
   - TransactionAttribute

docs/n3/develop/write/nep11.md

@@ -130,7 +130,7 @@ By now we have completed a simple NFT contract.
 
 The base class `Nep11Token` also provides the following methods and events:
 
-#### NEP-11 methods
+### NEP-11 methods
 
 | Name        | Parameters                                     | Returns          | Description                                                  |
 | ----------- | ---------------------------------------------- | ---------------- | ------------------------------------------------------------ |
@@ -144,13 +144,13 @@ The base class `Nep11Token` also provides the following methods and events:
 | tokensOf    | Hash160（owner）                               | InteropInterface | Returns all of the token ids owned by the specified address  |
 | transfer    | Hash160（to） ByteArray（tokenId） Any（data） | Boolean          | It transfers an amount of NFT with  TokenId. This method requires the signature of NFT owner. |
 
-#### Events
+### Events
 
 | Name     | Parameters                                                   | Returns         | Description                                                  |
 | -------- | ------------------------------------------------------------ | --------------- | ------------------------------------------------------------ |
 | transfer | Hash160（from） Hash160（to） Integer（amount） ByteArray（tokenId） | Transfer  event | When the `from` address is set to `null` tokens are created; When the `to` address set to `null`tokens are burned. |
 
-#### Compatibility check
+### Compatibility check
 
 Compatibility checks will be activated for any contract that includes the `[SupportedStandards("NEP-17")]` or `[SupportedStandards("NEP-11")]` attribute.
 The Compatibility Check reviews method names, parameters, return values, events, and similar elements to ensure they comply with the standard, and alerts about any failures in the check.

docs/n3/exchange/client.md

@@ -3,11 +3,11 @@ sidebar_label: 'Using Neo-CLI'
 sidebar_position: 2
 ---
 
-## Using Neo-CLI
+# Using Neo-CLI
 
 The Neo-CLI client works as a node in the P2P network and meanwhile a cross-platform wallet handling various assets transactions. 
 
-### Neo-CLI Security Policies
+## Neo-CLI Security Policies
 
 :::caution
 
@@ -23,7 +23,7 @@ Neo-CLI does not provide the function to remotely switching on/off the wallet, a
 | P2P                | 10333   | 20333   |
 | websocket          | 10334   | 20334   |
 
-### About Neo-CLI
+## About Neo-CLI
 
 Neo-CLI is a command-line client (wallet) for developers. Developers have two ways to interact with it： 
 
@@ -59,7 +59,7 @@ Neo-CLI provides the following features：
 - Provides transaction information of NEP-17 assets.
 
 
-### Creating a Wallet
+## Creating a Wallet
 
 The exchange needs to create an online wallet to manage the deposit addresses of users. A wallet is used to store the information of the accounts (both public keys and private keys) and the contracts. It is the most important proof that the user holds. Users must keep the wallet files and the wallet passwords secure. They must not lose or disclose these data. Exchanges do not have to create a wallet for every address. An online wallet usually keeps all deposit addresses of users. A cold wallet (offline wallet) is another storage option which provides better security.
 
@@ -76,7 +76,7 @@ To create a wallet, do the following：
 
 2. Set a password for the wallet. 
 
-### Generating Deposit Addresses
+## Generating Deposit Addresses
 
 A wallet can store multiple addresses. The exchange needs to generate a deposit address for each user. 
 

docs/n3/exchange/deploynode.md

@@ -38,6 +38,7 @@ install RpcNep17Tracker
 
 - The RpcServer plug-in must be installed before you can use the RpcNep17Tracker plug-in.
 - You must install the plugins ApplicationLogs and RpcNep17Tracker before synchronizing the Neo client, otherwise the log in the blocks synchronized before will be lost.
+
 :::
 
 ## Modifying configuration files

docs/n3/exchange/gas.md

@@ -18,8 +18,10 @@ In Neo N3 every time a NEO transfer transaction occurs in the address, GASs gene
 Claimed *GAS = f(neo_amount, Δt_const)*
 
 Δt_const = t_end - t_start
--  t_end = the current time that Neo is transferred into or out of the address. 
--  t_start = the last time that Neo was transferred into or out of the address. 
+
+- t_end = the current time that Neo is transferred into or out of the address. 
+
+- t_start = the last time that Neo was transferred into or out of the address. 
 
 Δt_const is fixed, thus the claimed Gas is of a fixed amount too. And this amount depends on the amount of Neo held by the user and the duration between the moments that the user transferred this amount of Neo into and out of his or her address. 
 

docs/n3/exchange/transaction.md

@@ -422,11 +422,11 @@ The exchange can choose one of the following way to send assets to users:
 
 ### Neo-CLI Command: send
 
-##### Syntax
+#### Syntax
 
 `send <id|alias> <address> <amount>|all [from=null] [signerAccounts=null]`
 
-##### Parameters
+#### Parameters
 
 - `id|alias`: asset ID or asset abbreviations, e.g. neo, gas
 - `address`: address to transfer assets to
@@ -437,7 +437,7 @@ The exchange can choose one of the following way to send assets to users:
 
 This command verifies the wallet password. 
 
-##### Example
+#### Example
 
 Transfer 100 Neo to the address NYxb4fSZVKAz8YsgaPK2WkT3KcAE9b3Vag: 
 

docs/n3/foundation/Transactions.md

@@ -103,10 +103,10 @@ In Neo all variable-length integer types except IP addresses and port numbers ar
 | `systemFee`       | -                                                            |
 | `networkFee`      | -                                                            |
 | `validUntilBlock` | -                                                            |
-| `signers`         | Need to serializes `WriteVarInt(length) `first and then other elements of the array |
+| `signers`         | Need to serializes `WriteVarInt(length)` first and then other elements of the array |
 | `attributes`      | Need to serializes `WriteVarInt(length)` first and then other elements of the array |
-| `script`          | Need to serializes `WriteVarInt(length) `first and then the byte array |
-| `witnesses`       | Need to serializes `WriteVarInt(length) `first and then other elements of the array |
+| `script`          | Need to serializes `WriteVarInt(length)` first and then the byte array |
+| `witnesses`       | Need to serializes `WriteVarInt(length)` first and then other elements of the array |
 
 
 :::note

docs/n3/foundation/Wallets.md

@@ -78,11 +78,11 @@ The address script in Neo N3 has changed not using the Opcode.CheckSig and OpCod
 
 ![Account Address](images/wallets/account_address_script_checksign.png)
 
-2. Calculate script hash of the contract (20 bytes, make once SHA256 and RIPEMD160 of the script). 
+1. Calculate script hash of the contract (20 bytes, make once SHA256 and RIPEMD160 of the script). 
 
-3. Add the version prefix in the hash (Currently, the Neo protocol version is 53 and the corresponding byte is  `0x35`).
+2. Add the version prefix in the hash (Currently, the Neo protocol version is 53 and the corresponding byte is  `0x35`).
 
-4. Make Base58Check encoding for the above byte data.
+3. Make Base58Check encoding for the above byte data.
 
 Example：
 

docs/n3/glossary.md

@@ -4,27 +4,27 @@ sidebar_label: 'Glossary'
 
 # Glossary
 
-#### Block
+## Block
 
 A block in a Blockchain contains a number of transaction records.  Blocks are paired up with the previous block according to the timestamp and the cryptographic hash of the previous block contained in each block header, thereby creating a chain of blocks, or a blockchain.
 
-#### Wallet
+## Wallet
 
 A wallet is a cryptographic public/private key pair which is used to sign and authenticate database transactions that occur on the Neo network.
 
-#### Account (Address)
+## Account (Address)
 
 Similar to your bank account, a blockchain account is used to transfer or receive assets in a transaction. The address is generated by the script hash through some operations, and can be converted back to the script hash. In Neo Legacy, the address starts with A, and in Neo N3, the address starts with N.
 
-#### Private Key/Public Key
+## Private Key/Public Key
 
 The private key is a 256-bit random number that is kept by users themselves, without disclosing to others. It is a proof of the user's right to use the account and ownership of assets in the account. Each private key has a public key paired with it.
 
-#### Transaction
+## Transaction
 
 A Neo transaction is a signed data package with an instruction for the network, for example a user indicating that he wants to transfer assets to another address. Each Neo block in the blockchain ledger contains one or more transactions, making each block a transaction batch. 
 
-#### Script
+## Script
 
 A script is a piece of code that consists of opcodes and operands. Each account is a contract with a script. A standard account script is composed of the public key and the OpCode that verifies the signature. The format is as follows
 
@@ -33,39 +33,39 @@ PUSHDATA1 03ac765294075da6f7927c96bfe3d3f64ae3680c5eb50f82f55170a9f1bea59dad
 SYSCALL Neo.Crypto.VerifyWithECDsaSecp256r1
 ```
 
-#### Script Hash
+## Script Hash
 
 The script hash is generated from the smart contract script with the RIPEMD-160 algorithm. Each script has a unique script hash. Any change made in the script of the contract will cause the script hash to change. The script hash length is 20 bytes (160 bits). The script hash is generated unidirectionally by the script, and cannot be reversed to the script. The script hash and address can be converted to each other.
 
-#### Opcode
+## Opcode
 
 Opcodes are similar to instructions in assembly language. For all OpCode, refer to [OpCode source](https://github.com/neo-project/neo/blob/master/src/Neo.VM/OpCode.cs).
 
-#### Cryptographic private key
+## Cryptographic private key
 
 Cryptographic private key refers to the encryption of the private key through the wallet password, which is more secure than the plaintext private key. In this way, you can write the cryptographic private key on paper and keep the password in your mind.
 
-#### Smart Contract
+## Smart Contract
 
 From the blockchain perspective, a smart contract is a set of promises, specified in digital form, including protocols within which the parties perform on these promises.
 
-#### NEP-17
+## NEP-17
 
 The NEP-17 proposal outlines a token standard for the Neo blockchain that will provide systems with a generalized interaction mechanism for tokenized smart contracts.
 
-#### SysCall
+## SysCall
 
 The system call is a special operation code, through which you can call the interoperable service layer interface. By calling the interoperable service layer interface, NeoVM can access data such as block, transaction , contract, and asset information that are required for running smart contracts. For more information refer to the files in  [Neo smart contract module](https://github.com/neo-project/neo/tree/master/src/Neo/SmartContract) starting with  `ApplicationEngine.` , such as  `ApplicationEngine.Contract.cs`, `ApplicationEngine.Blockchain.cs`.
 
-#### Dynamic Call
+## Dynamic Call
 
 A special system call that invokes another contract within a contract. It can be wrote as `Contract.Call(scriptHash, method, params)`. For more information refer to [Invoking Smart Contracts](develop/deploy/invoke).
 
-#### Storage
+## Storage
 
 Each smart contract deployed on the Neo blockchain has a private storage area for storing application data. When creating a smart contract or transaction to use this contract, the contract code needs to read and write its storage. Each contract can declare a storage area. For more information refer to [Storage](reference/scapi/framework/services/Storage.md).
 
-#### NEF
+## NEF
 
 NEF is short for Neo Executable Format. The smart contract compiler compiles the source code and eventually generate NEF files and Manifest files (see below).