How to Airdrop NFTs

$
node -v

$
mkdir nft-airdrop && cd nft-airdrop
>
npm init -y
>
npm install --save-dev hardhat
>
npx hardhat

$
npx hardhat test

$
npm install @openzeppelin/contracts

1
//SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.4;
3
4
import "hardhat/console.sol";
5
import "@openzeppelin/contracts/utils/Counters.sol";
6
import "@openzeppelin/contracts/access/Ownable.sol";
7
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
8
9
contract NFTAirdrop is ERC721Enumerable, Ownable {
10
    using Counters for Counters.Counter;
11
    
12
    Counters.Counter private _tokenIds;
13
    
14
    constructor() ERC721("NFT Aidrop Demo", "NAD") {
15
        console.log("Contract has been deployed!");
16
    }
17
18
    // Airdrop NFTs
19
    function airdropNfts(address[] calldata wAddresses) public onlyOwner {
20
21
        for (uint i = 0; i < wAddresses.length; i++) {
22
            _mintSingleNFT(wAddresses[i]);
23
        }
24
    }
25
    
26
    function _mintSingleNFT(address wAddress) private {
27
        uint newTokenID = _tokenIds.current();
28
        _safeMint(wAddress, newTokenID);
29
        _tokenIds.increment();
30
    }
31
}

$
npx hardhat compile

1
const { ethers } = require("hardhat");
2
const hre = require("hardhat");
3
4
async function main() {
5
6
  // Define a list of wallets to airdrop NFTs
7
  const airdropAddresses = [
8
    '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
9
    '0x3c44cdddb6a900fa2b585dd299e03d12fa4293bc',
10
    '0x90f79bf6eb2c4f870365e785982e1f101e93b906',
11
    '0x15d34aaf54267db7d7c367839aaf71a00a2c6a65',
12
    '0x9965507d1a55bcc2695c58ba16fb37d819b0a4dc',
13
  ];
14
15
  const factory = await hre.ethers.getContractFactory("NFTAirdrop");
16
  const [owner] = await hre.ethers.getSigners();
17
  const contract = await factory.deploy();
18
19
  await contract.deployed();
20
  console.log("Contract deployed to: ", contract.address);
21
  console.log("Contract deployed by (Owner): ", owner.address, "\n");
22
23
  let txn;
24
  txn = await contract.airdropNfts(airdropAddresses);
25
  await txn.wait();
26
  console.log("NFTs airdropped successfully!");
27
28
  console.log("\nCurrent NFT balances:")
29
  for (let i = 0; i < airdropAddresses.length; i++) {
30
    let bal = await contract.balanceOf(airdropAddresses[i]);
31
    console.log(`${i + 1}. ${airdropAddresses[i]}: ${bal}`);
32
  }
33
34
}
35
36
main()
37
  .then(() => process.exit(0))
38
  .catch((error) => {
39
    console.error(error);
40
    process.exit(1);
41
  });

$
npx hardhat run scripts/run.js

$
Contract has been deployed!
>
Contract deployed to:  0x5FbDB2315678afecb367f032d93F642f64180aa3
>
Contract deployed by (Owner):  0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 
>
>
NFTs airdropped successfully!
>
>
Current NFT balances:
>
1. 0x70997970c51812dc3a010c7d01b50e0d17dc79c8: 1
>
2. 0x3c44cdddb6a900fa2b585dd299e03d12fa4293bc: 1
>
3. 0x90f79bf6eb2c4f870365e785982e1f101e93b906: 1
>
4. 0x15d34aaf54267db7d7c367839aaf71a00a2c6a65: 1
>
5. 0x9965507d1a55bcc2695c58ba16fb37d819b0a4dc: 1

1
//SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.4;
3
4
import "hardhat/console.sol";
5
import "@openzeppelin/contracts/utils/Counters.sol";
6
import "@openzeppelin/contracts/access/Ownable.sol";
7
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
8
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
9
10
contract NFTAllowlist is ERC721Enumerable, Ownable {
11
    using Counters for Counters.Counter;
12
    
13
    Counters.Counter private _tokenIds;
14
15
    // Signature tracker
16
    mapping(bytes => bool) public signatureUsed;
17
    
18
    constructor() ERC721("NFT Allowlist Demo", "NAD") {
19
        console.log("Contract has been deployed!");
20
    }
21
22
    // Allowlist addresses
23
    function recoverSigner(bytes32 hash, 
24
													 bytes memory signature) 
25
						 public pure returns (address) {
26
		    bytes32 messageDigest = keccak256(
27
	        abi.encodePacked(
28
	          "\x19Ethereum Signed Message:\n32", 
29
            hash
30
	        )
31
		    );
32
		    return ECDSA.recover(messageDigest, signature);
33
		}
34
35
    // Airdrop mint
36
    function claimAirdrop(uint _count, bytes32 hash, bytes memory signature) public {
37
        require(recoverSigner(hash, signature) == owner(), "Address is not allowlisted");
38
        require(!signatureUsed[signature], "Signature has already been used.");
39
40
        for (uint i = 0; i < _count; i++) {
41
            _mintSingleNFT();
42
        }
43
44
        signatureUsed[signature] = true;
45
    }
46
    
47
    function _mintSingleNFT() private {
48
        uint newTokenID = _tokenIds.current();
49
        _safeMint(msg.sender, newTokenID);
50
        _tokenIds.increment();
51
    }
52
}

$
npx hardhat compile

1
const { ethers } = require("hardhat");
2
const hre = require("hardhat");
3
4
async function main() {
5
6
  const [owner, address1, address2] = await hre.ethers.getSigners();
7
8
  // Define a list of allowlisted wallets
9
  const allowlistedAddresses = [
10
    address1.address,
11
    address2.address,
12
  ];
13
14
  // Select an allowlisted address to mint NFT
15
  const selectedAddress = address1.address;
16
17
  // Define wallet that will be used to sign messages
18
  const walletAddress = '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266'; // owner.address
19
  const privateKey = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
20
  const signer = new ethers.Wallet(privateKey);
21
  console.log("Wallet used to sign messages: ", signer.address, "\n");
22
23
  let messageHash, signature;
24
25
  // Check if selected address is in allowlist
26
  // If yes, sign the wallet's address
27
  if (allowlistedAddresses.includes(selectedAddress)) {
28
    console.log("Address is allowlisted! Minting should be possible.");
29
30
    // Compute message hash
31
    messageHash = ethers.utils.id(selectedAddress);
32
    console.log("Message Hash: ", messageHash);
33
34
    // Sign the message hash
35
    let messageBytes = ethers.utils.arrayify(messageHash);
36
    signature = await signer.signMessage(messageBytes);
37
    console.log("Signature: ", signature, "\n");
38
  }
39
40
  const factory = await hre.ethers.getContractFactory("NFTAllowlist");
41
  const contract = await factory.deploy();
42
43
  await contract.deployed();
44
  console.log("Contract deployed to: ", contract.address);
45
  console.log("Contract deployed by (Owner/Signing Wallet): ", owner.address, "\n");
46
47
  recover = await contract.recoverSigner(messageHash, signature);
48
  console.log("Message was signed by: ", recover.toString());
49
50
  let txn;
51
  txn = await contract.connect(address1).claimAirdrop(2, messageHash, signature);
52
  await txn.wait();
53
  console.log("NFTs minted successfully!");
54
55
}
56
57
main()
58
  .then(() => process.exit(0))
59
  .catch((error) => {
60
    console.error(error);
61
    process.exit(1);
62
  });

$
npx hardhat run scripts/runAllowlist.js

$
Wallet used to sign messages:  0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 
>
>
Address is allowlisted! Minting should be possible.
>
Message Hash:  0x52d01c65d2e6acff550def14b5ce5bf353ac7ad53b132fc531c5d085d77c4ee3
>
Signature:  0x55d2baf93dff9184dea51cc81c7837c0d65e01962d7292f03afa80cedf3dcdb948ada6cae3bc49ae56d3546019ebd62cc56efe1ef9c946a7c4fe66f21596e6c91c 
>
>
Contract has been deployed!
>
Contract deployed to:  0x5FbDB2315678afecb367f032d93F642f64180aa3
>
Contract deployed by (Owner/Signing Wallet):  0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 
>
>
Message was signed by:  0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
>
NFTs minted successfully!

1
const { Alchemy, Network } = require("alchemy-sdk");
2
3
const config = {
4
    apiKey: "<-- ALCHEMY API KEY -->",
5
    network: Network.ETH_MAINNET,
6
};
7
const alchemy = new Alchemy(config);
8
9
const main = async () => {
10
11
    // BAYC contract address
12
    const address = "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D";
13
14
    // Block number or height
15
    const block = "15753215";
16
17
    // Get owners 
18
    const owners = await alchemy.nft.getOwnersForContract(address, false, block);
19
    console.log(owners);
20
};
21
22
const runMain = async () => {
23
    try {
24
        await main();
25
        process.exit(0);
26
    } catch (error) {
27
        console.log(error);
28
        process.exit(1);
29
    }
30
};
31
32
runMain();