Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Update overview.md #550

Merged
merged 1 commit into from
Mar 9, 2022
Merged

Update overview.md #550

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
33 changes: 11 additions & 22 deletions docs/native-tokens/overview.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,49 +22,38 @@ We will not go into how to spin up a Cardano node, but this is covered in the [i

## What are native tokens/assets?

The Cardano Blockchain features a unique ability to create, interact and destroy custom tokens (or so-called 'assets') in a native way.
Native, in this case, means besides sending and receiving the official currency ada, you can also interact with custom assets out of the box - without the need for smart contracts.
The Cardano Blockchain has the unique ability to create, interact with, and delete bespoke tokens (or 'assets') natively. In this example, native means that, in addition to sending and receiving the official currency ada, you may interact with custom assets right out of the box - without the use of smart contracts.

The functionality is already built-in, and native assets can almost be treated like ada in every way. Of course, there are some constraints (which we will cover later), but you can imagine native assets as a possibility to generate your own custom for now.
Native assets can practically be treated as ada in every sense because the capability is already built-in. Of course, there are some limitations (which we'll discuss later), but you can think of native assets as a way to produce your own custom for the time being.

## What you need to know
Here's a brief overview of what you need to know before we dive in any deeper.
Before we go any further, here's a quick rundown of what you need to know.

### How we interact with the blockchain
Pretty much every interaction with the Cardano network/blockchain comes down to a transaction. With this in mind, we can break interactions down into two layers.
Almost all interactions with the Cardano network/blockchain are transaction-based. We can divide interactions into two tiers with this in mind.

![img](../../static/img/nfts/overview_nfts.svg)

The top layer is more focused on a visual approach and covers regular interaction.
This includes sending and receiving ada or tokens, delegating your stake, or voting. Those interactions can be done through wallets like the full node Daedalus wallet or the more lightweight Yoroi wallet.
The top layer emphasizes a visual approach and covers standard interaction. Sending and receiving ada or tokens, delegating your stake, and voting are all examples of this. Wallets such as the full node Daedalus wallet or the lighter Yoroi wallet can be used to carry out these interactions.

But if we want to drill down and have more possibilities to interact and make more "custom" interactions, we need to go one layer below.
In this layer, we need a full node to issue transactions with custom parameters.
Most of the time, a full node is a compiled binary of the official latest cardano-node repository. There are alternatives out there, but we'll focus on the Linux version.
However, if we want to drill down and have more options for interacting and creating "custom" interactions, we must go one step deeper. We'll need a whole node in this layer to send transactions with specified parameters. A full node is often a built binary from the official latest cardano-node repository. There are more options, but we'll concentrate on the Linux version.

So what kind of advanced transactions can we build with a full node, and how?
The current way is to work with the command line and issue your transactions from there.
Stake pool operators need to use this way of making transactions to - for example - register their stake pool or make adjustments to their pledge etc.
But we can also use this way to create, send, receive or burn tokens.
So, what kinds of sophisticated transactions can we create with a full node, and how can we do it? Working on the command line and issuing transactions from there is the current method. Stake pool operators must utilize this method of transaction to register their stake pool or make changes to their commitment, among other things. However, we may utilize this method to produce, send, receive, and burn tokens.

In the future, this probably will also be the place where smart contracts are written, tested, and maybe executed if there isn't a visual frontend.

### Constraints when working with tokens

Since we already learned that interaction with the network is almost always a transaction, we need to be aware of a few things enforced through network parameters.

1. Issuing a transaction and sending something always requires a fee to be paid.
As of now, the fee depends on the size of the transaction (read: how much "information" gets sent). The size varies from a simple transaction like "A sends 2 ada to B" to a much more complex transaction that may have additional metadata attached to them.
2. There is a minimum value that needs to be sent. The value is currently set to 1 ada. This means if we want to send a token, we at least need to include 1 ada to the transaction. This is to prevent creating large sums of custom tokens and spamming the network with custom token transactions.
1. A fee must always be paid whether issuing a transaction or sending something. Currently, the cost is determined by the size of the transaction (read: how much "information" gets sent). The size of a transaction can range from a simple "A transmits 2 ada to B" to a considerably more sophisticated transaction with additional metadata.
2. There is a minimum value that must be sent. Currently, the value is set to 1 ada. This means that if we wish to send a token, we must include at least one ada in the transaction. This is to avoid huge amounts of custom tokens from being created and the network being flooded with custom token transactions.
3. We currently (June 2021) have no standard way to define an NFT. There is an [open pull request](https://github.com/cardano-foundation/CIPs/pull/85), however. Most of the current NFTs on Cardano mostly follow the proposed structure, as we will in this section.

Please keep those constraints in mind if you want to work with native assets.

## Difference between "regular" token and NFTs

Technically speaking, there is no real difference between "regular" token/native assets and NFTs.
This is because both can be created with a transaction issued through the cardano node cli and are native assets.

Compared to fungible native assets, which can range into millions of interchangeable tokens, an NFT is a single native asset that can not be re-minted or destroyed, living forever on the blockchain.

In terms of technology, there isn't much of a distinction between "regular" tokens/native assets and NFTs. This is due to the fact that both can be produced using the cardano node cli and are native assets.

Unlike fungible native assets, which might consist of millions of interchangeable tokens, an NFT is a single native asset that cannot be re-minted or destroyed, and it exists on the blockchain in perpetuity.