Claimez sans Staker
Published: 2022-09-12 18:02:50

---
title: Claimez sans Staker
published: true
description: 
tags: 
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pecjkjtc80cd09p67fo6.png
---

A l'époque de ce qu'on appelait DeFi 2.0 on avait du staking autocompund et des tokens avec des réflections. Ce concept peut aussi exister avec les NFTs. En ce video on va déployer des NFTs que contrôlent l'inflation d'un Token. Les holders peuvent gonfler un token sans avoir besoin de staker les NFTs, les nouvelles tokens vont être mintés directement sur notre wallet.

https://www.youtube.com/watch?v=UxuszsqYYZQ

## Avant de commencer

Pour ce video tu auras besoin de [Metamask](https://metamask.io/) ou n'importe quel wallet compatible avec l'EVM et aussi du GoerliETH que tu peux trouver gratuitement en un [faucet](https://goerlifaucet.com/).

## Les NFTs

D'abord on lance un contrat d'NFTs, remarquez la funcion `registre` que fait tout ça posible.

```solidity
// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

interface ITokenContract
{
    function register(uint tokenId) external;
}

contract NFTContract is ERC721, Ownable {  
    ITokenContract tokenContract;

    uint public price = 0.001 ether;
    uint public constant MAX_SUPPLY = 10000;
    uint public supply;

    constructor () ERC721 ("My NFT", "MNFT") {
    }

    function mint(uint _amount) public payable {
        require( supply + _amount <= MAX_SUPPLY, "Can't mint more than max supply" );
        require( msg.value == price * _amount, "Wrong amount of ETH sent" );
        require( _amount >= 1, "Must mint at least one" );
        for(uint i; i < _amount; i++){
            _safeMint( msg.sender, supply + i );
            tokenContract.register(supply + i);
        }
    }

    function withdrawETH() public onlyOwner
    {
        (bool sent, bytes memory data) = address(owner()).call{value: address(this).balance}("");
        require(sent, "Failed to send Ether");
        data;
    }

    function setTokenContract(address tokenContractAddress) public onlyOwner {
        tokenContract = ITokenContract(tokenContractAddress);
    }
}
```

## Les Tokens

Le même contrat de tokens distribue les récompenses aux holders. Tout de suite avoir déployé le contrat des tokens exécutez la function `setTokenContract` dans le contrat d'NFTs et passez comme paramètre l'adresse du contrat de tokens.

```solidity
// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

interface INFTContract
{
    function ownerOf(uint tokenId) external view returns (address owner);
}

contract TokenContract is ERC20, Ownable {
    uint public REWARD_PER_BLOCK = 0.1 ether;

    INFTContract public myERC721Contract;

    mapping(uint => uint) public checkpoints;
    mapping(uint => bool) public isRegistered;

    constructor(address nftContractAddress) ERC20("My Token", "TKN") {
        myERC721Contract = INFTContract(nftContractAddress);
    }

    function register(uint tokenId) public
    {
        require(msg.sender == address(myERC721Contract));
        isRegistered[tokenId] = true;
        checkpoints[tokenId] = block.number;
    }

    function claim(uint tokenId) public
    {
        require(myERC721Contract.ownerOf(tokenId) == msg.sender, "Must be token owner");
        uint256 reward = calculateReward(tokenId);
        _mint(msg.sender, reward);
        checkpoints[tokenId] = block.number;
    }

    function calculateReward(uint tokenId) public view returns(uint256)
    {
        if(!isRegistered[tokenId])
        {
            return 0;
        }
        uint256 checkpoint = checkpoints[tokenId];
        return REWARD_PER_BLOCK * (block.number-checkpoint);
    }
}
```

**¡Merci pour voir ce video!**

Suivez nous ici en dev.to et en [Youtube](https://www.youtube.com/channel/UCl3hXoRETXvoTWI-j0Y6ZTw) pour tout ce qui a à voir avec Blockchain en Francais.