DEV Community: Anil Dukkipatty

The New Reality - AR + dNFTs

Anil Dukkipatty — Tue, 21 Feb 2023 14:33:25 +0000

What if you could enhance your reality and own it? What if you could also allow others to experience it immersively? This idea can become a reality we could live in together. This is possible by utilizing the power of Augmented Reality (AR) and Dynamic NFTs (dNFTs).

So, let’s dive right in and see how we can use AR and dNFTs to create a new reality.

Intro to AR and dNFTs

Let’s start by understanding what AR and dNFT’s are.

AR

Augmented Reality is a technology designed to augment our reality. AR enhances our real world by incorporating different digital elements into our physical world. We can create interactive experiences using AR that are influenced by our real world.

Digital content is gaining a new outlook because of the immersive potential of AR.

Pokemon Go was a successful AR game showcasing the power of AR in gaming. You must have also experienced AR lenses on Instagram and Snapchat. This is one of AR’s use cases called “Social AR”.

Few Examples of AR experiences on Snapchat(source)

There are many more use cases and implementations of AR; we will get onto that soon. But now let’s learn about dNFTs.

dNFTs

dNFTs are nothing but the involvement of dynamics in NFTs.

So, what is dynamic? Well, it implies change; the opposite of it is static. Consider your name, it’s likely not gonna change; so we can consider it to be an example of static data. However, if we look at the temperature of our place or the price of a cryptocurrency; they keep on changing. This implies that they are dynamic. Let’s get back to dNFTs.

NFTs (Non-Fungible Tokens), as we know, are unique digital objects on a blockchain. Each NFT differs from the others as it possesses a unique token ID and contract address. Then, we can attach metadata like images, videos, and other forms of media to it; thus making it possible to own a token representing a unique digital object.

But what if we could incorporate new information and data into an NFT? This will increase its value and utility. Here’s where dNFTs come to light.

Dynamic NFTs (dNFTs) are expanding NFTs by their ability to respond to external events and data. A dNFT is a type of NFT that can change its property based on external conditions. Smart contracts are instructed on how the dNFT’s metadata should be changed based on an external trigger.

Eg. Dynamic Art (A piece of digital art in a dynamic NFT can change depending on the external weather)

Source: Chainlink

The intersection of AR and dNFTs

AR and dNFTs can be combined to enhance the way we experience our digital and physical worlds. For example, an AR app could recognize a dynamic NFT and display different information or animations depending on the token's current state.

Instead of letting NFTs stay in the wallet, AR allows us to experience them in the real world.

Artists are using AR to enhance their artwork and give it life!

The true power of the spatial web can be experienced by combining AR with NFTs.

dNFTs, for instance, can be created when specific events occur, such as when a hidden location in an AR app is discovered. dNFTs might also have “hidden features” that are only revealed when a user interacts with them.

By overlaying this digital art onto the real world through AR, users can experience the art in a unique way. For example, a dNFT art piece could respond to the user's motion or change its look based on the time of day.

Let’s explore a few use cases of dNFTs and AR -

Gaming - The immersion and engagement of gaming can be taken to the next level by overlaying game worlds onto the real world using AR. The items and assets in the game can be represented using dNFTs. dNFTs can also allow character progression i.e. as we level up in the game, our character’s look will change to reflect the progress. Example - Maddroids (https://maddroids.io/) are using the power of AR and dNFTs in their game.
Art - In the world of art, AR with dNFTs is enabling artists to create dynamic as well as interactive art pieces that can evolve over time. In addition, technologies like face tracking provide new methods of control for NFT-based interactive and animated artwork by providing a new canvas to place them. With a world lens, you can interact with an art NFT by placing it in your own environment, be it your living room, office, or art gallery, with AR.
Marketing and advertising - Companies can use the potential of dNFTs with AR to increase their consumer engagement and reward their customers with exclusive access to their events and products.

Education - With AR, we can provide an interactive learning experience to students by laying educational content in the real world. Also, dNFTs can be combined to provide students with badges, progress cards, and exam reports.
Fashion - AR could allow people to wear simple bodysuits in real life and view each other’s fashion NFTs through AR glasses, which overlay extra information onto a user’s real-world scene. Rtfkt, arguably the most successful NFT fashion brand, recently posted a video of people walking around New York City wearing Rtfkt’s clothing in AR, including its Metajacket, from the point of view of a person wearing AR glasses.
Passport and identity - Future passports can be issued as dNFTs, this getting automatically updated based on the locations you travel to. Also, you could go through your travel history in form of AR. (I am super excited to use this)
Business growth - Businesses will use AR and dNFTs as a means to provide loyalty points and discounts to their customers will see an incremental growth in their traction and profits.
Event organization - dNFTs as a form of event ticket can update its status on its own based on your activity and involvement in the event.
Supply chain - Supply chain can gain a surmountable benefit by using dNFTs and AR to get automatic and immersive updates on the status of delivery during each checkpoint.

Examples

Let’s look at some exciting projects in this space -

QR + AR + NFT

Pascal Boyart was one of the first street artists to attach Bitcoin QR codes to his work. He gives life to his murals using the power of AR, spatial audio and NFTs.

La Liberté Guidant le Peuple” (Liberty Guiding the People) - Pascal Boyart

Lamelo Ball dNFT -

Lamelo Ball, a professional NBA player, released dynamic NFT tied to his performance on the court.

Source - Lamelo Ball Website

AR filter to showcase NFT

The auction house Sotheby’s created an Instagram filter allowing users to see what Botticelli’s “Portrait of a Young Man Holding a Roundel” painting would look like in their homes.

Botticelli’s Portrait of a Young Man Holding a Roundel

AR + dNFTs

One can buy seed crystals which with time grow into OG crystal.

Source:OG Crystal

AR Mural NFT -

Ryan Sarfati and Eric Skotnes’s The Majestic artwork allows people who can’t visit Tulsa can enjoy the painting online in AR.

Source:Opensea

It is the largest mural in Oklahoma, holding the world record for the largest augmented mural.

Target Tracking AR NFT -

NFT Boba allows owners to view their NFT in the real world using AR plane tracking implementation.

Source:NFTBoba

dNFT gaming

Sunflower Land is a game allowing the creation of dynamic pfp and characters.

Source: Sunflower Land

Some other examples are -

Face filter NFTs - Melbourne-based artist Marc-O-Matic merges traditional illustrative art, 3D animation, and augmented reality.****
Ready Player Me - buy NFT avatars and use them in augmented reality and virtual reality environments.
Hololoot (https://hololoot.io/) - It is a blockchain-based ecosystem that integrates NFTs and AR assets, creating a metaverse for users to explore and create user-generated contents that are recorded on the blockchain.
AR Metaverse https://www.overthereality.ai/

Conclusion

With the powerful combination of AR and dNFTs, brands and creators can benefit as their immersive projects will gain improved engagement, greater loyalty, and flexible monetization. AR (Augmented Reality) and dynamic NFTs (Non-Fungible Tokens) are two emerging technologies that have the potential to revolutionize the way we interact with digital assets.

Overall, the future of AR with dynamic NFTs is bright, with the potential to transform various industries and create new and exciting experiences for users.

This new sphere of collaboration leaves us with a question to ponder,

If we can build the future, then why not?

For more updates about dynamic NFTs and their recent developments, follow us from the links below:

Website| Twitter| Discord| Instagram| Facebook

Exploring 5 Interesting Dynamic NFT Projects

Anil Dukkipatty — Sat, 11 Feb 2023 13:43:48 +0000

Dynamic NFTs are the next frontier of the ERC-721 standard. Why, you ask? Well, ERC-721 standard represents the static NFTs that were the first generation of digital collectibles. Dynamic NFTs, on the other hand, are capable of changing their appearance based on off-chain data feed. For example, you can program your dNFTs to display live weather updates or a soccer match’s live scores or anything you could think of. We are all aware of NFT avatars in games, virtual environments etc. Now imagine adding dynamicity to these characters in a way in which they can exhibit traits based on their positions in a game or follower count in a social media account etc. NFT creators/collectors are gradually warming up to dNFTs because of their extended use cases. As dNFTs hold the potential to be the next big thing in the web3 space, let’s have a look at some of the rising and innovative dynamic NFT projects that are taking the game to the next level.

Let’s get right into it!

Altered State Machine x FIFA

The partnership between Altered State Machine (ASM) and FIFA arrived just as the FIFA World Cup 2022 was approaching. FIFA in collaboration with ASM created an AI-enabled metaverse-focused game called AI League that allowed players to predict FIFA matches and compete against each other to earn exciting rewards. However, as FIFA is already over, players can now create their collectables team and lead them to victory in the metaverse. The best part about this collaboration is the ASM brains and Non Fungible Intelligence. Well, they both are ASM technology that can be used in digital avatars/characters, games, metaverse platforms, to infuse life (dynamic elements) into your digital avatars and gaming experience.

“The possibilities with ASM brains are endless as they are interoperable across games, avatars, forms, and different worlds. With training, they can evolve, learn, and are also capable of improving their skills” said Altered State Machine.

Yuga Labs Otherside

Yuga Labs needs no introduction thanks to the insanely popular BAYC, MAYC, and Cryptopunk NFTs that emerged from this house. Their Otherside metaverse, which they announced earlier this year, is also going to join their “hit” list. But what exactly is it? Well, the ApeCoin-powered metaverse, Otherside, is Yuga Labs’ metaverse space developed for digital community building and ownership opportunities. Over 10,000 people can engage with each other in Otherside at once and interact via natural voice chat option.

The most intriguing aspect of Otherside is “Otherdeeds”, which are virtual plots of land in the form of NFTs that can also be traded on secondary markets. There are only 200,000 parcels and owning one is necessary to get access to exclusive Otherside events. The fact that Otherdeed NFTs are dynamic in nature and will evolve based on the user’s in-game behavior makes them more fascinating. Moreover, users may also get to encounter artifacts, various gaming elements, and mysterious living creatures in their metaverse.

The Association NFT

The Association NFT is an NBA project that comprises 30,000 dynamic NFTs in the collection. It was minted for the 2022 NBA playoffs and had 125 editions per player. As they are not the regular non-fungible tokens, The Association NFTs are capable of changing appearance over time as per a team’s or a player’s in-game performance. The dynamic elements may include player accessories, emoticons designed by artists, and various backgrounds. NBA uses Chainlink Oracle to fetch live data feeds to update live performance of players so the changes may reflect automatically in the NFTs.

Life In Our Minds (LIOM)

Life In Our Minds touts itself as one of the most innovative dynamic NFT projects to date. It’s mainly because how rare the NFT evolves depends completely on how its owner interacts with or influences the asset. While some of LIOM NFTs properties are predefined (like number of Boids, evolution speed, and shape), others get influenced by the owner’s wallet. This gives the holders a reason to not trade their asset and hold them until it evolves into something rare. LIOM NFT consists of two main parts; first is the Boids which are an animated NFT collection, whereas, the second facet is the Mother Flock which represents a generative video sculpture. One interesting fact about Mother Flock is that the image it displays to its user represents the current behavior and psychology of humans and birds. LIOM started to roll out the NFTs for collectors on 25th October 2022. Check them out here.

Quirky Soul College

Quirky Soul College launched the first dynamic NFT game on the Neo N3 blockchain that allows users to level up their NFT characters as they progress and increase their powers to complete the missions. They minted 10,000 dynamic NFTs (which began on October 31t) that have 7 visual traits, 1 secret hidden trait, and 6 abilities. Players also get to earn Fresh Dark Elixir (FDE) tokens as they play with Quirky NFTs which they can later use to participate in various missions, heal their characters, and interact with the Quirky Soul College world. Have a look at their whitepaper to know everything about their dynamic NFTs, token, their character features, and much more here.

In Closing

There’s no doubt that dynamic NFTs have opened up a lot of new use cases that both popular legacy brands and web3 brands are utilising. Unlike static NFTs, dynamic NFTs have the power to change their appearance over time which sets them apart from the traditional ERC-721 standard. We’ve listed a few of the dynamic NFT projects that you can check out in this blog and see how they’re leveraging this outstanding technology to make an impact in the industry. In case you’re wondering how you can program an NFT, then have a look at our free simulator that allows you to change the properties, images, and automate your NFTs seamlessly.

For more updates about dynamic NFTs and their recent developments, follow us from the links below:

Website | Twitter| Discord| Instagram| Facebook

Revise Hack - Add and Update multiple NFT’s using the Revise SDK

Anil Dukkipatty — Fri, 10 Feb 2023 08:58:22 +0000

Here is a quick and easy way to add and update multiple dNFT’s for our collection using the Revise SDK.

Create a collection

Start by making a collection using the Revise SDK with the your collection name and uri.

const collection = await revise.addCollection({name: "My Dynamic Football Team", uri: "..CREATE YOUR UNIQUE URI"})

// Collection Name : Use any name you want for your collection (this gets shown in the marketplace))
// Collection_URI  : Use a unique name (no spaces or special characters)
//                   this will generate a unique link for your collection
//                   for e.g. if you choose "mydynamicplayer12345"
//                   your baseURI wil be "mydynamicplayer12345.revise.link"

After execution of the above code you will receive a unique collection ID as a response, copy it and paste it in your .env file or any other config file that you are maintaining as we will need it in the future while adding the dNFTs into your collection.

Storing NFT ID’s in a smart contract

Now in case you are using dNFT for various purposes in the tool , there might be a lot of dNFT’s getting added to your tool and in order to update them we will need to store their ID’s. Storing them in contract is the safest, so we have provided a contract below for context and for you to use.

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

//using counters provided by openzeppelin, one can aso write their own counter program
import "@openzeppelin/contracts/utils/Counters.sol";

contract RealEstate {

    using Counters for Counters.Counter;

        //making a counter to keep track of the number of dnft added to the collection
    Counters.Counter private nftcount;

        //function that will return the current number of dnft
    function currNFTcount() public view returns(uint256) {
        return nftcount.current();
    }

        //function that increase the count when a dnft is added to the collection
    function incNFTcount() private {
        nftcount.increment();
    }

        //array that will store the dnft ids in form of string
        string[] private nftTokenIds;

        //function that adds the dnft to the array and inc the nftcount
        function addNFT(string memory _nftTokenId) authorized(msg.sender) public payable {
        nftTokenIds.push(_nftTokenId);
        incNFTcount();
        }

        //function that returns all the dnftid added to the collection
        function getAllNFTIds() public view returns(string[] memory) {
        return nftTokenIds;
    }
}

Now we have a dNFT collection and a smart contract to store the nftcount and the nftID

Connecting our previous smart contract to our js file

Before we start adding NFT’s, we need to connect the smart contract we previously created with our Javascript code. There are various way of doing the below, but we prefer this method. Feel free to follow other methods, but ensure that you can establish a connection with the smart contract.

import Reactfrom "react";
const { ethers } = require("ethers");

    const {
  Contract, // address of the contract
  ContractABI, //abi of the contract
  key, //authkey provided by revise SDK
  collectionId, // collection Id recorded when we made the collection previously
} = require("./constants");

const { Web3Modal } = require("web3modal");
const { Revise } = require("revise-sdk");
const revise = new Revise({ auth: key });

export const TransactionContext = React.createContext();

export const TransactionProvider = ({ children }) => {

  const getEthereumContract = async () => {
    // Talk to the smart contact in Ethereum blockchain
    const provider = new ethers.providers.Web3Provider(window.ethereum);
    await provider.send("eth_requestAccounts", []);
    // Implement the signing in metamask
    const signer = provider.getSigner();

    // Three ingredients to fetch an contact

    const transactionContract = new ethers.Contract(
      Contract,
      ContractABI,
      signer
    );

    // logging the contrac
    return transactionContract;
  };

//other functions that are needed to be coded , like the generateNFT we will add after this ..... 
//....
//.....

return (
    <TransactionContext.Provider
      value={{
        connectWallet,
        checkIfWalletIsConnect,
        generateNFT,
      }}
    >
      {children}
    </TransactionContext.Provider>
  );
};

Adding NFT’s to our collection

Now let’s implement the function which handles the part of adding the NFT to the collection.


const generateNFT = async (param1,param2,param3) => {

    const contract = await getEthereumContract();
        // setting index to the current nft count number
    let index = await contract.currNFTcount();
    let ind = 1 + index.toNumber();
    let indfinal = ind.toString();

        // function to add the nft to the collection
    const res = await revise.addNFT(
      {
        name: "xyz",
        tokenId: indfinal,
        description:
          "This is a dnft made for demo purposes " +
          " " +
          landdetails,
        image: "https://i.ibb.co/4dXWQhC/Frame-57.gif",
      },
      [
        { param1: param1 },
        { param2: param2 },
        { param3: param3 },
      ],
      collectionId
    );

    console.log(res.id);

    const nftadded = await contract.addNFT(
      res.id,
      {
        gasLimit: 5000000,
      }
    );
    await nftadded.wait();
  };

The images above show the NFT’s being added on the Revise Dashboard.

You can have an array of objects containing relevant data and then loop over the array while conditionally triggering the function above. Below is just a simple example of how to use it , the function above can be used as per need of the tool so feel free to experiment/change.

const { connectWallet, currentAccount, generateNFT } =React.useContext(TransactionContext);
let nftdata=[{"data about nft1"},{"data about nft2"},{"data about nft3"},{"data about nft4"}..]

const multiplenft = () => {
    for(let i=0 ; i<nftdata.length;i++){
        generateNFT(data);
    }
}

Updating multiple NFT’s at the same time

As the NFTs has been added to the collection, we can now look at how to update them simultaneously. To achieve this we will use the array we prepared on the contract earlier which is nftTokenIds. We will acquire the array from contract and then loop it to update each and every NFT in out collection using their respective nftID.

We will be using Alchemy this time to integrate our contract to our Javascript - this is just another way to integrate contracts. You can choose whatever way you are comfortable with.

const { ethers } = require("ethers");
conequire("axios");
const {
  Contract,
  ContractABI,
  key,
  collectionId,
} = require("./constants");

let nftt = null;

//example data
const home = [
  {
    coins: "0",
    image: "https://i.ibb.co/0DKLtm0/home0.png",
  },
  {
    coins: "1",
    image: "https://i.ibb.co/JmHs3RJ/Home1.png",
  },
  {
    coins: "2",
    image: "https://i.ibb.co/YcBDqF9/Home2.png",
  },
  {
    coins: "3",
    image: "https://i.ibb.co/Nj65rrj/Home3.png",
  },
  {
    coins: "4",
    image: "https://i.ibb.co/j5SvNtN/Home4.png",
  },
];

async function API() {

 //current param of the dnft
  let param1 = nftt?.nft?.metaData[1]?.param1;
  let param2 = nftt?.nft?.metaData[1]?.param2;

  //do changes in the parameters or metadata of the dnft as you like using different conditional statments and apis

    //then return the desired changed data back to the update function 
  let data = Home[param1];
  return data;

}

//function to fetch the nftarray from the contract
const fetchNftArray = async () => {
  const alchemy = new ethers.providers.AlchemyProvider(
    "maticmum",
    "key"
  );
  const contract = new ethers.Contract(
    Contract,
    ContractABI,
    alchemy
  );
  const allNftIds = await contract.getAllNFTIds();
  return allNftIds;
};

//function that takes care of the update of the dnfts whose ids we acquired from the contract
async function update() {
  const nftArray = await fetchNftArray();

  for (let i = 0; i < nftArray.length; i++) {
    const res = await revise.fetchNFT(nftArray[i]);
    const nft = revise.nft(res);
    nftt = nft;
    revise
      .every("10s")
      .listenTo(API)
      .start(async (data) => {
        await nft
          .setProperty("param1", data.coins)
          .setImage(data.image)
          .save();
      });
  }
}

update();

Conclusion

To summarize:

Create a collection
Store the NFT ID’s in a smart contract - because its safer!
Add NFT’s to our collection and connect the smart contract from step 2 to your code
Update multiple NFT’s at the same time - while using Alchemy

And that’s all! Hope you found that easy and learned something new. Happy building on Revise!

If you want to learn more or explore opportunities creating with Revise, please schedule a call with us here join our Discord or message us on Twitter.

The AI Age of NFTs: Deep Dive

Anil Dukkipatty — Thu, 09 Feb 2023 12:51:41 +0000

2021 saw a massive rise in the adoption of NFTs and since then, we’ve witnessed its continuous growth and many new advancements that added to its use cases. While digital assets have already become fairly mainstream, there’s no doubt that we’ve just touched upon their actual potential and that they can certainly evolve into more disruptive tech with the advancement of technology.

AI has been here for a while now. However, with ChatGPT & OpenAI going viral - the discussion around the use of AI in the web3 space, especially NFTs has once again caught fire. Many are of the opinion that in order to advance the current state of NFTs, artificial intelligence comes out as one of the most promising solution, especially at a time when it's progressing exponentially.

So, what does AI has to do with NFTs?
What role does AI play in the NFT Space?
Are there any benefits or potential risks involved with using Artificial Intelligence in the NFT space?

These are some of the questions that we’ll be looking into & (possibly answer) in this blog. Allow us to elaborate.

The Role of AI in the NFT Space

We all know the first generation of NFTs were static and there was a lot of debate around whether they held any actual utilities. Considering that, several argue - AI can have a colossal impact on the next wave of NFTs as they must go from simple JPEG images to smart and intelligent collectables. Generative art is one such example where users can batch-create NFTs by using AI tools like NightCafe.

However, the use cases go far beyond that:

AI when converged with NFTs can let them evolve on their own and program smart contracts with dynamic elements as a result of their self-learning ability.
It would also be safe to envision NFTs explaining the inspiration behind why they evolved as a specific art.
We could also experience NFTs that could evolve as per our mood, feelings, and based on our conversations with them.
AI can also make the NFT marketplace smarter and more intuitive which may attract new customers and increase sales.

The role of artificial intelligence (AI) in non-fungible tokens (NFTs) can also vary depending on the specific application. Some other possible ways in which AI can be used in conjunction with NFTs include:

Generating unique digital content: AI can be used to create unique pieces of art, music, or other digital media that are represented by NFTs. For example, an artist could use an AI model to generate a series of unique paintings, and then sell NFTs representing ownership of each painting.
Creating interactive experiences: NFTs can be used to represent ownership of interactive experiences that use AI to generate unique content on demand. For example, an NFT could represent ownership of a virtual reality experience that uses AI to generate unique landscapes or characters each time it is accessed.
Verifying the authenticity of NFTs: AI can be used to help verify the authenticity of NFTs by analysing the content they represent and comparing it to other known works. This can help prevent the sale of counterfeit NFTs and increase confidence in the NFT market.

While these may sound futuristic, there are already projects who are bringing such imaginative visions to life. Let’s take a look at a few of them.

FUZZLE

Fuzzle, for example, is an AI-powered NFT that can engage around topics such as crypto, life, dating, religion, and so on. Not only so, but you can also play games with your NFT and create rare stories using AI.

ALETHEA AI

Another project called Alethea AI created the first intelligent NFT (iNFT), dubbed Alice, in 2021 and sold it for a massive $478,800. Alethea AI uses blockchain and AI technology to allow users to infuse AI animations and voice elements into their NFTs. What’s more interesting about Alethea is the fact that it lets users create, train, and earn from their iNFTs in Noah’s Ark, the world’s first intelligent metaverse.

ALTERED STATE MACHINE

Altered State Machine (ASM) is yet another budding platform that allows creators to infuse artificial intelligence into their existing NFTs. If you’re a soccer fan, then there are good chances that you might have already heard about their recent collaboration with FIFA to create an AI-powered metaverse-focused game called AI League. The best part about this platform is ASM Brains and Non-Fungible Intelligence (NFI) that can inject life into your digital avatars/NFTs.

Benefits of Using AI for NFTs

AI will certainly beef up the non-fungible tokens and the use cases we may experience with their intersection are unbelievable. The simple proof of ownership of NFTs will turn into intelligent proprietary software that'll help everyone - from NFT creators to consumers - get the most out of it.

As NFTs already reside on one of the safest techs ever (blockchain), integrating AI with NFTs will further expand it in dealing with cybersecurity attacks. AI when linked with NFTs will also let users see more specific content on the internet as per their interaction with the digital asset sitting in their wallet.

Brands can use such AI-powered NFTs for various purposes such as:

Attracting potential customers or audience
Innovative and new ways to produce and disseminate content
Exploring new trends in the industry
Keeping the community hooked with novel ways of interacting with their assets
Increased efficiency and accuracy in verifying authenticity
Ability to create unique, one-of-a-kind NFTs through AI-generated content
Enhanced user experience through AI-powered marketplaces and gaming environments. And many more.

Challenges and Ethical Concerns

As is with everything, AI into NFTs also stir up some ethical concerns & challenges that are worth noting:

Lack of transparency and understanding about how AI-generated NFTs are created
Potential for misuse or exploitation of AI in the NFT market
Ethical concerns surrounding the creation and ownership of AI-generated art and collectibles
Possibly with time, we’ll have a clearer resolution to all of these. However, it definitely does not act as a free pass to totally negate the use of AI.

In Closing

Looking at the use cases and the capabilities of both technologies (AI & NFTs), it might not be amiss to remark that the future looks promising once they both intertwine closely. AI still has a long way to go, however, it can radically change the entire NFT industry once fully matured.

If you seek a way to infuse dynamic elements into your digital assets, then it has never been easier with our simulator that allows changing the properties, images, and automating your NFTs in a few clicks. Try it for free here.

For more recent updates about NFTs and their convergence with AI, follow us from the links below:

Website | Twitter | Discord | Instagram | Facebook

Managing Real Estate as Dynamic NFTs

Anil Dukkipatty — Wed, 08 Feb 2023 12:03:35 +0000

A hot topic of discussion amongst our community has been real estate tokenisation and how upgrades, issues and sales data regarding a property can be stored and shared easily using the blockchain. In light of this, we thought of creating a simple technical example to help you understand how you can tokenise your property as a dynamic NFT (dNFT) and store updates about it on the blockchain using Revise.

Introduction to Revise

Revise is a platform that’ll let you build dynamic NFTs. NFTs today are fairly static. Once you buy it they don’t change. What you see is what you get. Dynamic NFTs are able to react to the outside world, to data, to user interactions, etc. They are capable of changing, and evolving over time.

Let’s use Revise to build your own real estate NFT collection, then tokenise a real estate property and finally store changes that are occurring on this property. We won’t cover how to deploy these NFTs to Ethereum/Opensea (click here to learn more).

Create a Repo

Let’s clone this GitHub repo to get started. The repo is an empty Javascript project with revise-sdk added to the package manager. Once you cd into the project folder, you can run npm install to install all the dependencies. Let’s create an index.js file. We’ll write all our code in this file, we’ll use node index.js to run the program.

Copy and paste the following code into the index.js file.

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "...PASTE YOUR AUTH TOKEN HERE...";
const revise = new Revise({auth: AUTH_TOKEN});

async function run() {

    // write your code here

}
run()

In the first couple of lines, we’re importing the Revise-sdk and adding our auth token (more on how to get this below). In the third line, we’re instantiating the revise object. We can now use this object to call all the functions needed to complete the exercise. Revise functions are mostly async, so we create a run function which is async and can call the revise functions using the await keyword. This will make our code more readable and maintainable.

💡 You can generate the Auth token from app.revise.network. For more details refer to the next section of this article.

Generate API Key (Auth Token)

Before we continue writing the rest of the code let’s go grab an auth key. Visit Revise and click on “get started”. Once you make an account and log in you’ll see the “generate API key” link in the header. Click on it, you should now be able to generate the API key (auth token). Copy the key that is shown on the screen and keep it safe. This key is not stored on Revise’s servers for security reasons. If you misplace the key it’s permanently lost. You can always come back and generate a new key.

Let’s replace the AUTH_TOKEN in the above code with the key we just generated. Now we’re ready to start writing out Dynamic real estate NFT.

Add a Collection

To start with let’s make a collection called “My Properties”. This collection can have multiple NFTs. Each NFT is a property. In order to make the collection, we’ll call the addCollection function. We’ll have to pass it two parameters, the name for the collection and the URI for the collection. The collectionURI is a unique project name that can be used to generate links for the NFT (why we need these links is described later). We have to make sure that the URI is unique and a single word. For e.g. “myproperties" is a valid Collection URI “my properties are epic” is not. Add the following code to your index.js inside the run function.

const collection = await revise.addCollection({name: "My Properties", uri: "..CREATE YOUR UNIQUE URI"})

// Collection Name : Use any name you want for your collection (this gets shown in the marketplace))
// Collection_URI  : Use a unique name (no spaces or special characters)
//                   this will generate a unique link for your collection
//                   for e.g. if you choose "myproperties12345"
//                   your baseURI wil be "myproperties.revise.link"

Add an NFT

Now let’s add our first NFT real estate. We’ll use the addNFT function to create our real estate NFT. Add the following code to your run function below the addCollection function call.

const nft = await revise.addNFT({
    image: 'https://revise-testing.fra1.cdn.digitaloceanspaces.com/tutorial/2023.png',
    name: 'Castle Street Property',
    tokenId: '1',
    description: 'Townhouse with great interiors'
  }, [
    {street: "10 Castle Street"}, {maintenance_history: ""}, {age: "1"}, {past_sales: ""}
  ], collection.id)

console.log(nft)

We’re passing parameters for the image of our property, the name, description, tokenId and some metadata properties. We’re also passing the collectionId we received after creating our collection for the earlier code snippet. tokenId is the unique ID of your NFT on the blockchain. This helps the blockchain and marketplaces distinguish between the NFTs part of the same collection. Two NFTs shouldn’t have the same tokenId. We can add any amount of custom data to our NFTs via its attributes. As you can see in the above snippet we’ve added “street”, “maintenance_history“, age”, “past_sales” etc. You can add any number of attributes here.

Run

The final state of our index.js file should look like this now.

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "...PASTE YOUR AUTH TOKEN HERE...";
const revise = new Revise({auth: AUTH_TOKEN});

async function run() {

const collection = await revise.addCollection({name: "My Properties", uri: "..CREATE YOUR UNIQUE URI"})

    const nft = await revise.addNFT({
    image: 'https://revise-testing.fra1.cdn.digitaloceanspaces.com/tutorial/2023.png',
    name: 'Castle Street Property',
    tokenId: '1',
    description: 'Townhouse with great interiors'
  }, [
    {street: "10 Castle Street"}, {maintenance_history: ""}, {age: "1"}, {past_sales: ""}
  ], collection.id)

console.log(nft)

}
run()

Let’s run this file to create a collection and add our first NFT. Run node index.js in your terminal. The expected output is an id as shown below.

The command you ran earlier should output the id for the NFT we just created. The ID is the unique identifier for this NFT, we’ll be using this nftId to fetch and makes updates to our real estate. Let’s store this ID carefully.

💡 Note: the tokenId and nftId are different. tokenId is used by marketplaces and wallets to identify your NFT. nftId is used by Revise to identify and control the NFT.

Visit your Revise dashboard to see your NFT real estate in action.

Click on the “View” button to see your NFT and it show show up with the image of your house from 2023.

Adding dynamic capabilities to your NFT

Now that we’ve created our NFT Real Estate property, let’s show any updates that have happened to it. Let’s add some mock data to show the maintenance related updates and also any new sales data for this house.

Create a new file called updates.js. Paste the following code in the file.

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "...AUTH_TOKEN...";
const revise = new Revise({auth: AUTH_TOKEN});

const API = async function() {
  const data ={maintenance_history : ["2022, New roof","2024, New deck"], past_sales : ["2022, $300,000", "2024, $380,000", "2028, $420,000"],image : "https://revise-testing.fra1.cdn.digitaloceanspaces.com/tutorial/2052.png"};
  return data;
}

async function run() {

  revise.every('10m').listenTo(API).start(async (data) => {
    const property = await revise.fetchNFT("b73897be-cf0e-4517-8de7-cd83be8aae8d")
    revise.nft(property)
      .setProperty("maintenance_history", data.maintenance_history)
      .setProperty("past_sales", data.past_sales)
      .setImage(data.image)
      .save()

            console.log(`${property.name} is updated`)
  })

}
run()

In the above code we are creating some mock data for maintenance_history and past_sales. Then we’re setting up automation which will fetch the data and update our real estate attributes every 10 minutes with a new image. Execute the above file by running node updates.js. The program will execute automatically and show all the updates that have occurred to your real estate. We are aware that our UI does not display the information correctly (no spacing etc) - don’t worry this is getting fixed in our next release (coming soon!) 😊

Congrats on creating your real estate collection and property NFT! Publish your Real Estate NFT to Opensea and show it off to the world.

If you want to learn more or explore opportunities creating with Revise, please schedule a call with us here or join our Discord or message us on Twitter.

Are you an Aspiring Web3 Developer? These 10 Tools Will Make your Life Easy

Anil Dukkipatty — Thu, 05 Jan 2023 15:04:41 +0000

The fuss about web3 that stirred up in its initial days has quickly turned into how valuable the tech is for everyone. Be it NFTs, DeFi, DAOs, or other technology that falls under the web3 umbrella, the third generation of the internet has experienced immense growth as a whole and will continue to transcend beyond that. The rise of web3 also opened a myriad of working opportunities for everyone, especially for developers as blockchain development is one of the fastest-growing sectors. However, things get a little daunting when you’re just starting out in web3, considering the space is still in its infancy and discovering authentic resources online is not a breeze.

But fret not! If you’re an aspiring web3 developer and in search of tools that can make your life easy, this guide is just for you. Stick with us till the end as we’re getting started.

Top 10 Tools You Must Know as a Web3 Developer

As a web3 developer, there are certain tools that you must know like programming languages, frameworks, testnets, wallets, etc., as these act as a base and you may need them from time to time. Let’s uncover all such and other necessary tools in the guide below.

Solidity - Programming Language

Developed by Ethereum, Solidity is a high-end popular coding language that allows the development of smart contracts on various blockchain networks like Avalanche, BNB Smart Chain, Polygon, and more. It was proposed by the CTO of Ethereum, Gavin Wood, and was inspired by popular programming languages like C, C++, JavaScript, and Python. As a web3 developer, you can reinforce your portfolio by learning Solidity as smart contracts are already popular in the industry and a huge percentage of them are running on the Ethereum blockchain.

Let’s have a look at its other offerings:

Like other programming languages, it also has functions, classes, variables, etc., to code the smart contract.
Solidity is capable of forming machine-level code and compiling it on EVM or Ethereum Virtual Machine.
Crowdfunding, blind auction, mortgages, voting are a few smart contract use cases.

Solidity alternates such as Vyper and Rust also make a good choice. Note that Rust is not an EVM-compatible language but it still supports new chains like NEAR, Polkadot, Solana, and more.

Revise - Dynamic NFT Platform

Dynamic NFTs are the next frontier of static NFTs. They can do much more than what standard NFTs are capable of and there’s no doubt that the next wave of NFTs will be dynamic. But do you wonder how to build such an NFT that has dynamic elements? Or how the process looks like? Well, it’s super fast, simple, and secure with Revise as we empower developers with a powerful back-end, a high-end SDK (Software Development Kit), and third-party integrations like Google Health and Ether Price for a better experience while creating them.

A few of their offerings are as follows:

Works across Ethereum Virtual Machine (EVM) chains
Library of Integrations
Works with any storage layer
Benchmarked at 20,000 TPS

Moreover, Revise also offers a free simulator that allows changing the properties, images, and automating your NFTs with ease. Try it for free now.

Truffle - Software Framework

Building a dApp is not a cakewalk, especially when you’re handling everything on your own. But, luckily, there are software frameworks like Truffle that can easily create, test, and deploy smart contracts. Truffle is a JavaScript-based framework and comes with built-in smart contracts functionalities and other resources like libraries and tools to create dApps seamlessly. Smart contract management, interactive console, network management, automated contract testing are among a few of its attributes that eases the entire development process. It also offers a dApp development ecosystem called Truffle Suite that comes with three parts:

Truffle- The development environment that eases the dApp creation process
Ganache- Testnet for testing your dApps/smart contracts first before making them live on mainnet
Drizzle- A set of frontend libraries

Let’s have a look at its other features:

Automated contract testing support
Allows direct contract communication with its interactive console
Allows to deploy contracts on a host of public and private networks

You can also check Hardhat and Embark development frameworks as they are good alternatives to Truffle.

Web3.js - Ethereum JavaScript API

Web3.js is an Ethereum JavaScript library that allows developers to interact with the Ethereum blockchain (both local and remote). It uses IPC, HTTP, or WebSocket for a smooth connection and allows users to call functions on smart contracts, sends ETH to different users, and gives access to smart contracts. A few of the most used functions that make it possible to interact with the Ethereum blockchain are:

Web3-eth: For Ethereum smart contracts and ecosystem
Web3-bzz: Used for decentralized file storage
Web3-shh: For the communication of p2p and broadcast
Web3-utils: Provides a collection of dApps functions

MetaMask - Web3 Wallet

MetaMask is one of the most popular cryptocurrency wallets in the market. It can be used as a browser extension or a mobile application to store digital assets. It allows a secure way to protect your virtual assets with the use of private keys that should be exclusive to the owners only to avoid scams. Developers can use MetaMask to access Ethereum-based dApps, however, it isn’t only limited to that. MetaMask also acts as a gateway to several layer-2 blockchain ecosystems such as Polygon.

Other than that, let’s see what else it has to offer

Allows running dApps on the local host
Makes it easy to sign transactions, identity management, read blockchain data, keys management, and access multiple accounts on different networks
Developers can also use a test blockchain network such as Ganache

In case you want to explore more crypto wallets with different functionalities, you can choose from a bunch of options such as Coinbase wallet, Trust wallet, Ambire wallet, MyEtherWallet, and more.

Remix IDE - Integrated Development Environment

Remix is one of the most trusted IDEs among web3 developers that aids with the application development process. It provides an intuitive user interface that eases the process of compiling, testing, and debugging smart contracts. Written in JavaScript, Remix can be accessed both ways— as a browser extension or a desktop application. It is packed with a host of plugins, libraries, and other functionalities that boosts smart contract development. Let’s explore some of its other qualities:

Requires no setup to get started
Offers a Remix plugins engine and Remix Libraries that are a part of its Remix Project

Alchemy NFT API - Application Programming Interface

NFTs are insanely popular among everyone out there and Alchemy’s NFT API lets you build one without any hassle. They launched a multi-chain API that is capable of verifying, creating, displaying, and trading NFTs easily. It works across Ethereum, Polygon, and Arbitrum to name a few, and abstracts away the need to go through the technical aspects of building an NFT.

Have a look at a few of its characteristics:

Allows access to NFT sales data
Can aid the process of building NFT drops, marketplaces, wallets, token-gating experiences, and much more
It has 4 times better spam detection and allows to filter spam and airdropped NFTs

Besides Alchemy’s NFT API, you can also check out Thirdweb SDK and Moralis API & SDK for a similar experience.

Ganache - Testnet

Testnets are alternative blockchain networks used for testing purposes that underlie the same blockchain technology as the main network (mainnet). As a web3 developer, you must already know that smart contracts are immutable and cannot be modified once deployed on the blockchain. Hence, to address this, testnets are used before deploying the contracts on mainnet, mainly to find any flaws and see whether the contract works the right way. Ganache is the tool that works exactly the same. It has a user-friendly interface and acts as a local blockchain for Ethereum development. Developers can access blockchain data, debug information, and also configure block time as per their development needs.

A few of Ganache’s features include:

Offers a desktop app and a command-line tool as well
Comes with advanced mining attributes
Shows blockchain log output
In-built block explorer

Chainlink - Oracle

Smart contracts are undoubtedly an innovative tech that has many use cases. However, its capabilities are still limited to accessing info present on the blockchain only. In other words, it cannot extract data from the outside world (off-chain) and put it to use. And that’s when Oracles come into the game. Oracles gather information from external sources and relay it to the smart contracts on the blockchain. One such popular decentralized oracle is Chainlink. With Chainlink, users can easily feed smart contracts with off-chain data such as live soccer scores, weather updates, etc., and ease the process of building dApps. The best part about this tool is that it allows automation, supports cross-blockchain interoperability, and provides verifiable sources of randomness.

Universal Market Access (UMA), Band Protocol, and Witnet are other decentralized tools that you can give a try.

Octopus - To Enhance Security

If there’s one thing that should not be overlooked while creating a dApp, then it’s the security aspect. Not to mention but 2022 saw some fatal hacks in the industry, which was enough for builders to emphasize the security of their applications first and not the gimmickry. Octopus is the one-stop solution that beefs up the security of your smart contract by running it through a detailed analysis. It comes with control flow analysis, symbolic execution, and call flow analysis that helps find contract errors and easily fix them.

TL;DR

Here are the ten tools we discovered in this blog:

Solidity - Programming Language
Revise - Dynamic NFT Platform
Truffle - Software Framework
Web3.js - Ethereum JavaScript API
MetaMask - Web3 Wallet
Remix IDE - Integrated Development Environment
Alchemy NFT API - Application Programming Interface
Ganache - Testnet
Chainlink - Oracle
Octopus - To Enhance Security

Closing Thoughts

Web3 is gradually running on the path of becoming more mainstream. The vast adoption of the next iteration of the internet will certainly bring in an influx of people together and a lot more job opportunities for everyone. Hence, if you’re thinking to go web3 full-time, it’s high time that you should do that. Also, if you’ve just started out as a web3 developer and struggling to find tools/resources that could facilitate your work, then check out the tools we mentioned in our guide above.

Moreover, as dNFTs are being embraced by many prominent brands and personalities worldwide, it’s safe to say that they are going to be the next big thing in 2023 and beyond. If you’re seeking a way to build dNFTs with ease, check out our free simulator now that allows changing the properties, images, and automating your NFTs.

For more such informative posts and recent updates about dNFT, follow us from the links below:

Website | Twitter | Discord | [Instagram | Facebook

Building Dynamic NFTs on Tezos

Anil Dukkipatty — Wed, 30 Nov 2022 12:27:20 +0000

Over the past year and a half, Non-fungible tokens (NFT) have gained a lot of traction, but the next generation of NFTs will be dynamic. Dynamic NFTs give us an opportunity to explore a new level of interpretability for NFTs and other tokens, as it allows us to alter the metadata of our NFT. The ‘dynamic-ness’ of the NFT is often dependent on some online or IRL event such as a piece of art or character updating based on weather data, real-life sports scores, or even simple user activities. In this article we will be looking at a simple example of a dynamic NFT, combining trading cards and their attributes being updated based on simulated sports data.

Tezos and NFTs

Creating and managing NFTs on Tezos is both sustainable and practical, due to the low energy consumption and low fees of the Tezos blockchain. Plus, the large ecosystem that exists on Tezos and the developers, artists and collectors make it a great fit for NFTs. Most Tezos NFTs can be found at a Tezos (hosted/compatible) NFT Marketplace such as Objkt, Kalamint and Rarible.

Start by deploying an NFT/smart contract on Tezos

Let’s use SmartPy to build the NFT smart contract in the example below.

A good place to get started is the Online SmartPy IDE. It runs directly in your browser and lets you build your SmartPy contracts and test them.

We’ll be building the NFT using the FA2 standard on Tezos.

Here is a link (click here) to the full smart contract you can use to build the NFT. We’ll walk you through some of the important parts of the smart contract below.

We start by importing smartpy into our project.

import smartpy as sp

In the below code, we’re defining the structure for our Token Metadata. This metadata helps us add media and attributes to our NFT.

class Token_meta_data:
    def __init__(self, config):
        self.config = config

    def get_type(self):
        return sp.TRecord(token_id = sp.TNat, token_info = sp.TMap(sp.TString, sp.TBytes))

    def set_type_and_layout(self, expr):
        sp.set_type(expr, self.get_type())

The following code lets us interact with the NFT smart contract to output the token metadata URI. Marketplaces and wallets will use this data to render the NFT correctly.

class FA2_token_metadata(FA2_core):
    def set_token_metadata_view(self):
        def token_metadata(self, tok):
            """
            Return the token-metadata URI for the given token.

            For a reference implementation, dynamic-views seem to be the
            most flexible choice.
            """
            sp.set_type(tok, sp.TNat)
            sp.result(self.data.token_metadata[tok])

        self.token_metadata = sp.offchain_view(pure = True, doc = "Get Token Metadata")(token_metadata)

The rest of the code in the smart contract linked above is boilerplate to enable interactions with the NFT. Some examples are mentioned below:

def count_tokens(self):
def does_token_exist(self, tok):
def all_tokens(self):
def total_supply(self, tok):
def is_operator(self, query):

Now let’s take a look at how we can deploy our Tezos smart contract. Before we can deploy anything, let's first get some Testnet ꜩ from the Tezos Faucet. Once you complete the CAPTCHA verification on the Faucet page, you will be given a faucet key. Keep this file in a secure location. It contains the secret key and mnemonic. This is used for deployment of the smart contract we have created.

Open your Temple wallet and import the account we got from the faucet.

Now let's deploy the actual contract. Hit run in the SmartPy online IDE. It will run your contract and output some simulations on the adjacent panel. Over there you will find the option to Deploy Michelson Contract:

Follow the subsequent steps and you’ll be able to finish deploying the contract.

Now we will learn about Revise and how it empowers you and your NFTs.

Introduction to Revise

Let’s use Revise to build your own football team NFT collections, then add NFTs too it and allow them to change dynamically.

Create a Repo

Copy and paste the following code into the index.js file.

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "...PASTE YOUR AUTH TOKEN HERE...";
const revise = new Revise({auth: AUTH_TOKEN});

async function run() {

    // write your code here

}
run()

In the first couple of lines, we’re importing the Revise-sdk and adding our auth token (more on how to get this below). In the third line, we’re instantiating the revise object. We can now use this object to call all the functions needed to complete the exercise. Revise functions are mostly async, so we create a run function that is async and can call the revise functions using the await keyword. This will make our code more readable and maintainable.

💡 You can generate the Auth token from app.revise.network. For more details refer to the next section of this article.

Generate API Key (Auth Token)

Let’s replace the AUTH_TOKEN in the above code with the key we just generated. Now we’re ready to start writing out Dynamic player NFT.

Add a Collection

To start with let’s make a collection called “My Dynamic Football Team”. This collection can have multiple NFTs. Each NFT is a player trading card. In order to make the collection, we’ll call the addCollection function. We’ll have to pass it two parameters, the name for the collection and the URI for the collection. The collectionURI is a unique project name that can be used to generate links for the NFT (why we need these links is described later). We have to make sure that the URI is unique and a single word. For e.g. “myfootballteam" is a valid Collection URI “my football team” is not. Add the following code to your index.js inside the run function.

const collection = await revise.addCollection({name: "My Dynamic Football Team", uri: "..CREATE YOUR UNIQUE URI"})

// Collection Name : Use any name you want for your collection (this gets shown in the marketplace))
// Collection_URI  : Use a unique name (no spaces or special characters)
//                   this will generate a unique link for your collection
//                   for e.g. if you choose "mydynamicplayer12345"
//                   your baseURI wil be "mydynamicplayer12345.revise.link"

Add an NFT

Now let’s add our first NFT player. We’ll use the addNFT function to create our player. Add the following code to your run function below the addCollection function call.

const nft = await revise.addNFT({
    image: 'https://revise-testing.fra1.cdn.digitaloceanspaces.com/players/bronze.png',
    name: 'Kylian Mbappe',
    tokenId: '1',
    description: 'Forward with exceptional abilities. Legend to have on your team'
  }, [
    {team: "PSG"}, {position: "Forward"}, {level: "Bronze"}, {offense: "75"}, {defense: "45"}, {stamina: "76"}, {skill: "71"}
  ], collection.id)

console.log(nft)

We’re passing parameters for the image of our player, the name, description, tokenId and some properties. We’re also passing the collectionId we received after creating our collection for the earlier code snippet. tokenId is the unique ID of your NFT on the blockchain. This helps the blockchain and marketplaces distinguish between the NFTs part of the same collection. Two NFTs shouldn’t have the same tokenId. We can add any amount of custom data to our NFTs via its attributes. As you can see in the above snippet we’ve added “team”, “position“, offense”, “defense”, “stamina” etc. You can add any number of attributes here.

Run

The final state of our index.js file should look like this now.

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "...PASTE YOUR AUTH TOKEN HERE...";
const revise = new Revise({auth: AUTH_TOKEN});

async function run() {

    const collection = await revise.addCollection({name: "My Dynamic Football Team", uri: "..CREATE YOUR UNIQUE URI"})

    const nft = await revise.addNFT({
    image: 'https://revise-testing.fra1.cdn.digitaloceanspaces.com/players/bronze.png',
    name: 'Kylian Mbappe',
    tokenId: '1',
    description: 'Forward with exceptional abilities. Legend to have on your team'
  }, [
    {team: "PSG"}, {position: "Forward"}, {level: "Bronze"}, {offense: "75"}, {defense: "45"}, {stamina: "76"}, {skill: "71"}
  ], collection.id)

console.log(nft)

}
run()

Let’s run this file to create a collection and add our first NFT. Run node index.js in your terminal. The expected output is an id as shown below.

💡 Note: the tokenId and nftId are different. tokenId is used by marketplaces and wallets to identify your NFT. nftId is used by Revise to identify and control the NFT.

Visit your Revise dashboard to see your NFT player in action.

Click on the “View” button to see your NFT and it should show up with the Bronze image.

Adding dynamic capabilities to your NFT

Now that we’ve created our first NFT player, let’s make it dynamic by changing its moods.

Create a new file called levels.js. Paste the following code in the file.

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "...AUTH_TOKEN...";
const revise = new Revise({auth: AUTH_TOKEN});

const API = async function() {
  const options = [
    {level: 'Silver', offense: '82', defense: '51', stamina: '82', skill: '79', image: "https://revise-testing.fra1.cdn.digitaloceanspaces.com/players/silver.png"},
    {level: 'Gold', offense: '98', defense: '64', stamina: '92', skill: '87', image: "https://revise-testing.fra1.cdn.digitaloceanspaces.com/players/gold.png"}
  ]
  const randomIndex =  Math.floor(Math.random() * 2)
  return options[randomIndex];
}

async function run() {

  revise.every('2m').listenTo(API).start(async (data) => {
    const player = await revise.fetchNFT("0d6cee67-d3c1-41d5-bd57-ebbe4d34ebd3")//Change the NFT Id to yours
    revise.nft(player)
      .setProperty("level", data.level)
      .setProperty("offense", data.offense)
      .setProperty("defense", data.defense)
      .setProperty("stamina", data.stamina)
      .setProperty("skill", data.skill)
      .setImage(data.image)
      .save()

            console.log(`${player.name}'s is now at level ${data.level}`)
  })

}
run()

In the above code, we’re setting up automation which will fetch a level every 2 mins and update our player attributes and image. Execute the above file by running node levels.js. The program will execute automatically and evolve our NFT player in the background. You should be able to see the player change its level to Silver or Gold and subsequent attributes and all the old versions (revisions) of the NFT as well.

Congrats on creating your dynamic football collection and NFT!

If you want to learn more or explore opportunities creating with Revise, please schedule a call with us here or join our Discord or message us on Twitter.

Unlock Multiple Revenue Streams in Web3 Through Dynamic NFTs - Revise Network

Anil Dukkipatty — Fri, 25 Nov 2022 10:11:54 +0000

Despite being considered just hype by some, the non-fungible tokens (NFTs) have disrupted the entire web3 industry and generated billions of sales in no time. Many big brands such as Adidas, Nike, Gucci, and Louis Vuitton are being a part of this paradigm shift and creating multiple revenue channels for themselves. However, the regular NFTs (ERC-721 standard) are monotonous and lack in providing real-life utilities. In contrast, dynamic NFTs are the new norm now due to their dynamic nature and increased use cases.

Keep reading to know more about Dynamic NFTs and how you can open numerous revenue streams with them.

What are Dynamic NFTs?

Dynamic NFTs are the next iteration of the ERC-721 standard, aka static NFTs. They come with better utility and inherit dynamic properties that it achieves with the help of smart contracts and oracles. Unlike a regular NFT, the dNFTs are capable of changing their characteristics whenever a pre-determined condition is met. For example, you can code your dNFT and program it to display snowy weather whenever it hits the real world.

How do dynamic NFTs open web3 business opportunities in the metaverse?

Dynamic NFTs open up a lot of business opportunities for brands and creators. Let’s have a look at some of the ways how it makes it possible:

Sports

Sports is one of the most sought-after sectors, and the reason behind it is simple— athletes. They possess a massive following among people, and as a result, their fans are always looking to get hands-on with their exclusive items or collectibles. Many brands are already partnering with athletes or sports institutions to build dynamic NFTs that allow users to engage with their favorite stars in a unique way.

One good example of this is the recent partnership between FIFA and Altered State Machine (ASM). They launched a metaverse-focused soccer game called AI League, where users can predict FIFA World Cup matches and compete against each other to win exciting perks. ASM uses NFTs and AI technology to infuse dynamic elements into their NFTs (gaming characters), making them more engaging.

Collectibles

Dynamic NFTs radically change the way how we used to collect rare items in the form of static NFTs. A recent partnership between the global sports league giant NBA and NBPA launched an initiative called The Association NFT, which comprises dynamic NFT collectibles that change over time based on athletes' in-game performance.

More than that, dynamic NFTs can also provide the holders extra perks whenever a player hits a certain performance level in the game. For example, if an athlete gets crowned as the “rookie of the year,” then their dNFT holders may get their signed merchandise or any other exciting rewards you could think of.

Tokenizing Real-World Assets

Certifications or documents like passports, driving licenses, etc., are a great way to verify someone's credentials. However, the fact that they can easily be counterfeited and are difficult to verify makes it challenging for students, employees, and everyone who owns them. With dynamic NFTs, they can be stored on blockchain technology (which is immutable) and will react as per your performance.

Another interesting real-life example can be the real-estate sector, where the dynamic NFT represents a real-world property and reflects metrics such as maintenance history, market value, age, past sales, and much more.

Credits: Chainlink

How can Dynamic NFT Builders/Creators Monetize Their Creations?

The ERC-1155 standard is already becoming widespread and adopted by the masses. Therefore, if you’re a dNFT builder/creator looking to monetize your creations, then follow the steps below to generate a windfall of money with your NFTs:

Royalties

At present, static NFTs or the ERC-721 is the most minted standard on the Ethereum chain. However, with static NFTs, the original creators lost out on gaining recurring revenue from their creations whenever they get sold, let’s say, for the 3rd, 4th, or 5th time. Dynamic NFTs, on the other hand, change this as their smart contract can be coded as per the creator’s requirements. For instance, you can code your dNFT to get a 10% share every time it gets sold on a secondary marketplace and enjoy persistent revenue.

Brand Deals & Sponsorships

Collaborating with brands and seeking sponsorships is another best way to monetize your creations. You can reach out to different brands to see if they’d be up for a partnership with you if you’re just starting out. However, attracting brand deals is a breeze if you’re already a prominent player in the industry.

For example, the Bored Ape Yacht Creators, Yuga Labs, bagged a collab with Adidas as their creations were highly admired and praised among NFT enthusiasts.

In Closing

Dynamic NFTs are the next frontier of the non-fungible tokens, where the possibilities and use cases it provides to everyone - from builders to brands to holders - are limitless. It is indeed the revolution needed in the web3 space that will have a colossal impact on the overall industry - and why not, as it opens a pool of revenue streams for brands and creators as well. If you’re wondering how you can build a dynamic NFT, then simply head to our website and try our free simulator that allows changing the properties, images, and automating your NFTs with ease.

For more recent updates about dynamic NFTs and Revise Network, follow us from the links below:

Website | Twitter | Discord | Instagram | Facebook

Changing the Game of Ticketing Using Revise and NFTs

Anil Dukkipatty — Mon, 21 Nov 2022 07:18:18 +0000

NFT’s have been all the buzz in the recent years, but dynamic NFTs is where the spotlight is at nowadays. This is a quick guide to creating your own ticket NFT, where your ticket will change once it is used and points will be added towards your ticket. These points can then be used for merchandise and food purchases, as well as to get early access to new albums from this artist.

Introduction to Revise

We’ll cover how to add NFTs using Revise and how to update the NFTs to make them dynamic in this guide. We won’t cover how to deploy these NFTs to Ethereum/Opensea (click here to learn more).

Clone the repository

Copy and paste the following code into the index.js file.

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "...PASTE YOUR AUTH TOKEN HERE...";
const revise = new Revise({auth: AUTH_TOKEN});

async function run() {

    // write your code here

}
run()

💡 You can generate the Auth token from app.revise.network. For more details refer here

Generate API Key (Auth Token)

Let’s replace the AUTH_TOKEN in the above code with the key we just generated. Now we’re ready to start building our dynamic ticket NFT.

Add a Collection

To start with let’s make a collection called “My Concert Tickets”. This collection can have multiple NFTs. Each NFT is a ticket. In order to make the collection, we’ll call the addCollection function. We’ll have to pass it two parameters, the name for the collection and the URI for the collection. The collectionURI is a unique project name that can be used to generate links for the NFT (why we need these links is described later). We have to make sure that the URI is unique and a single word. For e.g. “myconcerttickets" is a valid Collection URI “my concert tickets” is not. Add the following code to your index.js inside the run function.

const collection = await revise.addCollection({name: "My Concert Tickets", uri: "..CREATE YOUR UNIQUE URI"})

// Collection Name : Use any name you want for your collection (this gets shown in the marketplace))
// Collection_URI  : Use a unique name (no spaces or special characters)
//                   this will generate a unique link for your collection
//                   for e.g. if you choose "myconcerttickets12345"
//                   your baseURI wil be "myconcerttickets12345.revise.link"

Add an NFT

Now let’s add our first NFT ticket. We’ll use the addNFT function to create our ticket. Add the following code to your run function below the addCollection function call.

const nft = await revise.addNFT({
    image: 'https://revise-testing.fra1.cdn.digitaloceanspaces.com/tickets/regular.jpg',
    name: 'My Concert Ticket',
    tokenId: '1',
    description: 'A concert ticket with exclusive perks'
  }, [
    {points: "10"}, {category: "General"}, {refreshments: "Yes"}, {seat: "General Area"}
  ], collection.id)

console.log(nft)

We’re passing parameters for the image of our ticket, the name, description, tokenId and some properties. We’re also passing the collectionId we received after creating our collection for the earlier code snippet. tokenId is the unique ID of your NFT on the blockchain. This helps the blockchain and marketplaces distinguish between the NFTs part of the same collection. Two NFTs shouldn’t have the same tokenId. We can add any amount of custom data to our NFTs via its attributes. As you can see in the above snippet we’ve added “points”, “category”, “refreshments”, etc. You can add any number of attributes here.

Run

The final state of our index.js file should look like this now.

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "...PASTE YOUR AUTH TOKEN HERE...";
const revise = new Revise({auth: AUTH_TOKEN});

async function run() {

const collection = await revise.addCollection({name: "My Concert Tickets", uri: "..CREATE YOUR UNIQUE URI"})

    const nft = await revise.addNFT({
    image: 'https://revise-testing.fra1.cdn.digitaloceanspaces.com/tickets/regular.jpg',
    name: 'My Concert Ticket',
    tokenId: '1',
    description: 'A concert ticket with exclusive perks'
  }, [
    {points: "10"}, {category: "General"}, {refreshments: "Yes"}, {seat: "General Area"}, {used: "No"}
  ], collection.id)

console.log(nft)

}
run()

Let’s run this file to create a collection and add our first NFT. Run node index.js in your terminal. The expected output is an id as shown below.

💡 Note: the tokenId and nftId are different. tokenId is used by marketplaces and wallets to identify your NFT. nftId is used by Revise to identify and control the NFT.

Visit your Revise dashboard to see your NFT ticket in action.

Upgrading your ticket using points

The ticket you currently have is a “General” type ticket, but the fact that you’ve gotten this far in the exercise means your ticket should be upgraded to “VIP”. Imagine this happening at a real concert, where you can use the points on your NFT ticket to get exclusive privileges such as upgrading to a VIP ticket, claiming food/drinks, redeeming points for merchandise, or even backstage access. Let’s start by upgrading your ticket to a VIP.

Create a new file called update.js and paste the code snippet below. Run the code using node update.js

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "...AUTH_TOKEN...";
const revise = new Revise({auth: AUTH_TOKEN});
async function run() {
    const ticket = await revise.fetchNFT("...NFT_ID...")
    revise.nft(ticket)
            .setProperty("points", "5")
            .setProperty("category", "VIP")
            .setProperty("seat", "VIP")
      .setImage("https://revise-testing.fra1.cdn.digitaloceanspaces.com/tickets/vip.jpg")
      .save()
            console.log(`${ticket.name} has been updated`)
}

run()

In the above code we’re first referencing and fetching the NFT we just minted using the fetchNFT function and passing the nftId . Then we consume 5 points to upgrade our NFT to a VIP ticket, subsequently leading to a new image. You should be able to see the ticket change and it’s old version (revisions) of the NFT on your Revise dashboard as well.

💡 The setProperty function allows us to change the underlying NFT metadata properties. It takes two parameters, the name of the property and the new value that needs to be set.

Adding extra points for attending the concert

async function run() {
    const ticket = await revise.fetchNFT("...NFT_ID...")
    revise.nft(ticket)
            .setProperty("used", "Yes")
            .setProperty("points", "50")
      .save()
            console.log(`${ticket.name} has been updated`)
}

run()

This code is similar to the last, all thats changed is we are setting the “used” property to “Yes” to indicate the ticket has been used, and the “points” to 50. Run the code using node update.js .

Using your new points

With 50 points there’s a lot you can now claim. You can claim a t-shirt, mouse pad or a concert banner. Which one would you pick? T-shirts cost 35 points, mousepad is 25 points and the banner is 40 points. Plug in the remainder number for points and run the code snippet below.

We also change the image of the ticket to now show the claimed badge on the ticket. Run the code using node update.js .

async function run() {
    const ticket = await revise.fetchNFT("5acdcba9-4126-476d-8f62-e6efab3bdbfd")
    revise.nft(ticket)
            .setProperty("points", "...SET NEW POINTS BASED ON WHAT YOU CLAIM...")
            .setImage("https://revise-testing.fra1.cdn.digitaloceanspaces.com/tickets/vip-claimed.jpg")
      .save()
            console.log(`${ticket.name} has been updated`)
}

run()

Congrats on creating your concert ticket NFT! Publish your ticket to Opensea and show it off to the world.

If you want to learn more or explore opportunities creating with Revise, please schedule a call with us here or join our Discord or message us on Twitter.

NFT Ticketing System: All You Need to Know

Anil Dukkipatty — Wed, 16 Nov 2022 13:18:37 +0000

The OG year for the entire crypto and NFT space was 2021, hands down. NFTs alone reached a massive $22 billion market size compared to $232 million in the previous year attracting eyeballs from the everyman to the celebrated. One good example is the popular Grammy-winner and American Rock Band, Kings of Leon, which released three NFT collections to support their album “When You See Yourself” last year. Another example could be the football club, Dynamo, which released NFTs tickets on the Binance NFT marketplace for their 2021 season.

So coming back to the Kings of Leon NFT collection, out of the three, two NFTs contained an audio recording and a limited-edition album cover & vinyl, whereas, remarkably, the third one was a golden NFT ticket that could be used as an actual concert pass to the musical band’s shows for a lifetime with assured four front-row seats. The golden ticket holders also acquired a few other interesting perks, such as concierge, personal pick-and-drop drivers, access to exclusive merchandise, and personal interaction with the band. Now that’s crazy, right!

But, in case you’re scratching your head wondering, “what are NFT tickets?” then don’t fret. Follow our in-depth guide below to uncover everything you need to know about the NFT ticketing system.

> Moreover, you can register to our FREE Webinar where we present the step-by-step to build and manage NFT tickets. Happening on Thursday, 17 November 2022 at 6 PM IST - https://app.livestorm.co/revise-network/web3-in-30-mins-or-future-of-nft-tickets-is-dynamic

Let’s get right to it!

What is NFT Ticketing?

To give a quick rundown, NFTs are non-fungible tokens that represent digital assets stored on blockchain technology. Most people think of NFTs as just digital art like BAYC, CryptoPunks, etc. However, it’s much more than that. Real estate, digital collectibles, supply chain, and gaming are among a few industries where NFTs could be seen adding more value to their working operations. And just like that, ticketing is yet another sector NFTs are disrupting.

NFT tickets are exactly what they sound like: tickets in the form of non-fungible tokens which underlie blockchain technology. Unlike an artwork NFT, NFT tickets are specifically used to hold one’s credentials to an event or a show.

NFT Ticketing System - Is It the Future?

Digital tickets have replaced paper tickets, whereas NFT tickets have surpassed the digitization of tickets, which is, by the way, vulnerable to internet attacks. Users can simply carry their NFT tickets in their web3 wallets - MetaMask, Trust Wallet, etc. - and use them without fearing their tickets getting stolen, lost, or damaged.

Here are some of the few other challenges it solves:

Prevents Counterfeits

Counterfeits or forgery are pretty normal with paper tickets or the QR codes that users get in the email, as they can be easily faked. Additionally, most of the time, scammers use a pool of bots to buy tickets online and later sell them on third-party platforms at an inflated price, also known as black marketing or scalping. With NFT tickets, users don’t have to be anxious about the ticket’s legitimacy as their transactions get stored on blockchain technology. Hence, validating the ticket’s authenticity becomes a breeze for users.

No Further Value

Paper, or digital tickets, for that matter, are usually the use-and-throw thing. They don’t have any further value and can’t be used again for any purposes, which, however, is not the case with NFT tickets. The non-fungible tickets open additional revenue streams for its holders, artists, and event organizers as well. For instance, if a user trades their ticket on a secondary marketplace, the artist may also get a portion of the resale revenue if they’ve programmed their NFT tickets to work this way.

Major Brands Powering Themselves With NFT Tickets

The concept of NFT ticketing might not be mainstream right now, but it’ll certainly be with time. Many brands/artists are already leveraging this invincible technology to create a robust and risk-free environment for users to own the passes to a certain event. And yes, let’s not forget how NFT tickets are a great way to expand revenue opportunities and can even be used as rare collectibles.

The 2024 Paris Olympic Games, for example, would be seen using blockchain-powered tickets as the French government’s envoy, Michel Cadot, has already proposed the idea to their Prime Minister. Aligned with the same vision, the 2023 Rugby World Cup can also be seen implementing the same technology.

Moreover, in 2018, Shankai sports, an international company based in China, partnered with AlphaWallet to facilitate the sales, and distribution of FIFA World Cup tickets. This idea was to make the ticket distribution more secure for the event and eliminate fraudulent activities.

Besides that, one of the world's most popular music and arts festivals, Coachella, also announced the launch of Coachella Collectibles NFTs in Q1 of 2022. They launched 10 keys (or passes) that granted users lifetime access to their festival and 1,000 NFTs as Coachella photo books. Not just that, Coachella also introduced 10,000 NFTs for unique soundscapes and fan-favorite photos from the event, priced at $60/piece.

Moving on, independent musicians/artists or group bands are also utilizing NFT tickets for their live shows and events. For example, pop artist, Pip, released Cotton Candy NFTs as a part of its crowdfunding campaign and sold out “Gold Backstage Pass” within just 24 hours of its release.

NFT tickets are already prevalent in the music industry bringing in a lot of perks for artists and NFT holders as well. So, in that light, let’s discuss what NFT tickets offer to the guests and event coordinators.

NFT Tickets as Unique Collectables

NFT Tickets are more than just a one-time use thing. Due to their rarity, users or the event guests can acquire them as collectible items, coins, or even stamps. This is a great way to showcase rare art - both physically and virtually (in the metaverse).

Reselling Tickets

NFT tickets can easily be sold at secondary marketplaces if you can’t go to an upcoming event for any reason. Also, as NFT tickets are secure and can’t be forged, they can be sold at the same price the ticket was bought in the first place, or even higher, depending on the popularity of the event/artists.

Creating Aesthetic NFTs

Event coordinators can sit around with artists to infuse aesthetics into their NFT tickets. This way, they can increase the chances of selling the tickets at a relatively higher price. For example, instead of using an uninteresting random image for an NFT ticket, a musician can take its album cover, tweak it around with creativity, and attract more people towards it. Not to mention, the selling and distribution of NFT tickets to consumers can be better tracked than regular digital tickets.

NFT Ticketing and Dynamic NFTs

Dynamic NFTs are the next iteration of Static NFTs, also known as the ERC-721 standard. Even though the ERC-721 is the most used standard on the Ethereum blockchain, Dynamic NFTs are here to change that with their multiple use cases. One main aspect that differentiates non-fungible tokens from ERC-1155 tokens (Dynamic NFTs) is that they are dynamic, meaning, they can change over time as per the external parameters, which is done by programming the NFT’s smart contract.

Now, can Dynamic NFTs be used as NFT tickets? Absolutely. In fact, it’s better than the ERC-721 standard in so many aspects that it’ll completely transform the NFT ticketing system. Here’s how ERC-1155 will take the ticketing industry to the next level:

dNFTs are Programmable Unlocking Multiple Possibilities

A Dynamic NFT can be used as both a ticket and a rare collectible. By virtue of its dynamic nature, it can be programmed like a ticket at first, and then its metadata can be coded to work as a unique collectible, or anything really - like they say, the sky's the limit.

Revenue Sharing

Event organizers/artists may decide to share a percentage of their event’s revenue with their ticket holders using Dynamic NFTs. The same NFT can evolve from being a ticket to being a revenue-sharing smart contract.

Dynamic NFT Tickets as Marketing Tools

dNFT tickets can be programmed to evolve based on users' interactions like completing certain tasks, interacting with artists, etc., and finally acquiring, perhaps, a predetermined trait that unlocks rewards for the users. That way, users get more reasons to complete certain quests attached to brand promotion. On the other hand, Dynamic NFT tickets can help event organizers track and receive foolproof data of promotional activities performed by the audience members.

To Sum Up

NFT tickets are undoubtedly the future of the ticketing industry, and their mainstream adoption is pretty inevitable. The music and entertainment industry is already stepping in where everyone - from the artists to the guests - gets incentivized, which was not possible with paper, or even, regular digital tickets. In fact, it solves some major challenges associated with traditional tickets, such as fraud, tickets getting stolen or damaged, and a lot more.

Not just that, but the ERC-1155 standard, which is the Dynamic NFTs, can be a complete game-changer for the ticketing industry, as we already saw in the above section. If you’re looking for ways to create your first Dynamic NFT, follow this guide. You can also try our free simulator that allows changing the properties, images, and automating your NFTs with ease.

Website | Twitter | Discord

Re-defining Trading Cards using Dynamic NFTs

Anil Dukkipatty — Thu, 27 Oct 2022 10:37:05 +0000

Over the past year and a half, Non-fungible tokens (NFT) have gained a lot of traction, but the next generation of NFT’s will be dynamic. Dynamic NFT’s give us an opportunity to explore a new level of interpretability for NFT’s and other tokens, as it allows us to alter the metadata of our NFT. The ‘dynamic-ness’ of the NFT is often dependent on some online or IRL event such as a piece of art or character updating based on weather data, real life sport scores or even simple user activities. In this article we will be looking at a simple example of a dynamic NFT, combining trading cards and their attributes being updated based on simulated sports data.

Introduction to Revise

Let’s use Revise to build your own football team NFT collections, then add NFT’s too it and allow them to change dynamically. We won’t cover how to deploy these NFTs to Ethereum/Opensea (click here to learn more).

Create a Repo

Copy and paste the following code into the index.js file.

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "...PASTE YOUR AUTH TOKEN HERE...";
const revise = new Revise({auth: AUTH_TOKEN});

async function run() {

    // write your code here

}
run()

💡 You can generate the Auth token from app.revise.network. For more details refer to the next section of this article.

Generate API Key (Auth Token)

Let’s replace the AUTH_TOKEN in the above code with the key we just generated. Now we’re ready to start writing out Dynamic player NFT.

Add a Collection

const collection = await revise.addCollection({name: "My Dynamic Football Team", uri: "..CREATE YOUR UNIQUE URI"})

// Collection Name : Use any name you want for your collection (this gets shown in the marketplace))
// Collection_URI  : Use a unique name (no spaces or special characters)
//                   this will generate a unique link for your collection
//                   for e.g. if you choose "mydynamicplayer12345"
//                   your baseURI wil be "mydynamicplayer12345.revise.link"

Add an NFT

Now let’s add our first NFT player. We’ll use the addNFT function to create our player. Add the following code to your run function below the addCollection function call.

const nft = await revise.addNFT({
    image: 'https://revise-testing.fra1.cdn.digitaloceanspaces.com/players/bronze.png',
    name: 'Kylian Mbappe',
    tokenId: '1',
    description: 'Forward with exceptional abilities. Legend to have on your team'
  }, [
    {team: "PSG"}, {position: "Forward"}, {level: "Bronze"}, {offense: "75"}, {defense: "45"}, {stamina: "76"}, {skill: "71"}
  ], collection.id)

console.log(nft)

Run

The final state of our index.js file should look like this now.

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "...PASTE YOUR AUTH TOKEN HERE...";
const revise = new Revise({auth: AUTH_TOKEN});

async function run() {

    const collection = await revise.addCollection({name: "My Dynamic Football Team", uri: "..CREATE YOUR UNIQUE URI"})

    const nft = await revise.addNFT({
    image: 'https://revise-testing.fra1.cdn.digitaloceanspaces.com/players/bronze.png',
    name: 'Kylian Mbappe',
    tokenId: '1',
    description: 'Forward with exceptional abilities. Legend to have on your team'
  }, [
    {team: "PSG"}, {position: "Forward"}, {level: "Bronze"}, {offense: "75"}, {defense: "45"}, {stamina: "76"}, {skill: "71"}
  ], collection.id)

console.log(nft)

}
run()

Let’s run this file to create a collection and add our first NFT. Run node index.js in your terminal. The expected output is an id as shown below.

💡 Note: the tokenId and nftId are different. tokenId is used by marketplaces and wallets to identify your NFT. nftId is used by Revise to identify and control the NFT.

Visit your Revise dashboard to see your NFT player in action.

Click on the “View” button to see your NFT and it show show up with the Bronze image.

Adding dynamic capabilities to your NFT

Now that we’ve created our first NFT player, let’s make him dynamic by changing its moods.

Create a new file called levels.js. Paste the following code in the file.

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "...AUTH_TOKEN...";
const revise = new Revise({auth: AUTH_TOKEN});

const API = async function() {
  const options = [
    {level: 'Silver', offense: '82', defense: '51', stamina: '82', skill: '79', image: "https://revise-testing.fra1.cdn.digitaloceanspaces.com/players/silver.png"},
    {level: 'Gold', offense: '98', defense: '64', stamina: '92', skill: '87', image: "https://revise-testing.fra1.cdn.digitaloceanspaces.com/players/gold.png"}
  ]
  const randomIndex =  Math.floor(Math.random() * 2)
  return options[randomIndex];
}

async function run() {

  revise.every('2m').listenTo(API).start(async (data) => {
    const player = await revise.fetchNFT("0d6cee67-d3c1-41d5-bd57-ebbe4d34ebd3")
    revise.nft(player)
      .setProperty("level", data.level)
      .setProperty("offense", data.offense)
      .setProperty("defense", data.defense)
      .setProperty("stamina", data.stamina)
      .setProperty("skill", data.skill)
      .setImage(data.image)
      .save()

            console.log(`${player.name}'s is now at level ${data.level}`)
  })

}
run()

In the above code we’re setting up automation which will fetch a level every 2 mins and update our player attributes and image. Execute the above file by running node levels.js. The program will execute automatically and evolve our NFT player in the background. You should be able to see the player change it’s level to Silver or Gold and subsequent attributes and all the old versions (revisions) of the NFT as well.

Congrats on creating your dynamic football collection and player NFT! Publish your Player NFT to Opensea and show it off to the world.

If you want to learn more or explore opportunities creating with Revise, please schedule a call with us here or join our Discord or message us on Twitter.

Building NFTs using truffle and revise

Anil Dukkipatty — Tue, 27 Sep 2022 12:51:25 +0000

Index for the post:

Overview
Prerequisites
- Setting up Ganache
Installing truffle command-line app
Building the NFT ERC721 smart contract
Adding NFT data using Revise

This is a quick guide to building NFTs using truffle and javascript (revise-sdk).

Prerequisites: Node version 15 or above, NPM version 7 or above

We’ll start by installing Ganache. Ganache will run a sample blockchain locally on your development machine. This will allow us to build and test our NFT smart contracts.

Click on this link to visit the download page. Choose your platform and download the installer. Once it is installed, open the ganache app and click on the “Quickstart Ethereum” button. This will start a simulation of the Ethereum blockchain. We can now start developing and testing our NFT smart contracts in Truffle.

Let’s install Truffle next. We’ll use NPM to download and setup the truffle command-line app. Run npm install truffle -g in your terminal. Once this command is done installing Truffle you’ll be able to use it from any folder on your computer.

Make a new directory, call it truffle-revise-tutorial. Once you cd into that directory run truffle init this will setup all the boilerplate required to start building smart contracts. Make a new file in the contracts folder to write the smart contract. You can also run the truffle scaffolding command truffle create contract ReviseNFT from the terminal to create the “ReviseNFT.sol” file (smart contract file).

Paste the following code in the file you just created:

// Let’s start by importing the Openzeppelin ERC-721 template into our file
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
// Next, let’s add our NFT smart contract and name the NFT token (Dynamic NFT)
contract ReviseNFT is ERC721 {
    string baseuri = "";
    constructor(string memory _baseuri) ERC721("Dynamic NFT", "dNFT") {
        baseuri = _baseuri;
    }
    // Last but not the least, let’s add functions to enable minting and to enable setting the _baseURI().
    function mint(address to, uint256 tokenId) public {
        _safeMint(to, tokenId);
    }
    function _baseURI() internal view override(ERC721) returns (string memory) {
        return baseuri;
    }
}

Once you’re done pasting the above code run npm install @openzeppelin/contracts to install the missing dependencies.

This is boilerplate for an NFT smart contract. We’re using the Openzeppelin ERC721 template as the base and adding a couple of functions on top to enable minting and setting the “_baseuri”. The “_baseuri” allows you to add data (name, image, description, attributes, etc) to your NFTs.

We’ll use Revise (https://revise.network) to setup the backend and add the data to our NFTs. Let’s grab a development key from Revise. Visit https://revise.network and click on “Get started”, once you make an account click on “Generate API key” in the header. Once you generate the key, copy the key and save it somewhere.

Clone this repo. This is a very basic starter kit, it has the revise-sdk setup. Once you clone it, run npm install. Open the index.js and paste the following code:

const { Revise } = require("revise-sdk");
const AUTH_TOKEN = "...PASTE YOUR AUTH TOKEN HERE...";
const revise = new Revise({auth: AUTH_TOKEN});

async function run() {

    const collectionId = await revise.addCollection("Collection Name", "Collection_URI")

    // Collection Name : Use any name you want for your collection (this gets shown in the marketplace))
    // Collection_URI  : Use a unique name (no spaces or special characters)
    //                   this will generate a unique link for your collection
    //                   for e.g. if you choose "myuniquecollection"
    //                   your baseURI wil be "myuniquecollection.revise.link"
    const nft = await revise.addNFT({
    image: 'https://revise-testing.fra1.digitaloceanspaces.com/sample-collection/1.jpg',
    name: 'Star Lord',
    tokenId: '1',
    description: 'This is a test description'
  }, [
    {attack: "80"}, {color: "maroon"}, {stamina: "90"}
  ], collectionID.id)

    console.log(nft)
}
run()

Replace the AUTH_TOKEN with the auth token you’ve generated from Revise. In the above snippet we’re just importing the revise-sdk, setting up the authentication token and setting up the function to run the revise-sdk function calls. In the above code we’re create a collection for our NFT (all NFTs belong to a collection - think of it as files in a folder) and adding some data into the NFT. Run the index.js file node index.js. Now we’ve added our first NFT! We can test this out, visit revise.link/p/myuniquecollection/1 (replace “myuniquecollection” with the “collectionURI” you chose earlier).

Now all we have to do is replace the “_baseuri” in the above smartcontract with the link we’ve generated via Revise. We’ve successfully built our first NFT!

In the next article I’ll walk you through running the NFT smart contract we built on Ganache and an Ethereum testnet. See you soon.