[#CALENDRIER DE L'AVENT 21/25]
25 jours pour apprendre à développer des Smart Contracts en #Solidity 🔥
Jour 21 / 25 :
Staking : Aujourd'hui nous allons gérer les récompenses du staking, ainsi que le claim de ces récompenses ! 💸
🧵
Tweet précédent
🔽
Avant de commencer, vous pouvez repartir du code développé hier.
Il est présent dans le répertoire "Jour21/Staking_Jour21.sol".
N’oubliez pas de modifier les noms et les imports.
Si vous n'avez pas ce répertoire : git pull.
Nous allons passer à la gestion des récompenses !
Mais avant tout, nous devons comprendre comment va marcher le claim des récompenses !
Il y a deux possibilités : claim les récompenses sans de-staker, claim les récompenses en de-stakant.
Ceci va influencer notre gestion.
Nous allons donc commencer par définir une fonction qui permet de retourner le montant de tokens de récompense que l'utilisateur peut réclamer.
Cette fonction est externe et c'est une simple vue, elle ne permet pas de récupérer les récompenses !
Elle sera utile pour une dApp.
La vue prend en paramètre l'adresse pour laquelle on souhaite connaitre les récompenses ainsi qu'une liste de tokens.
On définit une variable pour stocker le montant des récompenses pour le retourner à la fin, et l'on définit une boucle qui va parcourir la liste des tokens.
Nous n'avons qu'un seul "require" pour cette fonction.
Il nous permet de regarder dans la structure associée à l'ID si le "owner" que nous avons spécifié dans la fonction "stake" est bien l'adresse passée en entrée de la fonction.
L'étape suivante pourrait être réduite, mais elle apporte plus de clarté dans le code.
On récupère "stakingStartTime" dans la structure afin de l'utiliser par la suite.
Une fois dans notre variable, on peut l'utiliser dans le calcul pour simplifier la lecture du code !
Maintenant il nous suffit d'ajouter à notre variable globale "totalEarned" le même calcul pour chaque NFT, à savoir :
("Le timestamp actuel" - "Le timestamp de début de staking") x les récompenses par heures / 3600 (seconde dans une heure).
Le timestamp étant en seconde !
Maintenant que nous avons, pour chaque token de la liste, additionné les récompenses récupérables dans la variable "totalEarned", il ne reste qu'à retourner la valeur !
Cette fonction sera très utile pour un dashboard utilisateur par exemple et elle ne coûte pas de gas !
Nous savons calculer les récompenses récupérables, il est temps de préparer la fonction qui permet de les récupérer maintenant !
Nous allons définir deux fonctions de "claim", une fonction externe, que l'utilisateur va appeler, et une interne, qui sera appelée par le contrat.
Cela vient du fait que nous pouvons claim en récupérant les NFTs ou non.
La fonction externe "claim" va appeler la fonction interne avec un paramètre "unstake" à "false".
Alors que plus tard, notre fonction "unstake" appellera la fonction "_claim" avec ce paramètre à "true".
L'intérêt d'un tel mécanisme est de permettre une fonction "internal" simple, et de pouvoir réutiliser la fonction de claim au moment où l'utilisateur va vouloir récupérer ses NFTs sans dupliquer le code !
Passons à notre fonction privée "_claim".
Pour commencer, elle est interne et prend en paramètre l'adresse du propriétaire, une liste de token ainsi que le fameux booléen pour savoir si on doit "unstake" ou non.
Par convention, une fonction "internal" est nommée avec un underscore en début de nommage.
Le début est identique à la fonction "getRewards" que nous avons déjà développée, nous pourrions d'ailleurs factoriser tout ça.
Mais, il est plus lisible de le faire ainsi, car nous devons rajouter quelque chose dans notre boucle "for".
Il faut penser à remettre au timestamp actuel le "stakingStartTime" de la structure lié à chaque NFT.
Le but ici est d'éviter que l'utilisateur puisse claim des tokens à l'infini sans remettre à zéro le temps de staking, car les récompenses sont calculées selon le temps passé.
L'étape suivante est le "mint" du token de récompense.
La condition est que la variable "totalEarned" soit suppérieur à 0.
On mint directement les tokens à l'adresse de l'utilisateur.
Il faut penser à ajouter notre contrat de staking en "admin" de notre contrat ERC20 !
Condition suivante, si le booléen d'entrée "_unstake" est à "true" alors nous allons déclencher la fonction interne "_unstakeNFT".
Cette fonction permettra de retransférer les NFTs à l'utilisateur, nous allons la commenter pour le moment, car nous la développerons demain !
Pour finir aujourd'hui, nous allons terminer la fonction interne "_claim".
Après tous les traitements, on émet un événement "Claimed" qui diffuse l'adresse de la personne qui a récupéré les jetons ainsi que le montant total de token qu'il a pu recevoir !
Et c'est terminé !
À ce stade, notre contrat permet de staker un ou plusieurs NFTs, de récupérer le nombre de récompenses disponibles via une vue et de récupérer les tokens de récompense que l'utilisateur accumule avec le temps !
Demain, place à la récupération des NFTs !
Share this Scrolly Tale with your friends.
A Scrolly Tale is a new way to read Twitter threads with a more visually immersive experience.
Discover more beautiful Scrolly Tales like this.