Filebase
HomepageFilebase DashboardDiscordBlog
  • 👋Welcome to Filebase!
  • Getting Started
    • FAQ
    • Service Limits
    • Getting Started Guides
      • Pin Your First File To IPFS
      • Developer Quick Start Guide
  • IPFS Concepts
    • What is IPFS?
    • What is an IPFS CID?
    • What is IPFS Pinning?
    • What is an IPFS Gateway?
  • IPFS Pinning
    • Pinning Files
    • Listing Files
    • Deleting Files
    • Event Notifications
  • IPNS Names
    • Managing Names
  • Dedicated IPFS Gateways
    • Managing Dedicated Gateways
    • Access Controls
    • Image Optimizations
    • Adding a Custom Domain
  • API Documentation
    • IPFS RPC API
    • S3-Compatible API
      • Cross Origin Resource Sharing (CORS)
        • Create and Apply a CORS Rule to a Filebase Bucket
        • Deep Dive: Cross Origin Resource Sharing (CORS)
      • Pre-Signed URLs
    • Filebase Platform APIs
    • IPFS Pinning Service API
  • Code Development + SDKs
    • Code Development
      • Apache Libcloud - Python
      • Apostrophe CMS
      • AWS Lambda - NodeJS
      • AWS Lambda - Python
      • AWS SDK - Go (Golang)
      • AWS SDK - Java
      • AWS SDK - JavaScript
      • AWS SDK - .NET
      • AWS SDK - PHP
      • AWS SDK - Python
      • AWS SDK - Ruby
      • Code Examples
        • How To Utilize Filebase with NodeJS
      • DataCamp
      • Dart / Flutter
      • Django
      • Docker
        • Docker Volume Backup
      • Elixir Phoenix
      • Filebase NPM Package
      • Fog.io - Ruby
      • Google App Scripts
      • Integrated Haskell Platform
      • Laravel
      • Nuxt
      • Paperspace
      • Postman
      • Reading a JSON File
      • UNA
      • Unity
      • Uppy AWS S3 Plugin
      • Vue
      • Watcher for NodeJS
      • Webpack S3 Plugin
      • Xamarin
    • SDK Examples: Pinning Files and Folders to IPFS
      • AWS SDK for .NET
      • AWS SDK for Go
      • AWS SDK for JavaScript
      • AWS SDK for PHP
      • AWS SDK for Python
      • AWS SDK for Ruby
  • Archive
    • Content Archive
      • IPFS Getting Started Guide
      • Web Console Getting Started Guide
      • IPFS Tools
        • IPFS CLI
        • IPFS Desktop
        • IPFS Pin Sync
        • IPFS Pinning Service API
        • IPFS3up
      • Third Party Tools and Clients
        • Backup Client Configurations
          • AhsayCBS
          • BackupAssist Classic
          • BackupAssist ER
          • BackupNinja
          • BackupSheep
          • Bacula Enterprise Edition
          • CloudBacko
          • CloudBerry Backup
          • Cloudron
          • cPanel
          • Comet
          • Commvault
          • Duplicacy
          • Ghost IPFS Storage Adapter
          • IPFS Pinning GitHub Action
          • JetBackup
          • Kopia
          • MoveBot
          • MSP360 Online Backup
          • oDrive
          • Photos+ Cloud Library
          • qBackup
          • S3 Uploader for GitHub Actions
          • SimpleBackups
          • SnapShooter
          • Strapi Provider Plugin
          • Veeam
          • Wordpress
            • Media Cloud
            • XCloner
          • Zerto
        • CLI Tools
          • Ansible
          • Apache Pulsar
          • AWS CLI
            • How To Delete Data with AWS CLI
            • What is Multipart Upload?
          • Bash
            • Backup Files to IPFS with Bash
            • Laravel Backup with Bash
            • MongoDB Backup with Bash
            • PostgreSQL Backup with Bash
            • Wordpress Backup with Bash
          • cURL
          • Elasticsearch
          • IPFS-CAR
          • IPFScrape
          • IPGet
          • Jenkins
          • JFrog Artifactory
          • Kubernetes
            • Backup and Restore InFluxDB to Filebase with TrilioVault
            • CSI-S3
            • Kasten K10
            • Kerberos Vault
            • Longhorn.io
            • Stash for Kubernetes
            • Velero
          • Litestream
          • Minty
          • MongoDB
          • MoSMB
          • MySQL
          • Next.js .CAR File Upload
          • NFT Image Generator
          • NGINX S3 Gateway
          • Pinning Docker Images to IPFS
          • Pinning Encrypted Files to IPFS
          • PowerShell
            • Calculate the Size of Filebase Buckets using PowerShell
          • Rclone
            • Backing Up DigitalOcean Spaces to Filebase using Rclone
          • Restic
          • S3cmd
          • S3Express
          • S3FS-FUSE
          • S3QL
          • S3Surfer
          • S4cmd
          • SeaweedFS
          • Tableland
        • Content Delivery Networks
          • Bunny CDN
          • CloudFront CDN
          • Fastly CDN
        • File Management Client Configurations
          • Airbyte
          • Arq
          • Astiga
          • AWS Rekognition
          • AWS S3 Manager - iOS App
          • BucketAnywhere for S3 - Android App
          • CentreStack
          • CloudFlyer
          • Cloudfser
          • Couchdrop
          • CrossFTP
          • CyberDuck
            • How To Delete Data with CyberDuck
          • Dropshare
          • Duplicati
          • FileBrowserGO
          • Flexify.IO
          • ForkLift
          • Goofys
          • Joplin
          • LucidLink
          • MASV
          • Matrix Synapse
          • MinIO Gateway for S3
          • Mountain Duck
          • NetDrive
          • Nexfs
          • NextCloud
          • Nodeum
          • ownCloud
          • Plesk
          • Pure Storage FlashBlade
          • RaiDrive
          • S3 Browser
          • ShareX
          • SmartFTP
          • StableBit Cloud Drive
          • Storage Made Easy Enterprise File Fabric
          • WinSCP
        • NAS Device Configurations
          • Buffalo TeraStation
          • Datadobi DobiProtect
          • Netapp ONTAP Select
          • OpenDrives Atlas
          • Synology Hyper Backup
          • TrueNAS CORE
      • Knowledge Base
        • Deep Dives
          • Deep Dive: Blockchains
          • Deep Dive: Decentralized Compute
          • Deep Dive: Decentralized Digital Identity
          • Deep Dive: Decentralized Storage
          • Deep Dive: Erasure Coding
          • Deep Dive: Geo-Redundancy
          • Deep Dive: Metadata
          • Deep Dive: Metaverse
          • Deep Dive: NFTs
          • Deep Dive: Web3
        • Filebase eBooks
        • Filebase One-Pagers
        • Filebase Whitepapers
        • Web3 Tutorials
          • Alchemy
            • Alchemy: Build a dApp That Provides Real-Time Ethereum Transaction Notifications
            • Alchemy: Create a Full-Stack dApp
            • Alchemy: Create a Hello World Smart Contract
            • Alchemy: Create Your Own ERC20 Cryptocurrency
            • Alchemy: Decentralized Youtube
            • Alchemy: How to Create and Mint an NFT using Filebase
            • Alchemy: How to Mint an NFT Using Web3.js
            • Alchemy: Using The Alchemy SDK with NFTs Minted Through thirdweb
          • Agoric
            • Agoric: Create a DeFi dApp Using Agoric That’s Stored on Filebase
          • AirSwap
            • AirSwap: Track NFT Contract Addresses with AirSwap CLI
          • ArcBlock
            • ArcBlock: Running an ArcBlock Blocket Server on IPFS
          • Ankr
            • Ankr: Create a Truffle Project with Ankr and Filebase
            • Ankr: Deploy a Smart Contract on Polygon using Ankr that is backed up to Filebase
          • Avalanche
            • Avalanche: How To Launch a Generative NFT Collection With Avalanche and IPFS
          • Backing Up NFTs
          • Brownie
            • Brownie: Create and Mint an NFT Using Brownie
          • Bueno
            • Bueno: How to Create a Generative NFT Collection with Bueno
          • Cardano
            • Cardano: Submit Cardano Blockchain Transactions with Embedded Metadata Stored on Filebase
          • Ceramic
            • Ceramic: How to Host a Ceramic Node Using Decentralized Storage
          • Create-IPFS-app
          • Cosmos
            • Cosmos: Storing Cosmos Chain Governance Metadata on IPFS
          • DeCommerce
          • Ethereum Name Service
            • ENS: Configure an ENS Domain to use a Filebase IPFS Dedicated Gateway
          • Figment Datahub
            • Figment Datahub and Avalanche: Make an e-Voting dApp Using Figment Datahub, Avalanche, and Filebase
            • Figment Datahub and Celo Network: Create an ERC1155 NFT on the Celo Network using Figment Datahub and Objects Stored on Filebase
          • Flow
            • Flow: How to Create an NFT Marketplace with Filebase + Flow
          • Fauna
            • Fauna: Host an Application on IPFS with IPFS Dedicated Gateways
          • Ganache
            • Ganache: Create a dApp Hosted on IPFS
          • GUN
            • GUN: Create a Decentralized Chat App with GUN and IPFS
          • Hardhat
            • Hardhat: Creating an NFT Contract using Hardhat and Setting NFT Metadata using IPFS on Filebase
          • Harmony
            • Harmony: Deploy an HRC721 NFT on Harmony with IPFS
          • Hosting a Form on IPFS
          • iExec
            • iExec: Using iExec and Tee Worker to Create Apps that Use Datasets Stored on Filebase
          • Infura
            • Infura: Build dApp Frontends with Infura, React, and IPFS
            • Infura: Create an NFT Contract Factory with Metadata stored on IPFS
          • Lens Protocol
            • Lens Protocol: Build a Decentralized Social Media Network Stored on IPFS
          • LIT Protocol
            • LIT Protocol: Create a MintLIT NFT with LIT Protocol and IPFS
          • LivePeer
            • LivePeer: Mint a Video NFT with LivePeer
          • Macrometa
            • Macrometa: Track IPFS Files with Macrometa
          • Mina Protocol
            • Mina Protocol: Create a Simple zkApp with Mina Protocol and IPFS
          • NEAR Protocol
            • NEAR Protocol: Storing Off-Chain Data on IPFS using Filebase
          • NFTPort
            • NFTPort: Create an NFT Collection with NFTPort
          • Ocean Protocol
            • Ocean Protocol: Publish Data NFTs Stored on IPFS using Ocean Protocol
          • Pin Tezos Tokens Tool
          • Polkadot
            • Polkadot: Deploy a Polkadot dApp on Decentralized Storage
          • Polygon
            • Polygon: Building an App NFT With Polygon
            • Polygon: Make a Donation App with IPFS and Polygon
          • Python
            • Generating NFT Metadata with Python
          • QuickNode
            • QuickNode: Create a Token dApp using QuickNode
          • Remix
            • Remix: Create a Web App with Remix to Upload to Decentralized Storage
          • Remix IDE
            • Remix IDE: Creating Interactive NFTs with IPFS and Remix IDE
          • Secret Network
            • Secret Network: Create an NFT on Secret Network with Data Stored on IPFS
          • Stargaze
            • Stargaze: Create an NFT Collection Using IPFS and Stargaze
          • Starknet
            • Starknet: Create a HardHat Project Using A Starknet Plugin Hosted On IPFS
          • Studio 721
            • Studio 721: Create an NFT Collection with Studio 721 and IPFS
          • Solana
            • Solana: Minting an NFT Using Sugar, Candy Machine, and Filebase
          • Subsquid
            • Subsquid: Querying NFT Data using Subsquid and a Filebase IPFS Dedicated Gateway
          • Tailwind CSS
            • Tailwind CSS: Build an Image Gallery App with IPFS and Tailwind CSS
          • Tatum
            • Tatum: How To Mint NFTs on Solana with Tatum
          • Tezos
            • Tezos: Create an NFT on the Tezos Network using IPFS on Filebase
          • thirdweb
            • thirdweb: Build an NFT Loot Box with thirdweb and IPFS
            • thirdweb: Build an NFT Minting Page with thirdweb, IPFS, RainbowKit, and WAGMI
            • thirdweb: Create a Discord Bot That Gives Roles to NFT Holders
            • thirdweb: Create a Gated Website Using NFTs and IPFS
            • thirdweb: Create an NFT Marketplace with thirdweb and IPFS
            • thirdweb: Release an NFT Drop Using thirdweb and IPFS
          • useDApp
            • useDApp: Create a dApp using useDApp and IPFS
          • Unstoppable Domains
            • Unstoppable Domains: Create a Decentralized Website Using Unstoppable Domains and IPFS Folders
            • Unstoppable Domains: Deploy a Decentralized Blog Using Unstoppable Domains, Akash, and IPFS
            • Unstoppable Domains: IPFS Configuration
          • Vultr
            • Vultr: Store Bedrock Minecraft Worlds on Decentralized Storage
            • Vultr: Store Forge Minecraft Worlds on Decentralized Storage
            • Vultr: Store PaperSpigot Minecraft Worlds on Decentralized Storage
            • Vultr: Store Vanilla Minecraft Worlds on Decentralized Storage
          • Waffle
            • Waffle: Deploy a Smart Contract with Waffle That’s Stored on IPFS
          • Walt.id
            • Walt.id: Mint an NFT with Walt.id and Filebase
          • Web3 Toolbox
            • Web3 Toolbox: Building an NFT Drop With Web3 Toolbox
Powered by GitBook
On this page
  • What is Polygon?
  • 1. Start by creating a new directory for your NFT app, then navigating into that directory with the commands:
  • 2. Next, initialize NPM and install HardHat with the commands:
  • 3. Install the OpenZeppelin smart contracts package:
  • 4. In the contracts folder, there will be a default contract that was created. Rename this file dAppNFT.sol, then open the file. Replace the existing content with the following:
  • 5. Save this file.
  • 6. Then, compile the project with the command:
  • 7. Next, we’ll need to create the front end of our application. To do this, run the following command:
  • 8. To configure IPFS, first we need to open the package.json file. In this file, add the following key/value pair:
  • 9. Next, install the AWS CLI tool.
  • 10. Then, configure AWS CLI to use your Filebase account. To do this, open a new terminal window. From there, run the command:
  • 11. Open the package.json file again. In the scripts section, add a new script called deploy:
  • 12. In the root of the project create the file upload.sh. Open this new file in a text editor, then add the following line:
  • 13. Next, run the following command:
  • 14. Navigate to the Filebase dashboard and view the bucket that your build folder was uploaded to.
  • 15. Next, navigate to the smart contract directory in your project and find the hardhat.config.js file.
  • 16. Next, create a file in the root of your project called metadata.json. In this file, insert the following content:
  • 17. Next, upload the metadata file to IPFS:
  • 18. Finally, open the scripts folder, and then open the deploy.js file. Replace the existing content with the following:
  • 19. Run the following command to deploy this script on the Polygon network:

Was this helpful?

  1. Archive
  2. Content Archive
  3. Knowledge Base
  4. Web3 Tutorials
  5. Polygon

Polygon: Building an App NFT With Polygon

Learn how to build an app NFT with Polygon and IPFS.

PreviousPolygonNextPolygon: Make a Donation App with IPFS and Polygon

Last updated 10 months ago

Was this helpful?

What is Polygon?

Polygon is a layer two blockchain network that is designed as a sidechain solution for scaling alongside the Ethereum blockchain network.

Read below to learn how to build an app NFT with Polygon and IPFS.

Prerequisites:

1. Start by creating a new directory for your NFT app, then navigating into that directory with the commands:

mkdir nft-app-contract && cd nft-app-contract

2. Next, initialize NPM and install HardHat with the commands:

npm init

npm install --save-dev hardhat

npx hardhat

3. Install the OpenZeppelin smart contracts package:

npm install @openzeppelin/contracts

4. In the contracts folder, there will be a default contract that was created. Rename this file dAppNFT.sol, then open the file. Replace the existing content with the following:

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

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract AppNFT is ERC721URIStorage {
    using Counters for Counters.Counter;
    Counters.Counter public versions;
    mapping(uint256 => string) public builds;
    address public appOwner;

    constructor(string memory tokenURI) ERC721("AppNFT", "APP") {
        appOwner = msg.sender;
        mint(tokenURI);
    }

    function updateApp(string memory newTokenURI) public {
        require(
            msg.sender == appOwner,
            "Only the app owner can make this change"
        );
        uint256 currentVersion = versions.current();
        _setTokenURI(1, newTokenURI);
        builds[currentVersion + 1] = newTokenURI;
        versions.increment();
    }

    function getPreviousBuild(uint256 versionNumber)
        public
        view
        returns (string memory)
    {
        return builds[versionNumber];
    }

    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721: caller is not token owner nor approved"
        );

        _transfer(from, to, tokenId);
        appOwner = to;
    }

    function mint(string memory tokenURI) private returns (uint256) {
        versions.increment();
        uint256 tokenId = 1;
        uint256 currentVersion = versions.current();
        _mint(msg.sender, tokenId);
        _setTokenURI(tokenId, tokenURI);
        builds[currentVersion] = tokenURI;
        return tokenId;
    }
}

5. Save this file.

Then in the root directory there will be another folder called test. Rename the existing file in the test folder as dAppNFT.js. Replace everything in that file with the following:

const { expect } = require("chai");
const URI = "ipfs://QmTXCPCpdruEQ5HspoTQq6C4uJhP4V66PE89Ja7y8CEJCw";
const URI2 = "ipfs://QmTXCPwpdruEQ5HBpoTQq6C4uJhP4V66PE89Ja7y8CEJC2"

describe("AppNFT", function () {
  async function deploy() {   
    const [owner, otherAccount] = await ethers.getSigners();

    const AppNFT = await ethers.getContractFactory("AppNFT");
    const appNft = await AppNFT.deploy(URI);
    await appNft.deployed();
    return appNft;
  }

  describe("Deployment", function () {
    it("Should deploy contract and mint", async function () {
      const appNft = await deploy();
      const uri = await appNft.tokenURI(1)
      expect(uri).to.equal(URI);
    });

    it("Should set the right version number", async function () {
      const appNft = await deploy();
      const versions = await appNft.versions()
      expect(versions).to.equal(1);
    })

    it("Should return correct URI based on version", async function() {
      const appNft = await deploy();
      const buildURI = await appNft.getPreviousBuild(1);
      expect(buildURI).to.equal(URI);
    })

    it("Should not allow minting additional tokens", async function() {
      const appNft = await deploy();
      let err;
      try {
        await appNft.mint(URI);
      } catch (error) {
        err = error.message;
      }

      expect(err).to.equal("appNft.mint is not a function");      
    })
  });

  describe("Versions", function () {
      it("Should allow the app owner to update versions", async function () {
        const appNft = await deploy();
        const uri = await appNft.tokenURI(1)
        expect(uri).to.equal(URI);
        await appNft.updateApp(URI2);
        const uri2 = await appNft.tokenURI(1)
        expect(uri2).to.equal(URI2);
      });

      it("Should show correct current version", async function () {
        const appNft = await deploy();
        const uri = await appNft.tokenURI(1)
        expect(uri).to.equal(URI);
        await appNft.updateApp(URI2);
        const uri2 = await appNft.tokenURI(1)
        expect(uri2).to.equal(URI2);
      });

      it("Should not allow someone who is not the app owner to update versions", async function() {
        const appNft = await deploy();
        const uri = await appNft.tokenURI(1)
        expect(uri).to.equal(URI);
        const [owner, otherAccount] = await ethers.getSigners();
        let err;
        try {
          await appNft.connect(otherAccount).updateApp(URI2);
          const uri2 = await appNft.tokenURI(1)
          expect(uri2).to.equal(URI2); 
        } catch (error) {
          err = error.message;                    
        }        
        expect(err).to.equal("VM Exception while processing transaction: reverted with reason string 'Only the app owner can make this change'");
      })
  });

  describe("Transfers", function () {
    it("Should not allow transfers from non owner and non approved", async function() {
      const appNft = await deploy();
      const [owner, otherAccount] = await ethers.getSigners();
      let err;
      try {
        await appNft.connect(otherAccount).transferFrom(owner.address, otherAccount.address, 1);
      } catch (error) {
        err = error.message;
      }

      expect(err).to.equal("VM Exception while processing transaction: reverted with reason string 'ERC721: caller is not token owner nor approved'");      
    });

    it("Should allow transfers from owner to another address", async function() {
      const appNft = await deploy();
      const [owner, otherAccount] = await ethers.getSigners();
      await appNft.transferFrom(owner.address, otherAccount.address, 1);   
      expect(await appNft.appOwner()).to.equal(otherAccount.address);
      expect(await appNft.ownerOf(1)).to.equal(otherAccount.address);
    });

    it("Should allow transfer from non-owner if address is approved", async function() {
      const appNft = await deploy();
      const [owner, otherAccount] = await ethers.getSigners();
      await appNft.approve(otherAccount.address, 1);   
      await appNft.connect(otherAccount).transferFrom(owner.address, otherAccount.address, 1);
      expect(await appNft.appOwner()).to.equal(otherAccount.address);
      expect(await appNft.ownerOf(1)).to.equal(otherAccount.address);
    })
  })
});

6. Then, compile the project with the command:

npx hardhat test

7. Next, we’ll need to create the front end of our application. To do this, run the following command:

npx create-react-app app-nft-frontend

8. To configure IPFS, first we need to open the package.json file. In this file, add the following key/value pair:

"homepage": "./"

10. Then, configure AWS CLI to use your Filebase account. To do this, open a new terminal window. From there, run the command:

aws configure

This command will generate a series of prompts, which should be filled out as such:

  • Access Key ID: Filebase Access Key

  • Secret Access Key: Filebase Secret Key

  • Region: us-east-1

11. Open the package.json file again. In the scripts section, add a new script called deploy:

"deploy": "npm run build && sh ./upload.sh"

This line includes a script called upload.sh that we haven’t created yet. We’ll create that next.

12. In the root of the project create the file upload.sh. Open this new file in a text editor, then add the following line:

aws --endpoint https://s3.filebase.com s3 sync ./build s3://bucket-name

Replace bucket-name with your Filebase IPFS bucket name.

13. Next, run the following command:

npm run deploy

After running this command, the build script will be initiated, followed by the build folder being uploaded to your Filebase bucket.

14. Navigate to the Filebase dashboard and view the bucket that your build folder was uploaded to.

Take note of this folder’s IPFS CID value:

15. Next, navigate to the smart contract directory in your project and find the hardhat.config.js file.

Replace the existing content with the following:

require("@nomicfoundation/hardhat-toolbox");
module.exports = {
  solidity: "0.8.9",
};
module.exports = {
  solidity: "0.8.9",
  networks: {
    mumbai: {
      url: `https://polygon-mumbai.g.alchemy.com/v2/ALCHEMY_KEY`,
      accounts: ["POLYGON MUMBAI WALLET PRIVATE KEY"]
    }
  }
};

In this file, you will need to replace two values:

16. Next, create a file in the root of your project called metadata.json. In this file, insert the following content:

{
"name": "dApp NFT",
"description": "A full-stack decentralized application that can be sold and transferred as an NFT.",
"image": "ipfs://CID",
"animation_url": "ipfs://BUILD_CID
}

Replace the following values:

  • BUILD_CID: This value is from the build folder that we uploaded to Filebase in step 14.

  • CID: This CID represents an image file that will be used for a visual representation of your app. To upload a file to Filebase to be used in this place, follow these steps:

    • Start by clicking on the ‘Buckets’ option from the menu to open the Buckets dashboard.

    • Select your IPFS Bucket.

  • After clicking on the bucket name, you will see any previously uploaded files. To upload another file, select 'Upload', then select 'File' from the options.

  • Select the file you want to upload to the IPFS.

  • Once uploaded, you will be able to view and copy the IPFS CID from the 'CID' category, as seen below.

17. Next, upload the metadata file to IPFS:

aws --endpoint https://s3.filebase.com s3 cp metadata.json s3://bucket-name

Replace bucket-name with your Filebase IPFS bucket name.

18. Finally, open the scripts folder, and then open the deploy.js file. Replace the existing content with the following:

const hre = require("hardhat");
const URI = "ipfs://METADATA_CID"
async function main() {
  const AppNFT = await ethers.getContractFactory("AppNFT");
  const appNft = await AppNFT.deploy(URI);
  await appNft.deployed();
  console.log(`Contract deployed to ${appNft.address}`);
}
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Replace the METADATA_CID value with the IPFS CID for the metadata.json file you uploaded to Filebase in the previous step. This value can be found in the Filebase web console dashboard.

19. Run the following command to deploy this script on the Polygon network:

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

From here, you can view this deployed NFT from a public marketplace like OpenSea by connecting your cryptowallet to the platform, or you can configure your app to be customized, since we used the default React app in this example.

9. Next, install the .

ALCHEMY_KEY: Your Alchemy API key. For instructions on how to get this value, see

POLYGON MUMBAI WALLET PRIVATE KEY: Polygon wallet private key. For instructions on how to get this value, see

MetaMask
Polygon Mumbai network
Install Node.js and npm
VSCode
Sign up
here
here
AWS CLI tool
this guide.
this guide.