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

NFT operations :

One of the main ways we integrate the Algorand ecosystem is through the use of the Java-Algosdk for account creation , NFT minting and other functionalities.

By using the AlgoSDK, we are able to easily and securely interact with Algorand Blockchain and perform the necessary actions to create and manage NFTs.

NFT Queries :

This module enables querying data from the Algorand Network using Pure Stake APIs. PureStake provides highly reliable and secure access to native Algorand REST APIs for Main, Test and Beta-Net, hence we can retrieve data such as NFTs metadata from Algorand.

Overview

The Algorand protocol enables the creation of on-chain assets that enjoy the same level of security, compatibility, speed, and user-friendliness as the Algo cryptocurrency. These assets are officially known as Algorand Standard Assets (ASA). ASA allows for the representation of various assets, including stablecoins, loyalty points, system credits, in-game points, and more. It also enables the representation of unique assets such as property deeds, collectible items, specific components in a supply chain, and others.

How to create NFTs on Algorand ?

Algorand Standard Assets (ASAs) are utilized to create Non-Fungible Tokens (NFTs) within the Algorand blockchain. ASAs are integrated into the protocol itself and can be generated through a specific type of transaction, distinguishing it from other blockchains that require smart contracts for asset representation. To create an NFT, only a few parameters need to be specified to designate it as such and establish a link to the metadata. This metadata provides potential owners with the necessary information to verify the asset's integrity. For example, setting the total amount of units to 1 and the number of decimals to 0 ensures the creation of a single, indivisible unit of the ASA. For proper formatting of NFT properties, the Algorand community adheres to the standards outlined in the Algorand Request for Comments. The creation transaction for such an asset can be implemented using any of Algorand's SDKs, in our case we will be using the java sdk.

Algorand Standard Asset for Non-Fungible Tokens

ARC-3 is the official Algorand Standard Asset Parameters Conventions for Fungible and Non-Fungible Tokens. It provides a standard for specifying ASA metadata, including asset name, unit name, and other properties. ARC-3 is more general and can be applied to both fungible and non-fungible tokens.

ASA Parameters Conventions (arc3) :

1. Asset Name: The asset name is either arc3 or suffixed by @arc3. This allows client software to know when an asset follows the ARC-3 conventions.

2. JSON Metadata File Schema: ARC-3 introduces a JSON Metadata File Schema that allows indicating the MIME type of the files pointed by any URI field. This helps clients to display the resource appropriately without having to first query it to find out the MIME type.

3. Asset Integrity: A digest of the JSON Metadata file is included in the ASA parameters to ensure the integrity of this file. This is important to ensure the integrity of the JSON file when IPFS is not used.

4. MIME Type Fields: MIME type fields are added to help clients know how to display the files pointed by URI.

5. Relative URI Support: Support for relative URI is added to allow storing both the JSON Metadata files and the files it refers to in the same IPFS directory.

6. Asset Configuration: Asset Name and Asset Unit can be optionally specified in the ASA parameters. This allows wallets that are not aware of ARC-3 or that are not able to retrieve the JSON file to still display meaningful information.

ARC-69 is an unofficial Algorand Standard Asset Parameters Convention popular in the Algorand NFT community. It is inspired by Open Sea's metadata standards and EIP-1155. ARC-69 focuses on optimization for fetching digital media and the use of on-chain metadata. It also allows for mutable or immutable metadata, depending on the use case.

ASA Parameters Conventions (arc69) :

1. Asset Name, Unit Name, and URL: These are specified in the ASA parameters. This allows applications to efficiently display meaningful information, even if they aren't aware of ARC-69 metadata.

2. MIME types: These help clients more effectively fetch and render media.

3. Metadata: All asset metadata is stored on-chain. Metadata can be either mutable or immutable. If an ASA has a manager address, then the manager may update an ASA's ARC-69 metadata by sending a new acfg transaction with the entire metadata represented as JSON in the transaction's note field.

NFTs on Algorand are created using the Algorand Standard Assets (ASAs), which are part of the core protocol and created using a special type of transaction. This makes Algorand different to other chains where smart contracts are needed for the creation of an NFT. You can learn more about it here.

ARC Standards we support:

• ARC-003 Standard

NFT creation based on ARC3

curl -X POST "http://0.0.0.0:7000/v2/nftkit/nft/Algorand/chain/{chain}/asset/create/{assetName}/{assetUnitName}/{url}" 
-H  "accept: application/json" -d ""

{
  "name": "string",
  "description": "string",
  "image": "string",
  "decimals": 0,
  "unitName": "string",
  "image_integrity": "string",
  "image_mimetype": "string",
  "properties": {
    "additionalProp1": "string",
    "additionalProp2": "string",
    "additionalProp3": "string"
  }
}

curl -X POST "https://nftkit.walt-test.cloud/v2/nftkit/nft/Algorand/chain/ALGORAND_TESTNET/asset/create" 
-H  "accept: application/json" 
-H  "Content-Type: application/json" 
-d "{\"name\":\"waltid\",\"description\":\"nft of waltid\",\"image\":\"ipfs://bafkreihph3lc43efz44d5hgukfbdxib4bdkwp4lrdg3pdrtw57nh4nkbwy\",\"decimals\":0,\"unitName\":\"waltid\",\"image_integrity\":\"string\",\"image_mimetype\":\"image/png\",\"properties\":{\"color\":\"blue\"}}"

{
  "txId": "string",
  "explorerUrl": "string"
}

import id.walt.nftkit.services.AlgorandChain
import id.walt.nftkit.services.AlgorandNftService

val result = AlgorandNftService.createAssetArc3(
        AlgorandChain.ALGORAND_TESTNET,
        "testAsset",
        "test",
        "ipfs://bafkreidsvna6qass5ntkgfa7xp6x3u53oee2wao2vjt26s6upqngsntpc4",
        "testAsset",
        0,
        mapOf("cap" to "red")
    )

Algorand utilizes a consensus algorithm called Pure Proof-of-Stake (PPoS), which ensures security and scalability while eliminating energy-intensive mining. The platform can handle high transaction throughput with low latency, processing thousands of transactions per second.

Getting Started

- See how Algorand was integrated into the NFT-Kit

- How to create NFTs using the Algorand Standard Assets (ASAs)

- How to verify NFT ownership

Ways to query information about Assets:

• - Get a list of assets (e.g. NFTs) of provided account

• - Get all information available for an Asset (e.g. NFT)

• - Query the NFT metadata

Standalone accounts have a low setup cost as you do not need to connect to a separate client that depends on separate hardware. All you need is the 25-word human-readable mnemonic of the relevant account.

Create an Algorand Account

You can later import the created account to any wallet supporting Algorand using the mnemonic phrase.

Using our , you can fetch and list your NFTs on the Flow blockchain.

Installation :

1 - Download waltid web wallet :

2 - Build Setup :

Using our , you can fetch and list your NFTs on the Algorand chains.

Usage :

Step1: Click on "Connect Algorand 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

To create NFTs on Algorand you need to:

1. Create an Account.

2. Upload image to IPFS and create the NFT.

NFT ownership verification:

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

curl -X GET "https://0.0.0.0:7000/v2/nftkit/nft/verifier/algorand/chain/{chain}/verifyNftOwnership" 
-H  "accept: application/json"

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/verifier/algorand/chain/ALGORAND_TESTNET/verifyNftOwnership?assetId=257177857&account=GYFVJLKGSWQDHFBHBLABUXYHHSU544RV3WH4ZCF3S6HONSDP73TK4VGY3Y" 
-H  "accept: application/json"

import id.walt.nftkit.services.AlgorandNftService
import id.walt.nftkit.services.AlgorandChain


val assetId = "257177850"
val address = "GYFVJLKGSWQDHFBHBLABUXYHHSU544RV3WH4ZCF3S6HONSDP73TK4VGY3Y"
val result = AlgorandNftService.verifyOwnership(address , assetId, AlgorandChain.TESTNET)
println(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 Algorand blockchain with NFT property verification.

curl -X GET "https://0.0.0.0:7000/v2/nftkit/nft/verifier/algorand/chain/{chain}/verifyAlgorandNftOwnershipWithTraits" 
-H  "accept: application/json"

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/verifier/algorand/chain/ALGORAND_TESTNET/verifyNftOwnershipWithTraits?assetId=257177850&account=GYFVJLKGSWQDHFBHBLABUXYHHSU544RV3WH4ZCF3S6HONSDP73TK4VGY3Y&trait=size&value=9814" 
-H  "accept: application/json"

import id.walt.nftkit.services.AlgorandNftService
import id.walt.nftkit.services.AlgorandChain


val assetId = "257177850"
val address = "GYFVJLKGSWQDHFBHBLABUXYHHSU544RV3WH4ZCF3S6HONSDP73TK4VGY3Y"

val traitType = "cap"
val traitValue = "red"
    
val result = AlgorandNftService.verifyOwnerShipWithTraits(address , assetId, AlgorandChain.TESTNET , traitType, traitValue)
println(result)

NFT ownership verification Based on Creator Address :

This Endpoint will verify if a given account has an NFT minted from a particular account .

curl -X GET "https://0.0.0.0:7000/v2/nftkit/nft/verifier/algorand/chain/{chain}/{address}/verifyNftOwnershipBasedOnCreator/{creatorAddress}"
-H  "accept: application/json"

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/verifier/algorand/chain/ALGORAND_TESTNET/PVY6K7CB4JDRSOSPM7HZPTAOVDMVGHPF7TN6O5CBMD7UEDJWHOCRWI2OU4/verifyNftOwnershipBasedOnCreator/GYFVJLKGSWQDHFBHBLABUXYHHSU544RV3WH4ZCF3S6HONSDP73TK4VGY3Y" 
-H  "accept: application/json"

NFT Metadata verification Against Dynamic Policy :

curl -X GET "https://0.0.0.0:7000/v2/nftkit/nft/verifier/algorand/chain/{chain}/token/{token id}/policy/{policyName}/verification"
-H  "accept: application/json"

curl -X GET "http://0.0.0.0:7000/v2/nftkit/nft/verifier/algorand/chain/ALGORAND_TESTNET/token/287718643/policy/policy%20algorand/verification"
-H  "accept: application/json"

{
  "name": "policy algorand",
  "description": "policy 1",
  "input": {
    "name": "waltid",
    "description" : "waltid nft on algorand#2"
         
  },
  "policy": "package app.nft

import future.keywords.if

default allow := false


allow if {
	valid_nft_name
	valid_nft_description
}


valid_nft_name if input.name= data.name
valid_nft_description if input.description= data.description



",
  "policyQuery": "data.app.nft.allow",
  "policyEngine": "OPA"
}