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

Smart Contract

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 .

Creation | Management Controller

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.

Querying NFT information controller

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.

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

Architecture - See how Near was integrated into the NFT-Kit

NFT | Minting - How to deploy Smart Contracts and mint NFTs

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

NFT | Wallet - View NFTs via a Web-Wallet

Tutorials

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

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

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.

• Verify all NFTs of a given account.

• Get NFT contract Metadata.

• Get NFT by Token Id.

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 {}

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 .

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

1. Only can create short top-level accounts (e.g. near, aurora).

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

NFT ownership verification

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

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.

In order for a contract to be considered a NFT-contract it has to follow the . The NEP-171 & NEP-177 standards explain the minimum interface required to be implemented, as well as the expected functionality.

Smart contract deployment with default metadata

Smart contract deployment with custom metadata

Mint NFT

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

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

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

Using our , you can fetch and list your NFTs on Near Protocol blockchain.

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.

Step 1: Go to testnet.mynearwallet.com and “Create Account”

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

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.

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

cd waltid-nftkit/js

npm install

npm start

gradle clean build

cd build/distributions/
tar xf waltid-nftkit-1.0.0.tar 
./waltid-nftkit-1.0.0/bin/waltid-nftki

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

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.

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.

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

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: