OAX Parrot

OAX Parachain for the Polkadot network, built using the Substrate Framework

Features

• ERC20 Standard
• Atomic Swap (Single tx swap for ERC20 tokens)
• Multi-Transfer
• Automatic Fee Burn
• Fee Delegation

Necessary Custom Types

We've added custom data types which you will need to customize via the Front-End UI Types.json

Pre-reqs

Install Pre-reqs :

curl https://getsubstrate.io -sSf | bash -s -- --fast

Initialize your Wasm Build environment:

./scripts/init.sh

Running the Node

1. cargo build (add --release for production build)
2. ./target/debug/parrot --alice --dev
3. If you want to re-launch the chain, you can start fresh by purging it ./target/debug/parrot purge-chain --dev

Testing Custom Pallets

1. cargo test
2. To run individual test, you can run cargo test MODULE , so if you wanted to test the burn module you could run cargo test burn

FrontEnd

You can use polkadot-js/apps.

The last tested stable release: https://github.com/polkadot-js/apps/tree/v0.48.1

If you use polkadot-js/apps UI must be configured for our Custom Types. Copy and paste the JSON into https://polkadot.js.org/apps/#/settings/developer

Client + End to End Tests + Demos

Instructions to run these tests and demos are in the README

Feature Implementations

ERC20 Standard

Atomic Swap

Native Multi Transfer

PRC20 Multi Transfer

Automatic Fee Burn

Fee Delegation

Run

Single Node Development Chain

Purge any existing developer chain state:

./target/release/parrot purge-chain --dev

Start a development chain with:

./target/release/parrot --dev

Detailed logs may be shown by running the node with the following environment variables set: RUST_LOG=debug RUST_BACKTRACE=1 cargo run -- --dev.

Multi-Node Local Testnet

If you want to see the multi-node consensus algorithm in action locally, then you can create a local testnet with two validator nodes for Alice and Bob, who are the initial authorities of the genesis chain that have been endowed with testnet units.

Optionally, give each node a name and expose them so they are listed on the Polkadot telemetry site.

You'll need two terminal windows open.

We'll start Alice's substrate node first on default TCP port 30333 with her chain database stored locally at /tmp/alice. The bootnode ID of her node is QmRpheLN4JWdAnY7HGJfWFNbfkQCb6tFf4vvA6hgjMZKrR, which is generated from the --node-key value that we specify below:

cargo run -- \
  --base-path /tmp/alice \
  --chain=local \
  --alice \
  --node-key 0000000000000000000000000000000000000000000000000000000000000001 \
  --telemetry-url 'ws://telemetry.polkadot.io:1024 0' \
  --validator

In the second terminal, we'll start Bob's substrate node on a different TCP port of 30334, and with his chain database stored locally at /tmp/bob. We'll specify a value for the --bootnodes option that will connect his node to Alice's bootnode ID on TCP port 30333:

cargo run -- \
  --base-path /tmp/bob \
  --bootnodes /ip4/127.0.0.1/tcp/30333/p2p/QmRpheLN4JWdAnY7HGJfWFNbfkQCb6tFf4vvA6hgjMZKrR \
  --chain=local \
  --bob \
  --port 30334 \
  --telemetry-url 'ws://telemetry.polkadot.io:1024 0' \
  --validator

Additional CLI usage options are available and may be shown by running cargo run -- --help.

Run in Docker

First, install Docker and Docker Compose.

Then run the following command to start a single node development chain.

./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/parrot --dev --ws-external) by appending your own. A few useful ones are as follow.

# Run Substrate node without re-compiling
./scripts/docker_run.sh ./target/release/parrot --dev --ws-external

# Purge the local dev chain
./scripts/docker_run.sh ./target/release/parrot purge-chain --dev

# Check whether the code is compilable
./scripts/docker_run.sh cargo check