Testnet Setup

Setting up a masternode with support for evo services requires a basic understanding of Linux and blockchain technology, as well as an ability to follow instructions closely. It also requires regular maintenance and careful security, particularly if you are not storing your Dash on a hardware wallet. There are some decisions to be made along the way, and optional extra steps to take for increased security.

Có các dịch vụ lưu trữ masternode nếu bạn thích việc uỷ nhiệm việc vận hành hàng ngày masternode của bạn cho những nhà vận hành chuyên nghiệp. Khi sử dụng dịch vụ lưu trữ, bạn vẫn giữ toàn quyền kiểm soát 1000 Dash đặt cọc và trả mức thoả thuận tương ứng với phần trăm của phần thưởng cho người vận hành. Bạn cũng có thể uỷ quyền bỏ phiếu cho một người đại diện, xem trong tài liệu về quản trị để biết thêm thông tin.

Trước khi bạn bắt đầu

This guide assumes you are setting up a single testnet masternode for the first time. If you are updating a masternode, see here instead. You will need:

  • 1000 Dash

  • Một ví để chứa Dash của bạn, tốt nhất là dùng một ví phần cứng, mặc dù ví Dash Core cũng có thể giúp bạn

  • Một máy chủ Linux, một máy chủ ảo (VPS) thì hay hơn

Dash 0.13.0 và sau đó triển khai DIP003, cái này mang đến một số thay đổi cách cài đặt và vận hành masternode của Dash. Trong khi nâng cấp mạng này đã được hoàn thành vào đầu năm 2019, chúng ta vẫn có một danh sách các tài liệu bên dưới:

Tài liệu này mo tả các câu lệnh khi chúng được nhập vào trong giao diện đồ hoạ của Dash bằng việc mở bảng điều khiển từ menu Công cụ > Giao diện gỡ rối, nhưng cũng có cùng kết quả trên một masternode bằng việc đánh cùng những câu lệnh đó và thêm tiền tố ~/.dashcore/dash-cli cho mỗi câu lệnh.

Cài đặt VPS của bạn

A VPS, more commonly known as a cloud server, is fully functional installation of an operating system (usually Linux) operating within a virtual machine. The virtual machine allows the VPS provider to run multiple systems on one physical server, making it more efficient and much cheaper than having a single operating system running on the "bare metal" of each server. A VPS is ideal for hosting a Dash masternode because they typically offer guaranteed uptime, redundancy in the case of hardware failure and a static IP address that is required to ensure you remain in the masternode payment queue. While running a masternode from home on a desktop computer is technically possible, it will most likely not work reliably because most ISPs allocate dynamic IP addresses to home users.

We will use Vultr hosting as an example of a VPS, although DigitalOcean, Amazon EC2, Google Cloud, Choopa and OVH are also popular choices. First create an account and add credit. Then go to the Servers menu item on the left and click + to add a new server. Select a location for your new server on the following screen:

../_images/setup-server-location.png

Màn hình chọn địa điểm cho máy chủ trên Vultr

Select Ubuntu 20.04 x64 as the server type. We use this LTS release of Ubuntu instead of the latest version because LTS releases are supported with security updates for 5 years, instead of the usual 9 months.

../_images/setup-server-type.png

Màn hình chọn kiểu máy chủ trên Vultr

Chọn một máy chủ với kích thước bộ nhớ yêu cầu tối thiểu là 2GB

../_images/setup-server-size.png

Màn hình lựa chọn kích thước máy chủ trên Vultr

Nhập tên máy chủ và nhãn cho máy chủ của bạn. Trong ví dụ này thì chúng tôi sử dụng dashmn1 làm tên cho máy chủ.

../_images/setup-server-hostname.png

Tên máy chủ và màn hình lựa chọn nhãn trên Vultr

Vultr sẽ cài đặt máy chủ cho bạn. Quá trình này sẽ mất vài phút.

../_images/setup-server-installing.png

Màn hình cài đặt máy chủ ở Vultr

Bấm vào Manage khi việc cài đặt được hoàn tất và bạn nên ghi lại địa chỉ IP, tên người dùng và mật khẩu.

../_images/setup-server-manage.png

Màn hình quản lý máy chủ của Vultr

Cài đặt hệ điều hành của bạn

We will begin by connecting to your newly provisioned server. On Windows, we will first download an app called PuTTY to connect to the server. Go to the PuTTY download page and select the appropriate MSI installer for your system. On Mac or Linux you can ssh directly from the terminal - simply type ssh root@<server_ip> and enter your password when prompted.

../_images/setup-putty-download.png

Trang tải PuTTY

Double-click the downloaded file to install PuTTY, then run the app from your Start menu. Enter the IP address of the server in the Host Name field and click Open. You may see a certificate warning, since this is the first time you are connecting to this server. You can safely click Yes to trust this server in the future.

../_images/setup-putty-alert.png

Cảnh báo an ninh của PuTTY khi kết nối với một máy chủ mới

Bây giờ bạn đã kết nối với máy chủ của mình và sẽ nhìn thấy một cửa sổ làm việc. Bắt đầu bằng việc đăng nhập vào máy chủ của bạn với tên người dùng là root và mật khẩu được cung cấp bởi nhà cung cấp dịch vụ lưu trữ của bạn.

../_images/setup-putty-connect.png

Yêu cầu mật khẩu khi bạn kết nối với máy chủ ảo - còn gọi là "VPS" trong lần đầu tiên

You should immediately change the root password and store it in a safe place for security. You can copy and paste any of the following commands by selecting them in your browser, pressing Ctrl + C, then switching to the PuTTY window and right-clicking in the window. The text will paste at the current cursor location:

passwd root

Nhập và nhập lại một khẩu mới (tốt nhất đủ dài và được sinh một cách ngẫu hiên). Tiếp đó chúng ta sẽ tạo một người dùng mới bằng câu lệnh sau, thay <username> với một tên người dùng mà bạn chọn:

adduser <username>

Bạn sẽ được nhắc nhập mật khẩu. Nhập và xác nhận lại một mật khẩu mới (khác với mật khẩu root) và lưu nó ở một nơi an toàn. Bạn cũng sẽ được nhắc về thông tin cho người dùng, nhưng cứ để nó trống. Một khi người dùng được tạo, chúng ta sẽ đưa nó vào trong nhóm sudo và họ có thể thực hiện các câu lệnh như là root:

usermod -aG sudo <username>

Bây giờ, trong khi vẫn là root, chúng ta sẽ cập nhật hệ thống từ hệ thống quản lý ứng dụng của Ubuntu:

apt update
apt upgrade

The system will show a list of upgradable packages. Press Y and Enter to install the packages. We will now install a firewall, add swap memory and reboot the server to apply any necessary kernel updates, and then login to our newly secured environment as the new user:

ufw allow ssh/tcp
ufw limit ssh/tcp
ufw allow 19999/tcp
ufw allow 26656/tcp
ufw allow 3000/tcp
ufw allow 3010/tcp
ufw logging on
ufw enable

(bấm YEnter để xác nhận)

fallocate -l 4G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile
nano /etc/fstab

Thêm dòng sau đây và ở cuối của file (bấm phím tab để phân cách mỗi từ/số), sau đó bấm tổ hợp phím Ctrl + X để đóng trình soạn thảo. sau đó YEnter để lưu file.

/swapfile none swap sw 0 0

Cuối cùng, để ngăn chặn việc dò mật khẩu, chúng ta sẽ cài fail2ban và tắt quyền truy cập ssh với root. Những bước sau là tuy chọn, nhưng rất khuyến khích. Bắt đầu với fail2ban nhé:

apt install fail2ban

Tạo một file cấu hình mới:

nano /etc/fail2ban/jail.local

Và dán cấu hinhf sau đây:

[sshd]
enabled = true
port = 22
filter = sshd
logpath = /var/log/auth.log
maxretry = 3

Bấm tổ hợp phím Ctrl + X để đóng trình soạn thảo, sau đó YEnter để lưu file. Khởi động lại và bật dịch vụ fail2ban:

systemctl restart fail2ban
systemctl enable fail2ban

Tiếp theo, mở file cấu hình SSH để tắt quyền đăng nhập của root qua SSH:

nano /etc/ssh/sshd_config

Locate the line that reads PermitRootLogin yes and set it to PermitRootLogin no. Directly below this, add a line which reads AllowUsers <username>, replacing <username> with the username you selected above. Then press Ctrl + X to close the editor, then Y and Enter save the file.

Sau đó khởi động lại máy chủ:

reboot now

PuTTY sẽ ngắt kết nối khi máy chủ khởi động lại.

While this setup includes basic steps to protect your server against attacks, much more can be done. In particular, authenticating with a public key instead of a username/password combination and enabling automatic security updates is advisable. More tips are available here. However, since the masternode does not actually store the keys to any Dash, these steps are considered beyond the scope of this guide.

Gửi khoản đặt cọc

A Dash address with a single unspent transaction output (UTXO) of exactly 1000 DASH is required to operate a masternode. Once it has been sent, various keys regarding the transaction must be extracted for later entry in a configuration file and registration transaction as proof to write the configuration to the blockchain so the masternode can be included in the deterministic list. A masternode can be registered from a hardware wallet or the official Dash Core wallet, although a hardware wallet is highly recommended to enhance security and protect yourself against hacking. This guide will describe the steps for both hardware wallets and Dash Core.

Option 1: Holding collateral in a hardware wallet

Set up your Trezor using the Trezor wallet at https://wallet.trezor.io/ and send a test transaction to verify that it is working properly. For help on this, see this guide - you may also choose to (carefully!) add a passphrase to your Trezor to further protect your collateral. Create a new account in your Trezor wallet by clicking Add account. Then click the Receive tab and send exactly 1000 DASH to the address displayed. If you are setting up multiple masternodes, send 1000 DASH to consecutive addresses within the same new account. You should see the transaction as soon as the first confirmation arrives, usually within a few minutes.

../_images/setup-collateral-trezor.png

Trang Wallet Receive của Trezor hiển thị đã nhận được giao dịch đặt cọc 1000 DASH

Once the transaction appears, click the QR code on the right to view the transaction on the blockchain. Keep this window open as we complete the following steps, since we will soon need to confirm that 15 confirmations exist, as shown in the following screenshot.

../_images/setup-collateral-blocks.png

Trình khám phá blockchain hiển thị 15 xác thực cho giao dịch đặt cọc

While we are waiting for 15 confirmations, download the latest version of the Dash Masternode Tool (DMT) from the GitHub releases page here. Unzip and run the file. The following window appears.

../_images/setup-collateral-dmt-start.png

Màn hình khởi động của Dash Masternode Tool

Click the third button from the left Check Dash Network Connection in the top left corner of the main window to verify that the connection is working. Then connect your Trezor device and click the next button Test Hardware Wallet Connection to verify the Trezor connection is working.

../_images/setup-collateral-connection.png
../_images/setup-collateral-hardware.png

Dash Masternode Tool xác nhận kết nối thành công

Bây giờ chúng ta sẽ sử dụng DMT để nhập vào một số thông tin căn bản về masternode và trích mã giao dịch. Thực hiện chuỗi các bước sau đây như trong ảnh chụp màn hình này:

../_images/setup-collateral-dmt-steps.png

Các bước cấu hình Dash Masternode Tool

  1. Bấm nút New.

  2. Nhập tên cho masternode của bạn. Bạn có thể dùng luôn tên máy chủ mà bạn xác định cho VPS ở trên.

  3. Enter the IP address of your masternode. This was given to you by the VPS provider when you set up the server. Then enter the TCP port number. This should be 19999.

  4. Click Locate collateral to view unused collateral funding transactions available on the connected hardware wallet. Select the address to which you sent 1000 Dash and click Apply. The Collateral address, path, Collateral TX hash and index fields should be filled automatically.

../_images/setup-collateral-dmt-ready.png

Dash Masternode Tool với cấu hình masternode

Leave DMT open and continue with the next step: installing Dash Core on your VPS.

Option 2: Holding collateral in Dash Core wallet

Mở ví Dash Core và đợi cho nó đồng bộ với mạng lưới. Nó sẽ nhìn như thế này khi đã sẵn sàng:

../_images/setup-collateral-dashcore.png

Ví Dash Core đã được đồng bộ xong

Click vào Công cụ > Giao diện gỡ rối để mở cửa sổ này. Nhập vào câu lệnh sau trong cửa sổ để sinh ra một địa chỉ Dash mới dùng cho việc gửi khoản đặt cọc:

getnewaddress
yiFfzbwiN9oneftd7cEfr3kQLRwQ4kp7ue

Take note of the collateral address, since we will need it later. The next step is to secure your wallet (if you have not already done so). First, encrypt the wallet by selecting Settings > Encrypt wallet. You should use a strong, new password that you have never used somewhere else. Take note of your password and store it somewhere safe or you will be permanently locked out of your wallet and lose access to your funds. Next, back up your wallet file by selecting File > Backup Wallet. Save the file to a secure location physically separate to your computer, since this will be the only way you can access our funds if anything happens to your computer. For more details on these steps, see here.

Now send exactly 1000 DASH in a single transaction to the new address you generated in the previous step. This may be sent from another wallet, or from funds already held in your current wallet. Once the transaction is complete, view the transaction in a blockchain explorer by searching for the address. You will need 15 confirmations before you can register the masternode, but you can continue with the next step at this point already: generating your masternode operator key.

../_images/setup-collateral-blocks.png

Trình khám phá blockchain hiển thị 15 xác thực cho giao dịch đặt cọc

Masternode Installation

The following tools are available for installing a Dash masternode:

dashmate installation

dashmate replaces the dashman masternode installer by moocowmoo. dashmate is based on Docker technology and features an interactive setup command and the ability to manage multiple node configs and multiple networks. It handles the installation of Dash Core and Tenderdash, as well as all dependencies and supporting services. Full dashmate documentation is available here.

Open PuTTY or a console again and connect using the username and password you just created for your new, non-root user. Begin by installing dashmate dependencies:

sudo apt install -y git curl docker.io docker-compose
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.38.0/install.sh | bash
source ~/.bashrc
nvm install --lts

Add your current user to the docker group, ensure docker starts on boot and refresh the environment:

sudo usermod -aG docker $USER
newgrp docker
sudo systemctl enable docker
sudo systemctl enable containerd

Clone the dashmate repository, set up the dependencies and link the CLI:

git clone -b master https://github.com/dashevo/dashmate.git
cd dashmate
npm ci
npm link

Run the interactive setup wizard:

dashmate setup

You will be prompted to select a network, node type, IP address and BLS private key. Enter this information or accept the detected/generated defaults. Start your node as follows:

dashmate start

You can manage your masternode status, configuration, and running state entirely from within dashmate. See the documentation here or use the built-in help system to learn more:

  • dashmate --help

  • dashmate <command> --help

../_images/dashmate-status.png

dashmate displaying a range of status output

You can check the status of your masternode using the various dashmate status commands as follows:

- dashmate status
- dashmate status:core
- dashmate status:host
- dashmate status:masternode
- dashmate status:platform
- dashmate status:services

Continue with the Registration step to setup the collateral, keys and construct the ProTx transaction required to enable your masternode.

Masternode Update

You can use dashmate to update minor versions of the software on your masternode as follows:

dashmate stop
dashmate update
dashmate start

Adding the following git and npm commands optionally also ensures you are using the latest stable version of dashmate:

dashmate stop
git checkout master
git pull
npm ci
dashmate update
dashmate start

Adding the following command will drop all data from Dash Platform (necessary if Platform has been wiped) and restart with the latest version:

dashmate stop
git checkout master
git pull
npm ci
dashmate reset --platform-only
dashmate update
dashmate start

Masternode registration

DIP003 introduced several changes to how a masternode is set up and operated. These changes and the three keys required for the different masternode roles are described briefly under DIP003 Những thay đổi Masternode in this documentation.

Tuỳ chọn 1: Đăng ký từ một ví phần cứng

Go back to DMT and ensure that all fields from the previous step are still filled out correctly. Click Generate new for the three private keys required for a DIP003 deterministic masternode:

  • Khoá riêng của chủ sở hữu

  • Operator private key (generate new or use private key generated by dashmate)

  • Khoá riêng bỏ phiếu

../_images/setup-dmt-full.png

Dash Masternode Tool sẵn sàng cho việc đăng ký một masternode mới

Then click Register masternode. Optionally specify a different Payout address and/or Operator reward, then click Continue. Select Remote Dash RPC Node (automatic method). (See here for documentation on using your own local RPC node.) and confirm the following two messages:

../_images/setup-dmt-send.png
../_images/setup-dmt-sent.png

Các bảng hội thoại của Dash Masternode Tool xác nhận việc đăng ký một masternode

The public key will be used in following steps. The private key must be entered in the configuration on the masternode. This allows the masternode to watch the blockchain for relevant Pro*Tx transactions, and will cause it to start serving as a masternode when the signed ProRegTx is broadcast by the owner (final step below). If you are using the BLS key generated by dashmate setup, this information is already configured for your masternode. If you generated your own BLS key pair, edit the dashmate configuration as follows:

dashmate config:set core.masternode.operator.privateKey <bls_private_key>
dashmate restart

At this point you can go back to your terminal window and monitor your masternode by entering dashmate status or using the Get status function in DMT.

You can now safely log out of your server by typing exit. Congratulations! Your masternode is now running.

Tuỳ chọn 2: Đăng ký từ ví Dash Core

Xác định giao dịch cấp vốn

If you used an address in Dash Core wallet for your collateral transaction, you now need to find the txid of the transaction. Click Tools > Debug console and enter the following command:

masternode outputs

Điều này sẽ trả về một chuỗi các ký tự tương tự như sau

{
"16347a28f4e5edf39f4dceac60e2327931a25fdee1fb4b94b63eeacf0d5879e3" : "1",
}

Dòng dài đầu tiên là collateralHash của bạn, còn số cuối cùng là collateralIndex.

Sinh một cặp khoá BLS

A public/private BLS key pair is required to operate a masternode. The private key is specified on the masternode itself, and allows it to be included in the deterministic masternode list once a provider registration transaction with the corresponding public key has been created.

If you are using a hosting service, they may provide you with their public key, and you can skip this step. If you are hosting your own masternode or have agreed to provide your host with the BLS private key, you can use the BLS key generated by the dashmate setup command. Alternatively, you can generate a BLS public/private keypair in Dash Core by clicking Tools > Debug console and entering the following command:

bls generate

{
  "secret": "395555d67d884364f9e37e7e1b29536519b74af2e5ff7b62122e62c2fffab35e",
  "public": "99f20ed1538e28259ff80044982372519a2e6e4cdedb01c96f8f22e755b2b3124fbeebdf6de3587189cf44b3c6e7670e"
}

These keys are NOT stored by the wallet or dashmate and must be kept secure, similar to the value provided in the past by the masternode genkey command.

Thêm khoá riêng vào cấu hình masternode của bạn

The public key will be used in following steps. The private key must be entered in the dash.conf file on the masternode. This allows the masternode to watch the blockchain for relevant Pro*Tx transactions, and will cause it to start serving as a masternode when the signed ProRegTx is broadcast by the owner (final step below). If you are using the BLS key generated by dashmate setup, this information is already configured for your masternode. If you generated your own BLS key pair, edit the dashmate configuration as follows:

dashmate config:set core.masternode.operator.privateKey <bls_private_key>
dashmate restart

Chúng ta sẽ chuẩn bị giao dịch được dùng để đăng ký masternode lên mạng.

Chuẩn bị cho một giao dịch ProRegTx

A pair of BLS keys for the operator were already generated above, and the private key was entered on the masternode. The public key is used in this transaction as the operatorPubKey.

First, we need to get a new, unused address from the wallet to serve as the owner key address (ownerKeyAddr). This is not the same as the collateral address holding 1000 Dash. Generate a new address as follows:

getnewaddress

yfgxFhqrdDG15ZWKJAN6dQvn6dZdgBPAip

This address can also be used as the voting key address (votingKeyAddr). Alternatively, you can specify an address provided to you by your chosen voting delegate, or simply generate a new voting key address as follows:

getnewaddress

yfRaZN8c3Erpqj9iKnmQ9QDBeUuRhWV3Mg

Then either generate or choose an existing address to receive the owner's masternode payouts (payoutAddress). It is also possible to use an address external to the wallet:

getnewaddress

yjZVt49WsQd6XSrPVAUGXtJccxviH9ZQpN

You can also optionally generate and fund another address as the transaction fee source (feeSourceAddress). If you selected an external payout address, you must specify a fee source address.

Either the payout address or fee source address must have enough balance to pay the transaction fee, or the register_prepare transaction will fail.

The private keys to the owner and fee source addresses must exist in the wallet submitting the transaction to the network. If your wallet is protected by a password, it must now be unlocked to perform the following commands. Unlock your wallet for 5 minutes:

walletpassphrase yourSecretPassword 300

We will now prepare an unsigned ProRegTx special transaction using the protx register_prepare command. This command has the following syntax:

protx register_prepare collateralHash collateralIndex ipAndPort ownerKeyAddr
  operatorPubKey votingKeyAddr operatorReward payoutAddress (feeSourceAddress)

Open a text editor such as notepad to prepare this command. Replace each argument to the command as follows:

  • collateralHash: Mã txid của giao dịch đặt cọc 1000 Dash

  • collateralIndex: Chỉ số đầu ra của giao dịch cấp vốn 1000 Dash

  • ipAndPort: Địa chỉ IP và cổng của masternode, theo định dạng x.x.x.x:yyyy

  • ownerKeyAddr: Địa chỉ Dash mới được sinh ở trên cho địa chỉ sở hữu/bỏ phiếu

  • operatorPubKey: Khoá công khai BLS được sinh ở trên (hoặc được cung cấp bởi nhà cung cấp dịch vụ lưu trữ)

  • votingKeyAddr: Địa chỉ Dash mới được sinh ở trên, hoặc địa chỉ uỷ nhiệm cho việc bỏ phiếu các đề xuất

  • operatorReward: Phần trăm phần thưởng khối sẽ được trả cho người vận hành

  • payoutAddress: Một địa chỉ mới hoặc cũ để nhận phần thưởng khối cho người chủ sở hữu

  • feeSourceAddress: Một địa chỉ (tuỳ chọn) dùng để cấp vốn cho khoản phí ProTx. Nếu feeSourceAddress không được cung cấp nó sẽ lấy tiền phí từ địa chỉ payoutAddress.

Note that the operator is responsible for specifying their own reward address in a separate update_service transaction if you specify a non-zero operatorReward. The owner of the masternode collateral does not specify the operator's payout address.

Ví dụ (hãy xoá các xuống dòng nếu copy):

protx register_prepare
  16347a28f4e5edf39f4dceac60e2327931a25fdee1fb4b94b63eeacf0d5879e3
  1
  45.76.230.239:19999
  yfgxFhqrdDG15ZWKJAN6dQvn6dZdgBPAip
  99f20ed1538e28259ff80044982372519a2e6e4cdedb01c96f8f22e755b2b3124fbeebdf6de3587189cf44b3c6e7670e
  yfRaZN8c3Erpqj9iKnmQ9QDBeUuRhWV3Mg
  0
  yjZVt49WsQd6XSrPVAUGXtJccxviH9ZQpN
  yR83WsikBaBaNusTnHZf28kAcL8oVmp1TE

Đầu ra:

{
  "tx": "030001000175c9d23c2710798ef0788e6a4d609460586a20e91a15f2097f56fc6e007c4f8e0000000000feffffff01a1949800000000001976a91434b09363474b14d02739a327fe76e6ea12deecad88ac00000000d1010000000000e379580dcfea3eb6944bfbe1de5fa2317932e260acce4d9ff3ede5f4287a34160100000000000000000000000000ffff2d4ce6ef4e1fd47babdb9092489c82426623299dde76b9c72d9799f20ed1538e28259ff80044982372519a2e6e4cdedb01c96f8f22e755b2b3124fbeebdf6de3587189cf44b3c6e7670ed1935246865dce1accce6c8691c8466bd67ebf1200001976a914fef33f56f709ba6b08d073932f925afedaa3700488acfdb281e134504145b5f8c7bd7b47fd241f3b7ea1f97ebf382249f601a0187f5300",
  "collateralAddress": "yjSPYvgUiAQ9AFj5tKFA8thFLoLBUxQERb",
  "signMessage": "yjZVt49WsQd6XSrPVAUGXtJccxviH9ZQpN|0|yfgxFhqrdDG15ZWKJAN6dQvn6dZdgBPAip|yfRaZN8c3Erpqj9iKnmQ9QDBeUuRhWV3Mg|ad5f82257bd00a5a1cb5da1a44a6eb8899cf096d3748d68b8ea6d6b10046a28e"
}

Next we will use the collateralAddress and signMessage fields to sign the transaction, and the output of the tx field to submit the transaction.

Ký cho giao dịch ProRegTx

We will now sign the content of the signMessage field using the private key for the collateral address as specified in collateralAddress. Note that no internet connection is required for this step, meaning that the wallet can remain disconnected from the internet in cold storage to sign the message. In this example we will again use Dash Core, but it is equally possible to use the signing function of a hardware wallet. The command takes the following syntax:

signmessage collateralAddress signMessage

Ví dụ:

signmessage yjSPYvgUiAQ9AFj5tKFA8thFLoLBUxQERb yjZVt49WsQd6XSrPVAUGXtJccxviH9ZQpN|0|yfgxFhqrdDG15ZWKJAN6dQvn6dZdgBPAip|yfRaZN8c3Erpqj9iKnmQ9QDBeUuRhWV3Mg|ad5f82257bd00a5a1cb5da1a44a6eb8899cf096d3748d68b8ea6d6b10046a28e

Đầu ra:

II8JvEBMj6I3Ws8wqxh0bXVds6Ny+7h5HAQhqmd5r/0lWBCpsxMJHJT3KBcZ23oUZtsa6gjgISf+a8GzJg1BfEg=

Gửi thông điệp đã được ký

We will now submit the ProRegTx special transaction to the blockchain to register the masternode. This command must be sent from a Dash Core wallet holding a balance on either the feeSourceAddress or payoutAddress, since a standard transaction fee is involved. The command takes the following syntax:

protx register_submit tx sig

Ở đó:

  • tx: Kết quả trường đầu ra tx được trả về từ câu lệnh protx register_prepare

  • sig: Là thông điệp được ký với khoá đặt cọc từ câu lệnh signmessage

Ví dụ:

protx register_submit 030001000175c9d23c2710798ef0788e6a4d609460586a20e91a15f2097f56fc6e007c4f8e0000000000feffffff01a1949800000000001976a91434b09363474b14d02739a327fe76e6ea12deecad88ac00000000d1010000000000e379580dcfea3eb6944bfbe1de5fa2317932e260acce4d9ff3ede5f4287a34160100000000000000000000000000ffff2d4ce6ef4e1fd47babdb9092489c82426623299dde76b9c72d9799f20ed1538e28259ff80044982372519a2e6e4cdedb01c96f8f22e755b2b3124fbeebdf6de3587189cf44b3c6e7670ed1935246865dce1accce6c8691c8466bd67ebf1200001976a914fef33f56f709ba6b08d073932f925afedaa3700488acfdb281e134504145b5f8c7bd7b47fd241f3b7ea1f97ebf382249f601a0187f5300 II8JvEBMj6I3Ws8wqxh0bXVds6Ny+7h5HAQhqmd5r/0lWBCpsxMJHJT3KBcZ23oUZtsa6gjgISf+a8GzJg1BfEg=

Đầu ra:

aba8c22f8992d78fd4ff0c94cb19a5c30e62e7587ee43d5285296a4e6e5af062

Your masternode is now registered and will appear on the Deterministic Masternode List after the transaction is mined to a block. You can view this list on the Masternodes -> DIP3 Masternodes tab of the Dash Core wallet, or in the console using the command protx list valid, where the txid of the final protx register_submit transaction identifies your masternode.

At this point you can go back to your terminal window and monitor your masternode by entering dashmate status or using the Get status function in DMT.

Manual installation

The manual installation guide is currently a work in progress.

This guide describes how to manually download and install the components of your Dash masternode under Ubuntu Linux 20.04 LTS "Focal Fossa" assuming you have a non-root user named dash. You will need to manually adjust apt commands if using a different distro.

Core services

Prepare your environment for installing keys through GPG:

sudo mkdir -m 600 /root/.gnupg

Dash Core

Dash Core is a fork of Bitcoin Core and is responsible for all consensus and communication relating to the base blockchain. Download Dash Core as follows:

cd /tmp
wget https://github.com/dashpay/dash/releases/download/v0.17.0.3/dashcore-0.17.0.3-x86_64-linux-gnu.tar.gz

Verify the authenticity of your download by checking its detached signature against the public key published by the Dash Core development team. All releases of Dash are signed using GPG with one of the following keys:

curl https://keybase.io/codablock/pgp_keys.asc | gpg --import
curl https://keybase.io/pasta/pgp_keys.asc | gpg --import
wget https://github.com/dashpay/dash/releases/download/v0.17.0.3/dashcore-0.17.0.3-x86_64-linux-gnu.tar.gz.asc
gpg --verify dashcore-0.17.0.3-x86_64-linux-gnu.tar.gz.asc

Extract the compressed archive and copy the necessary files to the directory:

tar xfv dashcore-0.17.0.3-x86_64-linux-gnu.tar.gz
sudo install -t /usr/local/bin dashcore-0.17.0/bin/*

Create a working directory for Dash Core:

mkdir ~/.dashcore

Configure Dash Core:

cat<<EOF>~/.dashcore/dash.conf
#----
rpcuser=dashrpc
rpcpassword=password
rpcallowip=127.0.0.1
#----
listen=1
server=1
daemon=1
#----
txindex=1
addressindex=1
timestampindex=1
spentindex=1
#----
zmqpubrawtx=tcp://0.0.0.0:29998
zmqpubrawtxlock=tcp://0.0.0.0:29998
zmqpubhashblock=tcp://0.0.0.0:29998
zmqpubrawchainlock=tcp://0.0.0.0:29998
#----
#masternodeblsprivkey=
externalip=$(curl ifconfig.co)
proxy=127.0.0.1:9050
torcontrol=127.0.0.1:9051
#----
testnet=1

[test]
port=19999
rpcport=19998
bind=0.0.0.0
rpcbind=0.0.0.0
EOF

Optionally replace the rpcuser and rpcpassword fields with your own values. Leave the masternodeblsprivkey field commented out for now. Configure Dash Core to start as a service:

cat << EOF | sudo tee /etc/systemd/system/dashd.service
[Unit]
Description=Dash Core
After=syslog.target network-online.target

[Service]
Type=forking
User=dash
Group=dash
ExecStart=/usr/local/bin/dashd
TimeoutStartSec=10m
ExecStop=/usr/local/bin/dash-cli stop
SyslogIdentifier=dashd
TimeoutStopSec=120
RestartSec=120

[Install]
WantedBy=multi-user.target
EOF

Start Dash Core:

sudo systemctl daemon-reload
sudo systemctl enable dashd
sudo systemctl start dashd

Verify Dash Core is running:

sudo systemctl status dashd

Sentinel

Sentinel is a watchdog and works to communicate to the network that your node is working properly. Install Sentinel as follows:

cd
sudo apt install -y python3-virtualenv
git clone -b master https://github.com/dashpay/sentinel.git
cd sentinel
virtualenv venv
venv/bin/pip install -r requirements.txt
venv/bin/python bin/sentinel.py

You will see a message reading dashd not synced with network! Awaiting full sync before running Sentinel. Use the following command to monitor sync status:

dash-cli mnsync status

Khi quá trình đồng bộ hoàn tất, bạn sẽ thấy những phản hồi như sau:

{
  "AssetID": 999,
  "AssetName": "MASTERNODE_SYNC_FINISHED",
  "AssetStartTime": 1558596597,
  "Attempt": 0,
  "IsBlockchainSynced": true,
  "IsSynced": true,
  "IsFailed": false
}

Tor

Tor is an internet relay system designed to preserve anonymity on the internet. Install Tor as follows:

sudo gpg --no-default-keyring --keyring /usr/share/keyrings/tor-archive-keyring.gpg --keyserver hkps://keyserver.ubuntu.com --recv-keys A3C4F0F979CAA22CDBA8F512EE8CBC9E886DDD89
echo "deb [signed-by=/usr/share/keyrings/tor-archive-keyring.gpg] https://deb.torproject.org/torproject.org $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/tor.list
sudo apt update
sudo apt install tor deb.torproject.org-keyring

Platform services

Next, we will install the Dash Platform services. Start with some common dependencies:

cd
curl -sL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt install -y libzmq3-dev nodejs build-essential
sudo npm install forever -g

MongoDB

MongoDB is a document-oriented database. Install MongoDB as follows:

sudo gpg --no-default-keyring --keyring /usr/share/keyrings/mongodb-archive-keyring.gpg --keyserver hkps://keyserver.ubuntu.com --recv-keys 20691EEC35216C63CAF66CE1656408E390CFB1F5
echo "deb [signed-by=/usr/share/keyrings/mongodb-archive-keyring.gpg] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb.list
sudo apt update
sudo apt install -y mongodb-org

Configure MongoDB:

sudo sed -i 's/#replication:/replication:\n  replSetName: driveDocuments/' /etc/mongod.conf

Restart MongoDB:

sudo systemctl restart mongod

Initiate the MongoDB client:

mongo<<<"rs.initiate({_id:'driveDocuments',version: 1,members:[{_id: 0,host: 'localhost:27017',},],});"

Verify MongoDB is running:

sudo systemctl status mongod

Drive

Drive is a replicated state machine for Dash Platform. Download Drive as follows:

cd
git clone -b master https://github.com/dashevo/js-drive
cd js-drive
cp .env.example .env

Configure Drive:

sed -i 's/^CORE_JSON_RPC_PORT.*/CORE_JSON_RPC_PORT=19998/' .env
sed -i 's/^INITIAL_CORE_CHAINLOCKED_HEIGHT.*/INITIAL_CORE_CHAINLOCKED_HEIGHT=415765/' .env
cat<<EOF>> .env
DPNS_CONTRACT_ID=76wgB8KBxLGhtEzn4Hp5zgheyzzpHYvfcWGLs69B2ahq
DPNS_CONTRACT_BLOCK_HEIGHT=59
DPNS_TOP_LEVEL_IDENTITY=4yaJaaeUU9xG6sonkCHZkcZkhcXGqwf5TcNLw5Nh5LJ4
DASHPAY_CONTRACT_ID=6wfobip5Mfn6NNGK9JTQ5eHtZozpkNx4aZUsnCxkfgj5
DASHPAY_CONTRACT_BLOCK_HEIGHT=71
FEATURE_FLAGS_CONTRACT_ID=4CTBQw6eJK9Kg7k4F4v6U1RPMtkfCoPbQzUJDCi85pQb
FEATURE_FLAGS_CONTRACT_BLOCK_HEIGHT=77
EOF

Install package dependencies:

npm_config_zmq_external=true npm install

Start Drive:

forever start -a --uid "drive" scripts/abci.js

Verify Drive is running by checking for a time value under uptime:

forever list

Tenderdash

Tenderdash is a fork of Tendermint and is the blockchain implementation used by Dash Platform. As binaries are not yet published, you will need to build from source. Install Go as follows:

cd /tmp
wget https://golang.org/dl/go1.16.4.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.16.4.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin

Build and install Tenderdash as follows:

cd
sudo apt install -y cmake libgmp-dev
git clone -b coreChainLocksV6 https://github.com/dashevo/tenderdash
cd tenderdash
make install-bls
make build-linux
sudo install -t /usr/local/bin build/*

Initialize Tenderdash:

tenderdash init

Several files will be generated in the ~/.tenderdash directory. Modify the configuration with the following commands:

sed -i 's/\(^moniker.*\)/#\1/' ~/.tenderdash/config/config.toml
sed -i 's/^timeout_commit.*/timeout_commit = "500ms"/' ~/.tenderdash/config/config.toml
sed -i 's/^create_empty_blocks_interval.*/create_empty_blocks_interval = "3m"/' ~/.tenderdash/config/config.toml
sed -i 's/^namespace.*/namespace = "drive_tendermint"/' ~/.tenderdash/config/config.toml
sed -i 's/^seeds.*/seeds = "aa4c3870e6cebd575c80371b4ae0e902a2885e14@54.189.200.56:26656,81c79324942867f694ee49108f05e744c343f5a1@52.43.162.96:26656"/' ~/.tenderdash/config/config.toml
curl https://gist.githubusercontent.com/strophy/ca6acd23bbdec1e55f322dac04a1059d/raw/741ffbba9e009157ad49ce4f7ee6644f45f8d677/genesis.json > ~/.tendermint/config/genesis.json

Configure Tenderdash to start as a service:

cat << EOF | sudo tee /etc/systemd/system/tenderdash.service
[Unit]
Description=Tenderdash
After=syslog.target network-online.target

[Service]
User=dash
Group=dash
TimeoutStartSec=10m
TimeoutStopSec=120
RestartSec=120
ExecStart=/usr/local/bin/tenderdash node
SyslogIdentifier=tenderdash

[Install]
WantedBy=multi-user.target
EOF

Ensure Dash Core is fully synced and start Tenderdash:

sudo systemctl daemon-reload
sudo systemctl enable tenderdash
sudo systemctl start tenderdash

Verify Tenderdash is running:

sudo systemctl status tenderdash

DAPI

DAPI provides masternode services over the JSON RPC and gRPC protocols. Download DAPI as follows:

cd
git clone -b master https://github.com/dashevo/dapi
cd dapi
cp .env.example .env

Modify the configuration with the following commands:

sed -i 's/^API_JSON_RPC_PORT.*/API_JSON_RPC_PORT=3004/' .env
sed -i 's/^API_GRPC_PORT.*/API_GRPC_PORT=3005/' .env
sed -i 's/^TX_FILTER_STREAM_GRPC_PORT.*/TX_FILTER_STREAM_GRPC_PORT=3006/' .env
sed -i 's/^DASHCORE_RPC_PORT.*/DASHCORE_RPC_PORT=19998/' .env
sed -i 's/^DASHCORE_ZMQ_PORT.*/DASHCORE_ZMQ_PORT=29998/' .env
sed -i 's/^DASHCORE_P2P_PORT.*/DASHCORE_P2P_PORT=19999/' .env

Install package dependencies:

npm_config_zmq_external=true npm install

Start DAPI:

forever start -a --uid "dapi" scripts/api.js

Start the transaction filter stream:

forever start -a --uid "tx-filter-stream" scripts/tx-filter-stream.js

Envoy

Envoy is a gRPC service proxy for cloud-native applications. Install Envoy as follows:

cd
sudo gpg --no-default-keyring --keyring /usr/share/keyrings/envoy-archive-keyring.gpg --keyserver hkps://keyserver.ubuntu.com --recv-keys 5270CEAC57F63EBD9EA9005D0253D0B26FF974DB
echo "deb [signed-by=/usr/share/keyrings/envoy-archive-keyring.gpg] https://dl.bintray.com/tetrate/getenvoy-deb focal stable" | sudo tee /etc/apt/sources.list.d/envoy.list
sudo apt update
sudo apt install -y getenvoy-envoy

Configure Envoy as follows:

sudo mkdir /etc/envoy
curl https://gist.githubusercontent.com/strophy/3724a3537d4cbc6fbdba169768392f28/raw/ba521d719c198f9bb44cf3231ad6507ac4418900/grpc.yaml | sudo tee /etc/envoy/config.yaml

Configure Envoy to start as a service:

cat << EOF | sudo tee -a /etc/systemd/system/envoy.service
[Unit]
Description=Envoy
After=syslog.target network-online.target

[Service]
ExecStart=bash -c '/usr/bin/envoy --config-path /etc/envoy/config.yaml | tee'
Restart=always
RestartSec=5
KillMode=mixed
SyslogIdentifier=envoy

[Install]
WantedBy=multi-user.target
EOF

Start Envoy:

sudo systemctl daemon-reload
sudo systemctl enable envoy
sudo systemctl start envoy

Verify Envoy is running:

sudo systemctl status envoy

Finishing up

Ensure services managed by forever start on reboot:

cat<<"EOF"|crontab
* * * * * cd ~/.dashcore/sentinel && ./venv/bin/python bin/sentinel.py 2>&1 >> sentinel-cron.log
@reboot { sleep 5;cd ~/js-drive&&forever start -a --uid "drive" scripts/abci.js;}
@reboot { sleep 6;cd ~/dapi&&forever start -a --uid "dapi" scripts/api.js;}
@reboot { sleep 7;cd ~/dapi&&forever start -a --uid "tx-filter-stream" scripts/tx-filter-stream.js;}
EOF

Ở thời điểm này bạn có thể thoát khỏi máy chủ của bạn bằng việc gõ exit. Chúc mừng bạn! Masternode của bạn bây giờ đang được chạy.

Developer installation

Developers requiring a local masternode can get started quickly by starting dashmate and providing a private key containing collateral directly. Install dependencies if necessary (Docker, NodeJS, NPM, Github CLI). Windows, macOS and Linux are supported, the following example shows how to install dependencies under Ubuntu 20.04 LTS.:

curl -sL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-key C99B11DEB97541F0
sudo apt-add-repository https://cli.github.com/packages
sudo apt install -y nodejs git docker.io docker-compose
sudo usermod -aG docker $USER
newgrp docker

Generate a new Dash address for temporary use using this script or the getnewaddress and dumpprivkey RPC commands in Dash Core in testnet mode. Go to https://testnet-faucet.dash.org/ and request 1000+ tDash to your new address using the promo code 'masternode'. Then download and initialize dashmate as follows:

git clone -b master https://github.com/dashevo/dashmate.git
cd dashmate
npm install && sudo npm link

If you are using Windows, you will need to change the path for two log files. Modify the example below with a log path of your choosing:

dashmate config:set platform.drive.abci.log.prettyFile.path C:\Users\strophy\Documents\GitHub\dashmate\testnet-drive-pretty.log
dashmate config:set platform.drive.abci.log.jsonFile.path C:\Users\strophy\Documents\GitHub\dashmate\testnet-drive-json.log

Register your masternode on the network as follows:

dashmate setup testnet masternode -p <funding-private-key>

Wait until sync and registration are complete. Then start the masternode:

dashmate start

Your masternode is now providing service on the following local ports:

Core P2P:     19999
Core RPC:     19998
Platform P2P: 26656
Platform RPC: 26657
DAPI HTTP:    3000
DAPI gRPC:    3010

Note that platform sync will take some time after core sync is complete. You can monitor progress with dashmate status:platform or use dashmate --help to view other commands.