Merge pull request #1 from LwwL-123/main

first add

.gitignore

@@ -8,3 +8,5 @@ Cargo.lock
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
+
+/.idea

Cargo.toml

@@ -0,0 +1,10 @@
+[workspace]
+members = [
+    'node',
+    'pallets/template',
+    'pallets/resource-order',
+    'runtime',
+    'primitives'
+]
+[profile.release]
+panic = 'unwind'

Dockerfile

@@ -0,0 +1,14 @@
+## ImageBuild
+FROM debian:11
+
+RUN apt-get update && \
+  apt-get install -y openssl && \
+  rm /var/lib/apt/ -rf && \
+  rm /var/cache/apt/ -rf
+
+WORKDIR /opt/ttchain/
+
+#COPY ./docker/run.sh /opt/run.sh
+ADD ./target/release/node-template /opt/ttchain/node-template
+
+#CMD /opt/run.sh

README.md

@@ -1,2 +1,215 @@
-# hamster
-Blockchain Implementation of hamster share
+# Substrate Node Template
+
+[![Try on playground](https://img.shields.io/badge/Playground-Node_Template-brightgreen?logo=Parity%20Substrate)](https://playground.substrate.dev/?deploy=node-template)
+
+A fresh FRAME-based [Substrate](https://www.substrate.io/) node, ready for hacking :rocket:
+
+## Getting Started
+
+Follow the steps below to get started with the Node Template, or get it up and running right from your browser
+in just a few clicks Using [Playground](https://playground.substrate.dev/) :hammer_and_wrench:
+
+### Using Nix
+
+Install [nix](https://nixos.org/) and optionally [direnv](https://github.com/direnv/direnv) and [lorri](https://github.com/target/lorri) for a fully plug
+and play experience for setting up the development environment. To get all the correct dependencies activate direnv `direnv allow` and lorri `lorri shell`.
+
+### Rust Setup
+
+First, complete the [basic Rust setup instructions](./docs/rust-setup.md).
+
+### Run
+
+Use Rust's native `cargo` command to build and launch the template node:
+
+```sh
+cargo run --release -- --dev --tmp
+```
+
+### Build
+
+The `cargo run` command will perform an initial build. Use the following command to build the node
+without launching it:
+
+```sh
+cargo build --release
+```
+
+### Embedded Docs
+
+Once the project has been built, the following command can be used to explore all parameters and
+subcommands:
+
+```sh
+./target/release/node-template -h
+```
+
+## Run
+
+The provided `cargo run` command will launch a temporary node and its state will be discarded after
+you terminate the process. After the project has been built, there are other ways to launch the
+node.
+
+### Single-Node Development Chain
+
+This command will start the single-node development chain with persistent state:
+
+```bash
+./target/release/node-template --dev
+```
+
+Purge the development chain's state:
+
+```bash
+./target/release/node-template purge-chain --dev
+```
+
+Start the development chain with detailed logging:
+
+```bash
+RUST_LOG=debug RUST_BACKTRACE=1 ./target/release/node-template -lruntime=debug --dev
+```
+
+### Connect with Polkadot-JS Apps Front-end
+
+Once the node template is running locally, you can connect it with **Polkadot-JS Apps** front-end
+to interact with your chain. [Click here](https://polkadot.js.org/apps/#/explorer?rpc=ws://localhost:9944) connecting the Apps to your local node template.
+
+### Multi-Node Local Testnet
+
+If you want to see the multi-node consensus algorithm in action, refer to
+[our Start a Private Network tutorial](https://substrate.dev/docs/en/tutorials/start-a-private-network/).
+
+## Template Structure
+
+A Substrate project such as this consists of a number of components that are spread across a few
+directories.
+
+### Node
+
+A blockchain node is an application that allows users to participate in a blockchain network.
+Substrate-based blockchain nodes expose a number of capabilities:
+
+-   Networking: Substrate nodes use the [`libp2p`](https://libp2p.io/) networking stack to allow the
+    nodes in the network to communicate with one another.
+-   Consensus: Blockchains must have a way to come to
+    [consensus](https://substrate.dev/docs/en/knowledgebase/advanced/consensus) on the state of the
+    network. Substrate makes it possible to supply custom consensus engines and also ships with
+    several consensus mechanisms that have been built on top of
+    [Web3 Foundation research](https://research.web3.foundation/en/latest/polkadot/NPoS/index.html).
+-   RPC Server: A remote procedure call (RPC) server is used to interact with Substrate nodes.
+
+There are several files in the `node` directory - take special note of the following:
+
+-   [`chain_spec.rs`](./node/src/chain_spec.rs): A
+    [chain specification](https://substrate.dev/docs/en/knowledgebase/integrate/chain-spec) is a
+    source code file that defines a Substrate chain's initial (genesis) state. Chain specifications
+    are useful for development and testing, and critical when architecting the launch of a
+    production chain. Take note of the `development_config` and `testnet_genesis` functions, which
+    are used to define the genesis state for the local development chain configuration. These
+    functions identify some
+    [well-known accounts](https://substrate.dev/docs/en/knowledgebase/integrate/subkey#well-known-keys)
+    and use them to configure the blockchain's initial state.
+-   [`service.rs`](./node/src/service.rs): This file defines the node implementation. Take note of
+    the libraries that this file imports and the names of the functions it invokes. In particular,
+    there are references to consensus-related topics, such as the
+    [longest chain rule](https://substrate.dev/docs/en/knowledgebase/advanced/consensus#longest-chain-rule),
+    the [Aura](https://substrate.dev/docs/en/knowledgebase/advanced/consensus#aura) block authoring
+    mechanism and the
+    [GRANDPA](https://substrate.dev/docs/en/knowledgebase/advanced/consensus#grandpa) finality
+    gadget.
+
+After the node has been [built](#build), refer to the embedded documentation to learn more about the
+capabilities and configuration parameters that it exposes:
+
+```shell
+./target/release/node-template --help
+```
+
+### Runtime
+
+In Substrate, the terms
+"[runtime](https://substrate.dev/docs/en/knowledgebase/getting-started/glossary#runtime)" and
+"[state transition function](https://substrate.dev/docs/en/knowledgebase/getting-started/glossary#stf-state-transition-function)"
+are analogous - they refer to the core logic of the blockchain that is responsible for validating
+blocks and executing the state changes they define. The Substrate project in this repository uses
+the [FRAME](https://substrate.dev/docs/en/knowledgebase/runtime/frame) framework to construct a
+blockchain runtime. FRAME allows runtime developers to declare domain-specific logic in modules
+called "pallets". At the heart of FRAME is a helpful
+[macro language](https://substrate.dev/docs/en/knowledgebase/runtime/macros) that makes it easy to
+create pallets and flexibly compose them to create blockchains that can address
+[a variety of needs](https://www.substrate.io/substrate-users/).
+
+Review the [FRAME runtime implementation](./runtime/src/lib.rs) included in this template and note
+the following:
+
+-   This file configures several pallets to include in the runtime. Each pallet configuration is
+    defined by a code block that begins with `impl $PALLET_NAME::Config for Runtime`.
+-   The pallets are composed into a single runtime by way of the
+    [`construct_runtime!`](https://crates.parity.io/frame_support/macro.construct_runtime.html)
+    macro, which is part of the core
+    [FRAME Support](https://substrate.dev/docs/en/knowledgebase/runtime/frame#support-library)
+    library.
+
+### Pallets
+
+The runtime in this project is constructed Using many FRAME pallets that ship with the
+[core Substrate repository](https://github.com/paritytech/substrate/tree/master/frame) and a
+template pallet that is [defined in the `pallets`](./pallets/template/src/lib.rs) directory.
+
+A FRAME pallet is compromised of a number of blockchain primitives:
+
+-   Storage: FRAME defines a rich set of powerful
+    [storage abstractions](https://substrate.dev/docs/en/knowledgebase/runtime/storage) that makes
+    it easy to use Substrate's efficient key-value database to manage the evolving state of a
+    blockchain.
+-   Dispatchables: FRAME pallets define special types of functions that can be invoked (dispatched)
+    from outside of the runtime in order to update its state.
+-   Events: Substrate uses [events](https://substrate.dev/docs/en/knowledgebase/runtime/events) to
+    notify users of important changes in the runtime.
+-   Errors: When a dispatchable fails, it returns an error.
+-   Config: The `Config` configuration interface is used to define the types and parameters upon
+    which a FRAME pallet depends.
+
+### Run in Docker
+
+First, install [Docker](https://docs.docker.com/get-docker/) and
+[Docker Compose](https://docs.docker.com/compose/install/).
+
+Then run the following command to start a single node development chain.
+
+```bash
+./scripts/docker_run.sh
+```
+
+This command will firstly compile your code, and then start a local development network. You can
+also replace the default command (`cargo build --release && ./target/release/node-template --dev --ws-external`)
+by appending your own. A few useful ones are as follow.
+
+```bash
+# Run Substrate node without re-compiling
+./scripts/docker_run.sh ./target/release/node-template --dev --ws-external
+
+# Purge the local dev chain
+./scripts/docker_run.sh ./target/release/node-template purge-chain --dev
+
+# Check whether the code is compilable
+./scripts/docker_run.sh cargo check
+```
+
+### CodeStructure
+├── docs                                docs
+├── node                                substrate node module package
+│   └── src                       substrate nodesource package
+├── pallets                             substrate pallets package
+│   ├── provider                  computing provides contract packages
+│   │   └── src             Computing provides contract implementation source code
+│   ├── resource-order            resource order contract package
+│   │   └── src             resource order contract implementation template
+│   └── template                  substrate pallet template
+│       └── src                   substrate pallet template hello-world case  
+├── primitives                          public object package
+│   └── src                       public object source package
+├── runtime                             substrate runtime package
+│   └── src                       substrate runtime implementation package
+└── scripts                             substrate run tool script directory           

dockerize.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+REGISTRY="registry.onecloud.newtouch.com"
+PACKAGE_VERSION=1.0.0
+IMAGEID="$REGISTRY/ttc/ttchain:$PACKAGE_VERSION"
+echo "Building $REGISTRY/ttc/ttchain:$PACKAGE_VERSION ..."
+docker run -it --rm -v $PWD:/app -w /app -v $PWD/.cargo/config:/root/.cargo/config paritytech/ci-linux:363245ca-20210706 cargo build --release
+docker build -t $IMAGEID .

docs/rust-setup.md

@@ -0,0 +1,81 @@
+---
+title: Installation
+---
+
+This page will guide you through the steps needed to prepare a computer for development with the
+Substrate Node Template. Since Substrate is built with
+[the Rust programming language](https://www.rust-lang.org/), the first thing you will need to do is
+prepare the computer for Rust development - these steps will vary based on the computer's operating
+system. Once Rust is configured, you will use its toolchains to interact with Rust projects; the
+commands for Rust's toolchains will be the same for all supported, Unix-based operating systems.
+
+## Unix-Based Operating Systems
+
+Substrate development is easiest on Unix-based operating systems like macOS or Linux. The examples
+in the Substrate [Tutorials](https://substrate.dev/tutorials) and [Recipes](https://substrate.dev/recipes/)
+use Unix-style terminals to demonstrate how to interact with Substrate from the command line.
+
+### macOS
+
+Open the Terminal application and execute the following commands:
+
+```bash
+# Install Homebrew if necessary https://brew.sh/
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
+
+# Make sure Homebrew is up-to-date, install openssl and cmake
+brew update
+brew install openssl cmake
+```
+
+### Ubuntu/Debian
+
+Use a terminal shell to execute the following commands:
+
+```bash
+sudo apt update
+# May prompt for location information
+sudo apt install -y cmake pkg-config libssl-dev git build-essential clang libclang-dev curl
+```
+
+### Arch Linux
+
+Run these commands from a terminal:
+
+```bash
+pacman -Syu --needed --noconfirm cmake gcc openssl-1.0 pkgconf git clang
+export OPENSSL_LIB_DIR="/usr/lib/openssl-1.0"
+export OPENSSL_INCLUDE_DIR="/usr/include/openssl-1.0"
+```
+
+### Fedora/RHEL/CentOS
+
+Use a terminal to run the following commands:
+
+```bash
+# Update
+sudo dnf update
+# Install packages
+sudo dnf install cmake pkgconfig rocksdb rocksdb-devel llvm git libcurl libcurl-devel curl-devel clang
+```
+
+## Rust Developer Environment
+
+This project uses [`rustup`](https://rustup.rs/) to help manage the Rust toolchain. First install
+and configure `rustup`:
+
+```bash
+# Install
+curl https://sh.rustup.rs -sSf | sh
+# Configure
+source ~/.cargo/env
+```
+
+Finally, configure the Rust toolchain:
+
+```bash
+rustup default stable
+rustup update nightly
+rustup update stable
+rustup target add wasm32-unknown-unknown --toolchain nightly
+```