Mungkin anda masih bingung tentang konsep deflasi (deflationary) dalam keuangan tradisional atau cryptocurrency, deflasi pada keuangan tradisional adalah hal yang sangat buruk, tetapi itu menjadi positif pada keuangan cryptocurency. Deflasi pada keuangan tradisional mengacu pada penurunan suatu harga asset karena kondisi tertentu atau karena over minting.
Deflasi pada cryptocurrency adalah hal yang bagus, hal ini adalah penurunan pasokan suatu token atau coin crypto seiring berjalannya waktu. faktor ini menyiratkan bahwa team developer dan pengguna token tersebut berpartisipasi ada aktifitas pengurangan supply, biasanya model seperti ini melalukan burning otomatis untuk mengurangi supply.
Bagaimana Token Deflasi Bekerja?
Seperti yang saya sebutkan sebelumnya, deflasi (deflationary) pada cryptocurrency adalah suatu mekanisnya yang melibatkan pembakaran (burning) token dari peredaran, ini bukan aktifitas literasi yang mengunci token ke dompet tertentu, tapi ini benar benar menghapus sebagian supply , sehingga sebagian supply benar benar hancur.
Contoh mekanismenya adalah pembakaran token secara otomatis ketika pengguna melakukan transaksi, contoh User1 megirim token ke User2, maka sebagian token akan terbakar otomatis, jumlah token yang terbakar tergantung dari konsensus atau dari ketentuan developer. Contoh TokenA mempunyai auto burn 1% ketika user melakukan transaksi, maka setiap transaksi seperti “kirim , stake, swap” akan terbakar secara otomatis (1% dari jumlah yang di transaksikan)
Manfaat Deflasi pada Cryptocurrency
Ada beberapa keuntungan yang di dapatkan oleh pengguna atau holder token deflasi,
- Meningkatkan Nilai Token : Hukum dasar market crypto adalah “penawaran dan permintaan”, ketika permintaan lebih tinggi dari pada penawaran, maka nilai token akan melambung tinggi, tetapi sebaliknya jika penawaran lebih tinggi dari pada permintaan, makan nilai token akan menurun. Deflasi akan meningkatkan permintaan karena supply token yang akan terus berkurang siring berjalanya waktu.
- Penurunan Supply : Mekanisme deflasi akan menurunkan supply setiap transaksi, semakin banyak transaksi pada token tersebut, maka supply akan semakin cepat berkurang.
- Lebih Banyak Holder : Karena mekanisme deflasi pada setiap transaksi, maka akan memicu “hold long time” bagi para investor, karena mereka sangat yakin token deflasi akan BOOM di masa depan. Pengguna lebih suka HOLD karena mereka menghindari penurunan supply token pada wallet mereka, dan mereka yakin harga akan naik seiring berjalan nya waktu.
Bagaimana Cara Membuat Token Deflasi ?
Di artikel ini saya akan memberikan tutorial cara membuat Deflationary CRC20 Token “Coinex Smart Chain“. Saya memilih blockchain CSC “coinex smart chain” untuk membuat token deflasi, karena blockchain tersebut lebih cepat, mempunyai TPS yan tinggi dan biaya transaksi sangat murah. Simak tutorial di bawah ini untuk mmbuat deflasi token pada CSC
# Siapkan Wallet & Coin CET
Anda bisa menggunakan wallet metamask, wallet tersebut lebih mudah ketika digunakan. Selanjutnya anda harus menyiapkan beberaa coin CET , CET merupakan coin native dari blockchain Coinex Smart Chain. Anda bisa membeli coin CET di Coinex Exchange dan mengirimnya ke address metamask
# Siapkan Smart Contract Deflationary
Ada banyak smart contract yang bisa anda gunakan, anda bebas menggunakan smart manapun, jika anda belum mempunyai smart contract deflasi, anda bisa menggunakan smart contract di bawah ini
pragma solidity ^0.6.12;
// SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Burn(address indexed from, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract TTD1 is IERC20 {
using SafeMath for uint256;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
uint256 internal _totalSupply;
uint8 internal _brate;
address internal _admin;
mapping (address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
constructor() public {
_admin = msg.sender;
_symbol = "TTD1";
_name = "TTD1";
_decimals = 6;
_brate = 1;
_totalSupply = 1000000* 10**uint(_decimals);
balances[msg.sender]=_totalSupply;
}
function changeBurnRate(uint8 brate) public {
require(msg.sender==_admin);
_brate = brate;
}
function brate() public view returns (uint8)
{
return _brate;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return balances[account];
}
function transfer(address _to, uint256 _value) public virtual override returns (bool) {
require(_to != address(0) && _value > 0);
uint burn_token = (_value*_brate)/100;
require(_value+burn_token > _value);
require(_value + burn_token <= balances[msg.sender]);
balances[msg.sender] = (balances[msg.sender]).sub(_value - burn_token);
balances[_to] = (balances[_to]).add(_value - burn_token);
emit Transfer(msg.sender, _to, _value - burn_token);
require( burn(burn_token));
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public virtual override returns (bool) {
require(_to != address(0) && _from != address(0) && _value > 0);
uint burn_token = (_value*_brate)/100;
require(_value+burn_token > _value);
require(_value + burn_token <= balances[_from]);
require(_value + burn_token <= allowed[_from][msg.sender]);
balances[_from] = (balances[_from]).sub(_value - burn_token);
balances[_to] = (balances[_to]).add(_value - burn_token);
allowed[_from][msg.sender] = (allowed[_from][msg.sender]).sub( _value - burn_token);
emit Transfer(_from, _to, _value - burn_token);
require( burn(burn_token));
return true;
}
function approve(address _spender, uint256 _value) public virtual override returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view virtual override returns (uint256) {
return allowed[_owner][_spender];
}
function burn(uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value); // Check if the sender has enough
balances[msg.sender] -= _value; // Subtract from the sender
_totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balances[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowed[_from][msg.sender]); // Check allowance
balances[_from] -= _value; // Subtract from the targeted balance
allowed[_from][msg.sender] -= _value; // Subtract from the sender's allowance
_totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
//Admin can transfer his ownership to new address
function transferownership(address _newaddress) public returns(bool){
require(msg.sender==_admin);
_admin=_newaddress;
return true;
}
}
# Buka Remix Ethereum
Buka website remix ethereum , untuk proses pembuatan token atau untuk deploy token ke blockchain coinex smart chain, pastikan wallet metamask anda sudah menggunakan RPC coinx smart chain. Buat file baru pada remix ethereum & paste smart contract di atas .
# Compile Smart Contract
Sebelum melakukan deploy, compile smart contract anda dan pastikan tidak ada error atau peringatan pada remix ethereum. Sebelum melakukan deploy, silahkan cek dahulu, Name, Supply, Symbol dan Decimal token
# Deploy Token Deflasi
Setelah compile selesai dan tidak ada error pada smart contract, silahkan deploy smart contract anda .
# Test Token Deflasi
Token yang ada di tutorial ini menggunakan mekanisme Auto Burn 1% pada setiap transaksi, setiap transaksi yang di lakukan di token tersebut , akan menghapus 1% dari jumlah token yang di transaksikan.
Saya test kirim 10000 token ke alamat lain, setelah transaksi terkonfirmasi , 1% dari jumlah token yang di transaksikan terhapus otomatis, dan alamat tersebut hanya menerima 9900 token
