How to find all ERC721 compliant NFTs owned by an address? (Web3 JS)

Assuming opensea is aware of the tokens you could use their api also:

https://api.opensea.io/api/v1/assets?owner=${address} 

No, web3 doesn't know about all ERC721 token contracts, which would be required to call ownerOf() for each NFT.

What could be done: take a list of popular ERC721 contracts (like this one from Bloxy) and check the owner of each and every token, which is quite cumbersome.

Alternative, more convenient approaches would be to use third-party APIs like Alchemy's Transfer API or Etherscan's Account API (see 'Get a list of "ERC721 - Token Transfer Events" by Address').

One thing worth checking out is if the NFT is ERC721Enumerable. This allows you to call the tokenOfOwnerByIndex function, which gives you to index through all the NFTs from the contract that the wallet has.

Fetching all ERC721 compliant NFTs is super easy to do with the Alchemy SDK and NFT API:

npm install @alch/alchemy-sdk 

and then in your code:

// Initializing the alchemy config object import { initializeAlchemy, getNftsForOwner } from '@alch/alchemy-sdk'; const alchemy = initializeAlchemy(); // using default settings - pass in a settings object to specify your API key and network getNftsForOwner(alchemy, '0xshah.eth').then(console.log); 

It is possible reading the events from the contract. This is an example using web3.js. You get the tokens that the address received and count the times it received each one. Then you count those who were sent by the address with the same procedure. If a token has been received more times than it was sent (it can only be equal or 1 more), then it means that it owns the token.

// Get the tokens that the account received const eventsReceivedTokens = await contract.getPastEvents("Transfer", { filter: { to: account, }, fromBlock: 0, }); // Count the number of times the account received the token let receivedTokensCount = {}; for (let key in eventsReceivedTokens) { let tokenId = eventsReceivedTokens[key]["returnValues"]["tokenId"]; receivedTokensCount[tokenId] = (receivedTokensCount[tokenId] || 0) + 1; } let receivedTokenIds = Object.keys(receivedTokensCount); // Get the tokens that the account sent const eventsSentTokens = await contract.getPastEvents("Transfer", { filter: { from: account, tokenId: receivedTokenIds, }, fromBlock: 0, }); let sentTokensCount = {}; for (let key in eventsSentTokens) { let tokenId = eventsSentTokens[key]["returnValues"]["tokenId"]; sentTokensCount[tokenId] = (sentTokensCount[tokenId] || 0) + 1; } // Substract the tokens received by the sent to get the tokens owned by account // Store them on ownedTokenIds let ownedTokenIds = []; for (let tokenId in receivedTokensCount) { if ( (sentTokensCount[tokenId] ? sentTokensCount[tokenId] : 0) < receivedTokensCount[tokenId] ) { ownedTokenIds.push(tokenId); } } 

It depends on the contract implementation. How the developer keeps track of the owner: This is one way you can implement it:

mapping(address=>mapping(uint=>uint)) private _ownedTokens; 

this mapping is like:

{"0x32j23h32h423.....":{1:tokenId-1 , 2:tokenId-2}} 

Have another mapping for a fast lookup:

 // id => index mapping(uint=> uint) private _idToOwnedIndex; 

Then define a function to update the state of owner:

function _addTokenToOwner(address to, uint tokenId) private{ uint length=ERC721.balanceOf(to); _ownedTokens[to][length]=tokenId; _idToOwnedIndex[tokenId]=length; } 

call _addTokenOwner() in _beforeTokenTransfer()

function _beforeTokenTransfer(address from, address to,uint tokenId)internal virtual override{ // in case this is provided in super contract, the contract that you are extending from call this super._beforeTokenTransfer(from,to,tokenId); // that means we are minting the token // Becasue inside ERC721._mint we call _beforeTokenTransfer(address(0),to,tokenId) if(from==address(0)){ _addTokenToAllTokens(tokenId); } // this also satisfied when we mint the token. if (to!=from){ _addTokenToOwner(to, tokenId); } } 

Now write the function to get the NFTs that msg.sender owns. I don't think you should implement a way to view other account's NFTs.

function getOwnedNfts() public view returns(NftItem[] memory){ uint ownedItemsCount=ERC721.balanceOf(msg.sender); NftItem[] memory items= new NftItem[](ownedItemsCount); for (uint i=0; i<ownedItemsCount; i++){ uint tokenId=tokenOfOwnerByIndex(msg.sender, i); NftItem storage item=_idToNftItem[tokenId]; items[i]=item; } return items; } 

This is the helper function used in the getOwnedNfts() function:

function tokenOfOwnerByIndex(address owner,uint index) public view returns(uint){ require(index<ERC721.balanceOf(owner), "Index out of bounds"); return _ownedTokens[owner][index]; }