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.
Commercial masternode hosting services are available if you prefer to delegate day-to-day operation of your masternode to a professional operator. When using these hosting services, you retain full control of the 1000 DASH collateral and pay an agreed percentage of your reward to the operator. It is also possible to delegate your voting keys to a representative, see the governance documentation for more information.
Antes de comenzar#
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
Una billetera para guardar tus Dash, preferiblemente una billetera de hardware, aunque la billetera Dash Core también es compatible
Un servidor Linux, preferiblemente un Servidor Privado Virtual (VPS)
Dash 0.13.0 and later implement DIP003, which introduces several changes to how a Dash masternode is set up and operated. While this network upgrade was completed in early 2019, a list of available documentation appears below:
cambios-dip3
Dash 0.13 Upgrade Procedure for Masternodes (legacy documentation)
Masternode completos guías de configuración (estas aquí)
This documentation describes the commands as if they were entered in the
Dash Core GUI by opening the console from Window > Console, but the
same result can be achieved on a masternode by entering the same
commands and adding the prefix ~/.dashcore/dash-cli
to each command.
Configurar tu VPS#
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:

Pantalla de selección de ubicación del servidor Vultr#
Select Ubuntu 22.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.

Pantalla de selección del tipo de servidor Vultr#
Selecciona un tamaño de servidor que ofrezca al menos 2 GB de memoria.

Pantalla de selección del tamaño del servidor Vultr#
Ingresa un nombre de alojamiento y una etiqueta para tu servidor. En este ejemplo usaremos dashmn1
como nombre de alojamiento.

Nombre dealojamiento del servidor de Vultr & pantalla de selección de etiqueta#
Vultr ahora instalará tu servidor. Este proceso puede tardar unos minutos.

Pantalla de instalación del servidor Vultr#
Haz click en Administrar cuando la instalación esté completa y toma nota de la dirección IP, el nombre de usuario y la contraseña.

Pantalla de administración del servidor Vultr#
Configurar tu sistema operativo#
Comenzaremos por conectarnos a tu servidor recién provisto. En Windows, primero descargaremos una aplicación llamada PuTTY para conectarnos al servidor. Ve a la Página de descargas de PuTTY y selecciona el instalador MSI apropiado para tu sistema. En Mac o Linux puedes escribir ssh directamente desde el terminal - simplemente escribe ssh root@<server_ip>
e ingresa tu contraseña cuando se le solicite.

Página de descargas de PuTTY#
Haz doble click en el archivo descargado para instalar PuTTY, luego ejecuta la aplicación desde tu menú de Inicio. Ingresa la dirección IP del servidor en el campo Nombre de alojamiento y haz click en Abrir. Puedes ver una advertencia de certificado, ya que esta es la primera vez que te conectas a este servidor. Puedes hacer click con seguridad en Si para confiar en este servidor en el futuro.

Alerta de seguridad de PuTTY cuando te conectas a un nuevo servidor#
You are now connected to your server and should see a terminal
window. Begin by logging in to your server with the user root
and
password supplied by your hosting provider.

Desafío de contraseña al conectarte a tu VPS por primera vez#
Deberías cambiar inmediatamente la contraseña de raíz y almacenarla en un lugar seguro para mayor seguridad. Puedes copiar y pegar cualquiera de los siguientes comandos seleccionándolos en tu navegador, presionando Ctrl + C, luego cambiando a la ventana PuTTY y haciendo click derecho en la ventana. El texto se pegará en la ubicación actual del cursor:
passwd root
Ingresa y confirma una nueva contraseña (preferiblemente larga y aleatoriamente generada). A continuación crearemos un nuevo usuario con el siguiente comando, reemplazando <username>
con un nombre de usario de tu elección:
adduser <username>
Se te solicitará una contraseña. Ingresa y confirma usando una nueva contraseña (diferente a tu contraseña de raíz) y guárdala en un lugar seguro. También verás solicitudes de información del usuario, pero esto puede dejarse en blanco. Una vez que el usuario ha sido creado, los agregaremos al grupo sudo para que puedan ejecutar comandos como root:
usermod -aG sudo <username>
Ahora, aunque todavía como raíz, actualizaremos el sistema desde el repositorio de paquetes de 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
(presiona Y y Entrar para confirmar)
fallocate -l 4G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile
nano /etc/fstab
Agregua la siguiente línea al final del archivo (presiona la pestaña para separar cada palabra/número), luego presiona Ctrl + X para cerrar el editor, luego presiona Y y Entrar para guardar el archivo .
/swapfile none swap sw 0 0
Finally, in order to prevent brute force password hacking attacks, we will install fail2ban and disable root login over ssh. These steps are optional, but highly recommended. Start with fail2ban:
apt install fail2ban
Crea un nuevo archivo de configuración:
nano /etc/fail2ban/jail.local
Y paga en la configuración a continuación:
[sshd]
enabled = true
port = 22
filter = sshd
logpath = /var/log/auth.log
maxretry = 3
Then press Ctrl + X to close the editor, then Y and Enter save the file. Retart and enable the fail2ban service:
systemctl restart fail2ban
systemctl enable fail2ban
Siguiente, abre el archivo de configuración SSH para deshabilitar registro de root por 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.
Reinicia el servidor:
reboot now
PuTTY se desconectará cuando el servidor se reinicie.
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.
Enviar garantía#
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.

Pestaña de recepción en la billetera Trezor que muestra la garantía de 1000 DASH recibida con éxito#
Una vez que aparece la transacción, haz click en el código QR a la derecha para ver la transacción en la cadena de bloques. Manten esta ventana abierta mientras completamos los siguientes pasos, ya que pronto necesitaremos confirmar que existen 15 confirmaciones, como se muestra en la siguiente captura de pantalla.

El explorador Trezor de la cadena de bloques muestra 15 confirmaciones para la transferencia de garantías#
Mientras esperamos 15 confirmaciones, descarga la última versión de la herramienta Dash Masternode (DMT) desde la página de lanzamientos de GitHub aquí. Descomprime y ejecuta el archivo. La siguiente ventana aparecerá.

Pantalla de inicio de la herramienta Dash Masternode#
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.


Herramienta Dash Masternode confirmaciones exitosas de conexión#
We will now use DMT to enter some basic information about the masternode and extract the transaction ID. Carry out the following sequence of steps as shown in this screenshot:

Pasos de configuración de la Herramienta Dash Masternode#
Haz clic en el nuevo botón.
Ingresa un nombre para tu masternode. El nombre del servidor que especifica para tu VPS es una buena opción.
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.
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.

Dash Masternode Tool with masternode configuration#
Leave DMT open and continue with the next step: installing Dash Core on your VPS.
Option 2: Holding collateral in Dash Core wallet#
Abre la billetera Dash Core y espera a que se sincronice con la red. Debería verse así esto cuando esté lista:

Billetera Dash Core totalmente sincronizada#
Click Window > Console to open the console. Type the following command into the console to generate a new Dash address for the collateral:
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.

El explorador Trezor de la cadena de bloques muestra 15 confirmaciones para la transferencia de garantías#
Masternode Installation#
The following tools are available for installing a Dash masternode:
Dash Masternode Zeus (does not yet support platform services)
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:
curl -fsSL https://get.docker.com -o get-docker.sh && sh ./get-docker.sh
sudo usermod -aG docker $USER
newgrp docker
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash
source ~/.bashrc
nvm install 16
Install dashmate:
npm install -g dashmate
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

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
npm update -g dashmate
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
npm update -g dashmate
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 Masternode Changes in this documentation.
Option 1: Registering from a hardware wallet#
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:
Llave privada del dueño
Operator private key (generate new or use private key generated by dashmate)
Llave privada votando

Dash Masternode Tool ready to register a new masternode#
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:


Dash Masternode Tool confirmation dialogs to register a 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.
Option 2: Registering from Dash Core wallet#
Identifica la transacción de financiamiento#
If you used an address in Dash Core wallet for your collateral transaction, you now need to find the txid of the transaction. Click Window > Console and enter the following command:
masternode outputs
This should return a string of characters similar to the following:
{
"16347a28f4e5edf39f4dceac60e2327931a25fdee1fb4b94b63eeacf0d5879e3" : "1",
}
The first long string is your collateralHash
, while the last number
is the collateralIndex
.
Genera un par de llaves 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 Window > 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.
Agrega la llave privada para la configuración de masternodes#
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
We will now prepare the transaction used to register the masternode on the network.
Prepara una transacción de 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)
Abre un editor de texto tal como un bloq de notas para preparar este comando. Reemplaza cada argumento para los comandos siguientes:
collateralHash
: The txid of the 1000 Dash collateral funding transactioncollateralIndex
: The output index of the 1000 Dash funding transactionipAndPort
: Masternode IP address and port, in the formatx.x.x.x:yyyy
ownerKeyAddr
: The new Dash address generated above for the owner/voting addressoperatorPubKey
: The BLS public key generated above (or provided by your hosting service)votingKeyAddr
: The new Dash address generated above, or the address of a delegate, used for proposal votingoperatorReward
: The percentage of the block reward allocated to the operator as paymentpayoutAddress
: A new or existing Dash address to receive the owner’s masternode rewardsfeeSourceAddress
: An (optional) address used to fund ProTx fee.payoutAddress
will be used if not specified.
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.
Ejemplo (elimina salto de lineas de copiado):
protx register_prepare
16347a28f4e5edf39f4dceac60e2327931a25fdee1fb4b94b63eeacf0d5879e3
1
45.76.230.239:19999
yfgxFhqrdDG15ZWKJAN6dQvn6dZdgBPAip
99f20ed1538e28259ff80044982372519a2e6e4cdedb01c96f8f22e755b2b3124fbeebdf6de3587189cf44b3c6e7670e
yfRaZN8c3Erpqj9iKnmQ9QDBeUuRhWV3Mg
0
yjZVt49WsQd6XSrPVAUGXtJccxviH9ZQpN
yR83WsikBaBaNusTnHZf28kAcL8oVmp1TE
Salida:
{
"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.
Firma la transacción 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
Ejemplo:
signmessage yjSPYvgUiAQ9AFj5tKFA8thFLoLBUxQERb yjZVt49WsQd6XSrPVAUGXtJccxviH9ZQpN|0|yfgxFhqrdDG15ZWKJAN6dQvn6dZdgBPAip|yfRaZN8c3Erpqj9iKnmQ9QDBeUuRhWV3Mg|ad5f82257bd00a5a1cb5da1a44a6eb8899cf096d3748d68b8ea6d6b10046a28e
Salida:
II8JvEBMj6I3Ws8wqxh0bXVds6Ny+7h5HAQhqmd5r/0lWBCpsxMJHJT3KBcZ23oUZtsa6gjgISf+a8GzJg1BfEg=
Ingresa el mensaje firmado#
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
Donde:
tx
: The serialized transaction previously returned in thetx
output field from theprotx register_prepare
commandsig
: The message signed with the collateral key from thesignmessage
command
Ejemplo:
protx register_submit 030001000175c9d23c2710798ef0788e6a4d609460586a20e91a15f2097f56fc6e007c4f8e0000000000feffffff01a1949800000000001976a91434b09363474b14d02739a327fe76e6ea12deecad88ac00000000d1010000000000e379580dcfea3eb6944bfbe1de5fa2317932e260acce4d9ff3ede5f4287a34160100000000000000000000000000ffff2d4ce6ef4e1fd47babdb9092489c82426623299dde76b9c72d9799f20ed1538e28259ff80044982372519a2e6e4cdedb01c96f8f22e755b2b3124fbeebdf6de3587189cf44b3c6e7670ed1935246865dce1accce6c8691c8466bd67ebf1200001976a914fef33f56f709ba6b08d073932f925afedaa3700488acfdb281e134504145b5f8c7bd7b47fd241f3b7ea1f97ebf382249f601a0187f5300 II8JvEBMj6I3Ws8wqxh0bXVds6Ny+7h5HAQhqmd5r/0lWBCpsxMJHJT3KBcZ23oUZtsa6gjgISf+a8GzJg1BfEg=
Salida:
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 22.04 LTS «Jammy Jellyfish»
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/v18.2.2/dashcore-18.2.2-$(uname -m)-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:
Alexander Block (codablock) with the key
63A9 6B40 6102 E091
, verifiable here on KeybasePasta (pasta) with the key
5252 7BED ABE8 7984
, verifiable here on Keybase
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/v18.2.2/dashcore-18.2.2-$(uname -m)-linux-gnu.tar.gz.asc
gpg --verify dashcore-18.2.2-$(uname -m)-linux-gnu.tar.gz.asc
Extract the compressed archive and copy the necessary files to the directory:
tar xfv dashcore-18.2.2-$(uname -m)-linux-gnu.tar.gz
sudo install -t /usr/local/bin dashcore-18.2.2/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
Sentinela#
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 software-properties-common python3-venv
git clone -b master https://github.com/dashpay/sentinel.git
cd sentinel
python3 -m venv . sentinel
bin/pip install -r requirements.txt
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
Cuando se completa la sincronización, deberías ver la siguiente respuesta:
{
"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 -y tor deb.torproject.org-keyring
Platform services#
Next, we will install the Dash Platform services. Start with some common dependencies:
cd
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash
source ~/.bashrc
nvm install 16
sudo apt install -y libzmq3-dev build-essential cmake libgmp-dev gcc-10 g++-10 apt-transport-https gnupg2 curl lsb-release
export CC=gcc-10 && export CXX=g++-10
npm install pm2 -g
Drive#
Drive is a replicated state machine for Dash Platform. Download Drive as follows:
git clone -b master https://github.com/dashevo/platform/
cd platform
corepack enable
yarn workspaces focus --production @dashevo/drive
cp packages/js-drive/.env.example packages/js-drive/.env
Configure Drive:
sed -i 's/^CORE_JSON_RPC_PORT.*/CORE_JSON_RPC_PORT=19998/' packages/js-drive/.env
sed -i 's/^INITIAL_CORE_CHAINLOCKED_HEIGHT.*/INITIAL_CORE_CHAINLOCKED_HEIGHT=415765/' packages/js-drive/.env
sed -i 's/^CORE_JSON_RPC_USERNAME.*/CORE_JSON_RPC_USERNAME=dashrpc/' packages/js-drive/.env
sed -i 's/^CORE_JSON_RPC_PASSWORD.*/CORE_JSON_RPC_PASSWORD=password/' packages/js-drive/.env
sed -i 's/^DPNS_MASTER_PUBLIC_KEY=.*/DPNS_MASTER_PUBLIC_KEY=022a5ffc9f92e005a02401c375f575b3aed5606fb24ddef5b3a05d55c66ba2a2f6/' packages/js-drive/.env
sed -i 's/^DASHPAY_MASTER_PUBLIC_KEY=.*/DASHPAY_MASTER_PUBLIC_KEY=02c6bf10f8cc078866ed5466a0b5ea3a4e8db2a764ea5aa9cb75f22658664eb149/' packages/js-drive/.env
sed -i 's/^FEATURE_FLAGS_MASTER_PUBLIC_KEY=.*/FEATURE_FLAGS_MASTER_PUBLIC_KEY=033d57d03ba602acecfb6fd4ad66c5fdb9a739e163faefa901926bdf28063f9251/' packages/js-drive/.env
sed -i 's/^MASTERNODE_REWARD_SHARES_MASTER_PUBLIC_KEY=.*/MASTERNODE_REWARD_SHARES_MASTER_PUBLIC_KEY=02182c19827a5e3151feb965b2c6e6bbe57bb1f2fe7579595d76b672966da4e8e6/' packages/js-drive/.env
Start Drive:
pm2 start yarn --name "drive" -- workspace @dashevo/drive abci
Verify Drive is running by checking for a time value under uptime
:
pm2 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://go.dev/dl/go1.18.2.linux-$(dpkg --print-architecture).tar.gz
sudo tar -C /usr/local -xzf go1.18.2.linux-$(dpkg --print-architecture).tar.gz
export PATH=$PATH:/usr/local/go/bin
Build and install Tenderdash as follows:
cd
git clone -b v0.7.1 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 = "74907790a03b51ac062c8a1453dafd72a08668a3@54.189.200.56:26656,2006632eb20e670923d13d4f53abc24468eaad4d@52.43.162.96:26656"/' ~/.tenderdash/config/config.toml
curl https://gist.githubusercontent.com/strophy/9a564bbc423198a2fdf4e807b7b40bb4/raw/797ed1a074ca90e574ef016cae4f43e97ae07f56/genesis.json > ~/.tenderdash/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. Start DAPI as follows:
cd ~/platform
yarn workspaces focus --production @dashevo/dapi
cp packages/dapi/.env.example packages/dapi/.env
Modify the configuration with the following commands:
sed -i 's/^API_JSON_RPC_PORT.*/API_JSON_RPC_PORT=3004/' packages/dapi/.env
sed -i 's/^API_GRPC_PORT.*/API_GRPC_PORT=3005/' packages/dapi/.env
sed -i 's/^TX_FILTER_STREAM_GRPC_PORT.*/TX_FILTER_STREAM_GRPC_PORT=3006/' packages/dapi/.env
sed -i 's/^DASHCORE_RPC_PORT.*/DASHCORE_RPC_PORT=19998/' packages/dapi/.env
sed -i 's/^DASHCORE_ZMQ_PORT.*/DASHCORE_ZMQ_PORT=29998/' packages/dapi/.env
sed -i 's/^DASHCORE_P2P_PORT.*/DASHCORE_P2P_PORT=19999/' packages/dapi/.env
Start DAPI:
pm2 start yarn --name "dapi" -- workspace @dashevo/dapi api
Start the transaction filter stream:
pm2 start yarn --name "dapi" -- workspace @dashevo/dapi core-streams
Envoy#
Envoy is a gRPC service proxy for cloud-native applications. Install Envoy as follows:
cd
curl -sL 'https://deb.dl.getenvoy.io/public/gpg.8115BA8E629CC074.key' | sudo gpg --dearmor -o /usr/share/keyrings/getenvoy-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/getenvoy-keyring.gpg] https://deb.dl.getenvoy.io/public/deb/ubuntu $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/getenvoy.list
sudo apt update
sudo apt install -y getenvoy-envoy
Configure Envoy as follows:
sudo mkdir /etc/envoy
curl https://gist.githubusercontent.com/strophy/a6f4f6e30212e7cadcefb65b179c9bce/raw/c8c879de320fc93f5c56793c7bb89acb3165bab9/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 pm2
start on reboot:
cat<<"EOF"|crontab
* * * * * cd ~/sentinel && ./bin/python bin/sentinel.py 2>&1 >> sentinel-cron.log
@reboot { sleep 5;cd ~/platform&&pm2 start yarn --name "drive" -- workspace @dashevo/drive abci;}
@reboot { sleep 6;cd ~/platform&&pm2 start yarn --name "dapi" -- workspace @dashevo/dapi api;}
@reboot { sleep 7;cd ~/platform&&pm2 start yarn --name "dapi" -- workspace @dashevo/dapi core-streams;}
EOF
En este punto, puedes cerrar la sesión de tu servidor de manera segura escribiendo salir
. ¡Felicitaciones! Tu masternode ahora se está ejecutando.
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 -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash
source ~/.bashrc
nvm install 16
curl -fsSL https://get.docker.com -o get-docker.sh && sh ./get-docker.sh
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:
npm install -g dashmate
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.