Links
🖼

CallistoNFT Standard

Intro

This article describes a new Non-Fungible Token standard developed by @Dexaran , the author of the existing ERC223 standard. The token standard is suitable for EthereumVM-compatible platforms.
The reference implementation is written in Solidity as an open-source software.
Source codes can be found here: https://github.com/Dexaran/Advanced-NFT/blob/main/NFT.sol​

Welcome The New NFT Standard

​NFTs are the new buzzword in the crypto industry during the last years. However, the concept of NFTs is not new at all. Our current NFTs were introduced in 2017 as Ethereum Improvement Proposal #721 (which defined the currently existing standard — ERC721).
This was the first implementation of such a token. It often happens that with “first-of-a-kind” things, it is impossible to take into account all possible features and eliminate the not-yet-discovered shortcomings. As the result, the ERC721 standard has flaws and lacks some important features.
I have always said that in programming it is much better to rely on ready-made solutions than to develop something from scratch. However, in this case, an exception must be made for security reasons — which is why I took on the development of a new standard exactly as it happened in 2016 with my ERC223 standard.

CallistoNFT vs ERC721

NOTE: ERC number is assigned when a developer submits his/her proposal to Ethereum Improvement Proposals repository. This is not yet done and the newly developed standard will be referenced as “CallistoNFT” in this article. This is to be replaced with ERC number as soon as the standard is finalised and proposed to Ethereum community
The main advantages of CallistoNFT over the existing ERC721 are:
  • Built-in “trades” — there is no need to rely on third-party marketplaces for NFTs now, you can express your willingness to sell/buy a specific NFT right through the token contract!
  • Monetization for NFT creators, not third-party marketplaces — NFT developers/creators can now earn a % fee on these built-in trades instead of the marketplaces that traditionally did this.
  • Communication model for smart contracts — “events” are very standard practice in programming and the key feature for programm-to-programm communication models. However, ERC721 lacks this feature. New standard addresses this to open up wider automatization opportunities.
  • Standardized properties — NFTs typically represent some unique objects and store their properties (for example bitmap for a picture or website link). These unique properties are implementaiton-specific in ERC721. CallistoNFT makes a step towards standardizing these features.
Let me describe it in more detail below.

1. Built-in “Trades”

The main property of NFTs is their uniqueness. As the result each NFT is trackable and a user may want to find an NFT on-chain.
A user may want to buy one particular NFT!
CallistoNFT standardizes the possibility to offer funds in exchange for NFT. At the same time, it also allows the owner of an NFT to set its “price”. If the proposed price will meet the bid then the token will be auto-sold at this exact moment and both parties will receive what they wanted.
The advantage of this approach is that it eliminates the issue of trust completely — users don’t need to worry about 3d party exchanges getting hacked while they hold their tokens there.
At the same time, the scalability and “reach” of this method is tremendous compared to traditional marketplaces. What if you found a cool NFT on-chain and you wanted to offer a million dollars for it but it was sitting on someone’s balance and you didn’t know who owns it? What if the NFT you want is not on the exchange you want to trade at? What if there are multiple exchanges but one particular NFT can only sit in order at one of them? — All of these issues are addressed with thorugh-the-token-contract trades.
And the most important thing about built-in trades — bids are not removed when the NFT is transferred. This means that it does not matter if the NFT was sold or changed its owner in another way — you can still offer your bid for it.

2. Monetization for NFT creators

Since the NFTs are now tradeable through the token contract itself we also allow developers to collect fees as exchanges are doing it. This simplifies monetization — if a developer creates a successful NFT then he doesn’t need to worry about how to get paid from it. Once it is getting adopted, used, and traded the developer receives lifetime revenue from it.
The system is flexible and layered — it is possible to remove the fee, make it fixed or adjustable.
A Layered NFT system allows to set up different amounts of fees for different types of NFTs or even introduce the “evolution model” of NFTs where some outer events determine the fee level of an NFT. For example, “old” NFTs can get a discount for built-in trade fees once 2 years passed since the moment of NFT issuing.

3. Communication model for smart-contracts

A lot has been said about the critical problems of ERC20 standard https://dexaran820.medium.com/erc20-token-standard-critical-problems-3c10fd48657b​
ERC721 inherits the same problems as it does not implement any communication model.
Have you ever thought about how two programs understand each other? You can take a phone and write a message to your friend on telegram. Then your friend can read it.
This is because of the communication model (request-response) your client and telegram server implement — when you write a message your software tells the telegram server “hey, I did something to <friend>”. Then the server tells his telegram client “hey, here is a message for you — look” and updates his message history.
ERC20 token works like a silent server however. When you send a transaction it gets your message “hey, I did something to <address>” and silently updates the address’es balance. It does not tell it what happened. As the result, if the receiver’s address is not supposed to receive tokens (for example receiver is a system contract that is not intended for storing tokens and transaction was sent by mistake) then it can not reject it neither it can return them back.
CallistoNFT addresses this issue.

4. Standardized properties

Most NFTs keep unique properties of what they represent in addition to their unique ID. These can be “stats” of a card for card game NFT, a link to an external website, or any other data.
However, the format of this data is not defined by the ERC721 standard. The functions that get this data from the contract are not defined either which makes it harder to build a general-purpose software (wallets, blockchain explorers) that would get this info from token contracts.
CallistoNFT makes a step towards standardizing the format of storing unique properties of NFTs in the contract as well as returning this via the contract functions.

P. S. “The Better Financial World”

A lot has been said about Ethereum, Callisto, and ERC721 standard in this article. The main goal of this “ERC20 vs ERC223” and “CallistoNFT vs ERC721” activity is to construct a better financial infrastructure for ourselves. What we are doing now can define what our human civilization will rely on in 20–30 years. Therefore the goal is more important than it may look at a first glance.
I appeared to be working with Callisto Network (since I found it myself) and speaking on its behalf though my goal is not to discredit the Ethereum community.
I really wish that the Ethereum community adopts better token standards too and I will be proposing our solutions to them as always. I will do the same for Ethereum Classic and other EVM-compatible projects as we can unite our efforts within our Ethereum-family to make it better for all of us.
This was the goal of creating Ethereum Commonwealth at the very beginning, and it has remained unchanged ever since.