Cronos: Dutch auction smart contract with Hardhat

• This tutorial shows how to create and deploy a Dutch auction NFT contract on Cronos Mainnet 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 the Cronos Explorer.
• Because this deploys to Cronos Mainnet, deployment and minting spend real CRO — fund your wallet with a small amount to start.

Main article

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

Prerequisites

• Chainstack account to deploy a reliable Cronos RPC endpoint.
• 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 Cronos Mainnet.
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 CRO to cover deployment and minting gas.
7. With Hardhat, deploy your Dutch auction contract.
8. With the Cronos Explorer, interact with your Dutch auction contract.

Step-by-step

Create a public chain project

Join Cronos Mainnet

Get your Cronos node endpoint

Install Hardhat

npm init -y
npm install --save-dev hardhat@hh2

Initialize a Hardhat project

Install additional dependencies

npm i @openzeppelin/contracts

npm i dotenv

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

   // SPDX-License-Identifier: MIT
   pragma solidity ^0.8.20;
   
   import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
   import "@openzeppelin/contracts/access/Ownable.sol";
   
   contract MyToken is ERC721, Ownable {
       uint256 private _nextTokenId;
   
       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") Ownable(msg.sender) {
           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 = _nextTokenId;
           require(tokenId < MAX_SUPPLY, "No more items left.");
           _nextTokenId++;
           onlyOne[msg.sender] = true;
           _safeMint(to, tokenId + 1);
       }
   
       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. The contract records the mint before calling _safeMint, so a receiving contract can’t mint a second NFT by calling back into safeMint.
2. To compile the contract, in your project directory, run:
   Shell

   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, funded with enough CRO to cover deployment gas.
   • API_KEY — a Cronos Explorer API key used to verify the deployed contract. Create one in the Cronos Explorer (see Block explorer and API keys).
   Example of the environment file data:
   env

   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

   require("@nomicfoundation/hardhat-toolbox");
   require('dotenv').config();
   
   module.exports = {
     solidity: {
       version: "0.8.28",
       settings: {
         evmVersion: "cancun",
       },
     },
     networks: {
       cronos: {
         url: `${process.env.RPC_URL}`,
         chainId: 25,
         accounts: [process.env.PRIVATE_KEY]
       },
     },
     etherscan: {
       apiKey: {
         cronos: `${process.env.API_KEY}`
       },
       customChains: [
         {
           network: "cronos",
           chainId: 25,
           urls: {
             apiURL: `https://explorer-api.cronos.org/mainnet/api/v1/hardhat/contract?apikey=${process.env.API_KEY}`,
             browserURL: "https://explorer.cronos.com"
           }
         }
       ]
     }
   };
   
   where
   • dotenv — library to import your sensitive data from the environment file securely
   • solidity — the compiler version and EVM target. OpenZeppelin Contracts 5 uses the Cancun mcopy instruction, and Hardhat 2 compiles for an older EVM by default, so set evmVersion to cancun, which Cronos supports
   • cronos — the Cronos Mainnet network 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 — Cronos Explorer verification settings: your API key plus the customChains entry that points hardhat-verify at the Cronos Explorer

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

   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.waitForDeployment();
   
     console.log("CronosToken deployed to:", await cronosToken.getAddress());
   }
   
   main()
     .then(() => process.exit(0))
     .catch((error) => {
       console.error(error);
       process.exit(1);
     });
   
3. In your project directory, run the following script:
   Shell

   npx hardhat run scripts/DeployDutch.js --network cronos
   
   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 Cronos Mainnet

npx hardhat verify --network cronos CONTRACT_ADDRESS

Interact with the contract

Conclusion

About the author

Priyank Gupta

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