从已铸造的 NFT 中随机选择令牌 ID 的正确方法

Question

I have an NFT project with 1000 NFTs . As part of my project, users who hold an NFT will be entered into a lottery.

The function I want to implement is the following:

Select x number of users to participate in the lottery. So lets say 500 NFTs have been minted out of the 1000 NFTs , I want the 500 users to participate in the lottery, and I get to pick any number of winners. In short, 500 NFT holders are entered into a draw, and 10 NFTs are randomly selected as winners.

I was fortunate enough to find a smart contract that match my criteria.

In the below code, the selectWinners() functions accepts a uint256 noOfWinners as a parameter, which then creates a date for a future draw, and increments a draw by 1.

The selectAWinner() function is looped x number of times (x = noOfWinners), and selects random winners.

The rand() function accepts random address and a random number. I believe this function helps in finding random winners.

In the below code, the selectAWinner() function generates a random token id between 1 to 5000, because the maxSupply of that project is 5000.

What I want is for the function to generate random token id's between 1 to 500, because 500 NFTs have been minting out of the 1000.

What I've tried:

In the rand() function, I tried to use totalSupply (the amount of NFT minted ie 500) instead of maxSupply . Unfortunately, I'm encountering errors.

Where am I going wrong? Any help is very much appreciated!

 function selectWinners(uint256 noOfWinners) public onlyOwner {
    require(!paused, "ERROR: Contract is paused");
    require(lotteryActive, "ERROR: Lottery not active yet");
    require(noOfWinners <= 50, "ERROR: Too many winners selected");

    uint256 epochNow = block.timestamp;
    uint256 nextLotteryDate = lotteryDates[lotteryDates.length - 1];

    require(epochNow >= nextLotteryDate, "ERROR: Cannot draw yet, too early");

    for (uint256 i = 0; i < noOfWinners; i++) {
        selectAWinner(
            0,
            epochNow,
            msg.sender,
            nextLotteryDate,
            msg.sender,
            0
        );
    }

    lotteryDates.push(epochNow + (epochDay * lotteryIntervalDays));

    // increment draw
    drawNumber++;
}


function selectAWinner(
    uint256 it,
    uint256 epochNow,
    address sender,
    uint256 lotteryDate,
    address randomAddr,
    uint256 randomNo
) internal {
    // Generate random id between 1 - 5000 (corresponds to NFT id)

    uint256 winningToken = rand(randomAddr, randomNo);
    address winnerAddress = ERC721.ownerOf(winningToken);
    uint256 lastWon = _winners[winnerAddress];

    bool alreadyWon = (lastWon == lotteryDate);

    Winner memory win;

    if ((it < 5) && alreadyWon) {
        uint256 newIt = it + 1;
        return
            selectAWinner(
                newIt,
                epochNow,
                sender,
                lotteryDate,
                winnerAddress,
                winningToken
            );
    } else if ((it >= 5) && alreadyWon) {
        return;
    } else {
        win.date = lotteryDate;
        win.winner = winnerAddress;
        win.tokenId = winningToken;
        winnerLog[drawNumber].push(win);

        _winners[winnerAddress] = lotteryDate;
    }

    return;
}

function rand(address randomAddress, uint256 randomNo) internal view returns (uint256) {
    uint256 seed = uint256(
        keccak256(
            abi.encodePacked(
                (block.timestamp - randomNo) +
                    block.difficulty +
                    ((
                        uint256(keccak256(abi.encodePacked(block.coinbase)))
                    ) / (block.timestamp)) +
                    block.gaslimit +
                    ((uint256(keccak256(abi.encodePacked(randomAddress)))) /
                        (block.timestamp)) +
                    block.number
            )
        )
    );

    return (seed - ((seed / maxSupply) * maxSupply)) + 1;
}

Answer 1

You could probably solve that by using the modulus % operator.

https://www.geeksforgeeks.org/solidity-operators/

Generate a random number and then use the modulus operator with the totalSupply() which corresponds to the number of existing ERC721 NFT. something like:

uint256 rand = _generateRandomness("rarity") % ERC721.totalSupply();

A little remark would be that using truly random numbers is impossible in Solidity without using oracles. The most famous and trustworthy is ChainLink's RNG.

https://docs.chain.link/docs/get-a-random-number/