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)

Dash version 0.13.0 et ultérieure met en œuvre la DIP003, qui introduit certains changements dans la façon d’installer et de gérer un masternode. Bien que cette mise à jour du réseau ait été achevée début 2019, veuillez trouver ci-dessous une liste de sa documentation disponible :

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.

Configuration de votre VPS

Un VPS, plus connu sous le nom de « serveur dans le nuage », est une installation entièrement fonctionnelle d’un système d’exploitation (Linux, en général) exécutée dans une machine virtuelle. La machine virtuelle permet au fournisseur de VPS de faire tourner de nombreux systèmes sur un seul serveur physique, rendant l’ensemble plus efficace et beaucoup moins cher que de faire tourner un unique système d’exploitation sur le « métal nu » de chaque serveur. Un VPS est idéal pour héberger un masternode Dash car les VPS proposent en général une garantie sur la disponibilité, une redondance dans le cas de problèmes matériels et une adresse IP statique qui est indispensable pour que votre masternode ne soit pas éjecté de la file d’attente des paiements. Bien que faire tourner un masternode depuis son domicile, sur un ordinateur de bureau, soit techniquement possible, cela ne marchera certainement pas de manière fiable car la plupart des fournisseurs d’accès allouent des adresses IP dynamiques aux utilisateurs domestiques.

Nous utiliserons l’hébergeur Vultr comme VPS pour notre exemple, bien que DigitalOcean, Amazon EC2, Google Cloud, Choopa ou encore OVH soient également des choix reconnus. Tout d’abord, créez un compte et créditez-le. Puis allez sur le menu Serveurs sur la gauche et cliquez sur + pour ajouter un nouveau serveur. Choisissez un endroit pour votre nouveau serveur, sur l’écran suivant :

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

Page Vultr de choix d’emplacement de serveur

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.

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

Page Vultr de choix du type de serveur

Choisissez une taille de serveur avec au moins 2 Go de mémoire vive.

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

Page Vultr de choix de taille de serveur

Tapez un nom d’hôte et une étiquette pour votre serveur. Dans cet exemple, nous utiliserons « dashmn1 » comme nom d’hôte.

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

Page Vultr de choix du nom d’hôte et de l’étiquette du serveur

Vultr installe à présent votre serveur. Cette étape peut prendre quelques minutes.

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

Page Vultr d’installation du serveur

Cliquez sur Gérer quand l’installation est terminée et prenez note de l’adresse IP, du nom d’utilisateur et du mot de passe.

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

Page Vultr de gestion du serveur

Configuration de votre système d’exploitation

Nous commencerons par nous connecter à votre serveur fraîchement créé. Sous Windows, vous devrez d’abord télécharger une application appelée PuTTY pour vous connecter au serveur. Allez sur la page de téléchargement de PuTTY et choisissez l’installeur MSI approprié à votre ordinateur. Sur Mac ou Linux, vous pouvez vous connecter directement par ssh depuis le Terminal — tapez simplement ssh root@<server_ip> puis votre mot de passe quand il vous est demandé.

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

Page de téléchargement de PuTTY

Double-cliquez sur le fichier téléchargé pour installer PuTTY, puis lancez l’application depuis votre menu Démarrer. Tapez l’adresse IP du serveur dans le champ Nom d’hôte puis cliquez sur Ouvrir. Il est possible qu’un avertissement sur le certificat vous soit affiché, puisque c’est votre première connexion à ce serveur. Vous pouvez sans risque cliquer sur Oui pour faire confiance à ce serveur à l’avenir.

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

Alerte de sécurité de PuTTY à la connexion à un nouveau serveur

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.

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

Demande de mot de passe à la première connexion à votre VPS

Il vous est fortement conseillé de modifier sans attendre le mot de passe de « root » et de le garder dans un endroit sûr. Vous pouvez copier et coller chacune des commandes suivantes en les sélectionnant dans votre navigateur, en faisant la combinaison de touches Ctrl-C puis en revenant sur le fenêtre PuTTY pour y faire un clic-droit. Le texte se collera à la position actuelle du curseur

passwd root

Tapez et confirmez un nouveau mot de passe (de préférence long et généré aléatoirement). Ensuite, nous allons créer un nouvel utilisateur avec la commande suivante, en remplaçant <username> par le nom d’utilisateur de votre choix

adduser <username>

You will be prompted for a password. Enter and confirm using a new password (different to your root password) and store it in a safe place. You will also see prompts for user information, but this can be left blank. Once the user has been created, we will add them to the sudo group so they can perform commands as root:

usermod -aG sudo <username>

Maintenant, toujours en tant que « root », nous allons mettre à jour le système directement depuis le dépôt logiciel Ubuntu

apt update
apt upgrade

Le système affiche une liste de paquets prêts à être mis à jour. Appuyez sur O et Entrée pour installer les paquets. Nous allons maintenant installer un pare-feu, ajouter de la mémoire virtuelle et redémarrer le serveur pour que soit appliquée toute mise à jour nécessaire du noyau. Puis nous nous connecterons en tant que nouvel utilisateur à notre environnement fraîchement sécurisé

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

(appuyez sur O et Entrée pour confirmer)

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

Ajoutez la ligne suivante à la fin du fichier (appuyez sur Tabulation pour séparer chaque mot ou nombre), puis faites la combinaison de touches Ctrl-X pour fermer l’éditeur de texte, puis appuyez sur O et Entrée pour enregistrer le fichier.

/swapfile none swap sw 0 0

Enfin, pour empêcher les attaques par force brute sur les mots de passe, nous allons installer fail2ban et désactiver le login root par SSH. Ces étapes sont facultatives, mais hautement recommandées. Commencez par fail2ban :

apt install fail2ban

Créez un nouveau fichier de configuration :

nano /etc/fail2ban/jail.local

Collez-y la configuration suivante :

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

Puis faites la combinaison de touches Ctrl-X pour fermer l’éditeur de texte, puis O et Entrée pour enregistrer le fichier. Redémarrez et activez le service fail2ban :

systemctl restart fail2ban
systemctl enable fail2ban

Ensuite, ouvrez le fichier de configuration SSH pour désactiver le login root par SSH

nano /etc/ssh/sshd_config

Repérez la ligne PermitRootLogin yes et changez-la en PermitRootLogin no. Juste en-dessous, ajoutez une ligne AllowUsers <username>, en remplaçant <username> avec le nom d’utilisateur que vous avez choisi plus haut. Puis faites la combinaison de touches Ctrl-X pour fermer l’éditeur de texte, puis Y et Entrée pour enregistrer le fichier.

Puis redémarrez le serveur :

reboot now

PuTTY se déconnectera au redémarrage du serveur.

Ce guide comprend les étapes de base pour protéger votre serveur des attaques, mais on peut faire beaucoup plus. En particulier, on peut s’authentifier avec une clé publique plutôt qu’avec une combinaison nom d’utilisateur/mot de passe et activer les mises à jour automatiques de sécurité. Plus d’astuces sont disponibles ici. Cependant, puisque le masternode ne stocke pas les clés de fonds Dash, ces étapes sont considérées comme en dehors de la portée de ce guide.

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.

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
sudo apt install python3-pip
sudo pip3 install docker-compose
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

Vous pouvez gérer l’état de votre masternode, sa configuration, et le lancer entièrement depuis Dashmate. Consultez la documentation ici ou utilisez l’aide intégrée pour en savoir plus :

  • 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

La DIP003 a inauguré plusieurs changements sur la façon de mettre en place et d’opérer un masternode. Ces changements et les trois clés requises pour les différents rôles de masternode sont décrits brièvement dans la section Nouveautés des masternodes DIP003 de la présente documentation.

Option 1 : Enregistrement depuis un portefeuille matériel

Revenez à DashMasternodeTool et assurez-vous que tous les champs de l’étape précédente sont encore remplis correctement. Cliquez sur Generate new (Générer nouveau) pour les trois clés privées requises pour un masternode déterministe DIP003 :

  • 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"
}

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)

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 mkdir -m 600 /root/.gnupg

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/v18.0.0-rc4/dashcore-18.0.0-rc4-$(uname -m)-linux-gnu.tar.gz

Vérifiez l’authenticité de votre téléchargement en comparant sa signature séparée à la clé publique diffusée par l’équipe de développement Dash Core. Toutes les versions de Dash sont signées avec GPG avec une des clés suivantes :

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.0.0-rc4/dashcore-18.0.0-rc4-$(uname -m)-linux-gnu.tar.gz.asc
gpg --verify dashcore-18.0.0-rc4-$(uname -m)-linux-gnu.tar.gz.asc

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

tar xfv dashcore-18.0.0-rc4-$(uname -m)-linux-gnu.tar.gz
sudo install -t /usr/local/bin dashcore-e66d539fa5d1/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

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

Sentinel

Sentinel est un outil de surveillance qui communique au réseau que votre nœud fonctionne sans problème. Installez Sentinel comme suit :

cd
sudo add-apt-repository ppa:deadsnakes/ppa -y
sudo apt install -y software-properties-common python3.9 python3.9-venv
git clone -b master https://github.com/dashpay/sentinel.git
cd sentinel
python3.9 -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

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
}

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

Services Platform

Ensuite, nous allons installer les services Dash Platform. Commençons par quelques dépendances courantes :

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 est une machine d’état répliqué pour Dash Platform. Téléchargez Drive comme suit :

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

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 est un fork de Tendermint. Il s’agit de l’implémentation de blockchain utilisée par Dash Platform. Comme les binaires ne sont pas encore publiés, vous devrez les compiler depuis la source. Installez Go comme suit :

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

Compilez et installez Tenderdash comme suit :

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/*

Initialisez 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/21ad1cdd6112b33a73c032727a096d1563ed0b07/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 est un proxy de service gRPC pour les applications cloud natives. Installez Envoy comme suit :

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

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:

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

À 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.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

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