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.

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

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

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

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

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.

This section elaborates the theory behind the NFT Kit:

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.

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:

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

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

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

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.

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

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

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.

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:

NFT ownership verification

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

NFT ownership verification with traits

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

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

Start Building

Kotlin/Java SDK

Gradle

Maven

Required Maven repos:

Start Building

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"
      }
    ]
  }

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

Getting Started

Deep dive

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

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

Tutorials

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.

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:

NFT Contract Deployment | ERC-721

Soulbound Token Contract Deployment | ERC-721 with extension

curl -X POST http://0.0.0.0:7000/nftkit/nft/chain/MUMBAI/contract/deploy \
-H  "Content-Type: application/json" \
-d '{"name":"Ticket","symbol":"TK","tokenStandard":"ERC721","accessControl":"OWNABLE","options":{"transferable":false,"burnable":true}}'

{
  "name": "string",
  "symbol": "string",
  "tokenStandard": "ERC721",
  "accessControl": "OWNABLE|ROLE_BASED_ACCESS_CONTROL",
  "options": {
    "transferable": false,
    "burnable": true
  }
}

val deploymentOptions = DeploymentOptions(AccessControl.OWNABLE, TokenStandard.ERC721)
val deploymentParameter = DeploymentParameter("Metaverse", "MTV",DeploymentParameter.Options(false, true))
val result = NftService.deploySmartContractToken(Chain.POLYGON, deploymentParameter, deploymentOptions)

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.

curl -X POST "http://0.0.0.0:7000/nftkit/nft/chain/MUMBAI/contract/0xf277be034881ee38a9b270e5b6c5c6f333af2517/token/mint" \
-H  "Content-Type: application/json" \
-d '{"metadataUri":"","metadata":{"description":"Ticket #1 Description","name":"Ticket #1","image":"ipfs://bafkreibpc3wpdg4mq3bbkesqrxtoho25s3shnfhyotd6rymsag3bcfpeni","attributes":[{"trait_type":"Trait 1","value":"Value 1"}]},"recipientAddress":"0x2555e3a97c4ac9705D70b9e5B9b6cc6Fe2977A74","metadataStorageType":"ON_CHAIN"}'

{
  "metadataUri": "string",
  "metadata": {
    "description": "string",
    "name": "string",
    "image": "string",
    "image_data": "string",
    "external_url": "string",
    "attributes": [
      {
        "trait_type": "string",
        "value": "string"
      }
    ]
  },
  "recipientAddress": "string",
  "metadataStorageType": "ON_CHAIN|OFF_CHAIN"
}

val attribute1 : NftMetadata.Attributes = NftMetadata.Attributes(trait_type = "trait_type1", value = JsonPrimitive("value1"))
val attribute2 : NftMetadata.Attributes = NftMetadata.Attributes(trait_type = "trait_type2", value = JsonPrimitive("value1"))
val attributes = mutableListOf(attribute1, attribute2)
val nftMetadata : NftMetadata = NftMetadata(name = "name", description = "description", image = "", attributes = attributes)
val mintingParameter = MintingParameter("", "0xaf87c5Ce7a1fb6BD5aaDB6dd9C0b8EF51EF1BC31",nftMetadata)
val mintingOptions = MintingOptions(MetadataStorageType.ON_CHAIN)
val result = NftService.mintToken(Chain.POLYGON,"0xFd9426f82Ae1edBC6b5eC2B0Ea5416D34Ca6E9b6", mintingParameter, mintingOptions)

Revoke NFT

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

curl -X GET "http://0.0.0.0:7000/nftkit/nft/chain/SHIMMEREVM/contract/0x3A4D948a123824Fc34FDDA0654D3C8D0D29c2FA9/token/1/revokeToken"

val result = NftService.revokeToken(Chain.SHIMMEREVM, "0xFd9426f82Ae1edBC6b5eC2B0Ea5416D34Ca6E9b6", BigInteger.valueOf(26))

NFT metadata

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

Fetch NFT metadata URI

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

val result = NftService.getNftMetadataUri(Chain.POLYGON, "0xFd9426f82Ae1edBC6b5eC2B0Ea5416D34Ca6E9b6", BigInteger.valueOf(26))

Fetch NFT metadata

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

val result = NftService.getNftMetadata(Chain.POLYGON, "0xFd9426f82Ae1edBC6b5eC2B0Ea5416D34Ca6E9b6", BigInteger.valueOf(26))

Update NFTs metadata trait

curl -X POST "http://0.0.0.0:7000/nftkit/nft/chain/ETHEREUM/contract/0xf277BE034881eE38A9b270E5b6C5c6f333Af2517/token/1/metadata" \
-H  "Content-Type: application/json" \
-d '{"key":"key1","value":"value1"}'

{
  "key": "string",
  "value": "string"
}

Get Account balance

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

Get Token owner

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

Get collection info

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

Get NFTs by account

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

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

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

1. Ownership

2. Role-Based Access Control

Ownership

Get smart contract owner.

Transfer ownership of the contract to a new account.

Renounce ownership of the smart contract.

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

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

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

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

Renounce role from the calling account.

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

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.

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:

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.

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.

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.

Fetch NFT metadata

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

Get account NFTs

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

Get contract metadata

This API allows fetching contract metadata.

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

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

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

use near_sdk::{near_bindgen,
borsh::{self, BorshDeserialize, BorshSerialize}
};
near_sdk::setup_alloc!();
#[near_bindgen]
#[derive(BorshDeserialize, BorshDeserialize)]
pub struct Contract {}
#[near_bindgen]
impl Contract {}

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.

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.

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/verifier/chain/{{chain}}/contract/{{contract}}/verifyNftOwnershipWithinCollection?account={{account}}" 
-H  "accept: application/json"

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/verifier/chain/GHOSTNET/contract/KT1RCzrLhBpdKXkyasKGpDTCcdbBTipUk77x/verifyNftOwnershipWithinCollection?account=tz1fXH6Tt2Qgvp7pjVpyNcZmunEbgRaHKcoQ" 
-H  "accept: application/json"

 val chain= Chain.GHOSTNET
 val smartContractAddress= "KT1Ennr99qgqzKEUCEqypXEexH4wWzVL5a9m"
 val account= "tz1LeScZyZqmg8ZXYoN3mE8vA9GFrPm4HXkx"
 val result = VerificationService.verifyNftOwnershipWithinCollection(chain, smartContractAddress, account!!)
 println("Result: ${result}")

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.

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/verifier/chain/{{chain}}/contract/{{contract}}/verifyNftOwnershipWithTraits?account={{account}}&tokenId={{tokenId}}&traitType={{traitType}}&traitValue={{traitValue}}"
-H  "accept: application/json"

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/verifier/chain/TEZOS/contract/KT1RCzrLhBpdKXkyasKGpDTCcdbBTipUk77x/verifyNftOwnershipWithTraits?account=tz1fXH6Tt2Qgvp7pjVpyNcZmunEbgRaHKcoQ&tokenId=0&traitType=trait&traitValue=value"
-H  "accept: application/json"

val chain= Chain.GHOSTNET
val smartContractAddress= "KT1Ennr99qgqzKEUCEqypXEexH4wWzVL5a9m"
val account= "tz1LeScZyZqmg8ZXYoN3mE8vA9GFrPm4HXkx"
val tokenId= "0"
val traitType = "Backgrounds"
val traitValue = "Green"
val result = VerificationService.verifyNftOwnershipWithTraits(chain, smartContractAddress, account, tokenId, traitType,traitValue)
println("Result: ${result}")

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.

Before we can mint an NFT, we need to define the collection, of which the NFT will be a part, via the deployment of a smart contract. Thanks to the REST-API from the NFT-Kit, we can easily deploy a contract based on the FA2 unified token standard from Tezos with the multiple implementation (equal to ERC-721 or ERC-1155on Ethereum). Which is one of the standards for creating NFTs.

Deploying the Contract

Before you mint a new NFT, you need to have an already deployed smart contract or deploy a new one. For this tutorial, we will deploy a new smart contract.

We will deploy the smart contract on the Tezos testnet "GHOSTNET". We need to provide the owner and the type of smart contract(our NFT Kit supports two smart contract implementations: you can click here for more details).

Response:

{
  "contractAddress": "KT1TPCdHiLQudhH79Zv7e5Ah46YYGQAA4t8o",
  "contractExternalUrl": "https://better-call.dev/ghostnet/KT1TPCdHiLQudhH79Zv7e5Ah46YYGQAA4t8o"
}

After that, you must define who can mint new tokens within an already deployed smart contract. In our case, we take the previously deployed contract.

The "minteraddress" is the account that will sign the mint transaction.

Response:

{
  "operationExternalUrl": "https://better-call.dev/ghostnet/opg/ooRwreh2VAkbK2C3REws1WLsJ1DcSWSZZMvKSrRjzcFji4f3BKL",
  "operationHash": "ooRwreh2VAkbK2C3REws1WLsJ1DcSWSZZMvKSrRjzcFji4f3BKL"
}

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.

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.

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

Tutorials

Named accounts can create sub-accounts of themselves, helping to better organize related-accounts. In this way, named accounts work as domains, particularly:

2. Anyone can create long top-level accounts, e.g. verylongaccountnamethatis32chars.

3. near can create bob.near, and bob.near can create app.bob.near.

4. near cannot create app.bob.near, and test.near cannot create sub.example.near.

Create a Near Sub-Account for NFT smart contract

To acquire information from the Near Blockchain, we have incorporated the near-java-api into our NFTKit. This allows us to effectively interact with the rpc-api, providing us with the ability to retrieve and process data from the blockchain in a efficient and streamlined manner.

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.

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.

Deploy smart contract with default Metadata :

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

Deploy smart contract with custom Metadata :

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

Mint NFT :

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

On Near Protocol , NFTs are not stored in the user's wallet, instead, each NFT lives in a NFT contract. The NFT contract works as a bookkeeper, this is: it is in charge of handling the creation, storage and transfers of NFTs.

Smart contract deployment with default metadata

Smart contract deployment with custom metadata

Mint NFT

curl -X POST "http://0.0.0.0:7000/v2/nftkit/nft/near/chain/{chain}/contract/{contract_id}/mint"
-H  "Content-Type: application/json"
-d  "{"account_id": "string","token_id": "string","title": "string","description": "string","media": "string","media_hash": "string","reference": "string","reference_hash": "string","receiver_id": "string"}"

{
  "account_id": "string",
  "token_id": "string",
  "title": "string",
  "description": "string",
  "media": "string",
  "media_hash": "string",
  "reference": "string",
  "reference_hash": "string",
  "receiver_id": "string"
}

curl -X POST "http://0.0.0.0:7000/v2/nftkit/nft/near/chain/testnet/contract/nft.waltid.testnet/mint"
-H  "Content-Type: application/json"
-d  "{"account_id": "waltid.testnet","token_id": "0","title": "Walt.id NFT Art","description": "Waltid NFT Kit Example","media": "https://avatars.githubusercontent.com/u/84637756","media_hash": "","reference": "","reference_hash": "","receiver_id": "nft.waltid.testnet"}"

val accountId = "waltid.testnet"
val contractId =  "nft.waltid.testnet"
val receiverId = "waltid.testnet"
val chain = "testnet"


val result = NearNftService.mintNftToken(
        account_id = accountId,
        contract_id = contractId,
        token_id = "1",
        title = "waltid",
        description = "My NFT",
        media = "https://waltid.net",
        media_hash = "",
        reference = "",
        reference_hash = "",
        receiver_id = receiverId,
        chain = chain,
        
    )
println("operation result: $result")

This API allows fetching contract metadata.

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/near/chain/{chain}/contract/{contract_id}/NFT/metadata"
-H "Content-Type: application/json" 

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/near/chain/testnet/contract/nft.waltid.testnet/NFT/metadata"
-H "Content-Type: application/json" 

val contractId = "demo.khaled_lightency1.testnet"
val chain = "testnet"
val result = NearNftService.getNftNearMetadata(contractId , chain)
println("operation result: $result")

NFT ownership verification

With this API , you can verify the ownership of All The NFTs for a given account.

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/near/chain/{chain}/contract/{contract_id}/account/{account_id}/NFTS"
-H  "Content-Type: application/json" 

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/near/chain/testnet/contract/nft.waltid.testnet/account/waltid.testnet/NFTS"
-H  "Content-Type: application/json" 

val accountId = "waltid.testnet"
val contractId = "nft.waltid.testnet"
val chain = "testnet"
    
val result = NearNftService.getNFTforAccount(accountId , contractId, chain)
println("operation result: $result")

NFT ownership verification

With this API , you can verify the ownership of a specific NFT by its unique Token_id.

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/near/chain/{chain}/contract/{contract_id}/NFT/{token_id}"
-H  "Content-Type: application/json" 

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/near/chain/testnet/contract/nft.waltid.testnet/NFT/0"
-H  "Content-Type: application/json" 

val contractId = "nft.waltid.testnet"
val tokenId = "0"
val chain = "testnet"
    
val result = NearNftService.getTokenById(contractId, tokenId, chain)
println("operation result: $result")

Installation :

1 - Download waltid web wallet :

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

2 - Build Setup :

# install dependencies
$ yarn install

# serve with hot reload at localhost:3000
$ yarn dev

# build for production and launch server
$ yarn build
$ yarn start

# generate static project
$ yarn generate

Usage :

Step1: Click on "Connect with web3" button.

Step 2: Click on "Near"

Step 3: Choose your wallet.

Step 4: Choose an account.

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

Step 6 : Click on "View" to see more details.

Deploying the Contract

Before you mint a new NFT, you need to have an already deployed smart contract or deploy a new one. For this tutorial, we will deploy a new smart contract.

We will deploy the smart contract on the Near testnet. We need to provide the owner and the metadata of smart contract.

Example 1 : Default Contract metadata

Example 2 : Custom Contract metadata

Click on “Get Started”

Step 2: Choose a Security Method

To protect your account, you’ll have to select an option to secure your NEAR wallet.

Choose from the three security methods mentioned to start your wallet initialization — Secure Passphrase / Ledger Hardware Wallet / Email

Step 3: Fund Your NEAR Wallet

What are NFTs?

NFTs (Non-Fungible Tokens) are a type of digital asset that are stored on a blockchain network and represent unique items or pieces of content. NFTs are typically used to represent things like artwork, music, videos, or other types of creative works, as they allow creators to verify and authenticate the ownership and provenance of their creations.

On the Near Protocol, NFTs are created and managed through smart contracts that are stored on the blockchain. These contracts define the rules and logic for how the NFTs are created, transferred, and managed.

To create an NFT on the Near Protocol, you would first need to create a smart contract that defines the NFT's properties and behaviors. This contract would typically include things like the NFT's name, description, image, and any other relevant metadata.

Once the NFT contract is deployed to the blockchain, you can then use it to mint new NFTs. To mint an NFT, you would typically need to provide some sort of payment, such as Near tokens, in exchange for the new NFT.

Once the NFT is minted, it can be transferred and traded just like any other asset on the blockchain. The unique properties of NFTs, such as their provenance and authenticity, make them particularly valuable for creators and collectors of digital content.

Start with our Tutorials

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 Near Protocol blockchain

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. We also need to provide the token id and the recipient account for the NFT.

Create a sub-account

Sub accounts on near help with the organisation of your project , it separates the smart contract address from your main account.

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

Fetching Token id & Collection id

With this API , you can return the list of token ids and collection ids for a given account

Fetching NFT metadata

With this API , you can return the list of NFTs on unique network.

The NFT Kit is responsible for fetching NFTs and their details from Polkadot. We have three main components:

1. REST APIs/Library: you can access the functionalities provided by the NFT Kit through two interfaces: as a library or through REST APIs.

2. NFTs operation: within this component, we will have a list of NFTs operations like fetching NFT metadata, a list of NFTs, verify NFT ownership/metadata against policies.

3. NFTs queries: this component generates a query and routes it to the specific ecosystem based on the demand of the NFTs operation component.

Different approaches to managing NFTs in the Polkadot ecosystem include PSP-34, PSP-37, RMRK, Uniques, etc. The NFT Kit provides an abstract layer for operations with any NFTs approach within the Polkadot ecosystem. With the NFT Kit, the NFTs ecosystem in Polkadot will be more accessible to developers to build more advanced use cases.

RMRK 2.0

• RMRK is a set of NFT standards which compose several "NFT 2.0 lego" primitives. Putting these legos together allows a user to create NFT systems of arbitrary complexity.

• Our solution will be integrated with Kusama canary network Implementation (Remarks).

Uniques

• Unique Network is the next generation NFT chain for advanced use cases and mass adoption.

• Unique provides REST APIs to query NFTs details in the Unique Network.

• Unique has three networks:

1. Unique is a Polkadot parachain.

2. Quartz is a Kusama parachain.

3. Opal is a testnet.

Astar

• Astar Network supports the building of dApps with EVM and WASM smart contracts and offers developers true interoperability.

• Astar supports EVM smart contracts.

• It enables Wasm smart-contract using The pallet-contracts. The pallet-contracts is a sandbox environment to deploy and execute WebAssembly smart contracts. Any language that compiles to Wasm can be used. But the code should be compatible with the pallet-contracts API.

• The Polkadot ecosystem provides two standard interfaces for Non-Fungible Token: PSP-34(Non-Fungible Token (ERC721 equivalent) with extensions) and PSP37( ERC1155 equivalent with extensions). The goal is to have a standard contract interface that allows tokens deployed on Substrate's contracts pallet.

Tools

• Blockscout: BlockScout provides a comprehensive, easy-to-use interface for users to view, confirm, and inspect transactions on EVM blockchains

• Subscan API: it provides a simple way to access the chain data of more than 10 substrate-based networks.

• Unique REST APIs

• Subsquid: A squid is a project that extracts and transforms on-chain data in order to present it as a GraphQL API.

• Polkaholic API: It gives you powerful access to over 50+ networks in Polkadot and Kusama ecosystems.

• Substrate API Sidecar: REST service that makes it easy to interact with blockchain nodes built using Substrate's FRAME framework.

NFT ownership verification

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

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 Polkadot blockchain with NFT property verification.

Usage :

Step1: Click on "Connect Polkadot (EVM)" button.

Step 2: Allow connection to the application.

Step 3 : You will have the list of NFTs on the selected Network.

Usage :

Step1: Click on "Connect Polkadot wallet" button:

Step 2: Allow connection to the application.

Step 3 : You will have the list of NFTs on the selected Network.

Step 4 : You can display NFT details .