AtomicAssets 1.0 — Launching the AtomicHub
After more than half a year of working on the AtomicAssets standard, the API and tools surrounding it and the AtomicHub, we’re extremely excited to announce that today we are releasing AtomicAssets 1.0 and launching the AtomicHub.
Today marks the begin of a new Era for Non Fungible Tokens!
AtomicAssets is a new Non Fungible Token (NFT) standard for the eosio blockchain technology. It solves usability issues that existing standards have, by not requiring any RAM from the user, it offers powerful features like native two sided trade offers and backing NFTs with tokens and it is very RAM efficient.
Learn more on atomicassets.io
From a user’s perspective
You don’t have to be a nerd (like us) to be excited about AtomicAssets. Most of AtomicAssets’ features translate directly into a better experience for users, even if they might not even be aware of it.
No RAM costs for users
The recent Garbage Pail Kids launch on the WAX blockchain was a huge success, but one question kept popping up.
“What is RAM and why am I getting error messages related to it?”
And this really shouldn’t be a surprise if you think about it. The concept of needing blockchain resources to interact with a website or application is something that mainstream users have never heard about. You don’t need to pay for every transfer you make on Steam or for every message you send on WhatsApp.
That’s why with AtomicAssets, the NFT author pays for the RAM cost once when minting it, and then you never have to think about it again.
Note: This applies only to the RAM cost of the actual NFT. Trade offers or e.g. sale listings on other smart contracts can still cost RAM for the user, but we give dapps the option to also pay for the RAM of those.
Everyone who has used a platform like Steam before is probably very familiar with the concept of trade offers. I offer you some of my items and want some of your items in return, so I create a trade offer and then you can accept or decline it.
With AtomicAssets, Trade Offers are a native feature of the standard. This makes sending and receiving them very easy, and it makes complicated intermediary smart contracts like WAX Express Trade obsolete.
It also means that you keep full ownership over the NFTs that you offer in a trade until it is accepted. This means that you can keep using them in Dapps and you can also offer them in multiple trades at the same time.
On the Explorer page, you are able to see all the information there is about the assets (NFTs) and their collections. You can see things like an asset’s attributes and its transfer history, and you can even see the details of their technical backbone (Schemas and Templates).
The marketplace offers exactly what you would expect from it: You can list your own NFTs for sale and you can browse existing listings. A very relevant feature is that NFTs of well known collections will get a verification checkmark, which will make it easier to spot the real NFTs. On the flipside, malicious collections will be blacklisted.
By utilizing the native trade offers, you are also able to keep full ownership over your NFTs until they are sold.
The marketplace uses the AtomicMarket smart contract at its core. You can find more information on what that means in the developer’s perspective.
A Trading Interface
The trading interface allows you to see the trade offers that you received and the ones that you sent, and it of course also allows you to create new trade offers. You are also able to transfer NFTs directly if you don’t want anything in return.
An additional exciting feature are “Shared Links”. You are able to select which NFTs you want to include, and then a link is generated. Anyone opening this link will then be able to claim the NFTs. This means you could for example easily share an NFT with a person without having to know their blockchain account, possibly even with someone who doesn’t even have a blockchain account yet and is then incentivized to create one.
An NFT Creator
Using the NFT Creator, anyone is able to create their own collections and mint their own NFTs, without requiring any programming knowledge.
- The first step is to create a Collection. Collections are like a group for NFTs that are of a similar theme, e.g. that belong to the same Dapp.
For example, Garbage Pail Kids could be a collection
- The second step is creating a Schema. Schemas belong to a specific collection, and a collection can have multiple schemas. They define which kind of attributes the assets will have (in tech terms: the data structure).
In the GPK example, Series 1 could be a schema, and the attributes could be Name, Image, ID, Variant, Rarity and Mint Number.
- The third step is optional, but can be very useful. It’s creating a Template, which belongs to a certain schema. Once again, a schema can have multiple templates.
Think of a template as a set of predefined attributes. Assets can later reference a template and then have the attribute values that were set in the template automatically. Templates can also have a maximum supply, which can give NFTs provable scarcity.
In the GPK example, you could create one template for every variation of the cards. On template could for example define the values:
- Name: “Fryin’ Brian”
- Image: A certain IPFS Hash
- ID: 4
- Variant: “A”
- Rarity: “Golden”
and set a maximum supply of 25.
- The final step is creating the asset (NFT). Assets also belong to a certain collection. When creating the asset, you set the values of the attributes that were previously defined in the schema.
As mentioned before, assets can also reference a template, in which case the values defined in the template are automatically applied to the asset.
In the GPK example, you could create 25 assets which all reference the “Fryin’ Brian” template. You would then only have to set the value of the Mint Number attribute, as all the other attributes are already set in the template.
Admittedly, going through those steps for the first time is not super user friendly. However, we believe that the benefits of this more refined structure far outweigh the additional 5 minutes or so that it takes before you can create your first NFT. Also keep in mind that collections and schemas only have to be created once and can then be used over and over again in the future.
Nevertheless, we already have plans to further simplify the process and we will put a lot of effort into making this process as easy to understand as possible.
From a developer’s perspective
Happy developers are the first step for happy users. That’s why our focus when designing the AtomicAssets standard has always been to make it as powerful and versatile as possible, but without adding unnecessary complexity to deal with. But we haven’t just been working on the standard itself, we have also put a lot of work into the ecosystem surrounding it.
No RAM costs for users
Wait, didn’t we mention this already? Yes we did, but there being no RAM costs related to transfers also has huge implications for Dapp developers.
A problem that we’re seeing with a lot of smart contracts and marketplaces that deal with NFTs of other standards is they can either be exploited in such a way that would drain all their RAM, or that they have to put complex mechanisms into place to prevent this.
With AtomicAssets, your smart contracts can operate entirely without needing to pay any RAM themselves. This is a guarantee that couldn’t be achieved using existing NFT standards
Very efficient RAM usage
AtomicAssets uses a custom, Protobuf-like serialization for the attribute data. We estimate that this will save between 30–70% of RAM costs compared to JSON strings. On top of that, by using templates you can also prevent storing the same data multiple times, which we estimate can also save up to 70% on the remaining RAM costs. Less RAM required means more money saved.
Notifications for Smart Contracts
Collections can specify notify accounts, which will receive on-chain inline notifications about relevant actions like transfers or burns. This allows Dapps to keep track of assets in their own smart contracts and thus make them a fully integrated part of their smart contract logic.
A powerful API
We have developed a powerful API for AtomicAssets and the AtomicMarket, which makes getting the data you need very easy. It is open source (Click here), which means that you can run it on your own servers, or you can just use the endpoints provided by us (WAX AtomicAssets, WAX AtomicMarket).
The AtomicMarket smart contract
The AtomicMarket smart contract, which is also used by the AtomicHub, is designed to have a decentralized fee structure. This means that there isn’t a single account that receives all the fees, but instead for every sale (or auction) the marketplaces facilitating the listing and the marketplace facilitating the purchase each get a 1% fee.
Because marketplaces still get the full marketplace fee when using the AtomicMarket smart contract, it makes sense to use it and thus tap into the shared liquidity pool. Shared liquidity is good for marketplaces, which are able to display more interesting sales to their users, and it is good for the users, whose sales will be displayed to more potential buyers.
That’s all for now!
We are extremely excited to finally release all the things that we have been working on for more than half a year into the public, but our vision doesn’t stop here. We already have ideas for improvements to our hub, new features and projects building on top of AtomicAssets!
So for now, go check out atomichub.io and maybe play around with the NFT creator, and get ready for the things still to come. If you want to stay up to date, you can join our Telegram channel and follow us on Twitter @pinknetworkx.