CallistoNFT advanced standard

Intro

This article describes a new Non-Fungible Token standard developed by @Dexaran , the author of 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 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 % fee on these built-in trades instead of the marketplaces that traditionally did this.
  • Communication model for smart-contracts “events” are a 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 automatisation opportunities.
  • Standardized properties — NFTs typically represent some unique objects and store their properties (for example bitmap for a picture or website link). This unique properties are implementaiton-specific in ERC721. CallistoNFT makes a step towards standardizing this features.

Let me describe it in more details 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 a NFT to set it’s “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 exchange 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 it’s 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.

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 a 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 address’es balance. It does not notify the receiver of this transaction about this event. 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, 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 the 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 like in a first glance.

I appeared to be working with Callisto Network (since I founded 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.

--

--

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store