Ethereum Tokens ERC 721 vs ERC 1155
BEFORE jumping into the ERC 721 & 115
What is an Ethereum Token
A token is a smart contract that represents a digital asset or service and these assets are present inside the blockchain. These Tokens are started using from the ICO era in 2017. Mainly used for creating collectibles in the ethereum games ex:- Cryptokitties , to creating a kitty the ‘cryptokitties’ used ERC 721-non fungible token.
CODE FOR TOKEN CONTRACT
pragma solidity ^0.6.8;
contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can’t be over max (2²⁵⁶ — 1).
//If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn’t wrap.
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping units.
//if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
A Question that happens often with these tokens is How can they represent value? The typical way to understand how these tokens get value is by collateral, while creating the smart contract for this token one needs to send some ‘ether’ to the contract so, including ether into the contract creates a value for the token. The widely used tokens are ERC 20- fungible token, ERC 721, and ERC 1155 — Non-fungible tokens.
WHAT ARE FUNGIBLE AND NON FUNGIBLE TOKENS
Let us understand the fungible and non-fungible tokens with an example
A non-fungible token is like a hand-crafted gold ring that you have engraved with your name, whereas a fungible token is like a gold block with no identifying markers on it.
This means every fungible token has exactly the same value, while non-fungible tokens can each hold a unique level of value based on their individual identity.
ERC 721
Most of the NFTs are implemented on top of the Ethereum platform as ERC-721 tokens. You can find other tokens as well under NFTs, with different standards and on other protocols and blockchain, like the one on NEO or EOS, but ERC-721 is currently the most popular NFT standard.
ERC-721 features a set of standard functions and attributes that define it, in the form of a smart contract. You need to follow these attributes and functions to own, trade, and manage ERC-721.
Simply put, ERC-721 provides us with a standard to create and exchange Non Fungible Tokens. Each ERC-721 token is unique, which is not in the case of ERC-20 tokens.
ERC-721 is currently the most used standard for blockchain digital art and gaming. It has been used by hundreds of Dapps so far.
ERC 1155
ERC-1155 is an advanced and better version of ERC-721 that offers a lot of new possibilities to create NFTS.
For example, with the new ERC-1155 standard, you can now use infinite numbers of Non-Fungible as well as Fungible items in a single deployed smart contract. According to Witek Radomski, it is also easy for the blockchain network to handle.
He also claims that this new set of standards is not only good for the blockchain-based gaming industry but also a good option to create tokens for all forms of ownership, no matter digital or tangible.
ERC-1155 was developed in response to the limitations of ERC-721 and ERC-20, which makes it a better alternative.
ERC-1155 vs ERC-721
All NFTs are not created equal, which is clear when comparing the ERC-1155 and ERC-721 token standards.
A token standard is a set of rules that defines the data and, therefore, the functions that each token is capable of.
The ERC-1155 token standard was created to function like a vending machine, where developers could deploy a single smart contract that can be used to mint unlimited fungible (identical) tokens and non-fungible (unique) tokens.
In comparison, the ERC-721 token standard only produces non-fungible tokens and forces developers to deploy a new smart contract for each new token.
