vagachain

module
v0.0.0-...-78bc507 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 25, 2022 License: Apache-2.0

README

 

Full-node implementation of the VagaChain blockchain.

Explore the Docs »

VagaChain reference · Go API · Rest API · Finder · Station


Table of Contents

What is VagaChain?

VagaChain is a public, open-source, proof-of-stake blockchain. **The VagaChain ** is the reference implementation of the VagaChain protocol written in Golang. The VagaChain Core is powered by the Cosmos SDK and Tendermint BFT consensus.

Installation

From Binary

The easiest way to install the VagaChain Core is to download a pre-built binary. You can find the latest binaries on the releases page.

From Source

Step 1: Install Golang

Go v1.18+ or higher is required for The VagaChain Core.

  1. Install Go 1.18+ from the official site. Ensure that your GOPATH and GOBIN environment variables are properly set up by using the following commands:

    For Windows:

    wget <https://golang.org/dl/go1.18.2.linux-amd64.tar.gz>
sudo tar -C /usr/local -xzf go1.18.2.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin
export PATH=$PATH:$(go env GOPATH)/bin

    For Mac:

    export PATH=$PATH:/usr/local/go/bin
export PATH=$PATH:$(go env GOPATH)/bin

  2. Confirm your Go installation by checking the version:

    go version

Step 2: Get VagaChain Core source code

Clone the VagaChain Core from the official repo and check out the main branch for the latest stable release.

git clone https://github.com/vagabond-cloud/vagachain/
cd core
git checkout main

Step 3: Build VagaChain core

Run the following command to install vagachaind to your GOPATH and build the VagaChain Core. vagachaind is the node daemon and CLI for interacting with a VagaChain node.

# COSMOS_BUILD_OPTIONS=rocksdb make install
make install

Step 4: Verify your installation

Verify your installation with the following command:

vagachaind version --long

A successful installation will return the following:

name: vagachain
server_name: vagachaind
version: <x.x.x>
commit: <Commit hash>
build_tags: netgo,ledger
go: go version go1.18.2 darwin/amd64

vagachaind

vagachaind is the all-in-one CLI and node daemon for interacting with the VagaChain blockchain.

To view various subcommands and their expected arguments, use the following command:

$ vagachaind --help

Stargate VagaChain App

Usage:
  vagachaind [command]

Available Commands:
  add-genesis-account Add a genesis account to genesis.json
  collect-gentxs      Collect genesis txs and output a genesis.json file
  debug               Tool for helping with debugging your application
  export              Export state to JSON
  gentx               Generate a genesis tx carrying a self delegation
  help                Help about any command
  init                Initialize private validator, p2p, genesis, and application configuration files
  keys                Manage your application's keys
  migrate             Migrate genesis to a specified target version
  query               Querying subcommands
  rosetta             spin up a rosetta server
  start               Run the full node
  status              Query remote node for status
  tendermint          Tendermint subcommands
  testnet             Initialize files for a vagachaind testnet
  tx                  Transactions subcommands
  unsafe-reset-all    Resets the blockchain database, removes address book files, and resets data/priv_validator_state.json to the genesis state
  validate-genesis    validates the genesis file at the default location or at the location passed as an arg
  version             Print the application binary version information

Flags:
  -h, --help                help for vagachaind
      --home string         directory for config and data (default "/Users/evan/.vagachain")
      --log_format string   The logging format (json|plain) (default "plain")
      --log_level string    The logging level (trace|debug|info|warn|error|fatal|panic) (default "info")
      --trace               print out full stack trace on errors

Use "vagachaind [command] --help" for more information about a command.

Visit the vagachaind documentation page for more info on usage.

Node Setup

Once you have vagachaind installed, you will need to set up your node to be part of the network.

Join the mainnet

The following requirements are recommended for running a mainnet node:

  • Four or more CPU cores
  • At least 32 GB of memory
  • At least 300 mbps of network bandwidth
  • At least 2 TB NVME SSD
  • A Linux distribution

VagaChain node quickstart

vagachaind init nodename
wget -O ~/.vagachain/config/genesis.json URL TO GENESIS JSON
curl URL TO ADDRESSBOOK JSON > ~/.vagachaind/config/addrbook.json
vagachaind start

Join a testnet

Several testnets might exist simultaneously. Ensure that your version of vagachaind is compatible with the network you want to join.

To set up a node on the latest testnet, visit the testnet repo.

Run a local testnet

The easiest way to set up a local testing environment is to run LocalVagaChain, a zero-configuration complete testing environment.

Run a single node testnet

You can also run a local testnet using a single node. On a local testnet, you will be the sole validator signing blocks.

Step 1: Create network and account

First, initialize your genesis file to bootstrap your network. Create a name for your local testnet and provide a moniker to refer to your node:

vagachaind init --chain-id=<testnet_name> <node_moniker>

Next, create a VagaChain account by running the following command:

vagachaind keys add <account_name>

Step 2: Add account to genesis

Add your account to genesis and set an initial balance to start. Run the following commands to add your account and set the initial balance:

vagachaind add-genesis-account $(vagachaind keys show <account_name> -a) 100000000uvaga
vagachaind gentx <account_name> 10000000uvaga --chain-id=<testnet_name>
vagachaind collect-gentxs

Step 3: Run vagachaind

Now you can start your private VagaChain network:

vagachaind start

Your vagachaind node will be running a node on tcp://localhost:26656, listening for incoming transactions and signing blocks.

Set up a production environment

Note: This guide only covers general settings for a production-level full node. Visit the VagaChain validator's guide for more information.

This guide has been tested against Linux distributions only. To ensure you successfully set up your production environment, consider setting it up on an Linux system.

Increase maximum open files

By default, vagachaind can't open more than 1024 files at once.

You can increase this limit by modifying /etc/security/limits.conf and raising the nofile capability.

*                soft    nofile          65535
*                hard    nofile          65535

Create a dedicated user

It is recommended that you run vagachaind as a normal user. Super-user accounts are only recommended during setup to create and modify files.

Port configuration

vagachaind uses several TCP ports for different purposes.

  • 26656: The default port for the P2P protocol. Use this port to communicate with other nodes. While this port must be open to join a network, it does not have to be open to the public. Validator nodes should configure persistent_peers and close this port to the public.

  • 26657: The default port for the RPC protocol. This port is used for querying / sending transactions and must be open to serve queries from vagachaind. DO NOT open this port to the public unless you are planning to run a public node.

  • 1317: The default port for Lite Client Daemon (LCD), which can be enabled in ~/.vagachain/config/app.toml. The LCD provides an HTTP RESTful API layer to allow applications and services to interact with your vagachaind instance through RPC. Check the VagaChain REST API for usage examples. Don't open this port unless you need to use the LCD.

  • 26660: The default port for interacting with the Prometheus database. You can use Promethues to monitor an environment. This port is closed by default.

Run the server as a daemon

Important:

Keep vagachaind running at all times. The simplest solution is to register vagachaind as a systemd service so that it automatically starts after system reboots and other events.

Register vagachaind as a service

First, create a service definition file in /etc/systemd/system.

Sample file: /etc/systemd/system/vagachaind.service

[Unit]
Description=VagaChain Daemon
After=network.target

[Service]
Type=simple
User=vagachain
ExecStart=/data/vagachain/go/bin/vagachaind start
Restart=on-abort

[Install]
WantedBy=multi-user.target

[Service]
LimitNOFILE=65535

Modify the Service section from the given sample above to suit your settings. Note that even if you raised the number of open files for a process, you still need to include LimitNOFILE.

After creating a service definition file, you should execute systemctl daemon-reload.

Start, stop, or restart service

Use systemctl to control (start, stop, restart)

# Start
systemctl start vagachaind
# Stop
systemctl stop vagachaind
# Restart
systemctl restart vagachaind

Access logs

# Entire log
journalctl -t vagachaind
# Entire log reversed
journalctl -t vagachaind -r
# Latest and continuous
journalctl -t vagachaind -f

Resources

Developer Tools:

Developer Forums:

Block Explorer:

Wallets:

Research:

Community

Contributing

If you are interested in contributing to VagaChain source, please review our code of conduct.

License

This software is licensed under the Apache 2.0 license.

© 2022 Vagabond Solutions FZCO

 

vagachain

Directories

Path Synopsis
app
ante
params
tx
wasmconfig
client
docs/statik
Package statik contains static assets.
 Package statik contains static assets.
cmd
vagachaind

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.