Test file:
const {expect} = require("chai");
const {ethers} = require("hardhat");
describe("NFT Marketplace", function () {
let NFTMarket;
let nftMarket;
let listingPrice;
let contractOwner;
let buyerAddress;
let nftMarketAddress
// returns a BigNumber representation of value, parsed with
// digits (if it's a number) or from the unit specified (if it's a string)
const auctionPrice = ethers.utils.parseUnits("100", "ether")
// hooks that perform before each test case
beforeEach(async () => { // get contract that we're targeting, so we can deploy or call the functions in that Contract
NFTMarket = await ethers.getContractFactory("NFTMarketplace");
// create a transaction to deploy the transaction and sends it to the network
// using the contract Signer, and returning a Promise to resolve to a Contract
nftMarket = await NFTMarket.deploy();
// return a Promise which will resolve once the contract is deployed
// or reject if there was an error during deployment
await nftMarket.deployed();
nftMarketAddress = nftMarket.address;
[contractOwner, buyerAddress] = await ethers.getSigners(); // get public address of the user wallet
listingPrice = await nftMarket.getListingPrice();
listingPrice = listingPrice.toString();
})
// mint and list NFT
const mintAndListNFT = async (tokenURI, auctionPrice) => {
const transaction = await nftMarket.createToken(tokenURI, auctionPrice, {value: listingPrice});
const receipt = await transaction.wait();
const tokenId = receipt.events[0].args.tokenId;
return tokenId;
}
describe("Resale of a marketplace item", async () => {
const tokenURI = "https://dummy-token.url/"; // test with a dummy token URI
const newNFTToken = await mintAndListNFT(tokenURI, auctionPrice);
await nftMarket.connect(buyerAddress).createMarketSale(newNFTToken, {value: auctionPrice});
await expect(nftMarket.resellToken(nftMarket, auctionPrice, {value: listingPrice})).to.be.revertedWith("You are not the owner of the token!");
await expect(nftMarket.connect(buyerAddress).resellToken(newNFTToken, auctionPrice, {value: 0})).to.be.rejectedWith("The amount sold does not equal the original listing price of the token!");
})
Contract file:
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
contract NFTMarketplace is ERC721URIStorage {
using Counters for Counters.Counter;
Counters.Counter private _tokenIDs; // total number of items created
Counters.Counter private _itemsSold; // total number of items sold
uint256 listingPrice = 0.001 ether; // price to list NFT on marketplace
address payable owner; // owner of the smart contract
constructor() ERC721("Metaverse Tokens", "META") {
owner == payable(msg.sender);
}
struct MarketItem {
uint256 tokenId;
address payable seller;
address payable owner;
uint256 price;
bool sold;
}
mapping(uint256 => MarketItem) private idToMarketItem;
event MarketItemCreated (uint256 indexed tokenId, address seller, address owner, uint256 price, bool sold);
// return the listing price of the NFT
function getListingPrice() public view returns(uint256) {
return listingPrice;
}
// update the listing price
function updatedListingPrice(uint _listingPrice) public payable{
require(owner == msg.sender, "You are not the owner!");
listingPrice = _listingPrice;
}
// create a NFT in the market
function createMarketItem(uint256 tokenId, uint256 price) private {
require(price > 0, "You must list an item with price more than 0!");
require(msg.value == listingPrice, "The amount of ether sent in the transaction does not equal the listing price!");
// seller is the msg.sender and owner is the address(this)
idToMarketItem[tokenId] = MarketItem(tokenId, payable(msg.sender), payable(address(this)), price, false);
_transfer(msg.sender, address(this), tokenId);
emit MarketItemCreated (tokenId, msg.sender, address(this), price, true);
}
// mints a token and list it in the market
function createToken(string memory tokenURI, uint256 price) public payable returns(uint) {
_tokenIDs.increment();
uint256 newTokenId = _tokenIDs.current();
_mint(msg.sender, newTokenId);
_setTokenURI(newTokenId, tokenURI);
createMarketItem(newTokenId, price);
return newTokenId;
}
// creating the sale of a marketplace item
// transfers ownership of the item and funds between parties
function createMarketSale(uint256 tokenId) public payable {
uint price = idToMarketItem[tokenId].price;
address seller = idToMarketItem[tokenId].seller;
require(msg.value == price, "The amount of ethers sent does not equal to the price of the item!");
idToMarketItem[tokenId].owner = payable(msg.sender); // transfer ownership
idToMarketItem[tokenId].seller = payable(address(0));
idToMarketItem[tokenId].sold = true;
_itemsSold.increment();
_transfer(address(this), msg.sender, tokenId);
payable(owner).transfer(listingPrice);
payable(seller).transfer(msg.value);
}
// allows users to resell a token they have purchased
function resellToken(uint256 tokenId, uint256 price) public payable {
require(idToMarketItem[tokenId].owner == msg.sender, "You are not the owner of the token!");
require(msg.value == listingPrice, "The amount sold does not equal the original listing price of the token!");
idToMarketItem[tokenId].sold = false;
idToMarketItem[tokenId].seller = payable(msg.sender); // msg.sender refers to address where the contract is being called from
idToMarketItem[tokenId].owner = payable(address(this)); // address(this) refers to the address of the instance where the call is being made
idToMarketItem[tokenId].price = price;
_itemsSold.decrement();
_transfer(msg.sender, address(this), tokenId);
}
}
What do these lines of code do specifically under the test case for "Resale of a marketplace item"?
- const newNFTToken = await mintAndListNFT(tokenURI, auctionPrice);
- await nftMarket.connect(buyerAddress).createMarketSale(newNFTToken, {value: auctionPrice});
- await expect(nftMarket.resellToken(nftMarket, auctionPrice, {value: listingPrice})).to.be.revertedWith("You are not the owner of the token!");
- await expect(nftMarket.connect(buyerAddress).resellToken(newNFTToken, auctionPrice, {value: 0})).to.be.rejectedWith("The amount sold does not equal the original listing price of the token!");
Any help is appreciated. Thank you.
