Lesson 15: Error: cannot find artifact "NftMarketPlace"

[BrysonHall]

I was doing the Patrick Collins tutorial link and got this error when running hh deploy

Nothing to compile
An unexpected error occurred:

Error: ERROR processing /home/theim/hardhatT/hardhat-nft-marketplace-fcc/deploy/01-deploy-nft-marketplace.js:
Error: cannot find artifact "NftMarketPlace"
    at getArtifact

I think this might be a compiler problem cause I can't compile my contracts. The solidity-files-cache.json is always empty with this

{
  "_format": "hh-sol-cache-2",
  "files": {}
}

Somehow hardhat isn't seeing the /contracts/ folder. I have tried deleting both the node_modules and the chache but it didn't work. I have also tried everything in this thread [hardhat beginner "Nothing to compile" error](NomicFoundation/hardhat#2712) incuding npm install glob@7.2.0. Help will be much appreciated.

NftMarketplace.sol

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

error NftMakredplace__PriceMustBeAboveZero();
error NftMakredplace__NotApprovedForMarkedplace();
error NftMarkedplace__AlreadyListed(address nftAdress, uint256 tokenId);
error NftMarketplace__NotOwner();
error NftMarketplace__NotListed(address nftAdress, uint256 tokenId);
error NftMarketplace__PriceNotMet(address nftAdress, uint256 tokenId, uint256 price);
error NftMarketplace__NoProceeds();
error NftMarketplace__TransferFailed();



import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract NftMarketplace is ReentrancyGuard {
    struct Listing {
        uint256 price;
        address seller;
    }

    event ItemListed(
        address indexed seller,
        address indexed nftAddress,
        uint256 indexed tokenId,
        uint256 price
    );

    event ItemBought(
        address indexed buyer,
        address indexed nftAddress,
        uint256 indexed tokenId,
        uint256 price
    );

    event ItemCanceled(
        address indexed seller,
        address indexed nftAddress,
        uint256 indexed tokenId
    )

    // Nft Contract address -> Nft TokenID -> Lisitng
    mapping(address => mapping(uint256 => Listing)) private s_listings;

    // Seller address -> Amount earned
    mapping(address => uint256) private s_proceeds;

    /////////////////////
    // Modifier //
    /////////////////////
    modifier notListed(
        address nftAddress,
        uint256 tokenId,
        address owner
    ) {
        Listing memory listing = s_listing[nftAddress][tokenId];
        if (listing.price > 0) {
            revert NftMarkedplace__AlreadyListed(nftAddress, tokenId);
        }
        _;
    }

    modifier isOwner(
        address nftAddress,
        uit256 tokenId,
        address spender
    ) {
        IERC721 nft = IERC721(nftAddress);
        address owner = nft.ownerOf(tokenId);
        if (spender != owner) {
            revert NftMarketplace__NotOwner();
        }
        _;
    }

    modifier isListed(address nftAddress, uint256 toejnId) {
        Listing memory listing = s_listings[nftAddress][tokenId];
        if (listing.price <= 0) {
            revert NftMarketplace__NotListed(nftAddress, toeknId);
        }
        _;
    }

    /////////////////////
    // Main Functions //
    /////////////////////
    /*
     * @notice Method for listing NFT
     * @param nftAddress Address of NFT contract
     * @param tokenId Token ID of NFT
     * @param price sale price for each item
     */

    function listItem(
        address nftAddress,
        uint256 tokenId,
        uint256 price
    ) external notListed(nftAddress, tokenId, msg.sender) isOwner(nftAddress, toeknId, msg.sender) {
        if (price <= 0) {
            revert NftMakredplace__PriceMustBeAboveZero();
        }
        IERC721 nft = IERC721(nftAddress);
        if (nft.getApproved(tokenId) != address(this)) {
            revert NftMakredplace__NotApprovedForMarkedplace();
        }
        s_listings[nftAddress][tokenId] = Listing(price, msg.sneder);
        emit ItemList(masg.sender, nftAddress, tokenId, price);
    }

    function buyItem(address nftAddress, uint256 tokenId)
        external
        payable
        nonReentrant
        isListed(nftAddress, tokenId)
    {
        Listing memory listedItem = s_listings[nftAddress][tokenId];
        if (msg.value < listedItem.price) {
            revert NftMarketplace__PriceNotMet(nftAddress, tokenId, listedItem.price);
        }
        s_proceeds[listed.seller] = s_proceeds[listedItem.seller] + msg.vaule;
        delete (s_listings[nftAddress][tokenId]);
        IERC721(nftAddress).safeTransferFrom(listedItem.seller, msg.sender, tokenId);
        // check to make sure the NFT was transfered
        emit ItemBought(msg.sender, nftAddres, tokenId, listedItem.price);
    }

    function calcelListing(address nftAddress, uint256 tokenId)
    external 
    isOwner(nftAddress, tokenId, msg.sender)
    is listed(nftAddress, tokenId){
        delete(s_listings[nftAddress][tokenId]);
        emit ItemCanceled(msg.sender, nftAddress, tokenId);
    }
    function updateLisitng(
        address nftAddress,
        uint256 toeknId,
        uint256 neePrice
    ) external isListed(nftAddress, tokenId) isOwner(nftAddress, tokenId, msg.sender){
        s_listing[nftAddress][tokenId].price = newPrice;
        emit ItemListed(msg.sender, nftAddress, tokenId, newPrice);
    }

    function withdrawProceeds() external {
        uint256 proceeds = s_proceeds[msg.sender];
        if(proceeds <=0){
            revert NftMarketplace__NoProceeds();
        }
        s_proceed[msg.sender]=0;
        (bool succes, ) = payable(msg.sender).call{value: proceeds}("");
        if(!success){
            revert NftMarketplace__TransferFailed();
        }
    }

    /////////////////////
    // Getter Functions //
    /////////////////////

    function getListing(address nftAddress, uint256 tokenId) external view return(Listing memory){
        return s_listing[nftAddress][tokenId];
    }

    function getProceeds(address seller) external view retruns(uint256){
        return s_proceeds[seller];
    }
    
}

01-deploy-nft-marketplace

const { network } = require("hardhat")
const { developmentChains, VERIFICATION_BLOCK_CONFIRMATIONS } = require("../helper-hardhat-config")
const { verify } = require("../utils/verify")

module.exports = async ({ getNamedAccounts, deployments }) => {
    const { deploy, log } = deployments
    const { deployer } = await getNamedAccounts()

    args = []
    const nftMarketplace = await deploy("NftMarketPlace", {
        from: deployer,
        args: args,
        log: true,
        waitConfirmation: network.config.blockConfirmation | 1,
    })

    // Verify the deployment
    if (!developmentChains.includes(network.name) && process.env.ETHERSCAN_API_KEY) {
        log("Verifying...")
        await verify(dynamicSvgNft.address, arguments)
    }

    log("--------------------------------------")
}

module.exports.tags = ["all", "nftmarketplace"]

[mattjaf]

dude you p is lowercase,
in your contract

NftMarketplace 

when your looking for

NftMarketPlace

in your deploy script

[BrysonHall]

I tried fixing that but that did not unfortunately fix the error. I still got the same error but in lowercase Error: cannot find artifact "NftMarketplace". Any other suggestions?

[mattjaf]

your contract name has to match the name in your deploy script.

run yarn hardhat clean

&
yarn harhat deploy --reset

[0Ksecurity]

i'm using yarn instead of npm but in my case i run :

yarn hardhat clean 

and after that i changed my nftMarketplace.sol to nftMarketPlace.sol and run :

yarn hardhat compile 

you can run deploy and compile it and deploy it in same time :

yarn hardhar deploy --tags nftmarketplace 

[vicentemunozlh]

Look into your artifacts folder. In the contracts sub folder the name of the .json file of your contract may have changed. one time my contract name was "ContractV2.sol" and the .json file of it in the artifacts folder converted to "Contract.json"

[vicentemunozlh]

So I changed in my deploy script:

const contract = await deploy("Contract", {

and it worked

[Shawon-Mandal]

If someone else is facing this problem:

the issue here is in this : contract NftMarketplace is ReentrancyGuard {
It should be: contract NftMarketPlace is ReentrancyGuard {

because: he is deploying const nftMarketplace = await deploy("NftMarketPlace", {

with an uppercase "P".I had same error and I found out it was this "P" that was causing the error.

[Taha-Zerarkaa]

the p of NftMarketPlace must be lower case

const nftMarketplace = await deploy("NftMarketPlace", {
        from: deployer,
        args: args,
        log: true,
        waitConfirmation: network.config.blockConfirmation | 1,
    })

to this

const nftMarketplace = await deploy("NftMarketplace", {
        from: deployer,
        args: args,
        log: true,
        waitConfirmation: network.config.blockConfirmation | 1,
    })