Welcome to our introduction to Non-Fungible Tokens (NFTs) for developers and technical readers.

Before you get started, feel free to explore other (less technical) resources that will help you and your team to get a more holistic understanding of NFTs and digital assets in general:

• Introduction to NFTs for Identity

• The future of decentralized identity: SSI vs NFTs

This section elaborates the theory behind the NFT Kit:

• NFT Kit | Basics - Learn what the NFT Kit is and what it does.

• NFT Flavors & Ecosystems- Learn which NFT flavors and ownership ecosystems we support.

• Architecture - Explore the NFT Kit's multi-layered architecture and components.

• Use Cases - Explore use cases you can implement with the NFT Kit.

• NFT Kit Feature List - Explore all features in an overview list

We believe in a multi-blockchain & multi-ecosystem future.

This is why we built an abstraction layer for ecosystem-specific operations and business logic. The idea is to support any ecosystem with a single solution that does not put any additional burden on developers. As a result, you can use our solutions to participate in different ecosystems without having to switch between different technical implementations.

Get started with your preferred option here.

The following is a short summary of the interfaces available. The detailed functions are described in the documentation further on.

The NFT Kit exposes high-level interfaces / APIs to hide the complex introduced by

• low-level services (e.g. key management, smart contract and minting operations)

• different ecosystems (i.e. different NFT flavours, business logic and governance frameworks).

The functionality of the high-level interfaces are grouped around:

• Creating / Minting NFTs

• Managing NFTs

• Verifying NFTs (ownership, metadata)

The interfaces can be used in JVM-based applications directly, or via the REST API. Get Started

Select your ecosystem/blockchain of choice here and start exploring the REST API.

Learn how to create and mange NFTs on Ethereum, Polygon and the Shimmer Network using the NFT-Kit's REST API or our Kotlin/Java library

Getting Started

Setup - How to use the NFT-Kit

NFT | Creation & Management - How to deploy Smart Contracts and mint NFTs

NFT | Ownership Verification - How to verify NFT ownership within a collection and traits

Smart Contract | Extensions - Pause token transfers, minting and burning

Smart Contract | Access Control - Access Control functionalities

This software-layer holds a set of generic core services for common NFT and cryptographic functions. The services are in the scope of Smart Contract deployment, Meta Data management, Token Minting etc..

The low-level services expose common interfaces that can be conveniently utilised directly via Kotlin/Java or via the REST API (Swagger doc of the core API).

Here are the most important things you need to know about the NFT Kit:

• It is written in Kotlin/Java. It can be directly integrated (Maven/Gradle dependency) or run as RESTful web-service. A CLI tool allows you to run all functions manually.

• It is open source (Apache 2). You can use the code for free and without strings attached.

• It is a holistic solution that allows you to build use cases “end-to-end”. There is no need to research, combine or tweak different libraries to build pilots or production systems.

• It abstracts complexity such as low-level functionality related to key handling, data storage, minting operations and interactions with third party systems.

• It is customizable in a sense that you can build NFTs in all kinds of variations based on different smart contracts (e.g. ERC-721, ERC-1155) using various configurations (e.g. supply size, metadata storage).

• It gives you advanced features like "soulbound" or "dynamic" NFTs or royalties.

• It is modular, composable and built on open standards allowing you to customize and extend functionality with your own or third party implementations and to preventing lock-in.

• It is flexible in a sense that you can deploy and run it on-premise, in your (multi) cloud environment or as a library in your application.

• It enables you to use different blockchains / ecosystems - starting with EVM-compatible blockchains (e.g. Ethereum, Polygon, Binance Smart Chain, Avalanche).

• Metadata is one of the core components of a NFT. We have a flexible and an abstract system to manage metadata. It can be on-chain (struct in smart contract, base64 string) or off-chain (IPFS, Arweave, centralized server).

Technical Perspective

Understanding NFTs from a technological perspective requires the understanding of a few core concepts:

• Registries, typically blockchains, which serve as a shared and trusted record of information. They serve as a “layer of trust” and a “single source of truth”.

• Cryptographic keys, which convey control over NFTs and enable other crucial functionality such as authentication.

• Token IDs, which are used to distinguish NFTs on a blockchain such that each token ID is linked to a unique address (establishing a public key infrastructure) and to metadata. This way different parties can easily find and interact with each other as well as benefit from blockchains’ unique properties like immutability.

• Metadata, which can be anything like a piece of digital art or a digital representation of a physical asset. Importantly, metadata can be stored on-chain or off-chain.

• Smart contracts, which can be thought of as the programs or apps that run on a blockchain and are responsible for minting NFTs.

• Wallets, which are used to store keys or potentially even metadata. Also, they enable the management and sharing of NFTs via easy-to-use applications.

Illustration of main technical concepts related to NFTs:

One can think of these core concepts as different building blocks that are available in different variations and can be put together in different ways. For example:

Different blockchains (or other distributed ledger technologies) can be used to establish Registries (e.g. Ethereum, Polygon, Solana, Avalanche, Polkadot, Tezos, IOTA). Similarly, NFT metadata can be stored in different ways such as on blockchains, other distributed data storage protocols (e.g. IPFS, filecoin) or even traditional databases. Similarly, different smart contract development standards with different strengths and weaknesses can be used (e.g. ERC-721 or ERC-1155 for EVM compatible chains like Ethereum).

As a result, there are many different “flavors” of NFTs depending on which variations of which building blocks have been used and how they have been put together.

This documentation will help you understand how the NFT Kit works and how you can use it. However, it presumes a certain level of knowledge about Non-Fungible Tokens (NFTs) so

• if you are already familiar with NFTs, you can jump to the NFT Kit.

• if you are new to the world of NFTs, please continue with our introduction to Non-Fungible Tokens (NFTs).

The NFT Kit offers everything you need to use Non-Fungible Tokens (NFTs) with ease.

The following sections elaborate the NFT Kit's unique properties and enabled functionality.

The NFT Kit establishes an ownership infrastructure layer for any use case in any industry. Its core services are in the scope of:

• Registry Interactions e.g. read, write; agnostic towards the underlying tech e.g. blockchain

• Key Management e.g. generate, sign, import, export, manage lifecycle

• Smart Contracts and NFT/Token e.g. create, mint, distribute, claim, verify ownership

• Metadata handling e.g. on-chain or off-chain storage, look-up, verify metadata and attributes

Illustration:

The NFT Kit abstracts complexity for developers by following a "multi-stack approach" that enables you to use different implementations or "flavours" of NFT.

As a result, you can participate in different ecosystems (e.g. Ethereum, Polygon, Tezos, ...) and avoid technology-related lock-in effects.

Based on our Introduction to Non-Fungible Token (NFT), we distinguish the following concepts or building blocks, which illustrate the variety of NFT "flavours" that exists.

API Docs

|

Smart Contracts

The NFT-Kit supports the ERC-721 standard with the option to be deployed as regular contract for NFTs or modified for Soulbound Tokens.

Do you want to modify your contract further? Have a look at our Smart Contract Extension Sections:

1. - Pause token minting and burning.

2. Enable role-based access control

NFT Contract Deployment | ERC-721

Soulbound Token Contract Deployment | ERC-721 with extension

Mint an NFT

It is a rich API to mint a new NFT token. It manages NFT metadata in multiple ways. You can generate token URI by yourself or let the NFT KIT generate it.

Revoke NFT

Owner of a soul bound NFT smart contract , can revoke a minted Token.

NFT metadata

Find out more information about your NFTs with the following actions.

Fetch NFT metadata URI

Fetch NFT metadata

Update NFTs metadata trait

Get Account balance

Get Token owner

Get collection info

Get NFTs by account

It will return a list of all NFTs which are associated with the provided account address.

You will learn how you can use the NFT Kit to verify the ownership and properties of Ocean protocol's (V4) ERC721 data NFT.

Ocean protocol V4 data NFTs have a specialized Smart Contract architecture to handle data or intellectual property related use cases. Therefore, the NFT Kit was extended with special interfaces to deploy contracts, mint tokens and most importantly to verify the ownership of data NFTs. Learn more in detail how things were implemented in the .

Getting Started

Deep dive

- How to use the NFT-Kit

- How to verify NFT ownership and properties in the metadata

- View NFTs via a Web-Wallet

- See how the Ocean Protocol was integrated into the NFT-Kit

Get started by choosing your system

Do you want to build using our APIs or add the NFT-Kits functionalities as a direct dependency in a Kotlin/Java application

API

Installation & Running the Project

Make sure you have Docker or a JDK 16 build environment including Gradle installed on your machine

Start Building

Kotlin/Java SDK

Gradle

Maven

Required Maven repos:

Start Building

The NFT Kit offers everything you need to use Non-Fungible Tokens (NFTs) with ease on different ecosystems. Chose yours and get started.

If you want to learn more about the NFT-Kit architecture and the general ideas? Visit the .

As the world is going digital, it becomes necessary to model ownership in a digital way. NFTs allow us to do just that by encoding ownership of any type of asset in a digital format.

As a result, NFT use cases can be found wherever there’s a need to digitally model ownership. In other words, the list of use cases is long and NFTs will likely be among the most important building blocks on which the digital world (or something like a metaverse) will be built.

The following graphic shows a range of NFT use cases across different industries to illustrate the potential of NFTs:

Ownership and Access Management

You can use the NFT Kit to enable your users, customers, employees or partners to create and manage any form of ownership (whether it's about a physical good, or digital items). This allows businesses to create digital ownership documents that are very hard to counterfeit but easy to verify, which makes the user experience more secure and enjoyable.

Decoupling the access to a product or service from a users’ identity is also possible as access can be given to the owner of a specific NFT only without having to know the identity of this owner in advance. The following categories show more specific use cases and examples.

Creator economy

The most famous NFT use case is certainly digital art. With NFTs, artist have the ability to create digital scarcity and thus sell their digital art as NFT. The creator economy also includes fashion brands that uses NFT as a "digital twin" of a physical product that a customer bought. In the luxury industries, NFT can also be used to issue authenticity certificates.

Entertainment

Entertainment is a big industry for NFTs. They can be used to represent items in video games which makes the players the true owners of those NFT gaming items, while allowing them to trade them and even use them in another video game or another context. Another use case that is becoming more and more popular is ticketing. When NFTs are used for ticketing, it allows a better management of events ticket because they are on a public blockchain with a high level of traceability, but it also reduces fraud because users can verify that the NFT they are buying is authentic. Lastly, NFT ticketing also provides consumers with a better user experience.

Travel and mobility

Similar tho the ticketing use case for events, NFT can be use to represent airplane or any public transport tickets; but also membership cards to access any services and transport.

Tourism and Travel

Loyalty program, exclusive content and vouchers are 3 practical use cases for NFTs in the Tourism and Travel industry. They are a great way to engage guests in a digital and interactive way as well as rewarding them.

Supply Chain

Thanks to its traceability characteristic, NFT are of course perfectly designed for Supply Chain usage. Product tracking and product authenticity is made easy when physical products are associated with NFTs.

Art

Digital art can be monetized by making unique digital assets that can have exclusive properties, on top of being easily sold or rented. In DeFi (Decentralized Finance), art NFTs can also be used as collateral for a loan

Music

In a similar way to digital art, musicians and singers can link their music to NFTs which makes it possible to own a piece of a song or album and receive royalties from it.

Ticketing

Event organizers may issue event tickets using NFT, as it would avoid fraud (by providing an easy way to verify tickets), but it would also allow for a better traceability of all the tickets that are resold.

Real Estate

Property ownership documents can also be made (created and issued) via NFTs which would represent a digital and immutable certificate of ownership of a physical real estate property. In another fashion, NFTs are also used to represent virtual properties.

Gaming

Items in online games can now be truly owned by the players, which offers many new possibilities such as selling and buying items outside of a game’s centralized marketplace, but also using those items in other digital environments like in other games.

Product Authenticity

Similar to the property ownership documents for the real estate use case, NFTs can also be used to prove the authenticity of any other physical products, such as clothing items, jewelry, cars, etc.

Fundraising and crowdfunding

Foundations and charities have already started to raise money by selling their own NFT collection, but crowdfunding platforms are now challenged by NFTs as it allows startups to raise funds in a peer to peer way.

Any Questions

The architecture of the NFT Kit consists of three layers:

1. Low-Level Services Abstraction: Abstracts complex, low-level operations (e.g. cryptography, key management, smart contract or minting operations).

2. Ecosystem Abstraction: Abstracts ecosystem-specific requirements based on the relevant technical and governance frameworks of a blockchain / NFT ecosystem.

3. High-Level Interfaces / APIs: Provides high-level interfaces that hide complexity and facilitate usage for developers.

Also, the architecture allows for the integration of third party solutions throughout the stack. For example:

• Key storage (e.g. HSM)

• Data storage (e.g. IPFS)

• Registries (e.g. blockchains)

This architectural openness prevents vendor lock-in and allows you to build NFT-based solutions that meet your unique requirements.

Illustration:

Read on to explore all three abstraction layers in more detail.

What are NFTs?

In a nutshell, NFTs are non-fungible tokens which digitally represent ownership of something.

Following this definition each NFT shares at least three properties:

1. NFTs are “non-fungible” which means that each NFT (or token) is unique in a sense that there is no other thing just like it. In other words, each NFT is one of a kind just like there is only one painting that is the real Mona Lisa. (A fungible token, on the other hand, is not unique. It would not make any difference if a fungible token would be exchanged for another token of the same kind such as a Bitcoin.)

2. NFTs represent ownership which implies that an NFTs is treated as the actual thing that it stands for so that by selling an NFT you are also selling “the real thing” that it represents.

3. NFTs can be used to tokenize and represent anything from physical things (like a house) to natively digital assets (like a crypto punk) to ideas and intellectual property.

How NFTs work ?

To understand how NFTs work, one must consider two perspectives:

• The functional perspective which is about understanding the implications of NFTs for its adopters and the market, particularly what NFTs enable one to do (that could not be done without NFTs).

• The , which is about understanding the technologies on which NFTs are built and their properties which give rise to NFT’s functionality in the first place.

Functional Perspective

NFTs allow us to have digital representations of potentially anything in a way that these representations are unique, trustworthy (or at least a tamper proof record of ownership) and can be traded. We can distinguish the following roles or functionalities:

• Issuers - Parties who create (“mint”) NFTs and issue (“drop”) them to someone else (“Holders”). Issuers are the original sources of an NFT. For example, artists who mint their creations as NFTs and transfers them to buyers.

• Holders - Individuals or organizations who receive NFTs from someone else (but not necessarily from the original “Issuer”, considering that NFTs are transferable).

• Verifiers - Parties who verify NFT ownership and metadata in order to provide access to information, services, products or other benefits, such as is the case with tickets, vouchers or other forms of memberships more generally.

Illustration of functional roles in NFT ecosystems

Swagger Doc | ReDoc

Pausable

Pause token transfers, minting and burning.

Get pausable state of the smart contract.

curl -X GET "http://0.0.0.0:7000/nftkit/nft/extensions/chain/MUMBAI/contract/0xf277BE034881eE38A9b270E5b6C5c6f333Af2517/paused" \

Pause smart contract

curl -X POST "http://0.0.0.0:7000/nftkit/nft/extensions/chain/MUMBAI/contract/0xf277BE034881eE38A9b270E5b6C5c6f333Af2517/pause" \

Unpause smart contract

curl -X POST "http://0.0.0.0:7000/nftkit/nft/extensions/chain/MUMBAI/contract/0xf277BE034881eE38A9b270E5b6C5c6f333Af2517/unpause" -H  

Burnable

Pause token burning.

Get burnable state of the smart contract.

curl -X GET "http://0.0.0.0:7000/nftkit/nft/extensions/chain/MUMBAI/contract/0xf277BE034881eE38A9b270E5b6C5c6f333Af2517/burnable"

Activate/Deactivate burnable feature.

curl -X POST "http://0.0.0.0:7000/nftkit/nft/extensions/chain/MUMBAI/contract/0xf277BE034881eE38A9b270E5b6C5c6f333Af2517/burnable" \
-H  "Content-Type: application/json" \
-d '{"burnable":false}'

{
  "burnable": true
}

Burn an NFT token.

curl -X DELETE "http://0.0.0.0:7000/nftkit/nft/extensions/chain/MUMBAI/contract/0xf277BE034881eE38A9b270E5b6C5c6f333Af2517/token/1" 

Update NFT metadata

curl -X PUT "http://0.0.0.0:7000/nftkit/nft/extensions/chain/MUMBAI/contract/0xf277BE034881eE38A9b270E5b6C5c6f333Af2517/token/1/tokenURI?signedAccount=0x6E7448a6335d5C947953994d071D4Dc1F6e5BE96" \
-H  "Content-Type: application/json" \
-d '{"metadataUri":"string","metadata":{"description":"string","name":"string","image":"string","image_data":"string","external_url":"string","attributes":[{"trait_type":"string","value":"string"}]}}'

{
  "metadataUri": "string",
  "metadata": {
    "description": "string",
    "name": "string",
    "image": "string",
    "image_data": "string",
    "external_url": "string",
    "attributes": [
      {
        "trait_type": "string",
        "value": "string"
      }
    ]
  }

Financial Application 2 (FA2) token standard

Create and mint NFTs via the FA2 (Financial Application 2) unified token standard on Tezos, offering the following token types:

• fungible (equals ERC-20 on Ethereum)

• non-fungible (equals ERC-721 on Ethereum)

• non-transferable (equals ERC-1238 on Ethereum)

• multi-asset contracts (equals ERC-1155 on Ethereum)

FA2 implementations

The FA2 standard has multiple implementations. We support the following:

Single

With this implementation, you can only have one collection. It is like the ERC-721 style. Only owner minter can mint new NFTs.

Multiple

With this implementation, you can have multiple collections. In each collection, you can define the number of copies of each NFT. It is somehow like the ERC-1155 style.

Smart contract deployment

We offer a set of default FA2 based smart contract templates, providing the main functionality needed for NFT projects.

curl -X POST "http://0.0.0.0:7000/v2/nftkit/nft/tezos/chain/{{chain}}/contract/deploy" 
-H  "Content-Type: application/json" 
-d "{"owner":"string","type":"string"}"

{
  "owner": "tz1YiZtFfeu6qmr2G6PnyisJNjxDyaEWXs9J",
  "type": "SINGLE"
}

curl -X POST "http://0.0.0.0:7000/v2/nftkit/nft/tezos/chain/GHOSTNET/contract/deploy" 
-H  "Content-Type: application/json" 
-d "{"owner":"tz1YiZtFfeu6qmr2G6PnyisJNjxDyaEWXs9J","type":"SINGLE"}"

val chain= TezosChain.GHOSTNET
val smartContractOwner= "tz1YiZtFfeu6qmr2G6PnyisJNjxDyaEWXs9J"
val smartContractType= Fa2SmartContractType.SINGLE
val result = TezosNftService.deploySmartContract(chain, smartContractOwner, smartContractType)
println("Smart contract address: ${result.contractAddress}"
println("Smart contract external url: ${result.contractExternalUrl}")

Add minter

The FA2 smart contract implementation allows minting NFTs from different accounts. The owner of the smart contract is allowed to add new minters.

curl -X POST "http://0.0.0.0:7000/v2/nftkit/nft/tezos/chain/{{chain}}/contract/{{contract}}/minter" 
-H  "Content-Type: application/json" 
-d "{"minterAddress":"string"}"

{
  "minterAddress": "string"
}

curl -X POST "http://0.0.0.0:7000/v2/nftkit/nft/TEZOS/chain/GHOSTNET/contract/KT1QDuCUqmgotFqRtCK757J7xu47Bc7Ajp6q/minter" 
-H  "Content-Type: application/json" 
-d "{"minterAddress":"tz1YiZtFfeu6qmr2G6PnyisJNjxDyaEWXs9J"}"

 val chain= TezosChain.GHOSTNET
 val smartContractAddress= "KT1Ennr99qgqzKEUCEqypXEexH4wWzVL5a9m"
 val minterAddress= "tz1YiZtFfeu6qmr2G6PnyisJNjxDyaEWXs9J"
 val result = TezosNftService.addMinter(chain, smartContractAddress , minterAddress)
 println("Operation ID: ${result.operationHash}")
 println("Operation external url: ${result.operationExternalUrl}")tl

NFT Minting

With this API, you can mint a new NFT. It have multiple options to manages NFT minting. You can generate NFT URI metadata by yourself or let the NFT KIT generate it.

curl -X POST "http://0.0.0.0:7000/v2/nftkit/nft/tezos/chain/{{chain}}/contract/{{contract}}/mint" 
-H  "Content-Type: application/json" 
-d "{"metadataUri":"string","tokenId":"string","amount":"string","recipientAddress":"string","metadata":{"name":"string","description":"string","symbol":"string","image":"string","creators":["string"],"decimals":"string","displayUri":"string","artifactUri":"string","thumbnailUri":"string","isTransferable":true,"isBooleanAmount":true,"shouldPreferSymbol":false,"attributes":[{"trait_type":"string","value":"string"},{"trait_type":"string","value":"string"},{"trait_type":"string","value":"string"}],"tags":["string"],"category":"string","collectionName":"string","creatorName":"string","keywords":"string"}}"

{
  "metadataUri": "string",
  "tokenId": "string",
  "amount": "string",
  "recipientAddress": "string",
  "metadata": {
    "name": "string",
    "description": "string",
    "symbol": "string",
    "image": "string",
    "creators": [
      "string"
    ],
    "decimals": "string",
    "displayUri": "string",
    "artifactUri": "string",
    "thumbnailUri": "string",
    "isTransferable": true,
    "isBooleanAmount": true,
    "shouldPreferSymbol": true,
    "attributes": [
      {
        "trait_type": "string",
        "value": "string"
      }
    ],
    "tags": [
      "string"
    ],
    "category": "string",
    "collectionName": "string",
    "creatorName": "string",
    "keywords": "string"
  }
}

curl -X POST "http://0.0.0.0:7000/v2/nftkit/nft/tezos/chain/TEZOS/contract/KT1QDuCUqmgotFqRtCK757J7xu47Bc7Ajp6q/mint" 
-H  "Content-Type: application/json" 
-d "{"metadataUri":"","tokenId":"0","amount":"","recipientAddress":"tz1fXH6Tt2Qgvp7pjVpyNcZmunEbgRaHKcoQ","metadata":{"name":"NFT #0","description":"Rocket Monsters 10k Bear Battalion","symbol":"RM10KBB","image":"","creators":["tz1YiZtFfeu6qmr2G6PnyisJNjxDyaEWXs9J"],"decimals":"0","displayUri":"ipfs://QmZ6tRBw9cxDrc6dzy74JgNLSRYSbQAp3GHEbFqg2EQ8og","artifactUri":"ipfs://QmZ6tRBw9cxDrc6dzy74JgNLSRYSbQAp3GHEbFqg2EQ8og","thumbnailUri":"ipfs://QmZ6tRBw9cxDrc6dzy74JgNLSRYSbQAp3GHEbFqg2EQ8og","isTransferable":true,"isBooleanAmount":true,"shouldPreferSymbol":false,"attributes":[{"trait_type":"Backgrounds","value":"Green"},{"trait_type":"Fur","value":"Yellow"},{"trait_type":"Belly","value":"Blue_Steel"}],"tags":["string"],"category":"gaming","collectionName":"Rocket Monsters","creatorName":"rocketmonsters","keywords":"gaming,collectible,rocket,monster,bear,battalion"}}"

val chain= TezosChain.GHOSTNET
val smartContractAddress= "KT1Ennr99qgqzKEUCEqypXEexH4wWzVL5a9m"
val metadataUri=""
val recipientAddress= "tz1LeScZyZqmg8ZXYoN3mE8vA9GFrPm4HXkx"
val tokenId= "0"
val attribute1= NftMetadata.Attributes(trait_type = "Backgrounds", value = "Green")
val attribute2= NftMetadata.Attributes(trait_type = "Fur", value = "Yellow")
val attributes= listOf(attribute1, attribute2)
val metadata= TezosNftMetadata(name = "NFT #0", description = "Rocket Monsters Battalion", symbol = "RMB", displayUri = "ipfs://QmZ6tRBw9cxDrc6dzy74JgNLSRYSbQAp3GHEbFqg2EQ8og",
    artifactUri = "ipfs://QmZ6tRBw9cxDrc6dzy74JgNLSRYSbQAp3GHEbFqg2EQ8og", thumbnailUri = "ipfs://QmZ6tRBw9cxDrc6dzy74JgNLSRYSbQAp3GHEbFqg2EQ8og", isTransferable = true,
    attributes = attributes)
val parameter= TezosMintingParameter(metadataUri, recipientAddress, tokenId, null, metadata)
val result = TezosNftService.mintNftToken(chain, smartContractAddress , parameter)
println("Operation ID: ${result.operationHash}")
println("Operation external url: ${result.operationExternalUrl}")

Fetch NFT metadata

You can get the NFT metadata based on the NFT smart contract address and the NFT token ID.

curl -X GET "http://0.0.0.0:7000/nftkit/nft/tezos/chain/{{chain}}/contract/{{contract}}/token/{{tokenId}}/metadata"

curl -X GET "http://0.0.0.0:7000/nftkit/nft/tezos/chain/TEZOS/contract/KT1Ennr99qgqzKEUCEqypXEexH4wWzVL5a9m/token/0/metadata"

val nftMetadata = TezosNftService.getNftTezosMetadata(Chain.TEZOS, "KT1RCzrLhBpdKXkyasKGpDTCcdbBTipUk77x", "93531")

Get account NFTs

You get the NFTs list of an account on the specified network.

curl -X GET "http://0.0.0.0:7000/nftkit/nft/chain/{{chain}}/owner/{{owner}}" 

curl -X GET "http://0.0.0.0:7000/nftkit/nft/chain/TEZOS/owner/tz1fXH6Tt2Qgvp7pjVpyNcZmunEbgRaHKcoQ" 

val nfts = NftService.getAccountNFTs(Chain.GHOSTNET, "tz1LFRt8fCjtJmkUpVhRtfFba9VVHH4oSrUz")

Get contract metadata

This API allows fetching contract metadata.

curl -X GET "https://0.0.0.0:7000/nftkit/nft/tezos/chain/{{chain}}/contract/{{contract}}/metadata"

curl -X GET "https://0.0.0.0:7000/nftkit/nft/tezos/chain/TEZOS/contract/KT1WGDVRnff4rmGzJUbdCRAJBmYt12BrPzdD/metadata" -H  "accept: */*"

val contractMetadata= TezosNftService.getContractMetadata(TezosChain.TEZOS, "KT1WGDVRnff4rmGzJUbdCRAJBmYt12BrPzdD")

Swagger Doc | ReDoc

NFT ownership verification

You can use this API to verify if an account is the real owner of an NFT.

curl -X POST "http://0.0.0.0:7000/nftkit/nft/verifier/chain/MUMBAI/contract/0xf277BE034881eE38A9b270E5b6C5c6f333Af2517/verifyCollection" \ 
-H  "Content-Type: application/json" \
-d '{"account":"0x2555e3a97c4ac9705d70b9e5b9b6cc6fe2977a74","tokenId":"1"}'

{
  "account": "string",
  "tokenId": "string"
}

NFT ownership verification with traits

The verification process can be based on NFT ownership and metadata traits.

curl -X POST "http://0.0.0.0:7000/nftkit/nft/verifier/chain/MUMBAI/contract/0xf277BE034881eE38A9b270E5b6C5c6f333Af2517/verifyTrait" \ 
-H  "Content-Type: application/json" \
-d '{"account":"0x2555e3a97c4ac9705d70b9e5b9b6cc6fe2977a74","tokenId":"1","traitType":"pass","traitValue":"silver"}'

{
  "account": "string",
  "tokenId": "string",
  "traitType": "string",
  "traitValue": "string"
}

Swagger Doc | ReDoc

Almost every smart contract must have an access control mechanism. We provide two:

1. Ownership

2. Role-Based Access Control

Ownership

"Ownership" is a simple approach to set up access control within your smart contract. You can easily provide the "accessControl" property with "OWNABLE" during deployment to get started. Thereby, the restricted areas of the contract can only be called by the owner of the contract.

Get smart contract owner.

curl -X GET "http://0.0.0.0:7000/nftkit/nft/accessControl/chain/MUMBAI/contract/0xf277BE034881eE38A9b270E5b6C5c6f333Af2517/owner"

Transfer ownership of the contract to a new account.

curl -X POST "http://0.0.0.0:7000/nftkit/nft/accessControl/chain/MUMBAI/contract/0xf277BE034881eE38A9b270E5b6C5c6f333Af2517/ownershipTransfer" \
-H  "Content-Type: application/json" \
-d '{"account":"0x8448Ff4b2733b52f62d81ca46d64bD16786299Cd"}'

{
  "account": "string"
}

Renounce ownership of the smart contract.

curl -X POST "http://0.0.0.0:7000/nftkit/nft/accessControl/chain/MUMBAI/contract/0xf277BE034881eE38A9b270E5b6C5c6f333Af2517/ownershipRenounce" 

Role-Based Access Control

"Role-Based Access Control" is a more complex approach than "Ownership" to manage access control. With this approach, you can define a hierarchy of roles, each allowed to perform a different set of actions. You can also assign multiple accounts to each role.

Verify if an account has been granted role

curl -X GET "http://0.0.0.0:7000/nftkit/nft/accessControl/chain/MUMBAI/contract/0xDc22fE8b277c03B5Af231b6a049631a06961F20d/account/0x8448Ff4b2733b52f62d81ca46d64bD16786299Cd/role/MINTING_ROLE" 

As we have a role hierarchy, You can use this API to get role admin that controls a sub role.

curl -X GET "http://0.0.0.0:7000/nftkit/nft/accessControl/chain/ETHEREUM/contract/0xDc22fE8b277c03B5Af231b6a049631a06961F20d/role/METADATA_UPDATER_ROLE/admin" 

Grant role to account. The caller must have role's admin role.

curl -X POST "http://0.0.0.0:7000/nftkit/nft/accessControl/chain/MUMBAI/contract/0xDc22fE8b277c03B5Af231b6a049631a06961F20d/grantrole" \
-H  "Content-Type: application/json" \
-d '{"role":"minting_role","account":"0x8448Ff4b2733b52f62d81ca46d64bD16786299Cd"}'

{
  "role": "string",
  "account": "string"
}

Revoke role to account. The caller must have role's admin role.

curl -X POST "http://0.0.0.0:7000/nftkit/nft/accessControl/chain/MUMBAI/contract/0xDc22fE8b277c03B5Af231b6a049631a06961F20d/revokeRole" \
-H  "Content-Type: application/json" \
-d '{"role":"METADATA_UPDATER_ROLE","account":"0x8448Ff4b2733b52f62d81ca46d64bD16786299Cd"}'

{
  "role": "string",
  "account": "string"
}

Renounce role from the calling account.

curl -X POST "http://0.0.0.0:7000/nftkit/nft/accessControl/chain/POLYGON/contract/0xDc22fE8b277c03B5Af231b6a049631a06961F20d/renounceRole" \
-H  "Content-Type: application/json" \
-d '{"role":"METADATA_UPDATER_ROLE","account":"0x8448Ff4b2733b52f62d81ca46d64bD16786299Cd"}'

{
  "role": "string",
  "account": "string"
}

In this tutorial with 5 modules, we will create our first Tezos NFT collection, mint one of the NFTs to our address, learn how to verify ownership + metadata and how to admire the minted token in a web wallet.

Modules

1. Setup - Clone and run the NFT-Kit

2. A new collection - Configurations and Deployment of the NFT Smart Contract

3. First NFT - Minting of the collection NFTs

4. Verification - How to verify NFT ownership + metadata fields

5. Wallet - Viewing the NFT in a web-wallet

Architecture of data NFTs

Unlike typical ERC 721 tokens where a Smart Contract allows the creation of multiple tokens, Smart Contracts of data NFTs allow just one token per contract. Therefore, a Factory Contract serves as creator of a number of custom contracts which may have each one token minted at max. This architecture allowed the custom contracts to have individual rules, which provides a lot of flexibility compared to the traditional architecture.

The following graphic illustrates the Factory Contract, which serves as creator for several custom contracts (need to be registered first) that are bound to a data NFT.

A further notable difference to classical NFTs is that data NFTs don't make use of external storage solutions like IPFS. Data NFTs use on-chain meta-data, which has the advantage that meta-data remains persistent due to the nature of the blockchain. Nevertheless, it comes with the disadvantage that on-chain storage space is limited and costly.

This diagram resume the integration of Tezos ecosystem in our NFT Kit. Tezos is rich ecosystem, theirs is flexibility in the integration of a such ecosystem. You can use our product either using REST APIs our as a library.

In general, there are two types of interactions: reading or writing from the Tezos blockchain.

For the writing operation, you need the smart contract (address or code), private key to sign operation, and an RPC connection. The NFT Kit will take care of the operation signing with the specified private key. Then, send the operation the the specified network(Mainnet or Testnet).

For reading operation, We use a Tezos indexer. We are making queries to TzKT API.

The smart contract is developed using the Archetype high-level programming language. We use FA2 Tezos standard.

The following example shows an OCEAN Data NFT minted by a contract from our own deployed contract factory on MUMBAI.

Visit the wallet

Verify ownership of data NFTs

The goal of the NFT Kit is to provide a simple library and web service for NFT-based access management. Therefore the ownership of NFTs, aligned with OCEAN protocols specifications, must be verified.

The library provides a VerificationService which exposed the method dataNftVerification that takes the following parameter:

• chain: the EVM-compatible chain name or chain ID

• factorycontractAddress: The address of the factory contract

• erc721contractAddress: The address of the custom contract

• account: The account to be verified

• propertyKey: The NFT meta data property key that should exist

• propertyValue: The NFT meta data property value that should exist

Verify data NFT

    val chain= Chain.ROPSTEN
    val factorycontractAddress= "0x13d474cc837549cd8106d6b945cf591a32a84e88"
    val erc721contractAddress= "0x0310aC2748616Ce399Ba83051DdE35126807c4DE"
    val account= "0xf31fc0d18a24c6ae4225a0d4eeb709ac0a18e993"
    val propertyKey= "color"
    val propertyValue="green"
    val verififcationResult= VerificationService.dataNftVerification(chain, factorycontractAddress, erc721contractAddress, account, propertyKey,propertyValue)

Choose your system

Do you want to build using our APIs or add the NFT-Kits functionalities as a direct dependency in a Kotlin/Java application

API

Installation & Running the Project

Make sure you have Docker or a JDK 16 build environment including Gradle installed on your machine

git clone https://github.com/walt-id/waltid-nftkit.git

cd waltid-nftkit/

docker build -t nftkit .

docker run -p 7000:7000 -it nftkit

git clone https://github.com/walt-id/waltid-nftkit.git

cd waltid-nftkit/

gradle clean build

cd build/distributions/
tar xf waltid-nftkit-1.SNAPSHOT.tar
./waltid-nftkit-1.SNAPSHOT/bin/waltid-nftkit

Start Building

NFT | Creation & Management - How to deploy Smart Contracts and mint NFTs

NFT | Ownership Verification - How to verify NFT ownership within a collection and traits

Smart Contract | Extensions - Pause token transfers, minting and burning

Smart Contract | Access Control - Access Control functionalities

Kotlin/Java SDK

Gradle

implementation("id.walt:waltid-nftkit:VERSION")

Maven

  <dependency>
        <groupId>id.walt</groupId>
        <artifactId>waltid-nftkit</artifactId>
        <version>VERSION</version>
   </dependency>

Required Maven repos:

https://maven.walt.id/repository/waltid/

Start Building

NFT | Creation & Management - How to deploy Smart Contracts and mint NFTs

NFT | Ownership Verification - How to verify NFT ownership within a collection and traits

Smart Contract | Extensions - Pause token transfers, minting and burning

Smart Contract | Access Control - Access Control functionalities

NFT ownership verification

You can use this API to verify if an account is the real owner of an NFT existed in Tezos blockchain.

NFT ownership verification within a collection

We use this API to verify that an account has a NFT within a particular collection.

NFT ownership verification with traits

You can use this API to verify if an account is the real owner of an NFT existed in Tezos blockchain with NFT property verification.

Before we can start with configuring our NFT collection, we need to clone and run the NFT-Kits REST API on our machine.

Installation & Running the Project

Make sure you have a JDK 16 build environment including Gradle installed on your machine

Make sure you have a Node.js and the npm installed on your machine.

Now we can visit the REST API at the endpoint displayed in the terminal after running the project. In the next section, we will be configuring our NFT collection and deploy the Smart Contract on Tezos.

Using our wallet, you can fetch and list your NFTs on Tezos blockchain.

Step1: Click on "Connect Tezos wallet" button.

Step 2: Choose an account.

Step 3: You will have the list of your NFTs in the main Tezos chain.

Step 4: You can switch between networks. Choose another network.

Step 5: You will have the list of your NFTs on the selected network.

Step 6: Click on the NFT you want to see their details.

Tezos is an open-source, self-upgradable, energy-efficient and built to last Proof of Stake blockchain protocol for assets and applications, backed by a global community of validators, researchers, and builders. Tezos will drive social, political and economic innovation on a global scale.

Getting Started

Depending on your preference, start exploring with the deep dive or a tutorial.

Deep dive

- See how Tezos was integrated into the NFT-Kit

- How to deploy Smart Contracts and mint NFTs

- How to verify NFT ownership within a collection and traits

- View NFTs via a Web-Wallet

Tutorials

- Deploy a contract, mint, validate and view an NFT in a web wallet

Smart Contracts & Formal Verification

Tezos offers a platform to create smart contracts and build decentralized applications, that cannot be censored or shut-down by third parties. Furthermore, Tezos facilitates formal verification, a technique used to improve security by mathematically proving properties about programs such as smart contracts. This technique, if used properly, can help avoid costly bugs and the contentious debates that follow.

The NFT Kit is designed to make the process of creating, managing and transferring NFTs easy and accessible to anyone.

Our NFT kit implements the NEP-171 standard for NFTs on the NEAR Protocol that provides the core functionalities of creating, transferring and managing ownership of unique digital assets .

One of the main ways we integrate the Near Protocol ecosystem is through the use of the NEAR JavaScript API. This API allows us to interact with the NEAR blockchain and perform a variety of operations such as deploying contracts and minting NFTs. By using the NEAR JavaScript API, we are able to easily and securely interact with the Near Protocol and perform the necessary actions to create and manage NFTs.

Another way we integrate the Near Protocol ecosystem is through the use of the Near Java API. This is a library that allows for interaction with the NEAR Protocol through the use of the RPC API. This means that we are able to query information from the NEAR blockchain and retrieve data such as NFTs metadata. By using the Near Java API, we are able to easily access the data stored on the Near Protocol and use it within our NFT Kit.

All of these functionalities are exposed through a Rest API in our NFT Kit.

NFT standard :

NEP-171 is the standard for creating and managing NFTs on the NEAR blockchain. It specifies the data structure and smart contract interface for NFTs, allowing developers to create and manage NFTs in a consistent and interoperable way.

Rust Language :

The NEAR Pathway utilizes AssemblyScript as the primary programming language for its smart contracts, which are then compiled to WebAssembly (WASM) for execution on the blockchain.

However, NEAR also supports the use of Rust, a language that is particularly well-suited for server applications and has gained popularity for its built-in safety checks and testing infrastructure.

The NEAR team highly recommends the use of Rust for any smart contracts of a financial nature.

Smart contract scaffolding :

which is a framework of how Dapps work

NEAR Protocol is a public Proof-of-Stake (PoS) blockchain that aims to bring DeFi to the masses with low transfer fees and fast transactions. NEAR competes with Avalanche, Solana, Cardano, Algorand, the new version of Ethereum, and other PoS networks.

Getting Started

Depending on your preference, start exploring with the deep dive or a tutorial.

Deep dive

- See how Near was integrated into the NFT-Kit

- How to deploy Smart Contracts and mint NFTs

- How to verify NFT ownership within a collection and traits

- View NFTs via a Web-Wallet

Tutorials

- Learn how to mint an NFT on Near using the REST interface

- Learn how to verify NFT ownership on Near using the REST interface

After minting your first NFT, you can see it using our wallet. It displays NFT details like smart contract address, token id, NFT name, etc. Click to use the test deployment of our wallet.

Click for more details about our wallet

NFTs verification enables multiple use cases. The NFT Kit provides numerous approaches to verify the ownership of the NFTs and that the NFTs have customized properties.

1- You can verify that an account owns a particular NFT.

2- You can verify that an account owns an NFT in a specific collection.

3- You can verify that an account owns a particular NFT with a specific NFT metadata property.

4- You can also verify that an NFT metadata confirms a policy. The policy is implemented using the high-level declarative language called Rego. It is based on open policy agent(OPA).

You need to add new policy:

Then, you can apply the policy to any NFT metadata.

Now, you're able to mint your first NFT. We will use the deployed smart contract in the previous section to mint a new NFT. Every NFT must have metadata. Using the NFT Kit, you have two options to provide the NFT metadata. Either give the metadata URI directly or let the NFT Kit generate the metadata URI based on IPFS. This tutorial will provide the metadata and let the NFT Kit generate the metadata URI.

We also need to provide the token id and the recipient account for the NFT.

The amount parameter must be an empty string because the type of the deployed smart contract is "SINGLE". If you use the "MULTIPLE" smart contract type, you should provide the number of copies of the minted NFT.

The NEAR Protocol provides a JavaScript API, known as near-api-js, that allows developers to interact with the Smart Contract and perform various operations related to Non-Fungible Tokens (NFTs).

near-api-js is a complete library to interact with the NEAR blockchain. You can use it in the browser, or in Node.js runtime.

Using near-api-js, developers can deploy smart contracts , mint new NFTs and transfer ownership of NFTs.

In the NFT kit we are using near-api-js to do interactions with the Near Protocol Blockchain

Create sub-account :

When developing it's a best practice to create a subaccount and deploy the contract to it. This function allows the subaccount creation and transfering Near token from the main account to use them for gas fees and storage.

  async createAccount(createSubAccount: CreateSubAccount) {
    try {
      let rpcUrl;
      let networkId;
      if (createSubAccount.chain === "testnet") {
        rpcUrl = "https://rpc.testnet.near.org";
        networkId = "testnet";
      } else if (createSubAccount.chain === "mainnet") {
        rpcUrl = "https://rpc.mainnet.near.org";
        networkId = "mainnet";
      } else {
        throw new Error("Chain parameter is not defined");
      }
      this.addKeyPairToKeyStore(
        createSubAccount.account_id,
        createSubAccount.chain
      );
      this.connectionConfig = {
        networkId: networkId,
        keyStore: this.myKeyStore, 
        nodeUrl: "https://rpc.testnet.near.org",
        walletUrl: "",
        helperUrl: "",
        explorerUrl: "",
      };
      const near = await nearAPI.connect(this.connectionConfig);
      const account = await near.account(createSubAccount.account_id);
      const publickey = this.keyPair.getPublicKey().toString();
      const PK = publickey.replace("ed25519:", "");
      const amount = new BN(createSubAccount.amount);
      const response = account.createAccount(
        createSubAccount.newAccountId,
        PK,
        amount.mul(new BN("1000000000000000000000000"))
      );
      return JSON.stringify( (await response).transaction.hash );
    } catch (err) {
      console.log(err);
    }
  }

Deploy smart contract with default Metadata :

Every NFT smart contract should be initialized , here we can deploy it with walt.id default metadata.

  async deployContract(contractDeployment: ContractDeployment) {
    this.addKeyPairToKeyStore(
      contractDeployment.account_id,
      contractDeployment.chain
    );
    const near = await nearAPI.connect(this.connectionConfig);
    const account = await near.account(contractDeployment.account_id);
    const response = await account.deployContract(
      fs.readFileSync("near/smart contract/waltid_nftkit.wasm")
    );
    const contract = new Contract(account, contractDeployment.account_id, {
      viewMethods: [],
      changeMethods: ["new_default_meta"],
    });
    const GAS = new BN("100000000000000");
    contract.new_default_meta({
      args: {
        owner_id: contractDeployment.account_id,
      },
      gas: GAS,
    });
    return JSON.stringify((await response).transaction.hash);
  }

Deploy smart contract with custom Metadata :

For more flexibility we offer a custom metadata initialization to the deployed smart contract.

  async deployContractWithCustomMetadata(
    ContractDeploymentWithCustomMetadata: DeployContractWithCustomInit
  ) {
    let rpcUrl;
    let networkId;
    if (ContractDeploymentWithCustomMetadata.chain === "testnet") {
      rpcUrl = "https://rpc.testnet.near.org";
      networkId = "testnet";
    } else if (ContractDeploymentWithCustomMetadata.chain === "mainnet") {
      rpcUrl = "https://rpc.mainnet.near.org";
      networkId = "mainnet";
    } else {
      throw new Error("Chain parameter is not defined");
    }
    this.addKeyPairToKeyStore(
      ContractDeploymentWithCustomMetadata.account_id,
      ContractDeploymentWithCustomMetadata.chain
    );
    this.connectionConfig = {
      networkId: networkId,
      keyStore: this.myKeyStore,
      nodeUrl: rpcUrl,
      walletUrl: "",
      helperUrl: "",
    };
    const near = await nearAPI.connect(this.connectionConfig);
    const account = await near.account(
      ContractDeploymentWithCustomMetadata.account_id
    );

    const response = await account.deployContract(
      fs.readFileSync("near/smart contract/waltid_nftkit.wasm")
    );
    const contract = new Contract(
      account,
      ContractDeploymentWithCustomMetadata.account_id,
      {
        viewMethods: [],
        changeMethods: ["new"],
      }
    );

    const GAS = new BN("100000000000000");
    contract.new({
      args: {
        owner_id: ContractDeploymentWithCustomMetadata.account_id,
        metadata: {
          spec: ContractDeploymentWithCustomMetadata.spec,
          name: ContractDeploymentWithCustomMetadata.name,
          symbol: ContractDeploymentWithCustomMetadata.symbol,
          icon: ContractDeploymentWithCustomMetadata.icon,
          base_uri: ContractDeploymentWithCustomMetadata.base_uri,
          reference: ContractDeploymentWithCustomMetadata.reference,
          reference_hash: ContractDeploymentWithCustomMetadata.reference_hash,
        },
      },
      gas: GAS,
    });
    return JSON.stringify((await response).transaction.hash);
  }

Mint NFT :

Finally we mint the non-fungible token with the custom metadata .

  async mintToken(nftmint: NftMint) {
    let rpcUrl;
    let networkId;
    if (nftmint.chain === "testnet") {
      rpcUrl = "https://rpc.testnet.near.org";
      networkId = "testnet";
    } else if (nftmint.chain === "mainnet") {
      rpcUrl = "https://rpc.mainnet.near.org";
      networkId = "mainnet";
    } else {
      throw new Error("Chain parameter is not defined");
    }
    this.addKeyPairToKeyStore(
      nftmint.account_id,
      nftmint.chain
    );
    this.connectionConfig = {
      networkId: networkId,
      keyStore: this.myKeyStore, 
      nodeUrl: rpcUrl,
      walletUrl: "",
      helperUrl: "",
    };
    const near = await nearAPI.connect(this.connectionConfig);
    const account = await near.account(nftmint.account_id);
    const GAS = new BN("100000000000000");
    const Amount_deposited = new BN("100000000000000000000000");
    const functionCallResponse = await account.functionCall({
      contractId: nftmint.contract_id,
      methodName: "nft_mint",
      args: {
              token_id: nftmint.token_id,
              metadata: {
                title: nftmint.title,
                description: nftmint.description,
                media: nftmint.media,
                media_hash: null,
              },
              receiver_id: nftmint.receiver_id,
            },
      gas: GAS,
      attachedDeposit: Amount_deposited,
    });
    return JSON.stringify(functionCallResponse.transaction.hash);
  }