erc721r/erc721r

An ERC721 base contract that mints tokens in a pseudo-random order. Because the token is revealed in the same transaction as the mint itself, this contract creates a fun but not fully secure experience.

erc721r's Issues

Metadata doesnt show

I set the uri with an ipfs link and it doesnt show.
Contract: https://polygonscan.com/address/0x5047ba65387378aa65b8fdddce4484228e2cb2e4
Opensea: https://opensea.io/collection/house-of-panther

Replace block.difficulty with block.prevrandao

Compiler generates the following warning:

_mintRandom ERC721REnumerable

Hey! I love this 721 feature and its accompanied documentation! Thank you for all the work done in brining this to the Ethereum developer community.

I am wanting to use the ERC721REnumerable in an upcoming project but having issues in using the tokenOfOwnerByIndex. Specifically, only the 0-index owner's token is showing a randomly generated index value.

I'm checking to see if I am implementing the Enumerable contract correctly. Here is the basic contract structure Im using for tests:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC721REnumerable.sol";

contract TEST is ERC721rEnumerable {    

    constructor(string memory name_, string memory symbol_, uint maxSupply_) ERC721r(name_, symbol_, maxSupply_) {}

    function mint(uint256 quantity) public {
        _mintRandom(msg.sender, quantity);
    }

}

And here is my mocha.js test:

const assert = require('assert');
const ganache = require('ganache-cli');
const HDWalletProvider = require('truffle-hdwallet-provider');
const Web3 = require('web3');
const web3 = new Web3(ganache.provider(HDWalletProvider));
const { abi, bytecode } = require('../../build/contracts/TEST.json')

let accounts;
let contract;

beforeEach( async () => {

    accounts = await web3.eth.getAccounts();
    contract = await new web3.eth.Contract(abi).deploy({data:bytecode, arguments: ['TEST', 'TEST', 777]}).send({from:accounts[0], gas:5000000})

})

describe( 'Mint Tests', () => {    
    
    it.skip("Contract Deploys", () => {
        assert(contract)
    })

    // this test passes
    it('Mint 1 Token', async () => {
        await contract.methods.mint(1).send({from: accounts[0], gas:1000000})
        const tokens = await contract.methods.balanceOf(accounts[0]).call()
        assert(tokens,1)
    })


    // this test passes
    it.skip('Mint 1 Token & Call Random TokenIdx', async () => {
        await contract.methods.mint(1).send({from: accounts[0], gas:1000000})
        const tokenIdx = await contract.methods.tokenOfOwnerByIndex(accounts[0],0).call()
        console.log(`Randomly Assigned Token Index: ${tokenIdx}`)
        assert.notEqual(0,tokenIdx)
    })

    // this test FAILS (see below)
    it('Mint Multiple Tokens & Call Random TokenIdx of all Tokens', async (numMints=10) => {                

        await contract.methods.mint(numMints).send({from: accounts[0], gas:1000000})
        const tokens = await contract.methods.balanceOf(accounts[0]).call()
        assert.equal(tokens, numMints)

        for (let i=0; i< numMints; i++ ){
            let tokenIdx = await contract.methods.tokenOfOwnerByIndex(accounts[0],i).call()
            console.log(`Randomly Assigned Token Index: ${tokenIdx}`)
            assert.notEqual(0,tokenIdx)
        }        
         
    })

})

The output for the last test is as follows:

  Mint Tests
    - Contract Deploys
    ✔ Mint 1 Token (108ms)
Randomly Assigned Token Index: 513
    ✔ Mint 1 Token & Call Random TokenIdx (82ms)
Randomly Assigned Token Index: 442
Randomly Assigned Token Index: 0
    1) Mint Multiple Tokens & Call Random TokenIdx of all Tokens


  2 passing (779ms)
  1 pending
  1 failing

  1) Mint Tests
       Mint Multiple Tokens & Call Random TokenIdx of all Tokens:
     AssertionError [ERR_ASSERTION]: 0 != '0'
      at Context.<anonymous> (test/mint.test.js:46:20)
      at processTicksAndRejections (node:internal/process/task_queues:96:5)

Any suggestions/feedback would be greatly appreciated!

Flashbots Exploit

Believe Flashbots are still able to exploit since they interact as EOA.

TokenOfOwnerByIndex issue

https://snowtrace.io/address/0xb85e821d2231a3cb2ea69527a69de63c2b759505#code

token of owner by index returns the next id despite owning non-serialized ids

call tokenOfOwnerByIndex(0xf17668ff22c63e63475d5f7dbdf7585d51e52c76, 1)
returns token 215 but actual token should be 357

Starting NFT ID

Could you include some docs on the lowest NFT ID that this contract generates?

Is the first NFT 0 or 1? There is mention of ERC721A where the ID is 0, and most other contracts use 1, it would be great to document this.

Great!

Hi,

Is it possible to integrate this without needing to include this erc721R file; could you make an example which just indicates that to add to a typical erc721 contract?

I want to use your approach, although I might tailor it to use a VRF2 random number for the shuffle as that would improve fairness.

I also notice you added a means for the owner to claim a specific id from the collection; this is perfect, as there are a few NFT I wish to handpick as prizes.

This is a godsend to me, I just need a little assistance implementing it; feel free to message @coeus_crypto on Telegram!