Avalanche: How To Launch a Generative NFT Collection With Avalanche and IPFS

Learn how to launch a generative NFT collection with IPFS and Avalanche.

What is Avalanche?

Avalanche is a blockchain smart contracts platform similar to Ethereum for developing and deploying smart contracts for NFT minting, dApp deployment, and other Web3-related workflows.

Read below to learn how to launch a generative NFT collection with IPFS and Avalanche.

Prerequisites:

• A cryptowallet, such as MetaMask.

• Configure your cryptowallet to use the Avalanche Fuji Network.

• Have some testnet AVAX currency for transaction gas fees. Use the faucet found here to obtain testnet currency.

• Install Node.js and npm.

• Download and install an IDE of your choice, such as VSCode.

• Sign up for a free Filebase account.

• Have your Filebase Access and Secret Keys. Learn how to view your access keys here.

1. First, we need to create an IPFS bucket on Filebase.

To do this, navigate to console.filebase.com. If you don’t have an account already, sign up, then log in.

2. Select ‘Buckets’ from the left sidebar menu, or navigate to.

Select ‘Create Bucket’ in the top right corner to create a new bucket for your NFTs.

3. Enter a bucket name and choose the IPFS storage network to create the bucket.

Bucket names must be unique across all Filebase users, be between 3 and 63 characters long, and can contain only lowercase characters, numbers, and dashes.

4. Next, run the following command to create a new project directory and navigate inside it:

mkdir avalanche-drop && cd avalanche-drop

5. Then, initialize the project directory:

npm init -y

6. Install and start Hardhat and its related dependencies:

npx hardhat

When prompted, select the create empty project option during the Hardhat initialization process.

7. Now, upload your NFTs to Filebase using the web console and selecting ‘Folder’, then selecting the folder that contains your NFT files.

These files need to be named in sequential order, such as 0.png, 1.png, 2.png, etc.

8. You will see your folder uploaded as a single object:

9. Copy the CID of your folder:

10. Navigate to your IPFS Folder using the Filebase IPFS gateway to see your folder’s files:

https://ipfs.filebase.io/ipfs/IPFS_CID

Replace IPFS_CID with your folder’s IPFS CID.

11. Install the OpenZeppelin smart contracts package:

npm install @openzeppelin/contracts

12. Create a new folder in your project directory called contracts, then create a new file in this directory called NFT.sol.

Open this new file in your IDE of choice, and paste in the following content:

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

import "hardhat/console.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

contract AvalancheNFTDrop is ERC721Enumerable, Ownable {
    using Counters for Counters.Counter;
    using Strings for uint256;

    string public BASE_URI;
    uint256 public MAX_SUPPLY = 10000;
    uint256 public PRICE = 0;

    constructor(
        string memory baseURI,
        uint256 price, 
        string memory name,
        string memory symbol
    ) ERC721(name, symbol) {
        PRICE = price;
        BASE_URI = baseURI;
    }

    function _baseURI() internal view override returns (string memory) {
        return string(abi.encodePacked(BASE_URI, "/"));
    }

    function mint(address addr)
        public
        payable
        returns (uint256)
    {
        uint256 supply = totalSupply();
        require(supply <= MAX_SUPPLY, "Would exceed max supply");    
        require(msg.value >= PRICE, "insufficient funds");
        uint256 tokenId = supply + 1;       
        _safeMint(addr, tokenId);
    
        return tokenId;
    }
}

13. Navigate back into the root of your project directory, then create a new folder called metadata.

mkdir metadata

14. Still in the root directory, create a new file called metadata-generator.js.

Open this file in your IDE and insert the following content:

require("@nomiclabs/hardhat-waffle");
const AVALANCHE_TEST_PRIVATE_KEY = "PRIVATE_KEY_FOR_FUJI";
module.exports = {
  solidity: "0.8.0",
  networks: {
    avalancheTest: {
    url: 'https://api.avax-test.network/ext/bc/C/rpc',
    gasPrice: 225000000000,
    chainId: 43113,
    accounts: [`0x${AVALANCHE_TEST_PRIVATE_KEY}`]
  }
 }
};

This code will generate metadata for each of the files in our IPFS folder. Replace the following values:

• “./Images”: The folder name and file path of your image folder that you uploaded to Filebase earlier.

• Name: Name for each NFT

• Description: Description for each NFT

• IPFS_FOLDER_CID: Your Filebase IPFS folder CID.

15. Run this metadata-generator.js script with the command:

node metadata-generator.js

16. Your metadata folder will now be populated with metadata files.

Upload these files to Filebase using the same folder upload method used at the beginning of this tutorial. Copy the CID of this folder for use in the next step.

17. Open the hardhat.config.js file at the root of your project folder.

Replace the existing content with the following:

const fs = require('fs');
const imageDir = fs.readdirSync("./Images");
imageDir.forEach(img => {
  const metadata = {
    name: `Filebase NFT ${img.split(".")[0]}`,
    description: "A Filebase NFT Collection",
    image: `ipfs://IPFS_FOLDER_CID/${img.split(".")[0]}.png`,
    attributes: []
  }
  fs.writeFileSync(`./metadata/${img.split(".")[0]}`, JSON.stringify(metadata))
});

Replace PRIVATE_KEY_FOR_FUJI with your cryptowallet’s private key. To export your private key from MetaMask, select your Account Details, then select ‘Export Private Key’.

18. Now it’s time to create our deploy script for our smart contract.

In your project’s root directory, create a new file called scripts:

mkdir scripts && cd scripts

19. Then, create a new file called deploy.js.

Open this file in your IDE of choice, then insert the following content:

const hre = require("hardhat");
const BASE_URI = "ipfs://METADATA_FOLDER_CID";
const TOKEN_NAME = "YOUR TOKEN NAME";
const TOKEN_SYMBOL = "YOUR TOKEN SYMBOL";
const PRICE = "500000000000000000" // 0.5 AVAX - use whatever price you want, but the denomiation is in WEI

async function main() {
  try {
    const Contract = await hre.ethers.getContractFactory("AvalancheNFTDrop");
    const contract = await Contract.deploy(BASE_URI, PRICE, TOKEN_NAME, TOKEN_SYMBOL);
  
    await contract.deployed();
  
    console.log(`contract deployed at ${contract.address}`); 
  } catch (error) {
    console.log(error);
  }  
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

Replace the METADATA_FOLDER_CID with the IPFS CID of your folder that contains the metadata files we generated earlier. Replace TOKEN_NAME and TOKEN_SYMBOL with your desired information.

20. Compile your project:

npx hardhat compile

21. Deploy your smart contract with the command:

npx hardhat run --network avalancheTest scripts/deploy.js

This will return a contract address. Copy this address for use in the next step.

22. Last, it’s time to create a minting script to mint our NFTs using this newly deployed smart contract.

In your scripts folder, create a new file called mint.js. Enter the following content:

const hre = require("hardhat");

async function main() {
  try {
    const Contract = await hre.ethers.getContractFactory("AvalancheNFTDrop");
    const contract = await Contract.attach(
      "CONTRACT_ADDRESS" // The deployed contract address
    );
    
    let overrides = {
      value: ethers.utils.parseEther((0.5).toString()),
    };
    const tx = await contract.mint("WALLET_ADDRESS");
  
    console.log("Minted: ", tx);
  } catch (error) {
    console.log(error);
  }  
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

Replace CONTRACT_ADDRESS with the contract address you took note of in the last step, then replace WALLET_ADDRESS with your crypto wallet address that is on the Fuji Avalanche network.

23. Run the mint.js script with the following command:

npx hardhat run --network avalancheTest scripts/mint.js

You’ve minted your NFTs on the Fuji Avalanche Testnet network! You can view each image and its metadata with the following IPFS URLs:

To view a metadata file:

https://ipfs.filebase.io/ipfs/METADATA_FOLDER_CID/1

To view an image file:

https://ipfs.filebase.io/ipfs/IMAGE_FOLDER_CID/1.png

You can now repeat these steps using the Avalanche mainnet network, and you can use a folder of images that include thousands of NFT collection pieces!