Cronos: Dutch auction smart contract with Hardhat

• This tutorial shows how to create and deploy a Dutch auction NFT contract on Cronos testnet using Hardhat.
• The price starts high and lowers at fixed intervals; buyers can mint an NFT once the price is acceptable.
• You’ll set up Hardhat, code and compile the contract, then verify and interact with it using Cronoscan.
• The same approach works for mainnet once you’re comfortable testing everything on Cronos testnet.

​

Main article

• Create a Dutch auction smart contract.
• Deploy and verify the contract on the Cronos testnet through a node deployed with Chainstack.
• Interact with the deployed contract.

​

Prerequisites

• Chainstack account to deploy a Cronos testnet node.
• Hardhat to compile and deploy the contract.
• MetaMask to interact with the contract through your Chainstack node.

​

Overview

1. With Chainstack, create a public chain project.
2. With Chainstack, join the Cronos testnet.
3. With Chainstack, access your Cronos node endpoint.
4. With Hardhat, set up your development environment.
5. With Hardhat, create and compile your Dutch auction contract.
6. With MetaMask, fund your wallet with Cronos test tokens (CRO) from the Cronos official faucet.
7. With Hardhat, deploy your Dutch auction contract.
8. With Cronos testnet explorer, interact with your Dutch auction contract.

​

Step-by-step

​

Create a public chain project

​

Join the Cronos testnet

​

Get your Cronos node endpoint

​

Install Hardhat

​

Initialize a Hardhat project

​

Install additional dependencies

npm i @openzeppelin/contracts

npm i dotenv

npm i --save-dev @nomiclabs/hardhat-etherscan@^3.1.0 @cronos-labs/hardhat-cronoscan

touch .env

​

Create and compile the contract

1. Navigate to your previously created project directory and go to the contracts directory. In the directory, create your Dutch auction smart contract: DutchAuction.sol.
   solidity

   Copy

   // SPDX-License-Identifier: MIT
   pragma solidity ^0.8.0;
   
   import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
   import "@openzeppelin/contracts/access/Ownable.sol";
   import "@openzeppelin/contracts/utils/Counters.sol";
   
   contract MyToken is ERC721, Ownable {
       using Counters for Counters.Counter;
   
       Counters.Counter private _tokenIdCounter;
   
       uint256 public immutable startPrice = 10 ether;
       uint256 public immutable startAt;
       uint256 public immutable endsAt;
       uint256 public immutable endPrice = 5 ether;
       uint256 public immutable discountRate = 0.01 ether;
       uint256 public duration = 500 minutes;
       uint256 public immutable MAX_SUPPLY = 100;
   
        mapping (address => bool) public onlyOne;
   
       constructor() ERC721("CronosNFT", "CroNFT") {
           startAt = block.timestamp;
           endsAt = block.timestamp + duration;
       }
   
       function price() public view returns (uint256) {
           if (block.timestamp > endsAt ) {
               return endPrice;
           }
   
           uint256 minutesElapsed = (block.timestamp - startAt) / 60;
   
           return startPrice - (minutesElapsed * discountRate);
       }
   
       function safeMint(address to) public payable {
           require(msg.value >= price(), "Not enough ether sent");
           require(!onlyOne[msg.sender], "Sorry, Address already has 1 NFT!");
           uint256 tokenId = _tokenIdCounter.current();
           require(tokenId < MAX_SUPPLY, "No more items left.");
           _safeMint(to, tokenId + 1);
           _tokenIdCounter.increment();
           onlyOne[msg.sender]=true;
   
       }
   
       function withdraw() public onlyOwner {
           payable(owner()).transfer(address(this).balance);
       }
   }
   

   The contract implementation is the following:
   • The price of an NFT starts at 10 ether and decreases to 5 ether over 500 minutes. A maximum of 100 NFTs can be minted.
   • The contract uses the onlyOne mapping to ensure that each address can only own one NFT from your collection.
   • The contract sets the values of the start and end price, which cannot be changed later on.
   • The function price() uses block.timestamp to calculate the price of an NFT each time the safeMint function is called.
   • If all the required conditions are satisfied, the wallet address gets an NFT minted.
2. To compile the contract, in your project directory, run:
   Shell

   Copy

   npx hardhat compile
   

​

Fund your account

​

Set up the environment and configuration files

1. In your project directory, navigate to a previously created environment file and edit it to add the following data:
   • RPC_URL — your Cronos node HTTPS endpoint deployed with Chainstack. See also View node access and credentials.
   • PRIVATE_KEY — the private key of your MetaMask wallet that has a sufficient amount of TCRO. See also the Cronos faucet.
   • API_KEY — a Cronos API key to verify the deployed smart contract using the Cronoscan and Etherscan plugins. Create an API key in the Cronos blockchain explorer.
   Example of the environment file data:
   env

   Copy

   RPC_URL=YOUR_CHAINSTACK_ENDPOINT
   PRIVATE_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXu7
   API_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXG5
   

2. In your project directory, navigate to the Hardhat configuration file and replace the current data with the following data:
   JavaScript

   Copy

   require("@nomicfoundation/hardhat-toolbox");
   require('dotenv').config();
   require("@nomiclabs/hardhat-etherscan");
   require("@cronos-labs/hardhat-cronoscan");
   
   module.exports = {
     solidity: "0.8.10",
     networks: {
       Cronos_testnet: {
           url: `${process.env.RPC_URL}`,
           accounts: [process.env.PRIVATE_KEY]
       },
   },
   
       etherscan: {
           apiKey: {
            cronosTestnet: `${process.env.API_KEY}`,
     },
   },
   };
   

   where
   • dotenv — library to import your sensitive data from the environment file securely
   • Cronos_testnet — the testnet to deploy the contract to
   • url — your Cronos node HTTPS endpoint imported from the environment file
   • accounts — your MetaMask wallet private key imported from the environment file
   • etherscan — your Cronos API key imported from the environment file to verify your contract

​

Deploy the Dutch auction contract

1. In your project directory, navigate to the scripts directory and create the DeployDutch.js file.
2. Edit the DeployDutch.js file to add the basic deployment script of Hardhat:
   JavaScript

   Copy

   const hre = require("hardhat");
   
   async function main() {
     const CronosToken = await hre.ethers.getContractFactory("MyToken");
     console.log("Deploying your contract, please Wait.....");
     const cronosToken = await CronosToken.deploy();
     await cronosToken.deployed();
   
     console.log("CronosToken deployed to:", cronosToken.address);
   }
   
   main()
     .then(() => process.exit(0))
     .catch((error) => {
       console.error(error);
       process.exit(1);
     });
   

3. In your project directory, run the following script:
   Shell

   Copy

   npx hardhat run scripts/DeployDutch.js --network Cronos_testnet
   

   The contract will deploy and the terminal will return the contract address. Use this address to verify and interact with your contract.

​

Verify your contract on the Cronos testnet

npx hardhat verify --network Cronos_testnet CONTRACT_ADDRESS

​

Interact with the contract

​

Conclusion

​

About the author

Priyank Gupta

Developer Advocate @ Chainstack BUIDLs on Ethereum, zkEVMs, The Graph protocol, and IPFS Part-time Rust aficionado