Haicoin is a next-generation cryptocurrency.
Links
Table of Contents
Changelog
CHANGELOG.md
Installation
Haicoin supports go1.10+.
Go 1.10+ Installation and Setup
Golang 1.10+ Installation/Setup
Go get haicoin
go get github.com/samoslab/haicoin/...
This will download github.com/samoslab/haicoin
to $GOPATH/src/github.com/samoslab/haicoin
.
You can also clone the repo directly with git clone https://github.com/samoslab/haicoin
,
but it must be cloned to this path: $GOPATH/src/github.com/samoslab/haicoin
.
Run Haicoin from the command line
cd $GOPATH/src/github.com/samoslab/haicoin
make run
Show Haicoin node options
cd $GOPATH/src/github.com/samoslab/haicoin
make run-help
Run Haicoin with options
Example:
cd $GOPATH/src/github.com/samoslab/haicoin
make ARGS="--launch-browser=false -data-dir=/custom/path" run
Docker image
This is the quickest way to start using Haicoin using Docker.
$ docker volume create haicoin-data
$ docker volume create haicoin-wallet
$ docker run -ti --rm \
-v haicoin-data:/data/.haicoin \
-v haicoin-wallet:/wallet \
-p 6968:6968 \
-p 6969:6969 \
samoslab/haicoin
This image has a haicoin
user for the haicoin daemon to run, with UID and GID 10000.
When you mount the volumes, the container will change their owner, so you
must be aware that if you are mounting an existing host folder any content you
have there will be own by 10000.
The container will run with some default options, but you can change them
by just appending flags at the end of the docker run
command. The following
example will show you the available options.
docker run --rm samoslab/haicoin -help
Access the dashboard: http://localhost:6969.
Access the API: http://localhost:6969/version.
Building your own images
Building your own images.
API Documentation
REST API
REST API.
JSON-RPC 2.0 API
Deprecated, avoid using this
JSON-RPC 2.0 README.
Haicoin command line interface
CLI command API.
Integrating Haicoin with your application
Haicoin Integration Documentation
Contributing a node to the network
Add your node's ip:port
to the peers.txt file.
This file will be periodically uploaded to http://downloads.haicoin.net/blockchain/peers.txt
and used to seed client with peers.
Note: Do not add Skywire nodes to peers.txt
.
Only add Haicoin nodes with high uptime and a static IP address (such as a Haicoin node hosted on a VPS).
URI Specification
Haicoin URIs obey the same rules as specified in Bitcoin's BIP21.
They use the same fields, except with the addition of an optional hours
parameter, specifying the coin hours.
Example Haicoin URIs:
haicoin:2hYbwYudg34AjkJJCRVRcMeqSWHUixjkfwY
haicoin:2hYbwYudg34AjkJJCRVRcMeqSWHUixjkfwY?amount=123.456&hours=70
haicoin:2hYbwYudg34AjkJJCRVRcMeqSWHUixjkfwY?amount=123.456&hours=70&label=friend&message=Birthday%20Gift
Development
We have two branches: master
and develop
.
develop
is the default branch and will have the latest code.
master
will always be equal to the current stable release on the website, and should correspond with the latest release tag.
Modules
api
- REST API interface
api/webrpc
- JSON-RPC 2.0 API [deprecated]
cipher
- cryptographic library
cli
- CLI library
coin
- blockchain data structures
daemon
- top-level application manager, combining all components (networking, database, wallets)
daemon/gnet
- networking library
daemon/pex
- peer management
visor
- top-level blockchain database layer
visor/blockdb
- low-level blockchain database layer
visor/historydb
- low-level blockchain database layer for historical blockchain metadata
wallet
- wallet file management
Client libraries
Haicoin implements client libraries which export core functionality for usage from
other programming languages.
For further details run make docs
to generate documetation and read the corresponding README and API references.
Running Tests
make test
Running Integration Tests
There are integration tests for the CLI and HTTP API interfaces. They have two
run modes, "stable" and "live.
The stable integration tests will use a haicoin daemon
whose blockchain is synced to a specific point and has networking disabled so that the internal
state does not change.
The live integration tests should be run against a synced or syncing node with networking enabled.
Stable Integration Tests
make integration-test-stable
or
./ci-scripts/integration-test-stable.sh -v -w
The -w
option, run wallet integrations tests.
The -v
option, show verbose logs.
Live Integration Tests
The live integration tests run against a live runnning haicoin node, so before running the test, we
need to start a haicoin node. Since the cli
integration test requires the rpc interface enabled,
we should start node with rpc-interface
:
./run.sh -launch-browser=false -rpc-interface
After the haicoin node is up, run the following command to start the live tests:
./ci-scripts/integration-test.live.sh -v
The above command will run all tests except the wallet related tests. To run wallet tests, we
need to manually specify a wallet file, and it must have at least 2 coins
and 256 coinhours
,
it also must have been loaded by the node.
We can specify the wallet by setting two environment variables: WALLET_DIR
and WALLET_NAME
. The WALLET_DIR
represents the absolute path of the wallet directory, and WALLET_NAME
represents the wallet file name.
Note: WALLET_DIR
is only used by the CLI integration tests. The GUI integration tests use the node's
configured wallet directory, which can be controlled with -wallet-dir
when running the node.
If the wallet is encrypted, also set WALLET_PASSWORD
.
export WALLET_DIR="$HOME/.haicoin/wallets"
export WALLET_NAME="$valid_wallet_filename"
export WALLET_PASSWORD="$wallet_password"
Then run the tests with the following command:
make integration-test-live
or
./ci-scripts/integration-test-live.sh -v -w
Debugging Integration Tests
Run specific test case:
It's annoying and a waste of time to run all tests to see if the test we real care
is working correctly. There's an option: -r
, which can be used to run specific test case.
For exampe: if we only want to test TestStableAddressBalance
and see the result, we can run:
./ci-scripts/integration-test-stable.sh -v -r TestStableAddressBalance
Update golden files in integration testdata
Golden files are expected data responses from the CLI or HTTP API saved to disk.
When the tests are run, their output is compared to the golden files.
To update golden files, use the -u
option:
./ci-scripts/integration-test-live.sh -v -u
./ci-scripts/integration-test-stable.sh -v -u
We can also update a specific test case's golden file with the -r
option.
All .go
source files should be formatted goimports
. You can do this with:
make format
Code Linting
Install prerequisites:
make install-linters
Run linters:
make lint
Dependency Management
Dependencies are managed with dep.
To install dep
:
go get -u github.com/golang/dep
dep
vendors all dependencies into the repo.
If you change the dependencies, you should update them as needed with dep ensure
.
Use dep help
for instructions on vendoring a specific version of a dependency, or updating them.
When updating or initializing, dep
will find the latest version of a dependency that will compile.
Examples:
Initialize all dependencies:
dep init
Update all dependencies:
dep ensure -update -v
Add a single dependency (latest version):
dep ensure github.com/foo/bar
Add a single dependency (more specific version), or downgrade an existing dependency:
dep ensure github.com/foo/bar@tag
Configuration Modes
There are 4 configuration modes in which you can run a haicoin node:
- Development Desktop Daemon
- Server Daemon
- Electron Desktop Client
- Standalone Desktop Client
Development Desktop Daemon Mode
This mode is configured via run.sh
$ ./run.sh
Server Daemon Mode
The default settings for a haicoin node are chosen for Server Daemon
, which is typically run from source.
This mode is usually preferred to be run with security options, though -disable-csrf
is normal for server daemon mode, it is left enabled by default.
$ go run cmd/samoslab/haicoin.go
Electron Desktop Client Mode
This mode configures itself via electron-main.js
Standalone Desktop Client Mode
This mode is configured by compiling with STANDALONE_CLIENT
build tag.
The configuration is handled in cmd/haicoin/haicoin.go
Wallet GUI Development
The compiled wallet source should be checked in to the repo, so that others do not need to install node to run the software.
Instructions for doing this:
Wallet GUI Development README
Releases
- If the
master
branch has commits that are not in develop
(e.g. due to a hotfix applied to master
), merge master
into develop
- Compile the
src/gui/static/dist/
to make sure that it is up to date (see Wallet GUI Development README)
- Update all version strings in the repo (grep for them) to the new version
- Update
CHANGELOG.md
: move the "unreleased" changes to the version and add the date
- Merge these changes to
develop
- Follow the steps in pre-release testing
- Make a PR merging
develop
into master
- Review the PR and merge it
- Tag the master branch with the version number. Version tags start with
v
, e.g. v0.20.0
.
Sign the tag. If you have your GPG key in github, creating a release on the Github website will automatically tag the release.
It can be tagged from the command line with git tag -as v0.20.0 $COMMIT_ID
, but Github will not recognize it as a "release".
- Make sure that the client runs properly from the
master
branch
- Release builds are created and uploaded by travis. To do it manually, checkout the
master
branch and follow the create release builds instructions.
If there are problems discovered after merging to master, start over, and increment the 3rd version number.
For example, v0.20.0
becomes v0.20.1
, for minor fixes.
Pre-release testing
Performs these actions before releasing:
make check
make integration-test-live
(see live integration tests) both with an unencrypted and encrypted wallet.
go run cmd/cli/cli.go checkdb
against a synced node
- On all OSes, make sure that the client runs properly from the command line (
./run.sh
)
- Build the releases and make sure that the Electron client runs properly on Windows, Linux and macOS.
- Use a clean data directory with no wallets or database to sync from scratch and verify the wallet setup wizard.
- Load a test wallet with nonzero balance from seed to confirm wallet loading works
- Send coins to another wallet to confirm spending works
- Restart the client, confirm that it reloads properly