DEV Community: FaithlessnessNo332

Career Opportunities in Blockchain

FaithlessnessNo332 — Mon, 20 Feb 2023 07:30:17 +0000

Introduction

Hello, 👋

Blockchain technology has been gaining significant attention in recent years due to its potential to revolutionize industries and transform businesses' operations. As a result, the demand for skilled blockchain professionals has increased, creating exciting new career opportunities in this rapidly growing field. If you're interested in pursuing a career in blockchain, there has never been a better time to get started. In this article, we will explore the different career paths available in the blockchain industry and provide insights on how you can develop the necessary skills and knowledge to succeed in this exciting and dynamic field.

I will only stick to the title and not going to explain what is blockchain technology and how it works,🙃 We can discuss that in some other article. As I have been into this technology for more than 5 years now, I will also elaborate on the minimum requirements and skillsets to enter this field. This will vary according to the job role.

Job roles in Blockchain

1. Smart Contract Developer

👨‍💻
This is a developer-oriented job. If you are a developer already and know something about programming/coding then you can easily enter into this. You just need to learn a few more programming languages like Solidity, Rust, GO, etc. If you are not a developer and starting from scratch then you'll face some difficulties, I am not saying you can't do it but you still need to clear the basics of programming languages e.g. oops concepts.

*So what is Smart Contract? *

A smart contract is a self-executing program that runs on a blockchain platform. It is a computer program that is designed to automatically enforce the terms of a contract by facilitating, verifying, or enforcing the negotiation or performance of a contract.

Following is the example of a simple smart contract designed in the solidity language for storing one variable on the Ethereum blockchain and reading it back.

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

contract Sample  {
   int256 a;

   function store(int256 x) public{
       a=x;
   }

   function retrieve() public view returns(int256){
       return a;
   }
}

Don't worry if you don't understand this. No need to scratch your head 🤕. Remember this article is not about smart contracts and move forward!

So what do you have to do here ?

It's fairly simple, build various smart contracts 😂. What kind? Well, Smart contracts can be used for a variety of applications such as managing digital identities, verifying the authenticity of digital assets, executing financial transactions, and automating supply chain management.

So what's the average salary for this kind of role?

The salary of a smart contract developer can vary depending on several factors, such as their level of experience, geographic location, and the type of company or organization they work for.

According to various job market data and salary estimation websites, the average salary of a smart contract developer in the United States ranges from around $90,000 to $180,000 per year. However, more experienced smart contract developers can earn even higher salaries, with some earning over $200,000 per year.

In other parts of the world, the average salary of a smart contract developer may be lower or higher depending on the local job market and economic conditions. It's worth noting that salaries for smart contract developers are generally higher in regions with a high demand for blockchain talent, such as the United States, Europe, and Asia.

2. Blockchain Developer

Here, the level slightly increases, You have to build more than just a Smart Contract. What more? Here the core concepts of blockchain come into play like cryptography, peer-to-peer network or you can say decentralized networks, distributed ledgers, etc. (I am not going to explain these things go google yourself! or take the Introduction to Blockchain course from DAppWorld)

If you are at a basic level of coding or just started with programming then it will be horrifying to you, right ?😨

If you are at an advanced level then you can directly get into this, but if you are a beginner you can take internship opportunities or jr level jobs to build up yourself.

Don't ask me about the salary here, because it varies according to your level. If you are at a very advanced level like Vitalik Buterin then you might not need the job 😇, build your own blockchain. 🤩

3. Blockchain solution architect

This is the best job if you have a complete understanding of how blockchain works and what's going on in the industry like what different solutions are available, what different blockchain platforms are available, which industry field requires what kind of blockchain, etc

A blockchain solution architect is responsible for designing and implementing secure and scalable blockchain-based solutions for an organization. Some of their responsibilities include:

Identifying business requirements
Designing blockchain architecture
Developing blockchain applications
Integration with existing systems
Security and risk management
Testing and validation
Documentation and training Overall, the blockchain solution architect plays a critical role in ensuring that the blockchain solution is designed and implemented correctly and meets the organization's requirements for security, scalability, and functionality.

There is no need to be a developer to take this job, interesting right? 🥳

4. Blockchain Legal Consultant

Since the technology is the latest one and provides very different solutions in finance there are cryptocurrencies, in company governance, there are decentralized autonomous organizations or DAOs, and there should be someone who can consult you for your legal formalities. Currently, there are no clear rules on these things, it varies according to the geo-location which country you are based in, or what are your operations does it include something that current government Acts don't support, this one is also one opportunity if you have a background from the legal field.

5. Blockchain Quality Engineer :

The role of a blockchain quality engineer is to ensure that blockchain-based applications and solutions are developed and delivered to meet the highest quality standards.

Some of the specific responsibilities of a blockchain quality engineer may include:

Designing test plans and strategies
Developing test cases
Performing tests
Reporting issues
Automation Overall, the role of a blockchain quality engineer is closely related to auditing, as they play a critical role in ensuring that the blockchain solution meets the desired specifications, functional requirements, and other quality standards.

So these are some main job roles apart from this there are a few roles there as well but they are not full blockchain field roles, you might be working in another area but some parts of your project could be related to blockchain. they are listed below -

Accountants
Public Relations
Marketers
Crypto journalists
Managers
Crypto brokers
Analysts
ICO advisors

6. Blockchain Full stack/Web/UX developer

This one is interesting. If you are already a front-end or full-stack or UX developer then you can learn some quick skills in web3 and get this job. Why is this needed? The blockchain technological stack is slightly different from the traditional server-database technical stack. So here you need some more skills like working with web3.js like libraries with react.js or nodejs, Working with wallets like metamask, etc. I am not going to give details here you can go through the following video and see for yourself -

Traditional apps vs DApps

So, that was all about building your career in blockchain. There are always numerous opportunities in the upcoming or new technologies as the competition is less compared to the opportunities and demand is high compared to supply.

Happy Job Changing! Start your career in blockchain right away with DApp World

Build blockchain with Polygon Edge

FaithlessnessNo332 — Wed, 15 Feb 2023 08:29:11 +0000

In this article, we will see how to build our own blockchain in on our local computer using polygon edge technology.

First things first — installations

In order to build our own blockchain with a polygon edge, we need to first install the polygon edge on our system. We will also discuss all the dependencies and packages that are used in this course and how to install them.

So what are the prerequisites to get started with polygon edge? You should have some knowledge of the following topics -
Using the terminal or command prompt
How the blockchain works and its terminologies
Using Metamask wallet
And lastly, the following packages installed on your system

1.GO
If you choose to install polygon edge by cloning the repository and building it on the local system then you should have ‘go’ installed on your system. Now to install the go on your system you can visit -

https://go.dev/doc/install

Follow the steps to install the go according to your operating system. Once installed you can check if the go is installed properly or not by typing the following command in the command prompt or terminal -

$ go version

( Skip the ‘$’ it’s not the command, in each case from here onwards ) 😜, This will print the version of go installed on your system.

2.NodeJS
In the complete process of building the blockchain with polygon edge, we will be using some of the packages that use nodejs like truffle or hardhat libraries for deploying smart contracts on our custom blockchain or building the openzeppelin ERC20 tokens using their npm package, etc. So make sure you’ve NodeJS installed on the system.

To install the nodejs on your system you can visit -

https://nodejs.org/en/

Follow the steps to install the nodejs according to your operating system. Once installed you can check if the nodejs is installed properly or not by typing the following command in the command prompt or terminal -

$ node -v

This will print the current version of nodejs installed on your system.

It is advised to install nodejs with NVM(Node Version Manager), it lets you install and manage multiple versions of nodejs at the same time on a single system. Also in some cases, it might solve the permission error problems.

3.Truffle
You can skip this for now, but you still have to install the truffle when we will build the ‘Hello World’ smart contract on our edge chain. So it’s up to you, if you want to install it at this stage you can do that by following -

https://trufflesuite.com/docs/truffle/getting-started/installation/

This documentation also covers the installation of NodeJS with NVM.

4.Git(Optional)
We need the ‘git’ to clone the repository of polygon edge and later to clone the staking smart contracts. Basically, there are two ways to clone the repositories from GitHub -

We can use the ‘git clone ’ from the command prompt or terminal itself or
Just directly visit the GitHub repository URL and download the zip version of the URL on our system and then extract it.

If you want to install the git you can do so by visiting -

https://github.com/git-guides/install-git

5.Polygon Edge
There are three ways to install polygon edge on our system.

Docker image

If you’re familiar with docker then you can go with this option otherwise skip this option.

Official Docker images are hosted under the hub.docker.com registry.

$ docker pull 0xpolygon/polygon-edge:latest

Building from source

Now, this option requires the go installed on our system. make sure the installed version of go is >=1.18.

$ git clone https://github.com/0xPolygon/polygon-edge.git
$ cd polygon-edge/
$ go build -o polygon-edge main.go
$ sudo mv polygon-edge /usr/local/bin

Follow the above steps one by one and install the polygon edge.

Using go install

This option also requires the go installed on our system. make sure the installed version of go is >=1.18.

$ go install github.com/0xPolygon/polygon-edge@develop

The binary will be available in your GOBIN environment variable and will include the latest changes from the mainline development branch.

If you ‘are facing any problems while installing any of the above packages on your system, you can ask for help from the DApp World community by joining the discord here -

https://discord.gg/efYvkwGyYu

Now once you’ve installed all the required dependencies we are good to go for building our own blockchain with polygon edge 🥳.

Now that you have completed the installations Let’s discuss what are the steps we are going to follow to build blockchain using polygon edge -

The first thing to consider here is that peer-to-peer networks are built of nodes that are nothing but computer machines, so to build that we need more than one computer machine here, but for now, we can make use of different ports available to run different nodes and create a network of nodes on one single system.

We’ve discussed that we are building a network of 4 nodes and why exactly 4 nodes in the last lesson. These 4 nodes will be the validator nodes and are eligible for both proposing the block and validating the blocks.

❗Why exactly 4 nodes?

There is no minimum to the number of nodes in a cluster, which means clusters with only 1 validator node are possible. Keep in mind that with a single node cluster, there is no crash tolerance and no BFT guarantee.

The minimum recommended number of nodes for achieving a BFT guarantee is 4 — since in a 4-node cluster, the failure of 1 node can be tolerated, with the remaining 3 functioning normally.

So each of these validator nodes will have a complete copy of the blockchain.

As all four nodes will be running on localhost, during the setup process it is expected that all the data directories for each of the nodes are in the same parent directory.

Steps to run a successful polygon edge chain on the local system -

Generate data directories for each of the 4 nodes
Prepare multiaddr string for bootnode
Generate genesis file
Running all servers and nodes.

Let’s see the steps one by one -

Step 1 : Initializing data directories

**-
Initialize the data directory with

$ polygon-edge secrets init - data-dir test-chain-1

This will generate the data directory for node one with name “test-chain-1”

And print the respective parameters -

Validator key
BLS public key
Node ID
Similarly for node 2 -

$ polygon-edge secrets init - data-dir test-chain-2

and node 3 -

$ polygon-edge secrets init - data-dir test-chain-3

and node 4 -

$ polygon-edge secrets init - data-dir test-chain-4

Step 2 : Preparing multiaddr string for bootnode

-
multiaddr format is as follows :

/ip4//tcp//p2p/
Here ip_address is 127.0.0.1, and the port will be 10001 in the case of node 1. The node_id is obtained while initializing the data directories.

So the complete multiaddr string for node 1 will look like -

/ip4/127.0.0.1/tcp/10001/p2p/16Uiu2HAmJxxH1tScDX2rLGSU9exnuvZKNM9SoK3v315azp68DLPW
Similarly, prepare the bootnode string for node2.

Step 3 : Generating genesis file

The basic command to generate the genesis file -

$ polygon-edge genesis
 — consensus ibft 
 — ibft-validators-prefix-path test-chain- 
 — bootnode <01_multiaddr> 
 — bootnode <02_multiaddr>

Now here you should replace the <01_multiaddr> and <02_multiaddr> with the multiaddr string prepared in the last tutorial.

To premine the tokens in some account you should use the premine flag like -

- premine=<public_key_address>:1000000000000000000000

here replace the with the public key address in which you want to premine the tokens.

so the complete command will look like -

polygon-edge genesis 
 - consensus ibft 
 - ibft-validators-prefix-path test-chain- 
 - bootnode /ip4/127.0.0.1/tcp/10001/p2p/16Uiu2HAmJxxH1tScDX2rLGSU9exnuvZKNM9SoK3v315azp68DLPW 
 - bootnode /ip4/127.0.0.1/tcp/20001/p2p/16Uiu2HAmS9Nq4QAaEiogE4ieJFUYsoH28magT7wSvJPpfUGBj3Hq
 - premine=0x3956E90e632AEbBF34DEB49b71c28A83Bc029862:1000000000000000000000

You can use as many as premine flags as you want.

To run the nodes -

For node 1 -

$ polygon-edge server 
 - data-dir ./test-chain-1 
 - chain genesis.json 
 - grpc-address :10000 
 - libp2p :10001 
 - jsonrpc :10002 
 - seal

For node 2 -

$ polygon-edge server 
 - data-dir ./test-chain-2 
 - chain genesis.json 
 - grpc-address :20000 
 - libp2p :20001 
 - jsonrpc :20002 
 - seal

Similarly, just replace the server port numbers and data directories for node 3 and node 4 respectively

Congratulations! You have now a blockchain running with 4 nodes on your local computer.

Now download and setup the meta mask wallet we will connect the wallet to the local blockchain.

Once the metamask account is set up now lets deploy the smart contract on our local blockchain -

The “Hello World” smart contract -

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
contract HelloWorld {
function helloworld() public pure returns(string memory){
 return "Hello World";
 }
}

Installing HDWalletProvider -

$ npm install @truffle/hdwallet-provider

Network configuration -

edgechain: {
 provider: () =>
 new HDWalletProvider(privatekey, `http://localhost:10002/`),
 network_id: '*',
 chain_id: 100,
},

Truffle commands -

Check version :

$ truffle version

Compile :

$ truffle compile

Migrate :

$ truffle migrate - network edgechain

Console :

$ truffle console - network edgechain

Getting contract instance in truffle console environment :

> let instance = await HelloWorld.deployed()

Fetching helloworld function :

> let msg = await instance.helloworld()

Congratulations! you have successfully create the blockchain on local computer and deployed the smart contract on it!

To get the complete guide with full Video+Reading+Quizzes and certification visit the DAppWorld and enroll in the course :

Complete course with videos+readings+quizzes+labs

Thanks for reading!

LeetCode, CodeChef for Blockchain (Solidity)

FaithlessnessNo332 — Mon, 13 Feb 2023 07:57:43 +0000

Want to solve competitive problems in blockchain (solidity) ?

Are you a competitive programmer? and solved many problem statements from platforms like leetcode, chedchef and recently started with solidity in the blockchain.

If you are looking for competitive problem statements, I have just the perfect platform for you!

Competitive programming for blockchain

The Platform
The DApp World Assessments is where you can practice the solidity problem statements.

Just visit the website and register to create the account. Pick any problem statement for example there are many problem statements -

Storage Smart Contract
Calculate greatest
Calculate factorial
Compare strings
etc Let’s pick the Storage Smart Contract.

Click on the Solve Challenge button. Then click on the Start Assessment button.

Now you will be presented with the following screen -

The Problem
Now let’s discuss the points here

1. The problem statement: Here, you’ll get a complete idea of what you’re going to solve with objective and task.

2. The code editor: You have to write your answer in this code editor.

3. Compile: It’s always good to compile the code before submitting the answer to check if there are any syntax or compilation errors in the code.

4. Submit: Once you are confident on your answer you can submit the code.

5. Report: If you have any problem regarding the execution process or anything else you can report the error to the team from here.

Now let’s write the answer and submit the code.

The Result

Once you have submitted the answer you will get the complete result like this.

Here you can see we have 4 tabs, output, compile, deploy, and testcases. The complete score is breakdown in 3 parts the compile score + deploy score + testcases score.

Here the testcases are the details. Here you’ll get a detailed analysis of your answer. You can check what went wrong and correct it for the next attempt.

The Leaderboard

In the leaderboard tab, you can check where you stand in the competition. The position is calculated with respect to the number of attempts, the total score, and the total gas used. If you want to top the leaderboard then you must have a higher score with fewer attempts and less gas used.

If you have any suggestions or exciting problem statements, you can write to us at contact@dapp-world.com

Thank you.

How to create dynamic NFTs ?

FaithlessnessNo332 — Sat, 11 Feb 2023 10:06:41 +0000

NFT is a very hot topic 🔥 of discussion these days due to the rise in cryptocurrency and blockchain-related technologies.

What is a dynamic NFT?

Now whatever NFTs are used currently are static ones, Which means they do not change based on an external trigger. What do I mean by do not change based on the external triggers?

Suppose you own an NFT from a crypto kitties 😺 collection, (If you don't know what is a crypto kitties collection, It is a famous NFT collection of cats arts which you can own and breed to create new kitties based on their attributes.) the NFT that you own is just a JPEG or PNG image at the back end. Now there is a whole story behind how this technology stack works, we will discuss it in another smartbook, but here let's stick to the title. This JPEG or PNG is in a static form means the kitten won't grow older with time or wear outfits according to the weather. Now If we implement something which makes the kitten dynamic then it's called dynamic NFTs.

Now in this smartbook, we will discuss how to mint our own dynamic NFT with the help of revise network.

Technical stack for creating NFT

So the above image shows how the NFT architecture works.

Some points to consider are -

The digital asset is not stored on the blockchain directly
The digital asset is stored on the cloud storage (it can be centralized [AWS, Google Cloud, etc], or decentralized [IPFS])
The storage link for the digital asset is also not stored in the smart contract directly🙃
There is something called a metadata file that need to be created according to the EIP standard.
This metadata file contains the URL pointing to the digital asset and some attributes like name, description and properties
Now this metadata file is again stored on the cloud storage it can be centralized or decentralized
Now this URL pointing to the metadata file is stored as tokenURI in the smart contract 😇

Minting the dynamic NFT
Now I suppose you are a developer and know the basics of solidity. We are going to use openzeppelin to mint our NFTs. If you don't know what openzeppelin is, it's an open-source contract library that can be used directly to build smart contracts.

Minting tokens without any tokenURI (Optional)

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract MyToken is ERC721, Ownable {
using Counters for Counters.Counter;

Counters.Counter private _tokenIdCounter;

constructor() ERC721("MyToken", "MTK") {}

function safeMint(address to) 
     public 
    onlyOwner 
{
    uint256 tokenId = _tokenIdCounter.current();
    _tokenIdCounter.increment();
    _safeMint(to, tokenId);
}

}
So the above code is used to create the NFT contract with the help of openzeppelin smart contract. This is very basic smart contract that mints the NFT tokens directly without any tokenURI.

Minting tokens with tokenURI

// contracts/GameItem.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

contract GameItem is ERC721URIStorage {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() ERC721("GameItem", "ITM") {}

    function awardItem(address player, string memory tokenURI)
        public
        returns (uint256)
    {
        uint256 newItemId = _tokenIds.current();
        _mint(player, newItemId);
        _setTokenURI(newItemId, tokenURI);

        _tokenIds.increment();
        return newItemId;
    }
}

Now in the above example we can set the tokenURI, I have already discussed about how and where the actual digital asset is stored and which tokenURI we are expected to add in the smart contract.

Now we are going to use Revise network to save our digital assets and change it later on to make them dynamic.

now visit the revise network here. and sign in and generate the API key.

Once you have generated the API key let's install the revise SDK on our system. Before that make sure you have nodeJS installed on the system.

Installations

To check if nodeJs is installed on the machine -

node -v

This will return the installed version of nodeJS otherwise the message, "node not found"

To install the nodeJs -

https://nodejs.org/en/download/

The Revise network page -

https://revise.network/

To install the revise-sdk -

npm install revise-sdk --save

--save flag is optional.

To clone the starter pack of revise -

https://github.com/revise-network/nft-tutorial-1

Creating Revise project
Now create an empty nodejs project and index.js file and paste the following code in the file

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "_past your api key"

const revise = new Revise({auth : AUTH_TOKEN});

async function AddNFT(){

    const collection  =  await revise.addCollection
     ({
          name : "_name of your collection",
          uri : "_choose unique uri"
      })

    const nft = await revise.addNFT({
        image : "_url of image", //!change here
        name : "_name of token",
        tokenId : '_id of token',
        description : "_description of token"
    },[
        {mood : 'Happy', stamina : 100}
    ], collection.id)

    console.log("Created NFT successfully, ID:", nft)

}

AddNFT()

Make sure to replace the API key to AUTH_TOKEN, and choose the unique name of the collection. Also, change all parameters in the addNFT function according to your requirements.

In the array, I have added the additional attributes for the respective NFT.

Deploying contract

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract MyDNFT is ERC721 {

    string baseuri = "";
    constructor(string memory _baseuri) 
    ERC721("Dynamic NFT", "dNFT")  
    {
        baseuri = _baseuri;
    }

    function mint(address to, uint256 tokenId) 
        public  
    {
        _safeMint(to, tokenId);
    }

    function _baseURI() 
        internal 
        view 
        override(ERC721) 
        returns (string memory)  
   {
        return baseuri;
    }
}

Now we will use the above smart contract to mint the NFT collection. Here I have added something called baseuri, this is something that you have to create. It depends on the collection name you have give while adding the NFT to the revise. Suppose your collection name is "MyNFT" then the baseuri will be MyNFT.revise.link.

Now that's it deploy the above smart contract and mint the token, you should see the token metadata along with the digital asset on the opensea. (if you have added the NFT to the revise network, otherwise add the nft again by running the index.js file with node index.js)

Adding dynamic property to the NFT

Create a new file called dynamic.js and paste the following code


const { Revise } = require('revise-sdk')
const AUTH_TOKEN = "_paste your api key"

const revise = new Revise({ auth: AUTH_TOKEN })

const API = async function () {
  const options = [
    {
      mood: 'Angry',
      image:
        '_url pointing to the angry version image of the prajwal',
    },
    {
      mood: 'Shy',
      image:
        '_url pointing to the shy version image of the prajwal',
    },
    {
      mood: 'Denying',
      image:
        '_url pointing to the denying version image of the prajwal',
    },
    {
      mood: 'Loving',
      image:
        '_url pointing to the loving version image of the prajwal',
    },
  ]

  const randomIndex = Math.floor(Math.random() * 4)
  return options[randomIndex]
}

async function run() {
  revise
    .every('2m')
    .listenTo(API)
    .start(async (data) => {
      const prajwal = await revise.fetchNFT(
        '_add your nft id here',
      )

      revise
        .nft(prajwal)
        .setProperty('mood', data.mood)
        .setImage(data.image)
        .save()

      console.log('Curernt mood of prajwal is', data.mood)
    })
}

run()

Replace the API key and images url. Also in the fetchNFT add your nft id here. (nftid is printed in the console when you have added the nft to the revise collection.)

Run the file with node dynamic.js

That's all ! Congratulations! 🎉 you have successfully create the dynamic NFT using revise network.

If you want a detailed course on this topic you can visit the following link -

https://dapp-world.com/course/introduction-to-dynamic-nfts-IsYJ

Thank you!

What are dynamic NFTs ?

FaithlessnessNo332 — Thu, 09 Feb 2023 08:24:25 +0000

You must have heard the term NFT, its Non-Fungible token, whats the difference between fungible and non fungible ?

Fungibility :
Fungibility is the ability of a good or asset to be interchanged with other individual goods or assets of the same type. Fungible assets simplify the exchange and trade processes, as fungibility implies equal value between the assets.

Now to simply explain it we can interchange the fungible tokens with each other and their value will remain the same. It’s like interchanging 1$ for 1$. Both have the same value in the market.

How come bitcoin is fungible if its price is changing?

cause, here you are comparing two fungible tokens of different types with each other, the dollar and bitcoin. This change in value totally depends upon supply and demand. If demand for bitcoin is less and supply is more, its value will decrease and its value increases if demand is more and supply is less.

Non-Fungible
Non-fungible tokens will always have their own value and can not be interchanged with other non-fungible tokens. The tokens will hold completely different purposes and have unique characteristics.

Examples of non-fungible assets can be paintings, antique pieces, land properties, etc. You don't interchange one painting with another or one land property with another. You buy these types of assets with money, a fungible token.

The current NFTs are static NFTs, let's say you own one NFT of a bored ape collection. Its just a static image that sits like that for years. But what if I say it grows older as time passes or changes its outfits according to the weather conditions?
Interesting right?
That's called as dynamic NFT.
To know more about how the Dynamic NFTs work and how to mint one you can take this course on DAppWorld -

https://dapp-world.com/course/introduction-to-dynamic-nfts-IsYJ