如何使用 balanceOf() 在合同上创建铸币限制

Question

I'm new to solidity and learning hardhat also, having a hard time on limit minting for NFT.

My contract is coded like:

>     function mint(uint256 quantity_) public payable{
>         require(isPublicMintEnabled, 'minting not enabled');
>         require(msg.value == quantity_ * mintPrice, 'wrong mint value');
>         require(totalSupply + quantity_ <= maxSupply, 'sold out');
>         require(walletMints[msg.sender] + quantity_ <= maxPerWallet, 'exceed max wallet');
> 
>         for(uint256 i = 0; i < quantity_; i++){
>             uint256 newTokenId = totalSupply + 1;
>             totalSupply++;
>             _safeMint(msg.sender, newTokenId);
>         }
>     }

and my minting.js is code

async function handleMint(){
        if(window.ethereum){
            const provider = new ethers.providers.Web3Provider(window.ethereum);
            const signer = provider.getSigner();
            const contract = new ethers.Contract(
                NFTAddress,
                NFT.abi,
                signer
            );
            try{
                const response = await contract.mint(BigNumber.from(mintAmount), {
                    value: ethers.utils.parseEther((0 * mintAmount).toString()),
                });
                console.log('response', response);

            } catch(err){
                console.log("error: ", err)
            }
        }
    }

this limit the address to mint an specific number but when the user repeat the process it overrides the maxPerWallet. I'm thinking if I can do like

if(balanceOf("address") > 2){
console.log('you already mint 2', response);
}
else{
console.log('you can mint 2', response);
}

how can i translate this into my js?

---------------------- Answered-------------

I just added

mapping(address => uint256) public walletMints;

and I still can't get the output. My js was written like this:

const MainMint = ({ accounts}) =>{
    const[mintAmount] = useState(1);
    const isConnected = Boolean(accounts[0]);

    async function handleMint(){
        if(window.ethereum){
            const provider = new ethers.providers.Web3Provider(window.ethereum);
            const signer = provider.getSigner();
            const contract = new ethers.Contract(
                NFTAddress,
                NFT.abi,
                signer
            );
            const amount = await contract.walletMints(signer.address);
                try{
                    if(amount < 2){
                        const response = await contract.mint(BigNumber.from(mintAmount), {
                            value: ethers.utils.parseEther((0 * mintAmount).toString()),
                        });
                        console.log('response', response);
                    }
                    else{
                        console.log('Mint Max');
                    }
                    
                }
                catch(err){
                    console.log("error: ", err);
                }

        }
    }

Answer 1

If you use the wallet balance you may not be able to correctly check the amount of mints made by a wallet, as the balance only tells you how many tokens the wallet currently has.

I think you should create a mapping to store the amount of mints of each wallet. In your smart contract create a public mapping of mint amount of each wallet:

mapping(address => uint) public walletMints;

And then when the user mints you need add this amount to the address:

walletMints[msg.sender] = walletMints[msg.sender] + quantity_

When you create a public mapping the smart contract automatically creates a getter of this mapping that you can use in your javascript code and check the amount of mints made by a wallet.

Using ethers, you can call this function in your javascript code passing the wallet address as parameter:

const amount = await contract.walletMints(signer.address)

And verify if the amount is permitted as you are planning:

if(amount > 2){
    console.log('you already mint 2');
}
else{
   console.log('you can mint 2');
}

Answer 2

You should use:

walletMints[msg.sender] += quantity_;
require(walletMints[msg.sender] <= maxPerWallet, "exceed max wallet");

no more change after your update.