MDL Talent Hub
Switch branches/tags
Nothing to show
Clone or download
MDLwtf Merge pull request #16 from thomasmodeneis/bugfix/pex_flood
fixing port to only allow "known" mdl ports
Latest commit 4ac0611 Sep 18, 2018
Failed to load latest commit information.
.github Create Mar 17, 2018
ci-scripts fixing integration-tests Jul 29, 2018
cmd fix lint tests Jul 31, 2018
dist/libskycoin fixing build Jul 29, 2018
docker/images/mainnet fixing build Jul 29, 2018
electron fixing integration-tests Jul 29, 2018
lib/cgo Merge branch 'master' of into merge_upstream May 25, 2018
src fixing port to only allow "known" mdl ports Sep 18, 2018
vendor Merge branch 'master' of into merge_upstream May 25, 2018
.appveyor.yml fixing build Jul 29, 2018
.gitignore fixing build Jul 29, 2018
.travis.yml Merge branch 'master' of into merge_upstream May 25, 2018 Modify changelog Apr 25, 2018
Dockerfile fixing build Jul 29, 2018
Gopkg.lock Update Gopkg.lock Mar 31, 2018
Gopkg.toml Remove constraint from Gopkg.toml Mar 31, 2018 fixing build Jul 29, 2018 Change -disable-wallet-api to -enable-wallet-api Apr 11, 2018
Makefile fixing integration-tests for cli Jul 30, 2018 Merge branch 'master' of into merge_upstream May 25, 2018
addresses 0.21.13 Jun 19, 2018 fixing build Jul 29, 2018
foo.addresses 0.21.13 Jun 19, 2018
gz-c.asc Add release signature notes Mar 23, 2018
info-sec.txt 0.21.3 New Wallet improvments Mar 15, 2018
info.txt 0.21.3 New Wallet improvments Mar 15, 2018
mdl.png Add files via upload Jan 29, 2018
peers.txt MDL Feb 2, 2018 fixing build Jul 29, 2018 Merge branch 'master' of into merge_upstream May 25, 2018

mdl logo


Build Status GoDoc Go Report Card

MDL is a token used in MDL Talent Hub platform. It's based on MDL's code base.

MDL improves on Bitcoin in too many ways to be addressed here. Read their website and blog instead.


Table of Contents



MDL supports go1.9+. The preferred version is go1.10.

Go 1.9+ Installation and Setup

Golang 1.9+ Installation/Setup

Go get MDL

go get

This will download to $GOPATH/src/

You can also clone the repo directly with git clone, but it must be cloned to this path: $GOPATH/src/

Run MDL from the command line

cd $GOPATH/src/
make run

Show MDL node options

cd $GOPATH/src/
make run-help

Run MDL with options


cd $GOPATH/src/
make ARGS="--launch-browser=false -data-dir=/custom/path" run

Docker image

$ docker volume create mdl-data
$ docker volume create mdl-wallet
$ docker run -ti --rm \
    -v mdl-data:/data \
    -v mdl-wallet:/wallet \
    -p 6000:6000 \
    -p 6420:6420 \
    -p 6430:6430 \

Access the dashboard: http://localhost:6420.

Access the API: http://localhost:6420/version. This is the quickest way to start using MDL using Docker.

$ docker volume create mdl-data
$ docker volume create mdl-wallet
$ docker run -ti --rm \
    -v mdl-data:/data \
    -v mdl-wallet:/wallet \
    -p 6000:6000 \
    -p 6420:6420 \
    -p 6430:6430 \

This image has a mdl user for the mdl 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 mdl/mdl -help

Access the dashboard: http://localhost:6420.

Access the API: http://localhost:6420/version.

Building your own images

There is a Dockerfile in docker/images/mainnet that you can use to build your own image. By default it will build your working copy, but if you pass the MDL_VERSION build argument to the docker build command, it will checkout to the branch, a tag or a commit you specify on that variable.


$ git clone
$ cd mdl
$ MDL_VERSION=v0.23.0
$ docker build -f docker/images/mainnet/Dockerfile \
  --build-arg=MDL_VERSION=$MDL_VERSION \
  -t mdl:$MDL_VERSION .

or just

$ docker build -f docker/images/mainnet/Dockerfile \
  --build-arg=MDL_VERSION=v0.23.0 \
  -t mdl:v0.23.0 .

API Documentation




Deprecated, avoid using this


MDL command line interface

CLI command API.

Integrating MDL with your application

MDL 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 and used to seed client with peers.

Note: Do not add MDLwire nodes to peers.txt. Only add MDL nodes with high uptime and a static IP address (such as a MDL node hosted on a VPS).

URI Specification

MDL 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 MDL URIs:

  • mdl:2hYbwYudg34AjkJJCRVRcMeqSWHUixjkfwY
  • mdl:2hYbwYudg34AjkJJCRVRcMeqSWHUixjkfwY?amount=123.456&hours=70
  • mdl:2hYbwYudg34AjkJJCRVRcMeqSWHUixjkfwY?amount=123.456&hours=70&label=friend&message=Birthday%20Gift


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.


  • /src/cipher - cryptography library
  • /src/coin - the blockchain
  • /src/daemon - networking and wire protocol
  • /src/visor - the top level, client
  • /src/gui - the web wallet and json client interface
  • /src/wallet - the private key storage library
  • /src/api/webrpc - JSON-RPC 2.0 API
  • /src/api/cli - CLI library

Client libraries

MDL implements client libraries which export core functionality for usage from other programming languages. Read the corresponding README file for further details.

  • lib/cgo/ - libskycoin C client library ( read more )

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 mdl 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


./ci-scripts/ -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 MDL node, so before running the test, we need to start a MDL node.

After the MDL node is up, run the following command to start the live tests:

./ci-scripts/ -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/.mdl/wallets"
export WALLET_NAME="$valid_wallet_filename"
export WALLET_PASSWORD="$wallet_password"

Then run the tests with the following command:

make integration-test-live


./ci-scripts/ -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/ -v -r TestStableAddressBalance

Update golden files in integration test-fixtures

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/ -v -u
./ci-scripts/ -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

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.

After adding a new dependency (with dep ensure), run dep prune to remove any unnecessary subpackages from the dependency.

When updating or initializing, dep will find the latest version of a dependency that will compile.


Initialize all dependencies:

dep init
dep prune

Update all dependencies:

dep ensure -update -v
dep prune

Add a single dependency (latest version):

dep ensure
dep prune

Add a single dependency (more specific version), or downgrade an existing dependency:

dep ensure
dep prune

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


  1. If the master branch has commits that are not in develop (e.g. due to a hotfix applied to master), merge master into develop
  2. Compile the src/gui/dist/ to make sure that it is up to date (see Wallet GUI Development README)
  3. Update all version strings in the repo (grep for them) to the new version
  4. Update move the "unreleased" changes to the version and add the date
  5. Merge these changes to develop
  6. Follow the steps in pre-release testing
  7. Make a PR merging develop into master
  8. Review the PR and merge it
  9. Tag the master branch with the version number. Version tags start with v, e.g. v0.20.0. Sign the tag. Example: git tag -as v0.20.0 $COMMIT_ID.
  10. Make sure that the client runs properly from the master branch
  11. Create the release builds from the master branch (see Create Release builds)

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 (./
  • 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

Creating release builds

Create Release builds.

Release signing

Releases are signed with this PGP key:


The fingerprint for this key is:

pub   ed25519 2017-09-01 [SC] [expires: 2023-03-18]
      10A7 22B7 6F2F FE7B D238  0222 5801 631B D27C 7874
uid                      GZ-C MDL <>
sub   cv25519 2017-09-01 [E] [expires: 2023-03-18] account:

Follow the Tor Project's instructions for verifying signatures.

If you can't or don't want to import the keys from a keyserver, the signing key is available in the repo: gz-c.asc.

Releases and their signatures can be found on the releases page.

Instructions for generating a PGP key, publishing it, signing the tags and binaries: