DEV Community: BlocOGs

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

BlocOGs — Thu, 05 Jan 2023 15:07:28 +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

BlocOGs — Wed, 30 Nov 2022 12:44:01 +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

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 football team NFT collections, then add NFTs too it and allow them to change dynamically.

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 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)

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 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.

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 player. 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 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

BlocOGs — Fri, 25 Nov 2022 10:27:01 +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

BlocOGs — Mon, 21 Nov 2022 07:04:39 +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

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.

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.