Mise en place d’un réseau de test#

Mettre en place un masternode avec support des services Evo demande une compréhension de base de Linux et de la technologie blockchain, ainsi qu’une capacité à suivre des instructions de près. Cela demande également une régularité de gestion et une sécurité pointilleuse, en particulier si vous ne stockez pas vos dashs sur un portefeuille matériel. Il y aura quelques choix à faire lors de la procédure, et quelques étapes supplémentaires facultatives à suivre pour une meilleure sécurité.

Des services commerciaux d’hébergement de masternode sont disponibles si vous préférez déléguer la gestion au jour le jour de votre masternode à un opérateur professionnel. En utilisant ces services d’hébergement, vous conservez un contrôle total sur la caution de 1000 dashs et vous payez un pourcentage convenu d’avance à l’opérateur, à titre de rétribution. Il est également possible de déléguer vos clés de vote à un représentant, veuillez consulter la documentation sur la gouvernance pour en savoir plus.

Avant de commencer#

Ce guide présuppose que vous mettez en place un seul masternode sur réseau de test, pour la première fois. Pour mettre à jour un masternode existant, voyez plutôt ici. Voici ce dont vous aurez besoin :

  • 1000 dashs

  • un portefeuille pour stocker vos dashs, de préférence un portefeuille matériel, bien que le portefeuille logiciel Dash Core soit aussi envisageable

  • un serveur Linux, de préférence un serveur privé virtuel (VPS)

For information about hosted masternodes, see the documentation listed below:

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.

Server configuration#

Proper server configuration is essential to successful masternode operation for both security and performance reasons. Refer to the Server configuration page for details on preparing your server to host a masternode.

Envoi de la caution#

Une adresse Dash avec une unique transaction de sortie non dépensée (UTXO) d’un montant exact de 1000 dashs est obligatoire pour mettre en place un masternode. Une fois cette transaction exécutée, différentes clés qui lui sont relatives doivent être collectées pour être, plus tard, saisies dans un fichier de configuration et dans une transaction d’enregistrement, en tant que preuve permettant d’enregistrer la configuration sur la blockchain et d’inclure le masternode dans la liste déterministe. Un masternode peut être démarré depuis un portefeuille matériel ou depuis le portefeuille logiciel officiel Dash Core, bien qu’un portefeuille matériel soit hautement recommandé pour améliorer la sécurité et vous protéger du piratage. Ce guide décrit toutes les étapes aussi bien pour les portefeuilles matériels que pour le portefeuille logiciel Dash Core.

Option 1 : Détenir la caution dans un portefeuille matériel#

Configurez votre Trezor en utilisant le portefeuille Trezor à l’adresse https://wallet.trezor.io/ et envoyez-lui une transaction d’essai pour vérifier que tout fonctionne bien. Pour obtenir de l’aide sur cette étape, voir ce guide. Vous pouvez aussi (avec prudence !) ajouter une phrase de passe à votre Trezor pour protéger encore mieux votre caution. Créez un nouveau compte dans votre portefeuille Trezor en cliquant sur Ajouter un compte. Puis cliquez sur l’onglet Recevoir et envoyez exactement 1000 dashs à l’adresse affichée. Si vous mettez en place plusieurs masternodes, envoyez 1000 dashs aux adresses consécutives du même compte. Vous devriez voir la transaction arriver dès les premières confirmations, en général sous quelques minutes.

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

Onglet Recevoir du portefeuille Trezor, montrant une caution de 1000 dashs bien reçue#

Une fois la transaction apparue, cliquez sur le QR-code à droite pour afficher la transaction dans la blockchain. Gardez cette fenêtre ouverte le temps des étapes suivantes, car nous aurons bientôt à vérifier que les 15 confirmations ont bien eu lieu, comme dans la capture d’écran suivante.

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

Explorateur de blocs de Trezor montrant 15 confirmations pour le transfert de la caution#

Pendant que nous attendons les 15 confirmations, téléchargez la plus récente version de DashMasternodeTool (DMT) depuis la page GitHub ici. Décompressez le fichier et lancez l’exécutable. La fenêtre suivante s’affiche.

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

Écran de démarrage de DashMasternodeTool#

Cliquez sur le troisième bouton depuis la gauche, Vérifier la connexion au réseau Dash, dans le coin supérieur gauche de la fenêtre principale, pour vérifier que la connexion fonctionne. Puis connectez votre appareil Trezor et cliquez sur Tester la connexion au portefeuille matériel pour vérifier que la connexion au Trezor fonctionne.

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

Confirmations de connexion réussie dans DashMasternodeTool#

Nous allons maintenant nous servir de DMT pour saisir quelques informations de base sur le masternode, et extraire l’identifiant de transaction. Suivez les étapes ci-dessous, telles que montrées dans cette capture d’écran :

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

Étapes de configuration de DashMasternodeTool#

  1. Cliquez sur le bouton Nouveau.

  2. Tapez un nom pour votre masternode. Le nom d’hôte que vous avez indiqué précédemment pour votre VPS est un bon choix.

  3. Tapez l’adresse IP de votre masternode. Elle vous a été donnée par l’hébergeur de VPS, à la mise en place de votre serveur. Puis entrez le numéro du port TCP, qui devrait être 19999.

  4. Cliquez sur Locate collateral (Trouver la caution) pour afficher les transactions de caution inutilisées qui sont disponibles sur le portefeuille matériel. Choisissez l’adresse à laquelle vous avez envoyé les 1000 dashs puis cliquer sur Apply (Appliquer). Les champs Collateral address (Adresse de caution), index et Collateral TX hash (Empreinte de la transaction de caution) devraient être remplis automatiquement.

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

DashMasternodeTool avec une configuration de masternode#

Laissez DMT ouvert puis passez à l’étape suivante : installer Dash Core sur votre VPS.

Option 2 : Détenir la caution dans un portefeuille logiciel Dash Core#

Lancez le portefeuille logiciel Dash Core et attendez qu’il se synchronise avec le réseau. Il devrait ressembler à ça, une fois prêt :

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

Portefeuille logiciel Dash Core entièrement synchronisé#

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

Prenez bonne note de l’adresse de la caution, car vous en aurez besoin plus tard. La prochaine étape est de sécuriser votre portefeuille (si vous ne l’avez pas déjà fait). Tout d’abord, chiffrez votre portefeuille en allant sur le menu Réglages > Chiffrer le portefeuille. Il vous est conseillé d’utiliser un mot de passe fort, nouveau, que vous n’avez jamais utilisé ailleurs. Prenez note de votre mot de passe et conservez-le dans un endroit sûr, sinon votre portefeuille vous sera inaccessible de manière définitive et vous perdrez tout accès à vos fonds. Ensuite, sauvegardez le fichier de votre portefeuille en allant dans le menu Fichier > Sauvegarder le portefeuille. Enregistrez le fichier dans un endroit sûr et physiquement séparé de votre ordinateur, car il sera le seul moyen d’accéder à vos fonds si quoi que ce soit arrive à votre ordinateur. Pour en savoir plus sur ces étapes, voir ici.

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

Explorateur de blocs de Trezor montrant 15 confirmations pour le transfert de la caution#

Installation de masternode#

Les outils suivants sont disponibles pour installer un masternode Dash :

installation Dashmate#

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.

Avertissement

Installation as root user is not supported or recommended.

Lancez une nouvelle fois PuTTY ou une console de terminal, et connectez-vous avec le nom d’utilisateur et le mot de passe que vous venez de créer pour votre nouvel utilisateur non-root. Commencez par installer les dépendances Dashmate :

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

Lancez l’assistant d’installation interactif :

dashmate setup

Il vous sera demandé de choisir un réseau, un type de nœud, une adresse IP et une clé privée BLS. Saisissez ces informations ou acceptez les valeurs par défaut détectées ou générées. Démarrez votre nœud comme suit :

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 affichant une série d’états#

Vous pouvez consulter l’état de votre masternode en utilisant les différentes commandes dashmate status comme suit :

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

Continuez avec l’étape d’enregistrement pour mettre en place la caution et les clés, et construire la transaction ProTx indispensable pour activer votre masternode.

Mise à jour de masternode#

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

Enregistrement de masternode#

The three keys required for the different masternode roles are described briefly under Masternode Concepts in this documentation.

Option 1 : Enregistrement depuis un portefeuille matériel#

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 masternode:

  • Clé privée du propriétaire

  • Clé privée d’opérateur (générez-en une neuve, ou bien utilisez la clé privée générée par Dashmate)

  • Clé privée de vote

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

DashMasternodeTool prêt à enregistrer un nouveau masternode#

Puis cliquez sur Register masternode (Enregistrer le masternode). Vous pouvez, facultativement, indiquer une Payout address (Adresse de paiement) différente et/ou une Operator reward (Récompense d’opérateur) différente, puis cliquez sur Continue. Choisissez Remote Dash RPC Node (automatic method) (Nœud Dash RPC distant (méthode automatique)). (Voir ici une documentation sur l’utilisation de votre propre nœud RPC local.) Confirmez les deux messages suivants :

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

Dialogues de confirmation de DashMasternodeTool pour enregistrer un masternode#

La clé publique sera utilisée lors des étapes suivantes. La clé privée doit être saisie dans la configuration sur le masternode. Cela permet au masternode de surveiller sur la blockchain les transactions Pro*Tx correspondantes, et cela le démarrera en tant que masternode quand la transaction signée ProRegTx sera diffusée par le propriétaire (dernière étape ci-dessous). Si vous utilisez la clé BLS générée par dashmate setup, cette information est déjà configurée pour votre masternode. Si vous avez généré votre propre paire de clé BLS, modifiez la configuration Dashmate comme suit :

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

Arrivé à cette étape, vous pouvez revenir à votre fenêtre de terminal et surveiller votre masternode avec la commande dashmate status, ou bien en utilisant la fonction Get status (Voir l’état) dans DMT.

À cette étape, vous pouvez vous déconnecter de votre serveur en tapant exit. Félicitations ! Votre masternode est désormais fonctionnel.

Option 2 : Enregistrement depuis le portefeuille logiciel Dash Core#

Identifier la transaction de financement#

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

Cela devrait vous renvoyer une chaîne de caractères analogue à celle-ci

{
"16347a28f4e5edf39f4dceac60e2327931a25fdee1fb4b94b63eeacf0d5879e3-1",
}

La première chaîne, longue, est votre collateralHash, et le nombre à la fin est le collateralIndex.

Générer une paire de clés BLS#

Une paire de clés BLS publique/privée est obligatoire pour opérer un masternode. La clé privée est spécifiée sur le masternode lui-même, et lui permet d’être inclus dans la liste déterministe des masternodes une fois qu’une transaction d’enregistrement avec la clé publique correspondante a été créée.

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",
  "scheme": "legacy"
}

Ces clés ne sont PAS stockées par le portefeuille ni par Dashmate, et elles doivent être conservées dans un lieu sûr, à l’image de la valeur que retournait, par le passé, la commande masternode genkey.

Ajouter la clé privée à la configuration de votre masternode#

La clé publique sera utilisée lors des étapes suivantes. La clé privée doit être saisie dans le fichier dash.conf sur le masternode. Cela permet au masternode de surveiller sur la blockchain les transactions Pro*Tx correspondantes, et cela le démarrera en tant que masternode quand la transaction signée ProRegTx sera diffusée par le propriétaire (dernière étape ci-dessous). Si vous utilisez la clé BLS générée par dashmate setup, cette information est déjà configurée pour votre masternode. Si vous avez généré votre propre paire de clé BLS, modifiez la configuration Dashmate comme suit :

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

Nous allons maintenant préparer la transaction qui sera utilisée pour enregistrer le masternode sur le réseau.

Préparer une transaction ProRegTx#

Une paire de clés BLS pour l’opérateur a déjà été générée ci-dessus, et la clé privée a été entrée sur le masternode. La clé publique est utilisée dans cette transaction en tant que operatorPubKey.

D’abord, nous devons obtenir du portefeuille une adresse neuve et inutilisée, qui servira comme adresse de clé du propriétaire (ownerKeyAddr). Elle est différente de l’adresse de la caution de 1000 dashs. Générez une nouvelle adresse comme suit :

getnewaddress

yfgxFhqrdDG15ZWKJAN6dQvn6dZdgBPAip

Cette adresse peut aussi être utilisée comme adresse de clé de vote (votingKeyAddr). Alternativement, vous pouvez indiquer une adresse fournie par votre délégataire de vote, ou bien simplement générer une nouvelle adresse de clé de vote, comme suit :

getnewaddress

yfRaZN8c3Erpqj9iKnmQ9QDBeUuRhWV3Mg

Ensuite, générez une seconde adresse ou choisissez une adresse déjà existante, qui servira au propriétaire pour recevoir les paiements du propriétaire du masternode (payoutAddress). Il est également possible d’utiliser une adresse externe au portefeuille :

getnewaddress

yjZVt49WsQd6XSrPVAUGXtJccxviH9ZQpN

Vous pouvez aussi, facultativement, générer et alimenter une troisième adresse comme source des frais de transaction (feeSourceAddress). Si vous avez choisi une adresse de paiement externe, vous devez indiquer une adresse source pour les frais.

L’une de ces deux adresses, de paiement ou de frais, doit avoir un solde suffisant pour régler les frais de transaction, faute de quoi la transaction register_prepare échouera.

Les clés privées des adresses du propriétaire et des frais doivent être accessibles par le portefeuille qui soumettra la transaction au réseau. Si votre portefeuille est protégé par mot de passe, il doit à présent être déverrouillé pour exécuter les commandes suivantes. Déverrouillez votre portefeuille pendant 5 minutes :

walletpassphrase yourSecretPassword 300

Nous allons maintenant préparer une transaction spéciale ProRegTx non signée, en utilisant la commande protx register_prepare. Cette commande a la syntaxe suivante :

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

Avertissement

After v19 hard fork activation, protx register_prepare_legacy must be used if a legacy scheme BLS key is being used to register a masternode. It’s recommended to instead generate a new basic scheme BLS key where possible. This can be done by following the Generate a BLS key pair instructions.

Ouvrez un éditeur de texte, tel que Notepad, pour préparer cette commande. Remplacez chaque argument de la commande comme suit :

  • collateralHash : l’identifiant de la transaction (txid) de la caution de 1000 dashs

  • collateralIndex : l’index de sortie de la transaction de la caution de 1000 dashs

  • ipAndPort : l’adresse IP et le port du masternode, suivant le format x.x.x.x:yyyy

  • ownerKeyAddr : l’adresse Dash nouvellement générée ci-dessus, pour l’adresse du propriétaire et de vote

  • operatorPubKey : la clé publique BLS générée ci-dessus (ou fournie par votre service d’hébergement de masternode)

  • votingKeyAddr : l’adresse Dash nouvellement générée ci-dessus, ou bien l’adresse d’un délégué, utilisée pour le vote des propositions budgétaires

  • operatorReward : le pourcentage de la récompense de bloc à allouer à l’opérateur en tant que paiement

  • payoutAddress : une adresse Dash nouvelle ou déjà existante, où le propriétaire recevra les paiements de masternode

  • feeSourceAddress : une adresse (facultative) d’où seront prélevés les frais de la transaction ProTx. Si elle n’est pas spécifiée, c’est l’adresse payoutAddress qui sera utilisée.

Veuillez noter qu’il revient à l’opérateur de spécifier sa propre adresse de paiement avec une transaction update_service distincte, dans le cas où vous définissez une operatorReward différente de zéro. Le propriétaire de la caution du masternode ne spécifie pas lui-même l’adresse de paiement de l’opérateur.

Exemple (effacez les sauts de ligne si vous le copiez) :

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

Sortie :

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

Ensuite, nous allons utiliser les champs collateralAddress et signMessage pour signer la transaction, et la sortie du champ tx pour soumettre la transaction au réseau.

Signer la transaction ProRegTx#

Nous allons maintenant signer le contenu du champ signMessage au moyen de la clé privée de l’adresse de la caution telle que spécifiée dans collateralAddress. Veuillez noter qu’aucune connexion à Internet n’est obligatoire pour cette étape, ce qui signifie que le portefeuille peut être déconnecté de l’Internet (en « chambre froide ») pour signer le message. Dans cet exemple nous allons à nouveau utiliser le portefeuille logiciel Dash Core, mais il est également possible d’utiliser la fonction de signature d’un portefeuille matériel. La commande a la syntaxe suivante :

signmessage collateralAddress signMessage

Exemple :

signmessage yjSPYvgUiAQ9AFj5tKFA8thFLoLBUxQERb yjZVt49WsQd6XSrPVAUGXtJccxviH9ZQpN|0|yfgxFhqrdDG15ZWKJAN6dQvn6dZdgBPAip|yfRaZN8c3Erpqj9iKnmQ9QDBeUuRhWV3Mg|ad5f82257bd00a5a1cb5da1a44a6eb8899cf096d3748d68b8ea6d6b10046a28e

Sortie :

II8JvEBMj6I3Ws8wqxh0bXVds6Ny+7h5HAQhqmd5r/0lWBCpsxMJHJT3KBcZ23oUZtsa6gjgISf+a8GzJg1BfEg=

Soumettre le message signé#

Nous allons maintenant créer la transaction spéciale ProRegTx pour enregistrer le masternode sur la blockchain. Cette commande doit être envoyée depuis un portefeuille Dash Core contenant des fonds à l’adresse feeSourceAddress ou à l’adresse payoutAddress, car des frais de transaction standard seront prélevés. La commande a la syntaxe suivante :

protx register_submit tx sig

Où :

  • tx : la transaction sérialisée précédemment renvoyée dans le champ de sortie tx par la commande protx register_prepare

  • sig : le message signé avec la clé de la caution par la commande signmessage

Exemple :

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

Sortie :

aba8c22f8992d78fd4ff0c94cb19a5c30e62e7587ee43d5285296a4e6e5af062

Votre masternode est à présent enregistré et il apparaîtra dans la liste des masternodes déterministes dès que la transaction sera minée dans un bloc. Vous pouvez afficher cette liste dans l’onglet Masternodes > Masternodes DIP3 du portefeuille logiciel Dash Core, ou dans la console en utilisant la commande protx list valid, où l’identifiant (txid) de la transaction finale protx register_submit identifie votre masternode.

Arrivé à cette étape, vous pouvez revenir à votre fenêtre de terminal et surveiller votre masternode avec la commande dashmate status, ou bien en utilisant la fonction Get status (Voir l’état) dans DMT.

Installation manuelle#

Ce guide d’installation manuelle est actuellement un travail non achevé.

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.

Services Core#

Prepare your environment for installing keys through GPG:

sudo apt update
sudo apt install apt-transport-https
sudo mkdir -m 600 /root/.gnupg

Tor#

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

wget -qO- https://deb.torproject.org/torproject.org/A3C4F0F979CAA22CDBA8F512EE8CBC9E886DDD89.asc | gpg --dearmor | sudo tee /usr/share/keyrings/tor-archive-keyring.gpg >/dev/null
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

Dash Core#

Dash Core est un fork de Bitcoin Core et il est responsable de tout le consensus et de toute la communication relative à la blockchain de base. Téléchargez Dash Core comme suit :

cd /tmp
wget https://github.com/dashpay/dash/releases/download/v20.0.4/dashcore-20.0.4-$(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 the following key:

curl https://keybase.io/pasta/pgp_keys.asc | gpg --import
wget https://github.com/dashpay/dash/releases/download/v20.0.4/dashcore-20.0.4-$(uname -m)-linux-gnu.tar.gz.asc
gpg --verify dashcore-20.0.4-$(uname -m)-linux-gnu.tar.gz.asc

Décompressez l’archive et copiez les nouveaux fichiers dans le répertoire :

tar xfv dashcore-20.0.4-$(uname -m)-linux-gnu.tar.gz
sudo install -t /usr/local/bin dashcore-20.0.4/bin/*

Create a working directory for Dash Core:

mkdir ~/.dashcore

Configure Dash Core:

cat << EOF | tee ~/.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 icanhazip.com)
#---- comment the following lines if you are not using Tor
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

Démarrez Dash Core :

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

Vérifiez si Dash Core fonctionne :

sudo systemctl status dashd

Utilisez la commande suivante pour surveiller l’état de synchronisation :

dash-cli mnsync status

Quand la synchronisation est terminée, vous devriez voir le message suivant

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

Services Platform#

Next, we will install the Dash Platform services. Start with installing JavaScript dependencies:

cd
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash
source ~/.bashrc
nvm install 20
npm install pm2 -g

Followed by Rust dependencies:

sudo apt install -y build-essential clang cmake curl g++ gcc gnupg2 libgmp-dev libpython3.10-dev libssl-dev libzmq3-dev lsb-release pkg-config
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
source "$HOME/.cargo/env"
rustup toolchain install stable
rustup target add wasm32-unknown-unknown --toolchain stable
cargo install -f wasm-bindgen-cli@0.2.86

And Go dependencies:

cd /tmp
wget https://go.dev/dl/go1.19.11.linux-$(dpkg --print-architecture).tar.gz
sudo tar -C /usr/local -xzf go1.19.11.linux-$(dpkg --print-architecture).tar.gz
export PATH=$PATH:/usr/local/go/bin

Drive#

Drive est une machine d’état répliqué pour Dash Platform. Téléchargez Drive comme suit :

git clone --depth 1 --branch master https://github.com/dashpay/platform/
cd platform
corepack enable
yarn install
yarn workspace @dashevo/rs-drive build
yarn workspace @dashevo/wasm-dpp build
yarn workspaces focus --production @dashevo/drive
cp packages/js-drive/.env.example packages/js-drive/.env

Configure Drive:

sed -i 's/^CORE_JSON_RPC_PASSWORD.*/CORE_JSON_RPC_PASSWORD=password/' packages/js-drive/.env
sed -i 's/^CORE_JSON_RPC_PORT.*/CORE_JSON_RPC_PORT=19998/' packages/js-drive/.env
sed -i 's/^CORE_JSON_RPC_USERNAME.*/CORE_JSON_RPC_USERNAME=dashrpc/' packages/js-drive/.env
sed -i 's/^INITIAL_CORE_CHAINLOCKED_HEIGHT.*/INITIAL_CORE_CHAINLOCKED_HEIGHT=854281/' packages/js-drive/.env
sed -i 's/^VALIDATOR_SET_LLMQ_TYPE.*/VALIDATOR_SET_LLMQ_TYPE=6/' packages/js-drive/.env
sed -i 's/^DASHPAY_MASTER_PUBLIC_KEY=.*/DASHPAY_MASTER_PUBLIC_KEY=02d4dcce3f0a8d2936ce26df4d255fd2835b629b73eea39d4b2778096b91e77946/' packages/js-drive/.env
sed -i 's/^DASHPAY_SECOND_PUBLIC_KEY=.*/DASHPAY_SECOND_PUBLIC_KEY=03699c8b4ebf1696c92e9ec605a02a38f6f9cec47d13fb584fdad779e936e20ccb/' packages/js-drive/.env
sed -i 's/^DPNS_MASTER_PUBLIC_KEY=.*/DPNS_MASTER_PUBLIC_KEY=02c8b4747b528cac5fddf7a6cc63702ee04ed7d1332904e08510343ea00dce546a/' packages/js-drive/.env
sed -i 's/^DPNS_SECOND_PUBLIC_KEY=.*/DPNS_SECOND_PUBLIC_KEY=0201ee28f84f5485390567e939c2b586010b63a69ec92cab535dc96a8c71913602/' packages/js-drive/.env
sed -i 's/^FEATURE_FLAGS_MASTER_PUBLIC_KEY=.*/FEATURE_FLAGS_MASTER_PUBLIC_KEY=029cf2232549de08c114c19763309cb067688e21e310ac07458b59c2c026be7234/' packages/js-drive/.env
sed -i 's/^FEATURE_FLAGS_SECOND_PUBLIC_KEY=.*/FEATURE_FLAGS_SECOND_PUBLIC_KEY=02a2abb50c03ae9f778f08a93849ba334a82e625153720dd5ef14e564b78b414e5/' packages/js-drive/.env
sed -i 's/^MASTERNODE_REWARD_SHARES_MASTER_PUBLIC_KEY=.*/MASTERNODE_REWARD_SHARES_MASTER_PUBLIC_KEY=0319d795c0795bc8678bd0e58cfc7a4ad75c8e1797537728e7e8de8b9acc2bae2b/' packages/js-drive/.env
sed -i 's/^MASTERNODE_REWARD_SHARES_SECOND_PUBLIC_KEY=.*/MASTERNODE_REWARD_SHARES_SECOND_PUBLIC_KEY=033756572938aaad752158b858ad38511c6edff4c79cf8462f70baa25fc6e8a616/' packages/js-drive/.env
sed -i 's/^WITHDRAWALS_MASTER_PUBLIC_KEY=.*/WITHDRAWALS_MASTER_PUBLIC_KEY=032f79d1d9d6e652599d3315d30306b1277fbf588e32e383aef0a59749547d47b7/' packages/js-drive/.env
sed -i 's/^WITHDRAWALS_SECOND_PUBLIC_KEY=.*/WITHDRAWALS_SECOND_PUBLIC_KEY=03eebbe3dc3721603a0b5a13441f214550ffa7d035b7dea9f1911de0f63ddac58d/' packages/js-drive/.env

Démarrez Drive :

pm2 start yarn --name "drive" -- workspace @dashevo/drive abci

Vérifiez que Drive fonctionne en inspectant une valeur temporelle sous 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. Build and install Tenderdash as follows:

cd
git clone --depth 1 --branch v0.11.3 https://github.com/dashpay/tenderdash
cd tenderdash
make install-bls
make build-linux
sudo install -t /usr/local/bin build/*

Initialisez Tenderdash :

tenderdash init full

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/^bootstrap-peers.*/bootstrap-peers = "74907790a03b51ac062c8a1453dafd72a08668a3@35.92.167.154:36656,2006632eb20e670923d13d4f53abc24468eaad4d@52.12.116.10:36656"/' ~/.tenderdash/config/config.toml
sed -i 's/^core-rpc-host.*/core-rpc-host = "localhost:19998"/' ~/.tenderdash/config/config.toml
curl https://gist.githubusercontent.com/strophy/d8665f30aa7544785439e5973a98a1c5/raw/ab254ae5ff4e176daaf6a53c7448e527fe5800d2/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

Assurez-vous que Dash Core est entièrement synchronisé, puis démarrez Tenderdash :

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

Vérifiez que Tenderdash est fonctionnel :

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

Démarrez DAPI :

pm2 start yarn --name "dapi" -- workspace @dashevo/dapi api

Démarrez les filtres de transaction :

pm2 start yarn --name "dapi" -- workspace @dashevo/dapi core-streams

Envoy#

Envoy is a gRPC service proxy for cloud-native applications. As it is responsible for TLS termination, you will need to obtain a TLS certificate for your public IP address before configuring Envoy. You can do this independently using a provider of your choice, or use ZeroSSL to obtain a free certificate. Visit https://app.zerossl.com/certificate/new and enter your public IP address, select HTTP File Upload as the verification method and then download the auth file. Place the contents of this file in the /var/www/html/.well-known/pki-validation/ directory with the original filename on your server and serve it using nginx as follows:

sudo mkdir -p /var/www/html/.well-known/pki-validation/
sudo nano /var/www/html/.well-known/pki-validation/<your_auth_file_name>.txt
sudo apt install -y nginx

Click the link shown in Step 3 of the ZeroSSL interface and verify that the contents of the auth file are displayed in your browser. Complete validation in ZeroSSL and download the bundle file in .zip format. Extract it on your local computer, and copy the contents of the certificate.crt followed by ca_bundle.crt one after the other into the bundle file at the following location on the remote node:

sudo nano /etc/ssl/bundle.crt

Then copy the contents of private.key into the following location on the remote node:

sudo nano /etc/ssl/private.key

Remove nginx and the temporary auth file as follows:

sudo apt -y –purge autoremove nginx sudo rm -rf /var/www/html/.well-known

Install Envoy as follows:

cd /tmp
echo $(uname -m) | grep -q "aarch64" && envoy_arch="aarch_64" || envoy_arch="x86_64"
wget https://github.com/envoyproxy/envoy/releases/download/v1.23.10/envoy-1.23.10-linux-$envoy_arch
sudo install -T envoy-1.23.10-linux-$envoy_arch /usr/local/bin/envoy

Configure Envoy as follows:

sudo mkdir /etc/envoy
curl https://gist.githubusercontent.com/strophy/2716c203d88e77419152f6392623b844/raw/ce7aa360b544621c22587a09e0cf7190fd4a202e/envoy.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/local/bin/envoy --config-path /etc/envoy/config.yaml | tee'
Restart=always
RestartSec=5
KillMode=mixed
SyslogIdentifier=envoy

[Install]
WantedBy=multi-user.target
EOF

Démarrez 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:

pm2 save
pm2 startup

Copy and paste the resulting command to ensure PM2 restarts processes on boot:

sudo env PATH=$PATH:/home/dash/.nvm/versions/node/v16.20.2/bin /home/dash/.nvm/versions/node/v16.20.2/lib/node_modules/pm2/bin/pm2 startup systemd -u dash --hp /home/dash

À cette étape, vous pouvez vous déconnecter de votre serveur en tapant exit. Félicitations ! Votre masternode est désormais fonctionnel.

Installation pour développeurs#

Les développeurs qui ont besoin d’un masternode local peuvent démarrer rapidement en lançant Dashmate et en fournissant une clé privée contenant directement la caution. Installez des dépendances si nécessaire (Docker, NodeJS, NPM, Github CLI). Windows, macOS et Linux sont compatibles. L’exemple suivant montre comment installer des dépendances sous Ubuntu 20.04 LTS :

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash
source ~/.bashrc
nvm install 20
curl -fsSL https://get.docker.com -o get-docker.sh && sh ./get-docker.sh
sudo usermod -aG docker $USER
newgrp docker

Générez une nouvelle adresse Dash à usage temporaire en utilisant ce script ou bien les commandes RPC getnewaddress et dumpprivkey dans Dash Core en mode testnet. Allez sur https://testnet-faucet.dash.org/ et demandez plus de 1000 tDash à votre nouvelle adresse, en utilisant le code promo “masternode”. Puis téléchargez et initialisez Dashmate comme suit :

npm install -g dashmate

Si vous utilisez Windows, vous devrez modifier le chemin de deux fichiers journal. Modifiez l’exemple ci-dessous avec un chemin journal de votre choix :

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

Enregistrez votre masternode sur le réseau, comme suit :

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

Attendez que la synchronisation et l’enregistrement soient terminés. Puis démarrez le masternode :

dashmate start

Votre masternode fournit désormais ses services sur les ports locaux suivants :

Core P2P:     19999
Core RPC:     19998
Platform P2P: 26656
Platform RPC: 26657
DAPI:    3000

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.