Use queryFilter & get unique address count

Author: embiem

frontend/_tests_/hooks/useDevNFTSupply.test.ts

@@ -1,21 +1,32 @@
+import { BigNumber } from '@ethersproject/bignumber';
 import { renderHook } from '@testing-library/react-hooks';
+import crypto from 'crypto';
 
-import useDevNFTSupply from '../../src/hooks/useDevNFTSupply';
+import { useDevNFTSupply } from '../../src/hooks/useDevNFTSupply';
 import { Ddao__factory } from '../../types/ethers-contracts/factories/Ddao__factory';
 
 jest.mock('../../types/ethers-contracts/factories/Ddao__factory');
+
 const mockedDdaoFactory = Ddao__factory as jest.Mocked<typeof Ddao__factory>;
 
 test('should return correct supply values & transition loading state', async () => {
-  mockedDdaoFactory.connect.mockImplementationOnce((address, provider) => {
+  mockedDdaoFactory.connect.mockImplementation((address, provider) => {
     return {
-      totalSupply: async () => ({ toNumber: () => 2345 }),
-      ownerOf: async (tokenId: number) => {
-        if (tokenId === 8000)
-          return '0x91d7a9e7c09477392290fe16c1b243e4a36d279a';
-
-        throw Error();
-      },
+      queryFilter: async () => [
+        {
+          args: {
+            tokenId: BigNumber.from(1),
+            to: '0x91d7a9e7c09477392290fe16c1b243e4a36d279a',
+          },
+        },
+        {
+          args: {
+            tokenId: BigNumber.from(8000),
+            to: '0x91d7a9e7c09477392290fe16c1b243e4a36d279a',
+          },
+        },
+      ],
+      filters: { Transfer: () => {} },
     } as any;
   });
 
@@ -26,21 +37,29 @@ test('should return correct supply values & transition loading state', async ()
   expect(result.current.isLoading).toBe(false);
 
   expect(result.current.maxSupply).toBe(8000);
-  expect(result.current.totalSupply).toBe(2345);
+  expect(result.current.totalSupply).toBe(2);
   expect(result.current.lockedSupply).toBe(1);
-  expect(result.current.publicSupply).toBe(2344);
+  expect(result.current.publicSupply).toBe(1);
 
-  expect(result.current.remainingTotalSupply).toBe(8000 - 2345);
-  expect(result.current.remainingPublicSupply).toBe(7777 - 2344);
+  expect(result.current.uniqueTokenHolders).toBe(1);
+
+  expect(result.current.remainingTotalSupply).toBe(8000 - 2);
+  expect(result.current.remainingPublicSupply).toBe(7777 - 1);
   expect(result.current.remainingLockedSupply).toBe(8000 - 7777 - 1);
 });
 
 test('should correctly handle "all minted" state', async () => {
-  mockedDdaoFactory.connect.mockImplementationOnce((address, provider) => {
+  mockedDdaoFactory.connect.mockImplementation((address, provider) => {
     return {
-      totalSupply: async () => ({ toNumber: () => 8000 }),
-      ownerOf: async (tokenId: number) =>
-        '0x91d7a9e7c09477392290fe16c1b243e4a36d279a',
+      totalSupply: async () => ({ toNumber: () => 1 }),
+      queryFilter: async () =>
+        [...Array(8000)].map((_, idx) => ({
+          args: {
+            tokenId: BigNumber.from(idx + 1),
+            to: `0x${crypto.randomBytes(32).toString('hex')}`,
+          },
+        })),
+      filters: { Transfer: () => {} },
     } as any;
   });
 
@@ -55,6 +74,8 @@ test('should correctly handle "all minted" state', async () => {
   expect(result.current.lockedSupply).toBe(8000 - 7777);
   expect(result.current.publicSupply).toBe(7777);
 
+  expect(result.current.uniqueTokenHolders).toBe(8000);
+
   expect(result.current.remainingTotalSupply).toBe(0);
   expect(result.current.remainingPublicSupply).toBe(0);
   expect(result.current.remainingLockedSupply).toBe(0);

frontend/public/locales/en/common.json

@@ -30,7 +30,7 @@
   "connectWalletText": "Connect Wallet",
   "ethereumNetworkPrompt": "Please Connect to the Ethereum Mainnet",
   "availableTokensText": "View the available Token IDs",
-  "remainingTokensText": "{{remainingTokens}} tokens left / {{totalSupply}} already joined",
+  "remainingTokensText": "{{remainingTokens}} tokens left / {{uniqueAddressCount}} devs joined",
   "mintPageHeader": "DEVS Token Minter",
   "projectsList": "A list of community projects created by the Developer DAO community.",
   "ddaoTokenSearch": "DDAO Token Search",

frontend/src/components/DirectMint/DirectMintBox.tsx

@@ -12,13 +12,15 @@ import {
 } from '@chakra-ui/react';
 import { useTranslation } from 'next-i18next';
 import { TOKEN_FINDER_URL } from '../../utils/DeveloperDaoConstants';
-import useDevNFTSupply from '../../hooks/useDevNFTSupply';
+import { useDevNFTSupply } from '../../hooks/useDevNFTSupply';
 
 // Layout for the Direct Mint Box
 // used on the minting page
 const DirectMintBox = () => {
   const { t } = useTranslation();
-  const { isLoading, remainingPublicSupply, totalSupply } = useDevNFTSupply();
+  const { isLoading, remainingPublicSupply, uniqueTokenHolders } =
+    useDevNFTSupply();
+
   return (
     <>
       <Container maxW="container.md" centerContent>
@@ -44,7 +46,9 @@ const DirectMintBox = () => {
                 remainingTokens: isLoading
                   ? '...'
                   : remainingPublicSupply.toLocaleString(),
-                totalSupply: isLoading ? '...' : totalSupply.toLocaleString(),
+                uniqueAddressCount: isLoading
+                  ? '...'
+                  : uniqueTokenHolders?.toLocaleString(),
               })}
             </Text>
             <DirectMint />

frontend/src/hooks/useDevNFTSupply.ts

@@ -13,69 +13,85 @@ import { Ddao__factory } from '../../types/ethers-contracts/factories/Ddao__fact
 const MAX_SUPPLY = 8000;
 const PUBLIC_MAX_SUPPLY = 7777;
 
-export default function useDevNFTSupply() {
+export function useDevNFTSupply() {
   const [totalSupply, setTotalSupply] = useState<number>(-1);
   const [lockedSupply, setLockedSupply] = useState<number>(-1);
+  const [uniqueTokenHolderCount, setUniqueTokenHolderCount] =
+    useState<number>(-1);
 
   useEffect(() => {
-    const contract = Ddao__factory.connect(
-      DEVELOPER_DAO_CONTRACT,
-      new FallbackProvider([
-        { provider: new InfuraProvider() },
-        { provider: new AlchemyProvider() },
-      ]),
-    );
-
-    // Fetches the count of minted DEV NFTs
-    const fetchTotalSupply = async () => {
-      const totalSupply: number = (await contract.totalSupply()).toNumber();
-      setTotalSupply(totalSupply);
-    };
+    const fetch = async () => {
+      const contract = Ddao__factory.connect(
+        DEVELOPER_DAO_CONTRACT,
+        new FallbackProvider([
+          { provider: new InfuraProvider() },
+          { provider: new AlchemyProvider() },
+        ]),
+      );
+
+      // Get all TransferEvents
+      const transferredTokens = await contract.queryFilter(
+        contract.filters.Transfer(),
+        0,
+        'latest',
+      );
+
+      // Track the latest owner of each token
+      const claimedTokens: Record<string, string> = {};
+      transferredTokens.forEach((tx) => {
+        const tokenId = tx.args.tokenId.toNumber();
+        claimedTokens[tokenId] = tx.args.to;
+      });
+
+      // Amount of minted tokens
+      const totalSupply = Object.keys(claimedTokens).length;
 
-    // Counts how many tokens of the locked supply have been minted
-    const fetchLockedSupply = async () => {
-      const requests = [];
+      // Put the addresses in a set to get the amount of unique addresses
+      const uniqueAddresses = new Set<string>(Object.values(claimedTokens));
 
+      // Count how many tokens of the locked supply have been minted
+      let countLockedAndMinted = 0;
       for (
         let lockedTokenId = PUBLIC_MAX_SUPPLY + 1;
         lockedTokenId <= MAX_SUPPLY;
         lockedTokenId++
       ) {
-        requests.push(
-          contract.ownerOf(lockedTokenId).then(
-            // Return the owner's address
-            (addressResponse) => addressResponse,
-            // Return the zero-address if no owner was found
-            () => ethers.constants.AddressZero,
-          ),
-        );
+        if (
+          claimedTokens[lockedTokenId] &&
+          claimedTokens[lockedTokenId] !== ethers.constants.AddressZero
+        )
+          countLockedAndMinted++;
       }
 
-      const addresses = await Promise.all(requests);
-
-      const countMinted = addresses.reduce(
-        (count, address) =>
-          address !== ethers.constants.AddressZero ? ++count : count,
-        0,
-      );
-
-      setLockedSupply(countMinted);
+      setLockedSupply(countLockedAndMinted);
+      setTotalSupply(totalSupply);
+      setUniqueTokenHolderCount(uniqueAddresses.size);
     };
 
-    fetchTotalSupply();
-    fetchLockedSupply();
+    fetch();
   }, []);
 
   return {
-    isLoading: totalSupply === -1 || lockedSupply === -1,
+    isLoading:
+      totalSupply === -1 ||
+      lockedSupply === -1 ||
+      uniqueTokenHolderCount === -1,
+
     // This is the amount of total minted DEV NFTs, same as calling `totalSupply()` on the contract
     totalSupply,
+
+    // Count of unique token holder addresses
+    uniqueTokenHolders: uniqueTokenHolderCount,
+
     // This is the amount of minted DEV NFTs that only the contract owner can mint (TokenIDs 7778-8000, incl.)
     lockedSupply,
+
     // This is the amount of publicly minted DEV NFTs, which is open to mint by anyone (TokenIDs 1-7777, incl.)
     publicSupply: totalSupply - lockedSupply,
+
     // Total number of possible DEV NFT. This is a constant that cannot be changed
     maxSupply: MAX_SUPPLY,
+
     // Some calculations to make these values easily accessible for display in UI
     remainingTotalSupply: MAX_SUPPLY - totalSupply,
     remainingPublicSupply: PUBLIC_MAX_SUPPLY - (totalSupply - lockedSupply),