Add vesting pallet tests

vesting-palletwith-substrate/.devcontainer/devcontainer.json

@@ -0,0 +1,25 @@
+{
+  "name": "Substrate Node template",
+  "context": "..",
+  "settings": {
+    "terminal.integrated.shell.linux": "/bin/bash",
+    "lldb.executable": "/usr/bin/lldb"
+  },
+  "extensions": [
+    "rust-lang.rust",
+    "bungcip.better-toml",
+    "vadimcn.vscode-lldb"
+  ],
+  "forwardPorts": [
+    3000,
+    9944
+  ],
+  "onCreateCommand": ["cargo build", "cargo check"],
+  "postStartCommand": "./target/debug/node-template --dev --ws-external",
+  "menuActions": [
+    {"id": "polkadotjs",
+     "label": "Open PolkadotJS Apps",
+     "type": "external-preview",
+     "args": ["https://polkadot.js.org/apps/?rpc=wss%3A%2F%2F/$HOST/wss"]}
+  ]
+}

vesting-palletwith-substrate/.editorconfig

@@ -0,0 +1,16 @@
+root = true
+
+[*]
+indent_style=space
+indent_size=2
+tab_width=2
+end_of_line=lf
+charset=utf-8
+trim_trailing_whitespace=true
+insert_final_newline = true
+
+[*.{rs,toml}]
+indent_style=tab
+indent_size=tab
+tab_width=4
+max_line_length=100

vesting-palletwith-substrate/.envrc

@@ -0,0 +1,7 @@
+# If lorri exists, better try it first.
+if has lorri; then
+    eval "$(lorri direnv)"
+else
+    # Otherwise fall back to pure nix
+    use nix
+fi

vesting-palletwith-substrate/.vscode/tasks.json

@@ -0,0 +1,37 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Run ",
+            "type": "shell",
+            "command": "cargo",
+            "args": ["run", "--release", "--", "--dev"],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "presentation": {
+                "reveal": "always",
+                "panel": "new"
+            },
+            "problemMatcher": [
+            {
+                "owner": "rust",
+                "fileLocation": ["relative", "${workspaceRoot}"],
+                "pattern": {
+                "regexp": "^(.*):(\\d+):(\\d+):\\s+(\\d+):(\\d+)\\s+(warning|error):\\s+(.*)$",
+                "file": 1,
+                "line": 2,
+                "column": 3,
+                "endLine": 4,
+                "endColumn": 5,
+                "severity": 6,
+                "message": 7
+                }
+            }
+            ]
+        }
+    ]
+}

vesting-palletwith-substrate/Cargo.toml

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

vesting-palletwith-substrate/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org>

vesting-palletwith-substrate/README.md

@@ -0,0 +1,235 @@
+# Substrate Node Template
+
+[![Try on playground](https://img.shields.io/badge/Playground-Node_Template-brightgreen?logo=Parity%20Substrate)](https://docs.substrate.io/playground/) [![Matrix](https://img.shields.io/matrix/substrate-technical:matrix.org)](https://matrix.to/#/#substrate-technical:matrix.org)
+
+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
+the [Substrate Playground](https://docs.substrate.io/playground/) :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 non-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_BACKTRACE=1 ./target/release/node-template -ldebug --dev
+```
+
+> Development chain means that the state of our chain will be in a tmp folder while the nodes are
+> running. Also, **alice** account will be authority and sudo account as declared in the
+> [genesis state](https://github.com/substrate-developer-hub/substrate-node-template/blob/main/node/src/chain_spec.rs#L49).
+> At the same time the following accounts will be pre-funded:
+> - Alice
+> - Bob 
+> - Alice//stash
+> - Bob//stash
+
+In case of being interested in maintaining the chain' state between runs a base path must be added
+so the db can be stored in the provided folder instead of a temporal one. We could use this folder 
+to store different chain databases, as a different folder will be created per different chain that
+is ran. The following commands shows how to use a newly created folder as our db base path.
+
+```bash
+// Create a folder to use as the db base path
+$ mkdir my-chain-state
+
+// Use of that folder to store the chain state
+$ ./target/release/node-template --dev --base-path ./my-chain-state/
+
+// Check the folder structure created inside the base path after running the chain
+$ ls ./my-chain-state
+chains
+$ ls ./my-chain-state/chains/
+dev
+$ ls ./my-chain-state/chains/dev
+db keystore network
+```
+
+
+### 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://docs.substrate.io/tutorials/v3/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://docs.substrate.io/v3/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://docs.substrate.io/v3/runtime/chain-specs) 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://docs.substrate.io/v3/tools/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://docs.substrate.io/v3/advanced/consensus#longest-chain-rule),
+  the [Aura](https://docs.substrate.io/v3/advanced/consensus#aura) block authoring
+  mechanism and the
+  [GRANDPA](https://docs.substrate.io/v3/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://docs.substrate.io/v3/getting-started/glossary#runtime)" and
+"[state transition function](https://docs.substrate.io/v3/getting-started/glossary#state-transition-function-stf)"
+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://docs.substrate.io/v3/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://docs.substrate.io/v3/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://docs.substrate.io/v3/runtime/frame#support-crate)
+  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://docs.substrate.io/v3/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 and errors](https://docs.substrate.io/v3/runtime/events-and-errors)
+  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
+```

vesting-palletwith-substrate/docker-compose.yml

@@ -0,0 +1,17 @@
+version: "3.2"
+
+services:
+  dev:
+    container_name: node-template
+    image: paritytech/ci-linux:974ba3ac-20201006
+    working_dir: /var/www/node-template
+    ports:
+      - "9944:9944"
+    environment:
+      - CARGO_HOME=/var/www/node-template/.cargo
+    volumes:
+      - .:/var/www/node-template
+      - type: bind
+        source: ./.local
+        target: /root/.local
+    command: bash -c "cargo build --release && ./target/release/node-template --dev --ws-external"