How to Build An English Auction Smart Contract On The Celo Blockchain

English Auction is a type of auction in which bidders openly compete against each other, with each subsequent bid being higher than the previous bid. This style of auction is also known as an ascending-price auction.

A smart contract is a self-executing contract that is capable of enforcing the terms of an agreement. In the context of an English Auction, a smart contract can be used to govern the bidding process and the transfer of ownership of an item to the highest bidder, in our case it's an NFT.

In this article, you will learn how to implement an NFT English auction smart contract on the Celo blockchain network. Finally, we will demonstrate how our English smart contract works.

Table of Contents
Prerequisites
Requirements
English Auction Smart Contract Development
Smart Contract Deployment
Conclusion

Prerequisites

Before you get started with this tutorial, make sure you have a basic understanding of the following:

Requirements

To successfully build this smart contract, your computer should have the following tools:

A chromium-based web browser
An internet connection
The Celo plugin activated in Remix IDE
The Remix IDE
The Metamask Extension Wallet
A Metamask account with Alfajores CELO tokens
A Celo extension wallet account with Alfajores CELO tokens

English Auction Smart Contract Development

Navigate to The Remix IDE or any other IDE compatible with the Solidity programming language. Then Follow the steps below to create an English auction smart contract.

Step 1: Create a Solidity File

In the Remix IDE, create a new file. Name it EnglishAuction.sol. This will contain our smart contract code. Open the file.

Step 2: Add IERC721 Interface

Copy the code below, and paste it into the opened EnglishAuction.sol file.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

interface IERC721 {
    function safeTransferFrom(address from, address to, uint tokenId) external;

    function transferFrom(address, address, uint) external;
}

At the top level of our contract, we have a comment that specifies the license the contract uses. The SPDX license identifier is a standard format that communicates licensing information about a software package.

Next, we defined the version of the Solidity compiler that should be used to compile our smart contract code. In our case, we specified version 0.8.17.

Next, we declared the IERC721 interface. IERC721 are standards that provide a way to interact with non-fungible tokens (NFTs). The IERC721 interface ensures that contracts and applications that implement the IERC721 interface are compatible with one another. In other words, these contracts and applications can easily transfer NFTs between one another.

Step 3: Add State Variables

Add the code below to EnglishAuction.sol file.

contract EnglishAuction {
    event Start();
    event Bid(address indexed sender, uint amount);
    event Withdraw(address indexed bidder, uint amount);
    event End(address winner, uint amount);

    IERC721 public nft;
    uint public nftId;

    address payable public auctionSeller;
    uint public endEnglishAuction;
    bool public startedEnglishAuction;
    bool public endedEnglishAuction;

    address public auctionHighestBidder;
    uint public auctionHighestBid;
    mapping(address => uint) public auctionTotalBids;
}

The contract defines four events that can be emitted (i.e., triggered) during the execution of the contract. These events are:

Start()
Bid()
Withdraw()
End().

Events are used to provide feedback to the users of the contract when certain actions are taken or conditions are met.

Next, we have two public variables that define the NFT to be sold in the auction, these public variables are:

IERC721 public nft - This is a public variable that stores the NFT to be auctioned.
uint public nftId - This is another public integer variable. It stores the unique token ID of the non-fungible token to be auctioned in this smart contract.

Next, we declared some variables involving the bids. These include:

address payable public auctionSeller: This is a public variable of type address payable, which stores the address of the seller who created the auction. The payable keyword allows this address to receive funds.
uint public endEnglishAuction: Another public variable of type uint, which stores the timestamp when the auction will end.
bool public startedEnglishAuction: This public boolean variable keeps track of whether the auction has started or not. Its value is true if the auction has started, and false otherwise.
bool public endedEnglishAuction: This public boolean variable keeps track of whether the auction has ended or not. Its value is true if the auction has ended, and false otherwise.
address public auctionHighestBidder: This public variable of type address stores the address of the highest bidder in the auction.
uint public auctionHighestBid: Another public variable of type uint, which stores the highest bid amount made in the auction so far.
mapping(address => uint) public auctionTotalBids: This is a public mapping that maps addresses to their respective bid amounts. Whenever a bidder makes a new bid, the address => uint pair is added to the mapping. Where address is the address of the bidder and uint is the amount they bid.