ERC — Ethereum Request for Comments

ERC (Ethereum Request for Comments) ဆိုတာ Ethereum blockchain မှာ token တွေ ဖန်တီးဖို့အတွက် စံသတ်မှတ်ချက်တွေ ဖြစ်ပါတယ်။ ဒီစံသတ်မှတ်ချက်တွေက token တွေကို တူညီတဲ့ပုံစံနဲ့ အလုပ်လုပ်စေပြီး၊ ကွဲပြားတဲ့ application တွေကြားမှာ အဆင်ပြေပြေ အသုံးပြုနိုင်အောင် ဖန်တီးထားတာ ဖြစ်ပါတယ်။

အသုံးများတဲ့ ERC standard တွေထဲက တစ်ခုကတော့ ERC-20 ပါ။ ဒီ standard က fungible token တွေအတွက် သတ်မှတ်ထားတဲ့ စံနှုန်းဖြစ်ပါတယ်။ Fungible ဆိုတာ token တစ်ခုချင်းစီက တန်ဖိုးတူညီပြီး၊ အပြန်အလှန် လဲလှယ်နိုင်တဲ့ သဘောပါ။ ဥပမာ — Bitcoin တစ်ခုရဲ့ တန်ဖိုးက နောက်ထပ် Bitcoin တစ်ခုနဲ့ အတူတူပဲ ဖြစ်ပါတယ်။

နောက်ထပ် ထင်ရှားတဲ့ standard တစ်ခုကတော့ ERC-721 ပါ။ ဒါက non-fungible token (NFT) တွေအတွက် သတ်မှတ်ထားတဲ့ စံနှုန်းဖြစ်ပါတယ်။ Non-fungible ဆိုတာ token တစ်ခုချင်းစီက unique ဖြစ်ပြီး၊ သီးခြားတန်ဖိုး ရှိနိုင်တဲ့သဘောပါ။ Digital art တွေ၊ collectible တွေကို NFT အနေနဲ့ ရောင်းဝယ်တာမျိုးမှာ ERC-721 ကို အသုံးပြုပါတယ်။

ERC-1155 ကတော့ နောက်ထပ်တစ်ဆင့် တိုးတက်လာတဲ့ standard ဖြစ်ပါတယ်။ ဒီ standard မှာ fungible နဲ့ non-fungible token နှစ်မျိုးလုံးကို တစ်ခုတည်းသော smart contract ထဲမှာ ရောနှောပြီး အသုံးပြုနိုင်ပါတယ်။ Gaming platform တွေမှာ ဒီ standard ကို အသုံးများပါတယ်။

Smart contract developer တွေအနေနဲ့ ERC standard တွေကို လိုက်နာခြင်းအားဖြင့် သူတို့ရဲ့ token တွေက Ethereum ecosystem ထဲမှာ အခြား application တွေနဲ့ compatible ဖြစ်မှာ ဖြစ်ပါတယ်။ ဥပမာ — MetaMask လို wallet တွေမှာ ERC-20 token တွေကို လွယ်လွယ်ကူကူ ထည့်သွင်းနိုင်ပါတယ်။

ERC standard တွေဟာ Ethereum community ထဲက developer တွေရဲ့ proposal တွေကနေ ဖြစ်ပေါ်လာတာဖြစ်ပြီး၊ အဲဒီ proposal တွေကို လူအများက review လုပ်၊ ဆွေးနွေးပြီးမှ standard အဖြစ် သတ်မှတ်ကြတာပါ။ ဒီလို process က blockchain ecosystem တစ်ခုလုံးကို ပိုမိုကောင်းမွန်အောင် ပြုလုပ်နိုင်စွမ်း ရှိပါတယ်။

ERC-20 Token အကြောင်း

ERC-20 ဆိုတာ Ethereum blockchain ပေါ်မှာ အသုံးအများဆုံး token standard တစ်ခု ဖြစ်ပါတယ်။ ၂၀၁၅ ခုနှစ်မှာ Fabian Vogelsteller ဆိုတဲ့ developer က ဒီ standard ကို စတင်အဆိုပြုခဲ့ပြီး၊ နောက်ပိုင်းမှာ cryptocurrency လောကအတွက် အရေးပါတဲ့ အခြေခံတစ်ခု ဖြစ်လာခဲ့ပါတယ်။

ERC-20 token တွေမှာ မဖြစ်မနေပါဝင်ရမယ့် function ခြောက်ခု ရှိပါတယ်။ ပထမဆုံးက totalSupply() function ဖြစ်ပြီး၊ ဒီ function က token အရေအတွက် စုစုပေါင်းကို ပြန်ပေးပါတယ်။ ဒုတိယက balanceOf() function ဖြစ်ပြီး၊ သတ်မှတ်ထားတဲ့ wallet address တစ်ခုမှာ ရှိတဲ့ token အရေအတွက်ကို စစ်ဆေးဖို့ သုံးပါတယ်။ transfer() function ကတော့ token တွေကို တခြား address ဆီ ပို့ဆောင်ဖို့အတွက် ဖြစ်ပါတယ်။

ထူးခြားချက်တစ်ခုက approve() နဲ့ allowance() function တွေပါ။ ဒီ function တွေက third-party application တွေကို ကိုယ့်ရဲ့ token တွေကို သုံးခွင့်ပြုဖို့အတွက် ဖြစ်ပါတယ်။ ဥပမာ — decentralized exchange တစ်ခုမှာ token trade လုပ်တဲ့အခါ၊ exchange က သင့်ရဲ့ token တွေကို စီမံခွင့် ရှိဖို့လိုအပ်ပါတယ်။ နောက်ဆုံး transferFrom() function ကတော့ approve လုပ်ထားတဲ့ token တွေကို third-party က တကယ်လက်တွေ့ လွှဲပြောင်းတဲ့အခါ သုံးပါတယ်။

ERC-20 token တွေမှာ name၊ symbol နဲ့ decimal ဆိုတဲ့ property သုံးခုလည်း ပါဝင်လေ့ရှိပါတယ်။ ဥပမာ — Dai stablecoin ဆိုရင် name က “Dai Stablecoin”၊ symbol က “DAI”၊ decimal က ၁၈ ဖြစ်ပါတယ်။ Decimal က token ရဲ့ အသေးဆုံးယူနစ်ကို သတ်မှတ်ပေးပါတယ်။ ၁၈ decimal ဆိုတာ token တစ်ခုကို အပိုင်း ၁၀^၁၈ ပိုင်းအထိ ခွဲလို့ရတယ် ဆိုတဲ့သဘောပါ။

ERC-20 ရဲ့ အားသာချက်တွေထဲမှာ fungibility (token တိုင်းက တန်ဖိုးတူညီခြင်း)၊ interoperability (application အမျိုးမျိုးနဲ့ အဆင်ပြေပြေ အလုပ်လုပ်နိုင်ခြင်း) နဲ့ simplicity (ရိုးရှင်းပြီး နားလည်ရလွယ်ကူခြင်း) တို့ ပါဝင်ပါတယ်။ ဒါကြောင့် DeFi (Decentralized Finance) project အများစုက ERC-20 ကို ရွေးချယ်အသုံးပြုကြတာ ဖြစ်ပါတယ်။

ERC-20 token တစ်ခု ဖန်တီးဖို့အတွက် smart contract တစ်ခု ရေးသားရပါတယ်။ Solidity programming language ကို အသုံးပြုပြီး၊ OpenZeppelin လို library တွေက ပေးထားတဲ့ template တွေကို အခြေခံပြီး ရေးသားနိုင်ပါတယ်။ Contract deploy လုပ်ပြီးတဲ့အခါ token တွေကို mint လုပ်နိုင်ပြီး၊ ရောင်းဝယ်ဖလှယ်နိုင်ပါပြီ။

Event တွေကလည်း ERC-20 မှာ အရေးကြီးတဲ့ အစိတ်အပိုင်းတစ်ခု ဖြစ်ပါတယ်။ Transfer နဲ့ Approval event တွေက token လွှဲပြောင်းမှုတွေနဲ့ ခွင့်ပြုချက်တွေကို blockchain ပေါ်မှာ မှတ်တမ်းတင်ထားပါတယ်။ Dapp တွေက ဒီ event တွေကို စောင့်ကြည့်ပြီး user interface ကို update လုပ်နိုင်ပါတယ်။

လက်ရှိအချိန်မှာ USDT၊ USDC၊ DAI စတဲ့ stablecoin တွေ၊ LINK၊ UNI၊ AAVE စတဲ့ utility token တွေအပါအဝင် token ထောင်ပေါင်းများစွာက ERC-20 standard ကို အသုံးပြုနေကြပါတယ်။ ဒီ standard က cryptocurrency ecosystem ရဲ့ အဓိက ကျောရိုးတစ်ခု ဖြစ်နေပြီး၊ DeFi innovation တွေအတွက် အခြေခံကောင်းတစ်ခု ဖြစ်နေပါတယ်။

ERC-20 Smart Contract အကြောင်း

Smart contract ကို Solidity programming language နဲ့ ရေးသားရပါတယ်။ ပထမဆုံးအနေနဲ့ contract ရဲ့ အခြေခံ ဖွဲ့စည်းပုံကို လေ့လာကြည့်ရအောင်။

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract MyToken {
 string public name;
 string public symbol;
 uint8 public decimals;
 uint256 public totalSupply;
 mapping(address => uint256) public balanceOf;
 mapping(address => mapping(address => uint256)) public allowance;
 
 event Transfer(address indexed from, address indexed to, uint256 value);
 event Approval(address indexed owner, address indexed spender, uint256 value);
 
 constructor(string memory _name, string memory _symbol, uint8 _decimals, uint256 _totalSupply) {
 name = _name;
 symbol = _symbol;
 decimals = _decimals;
 totalSupply = _totalSupply;
 balanceOf[msg.sender] = _totalSupply;
 }
}

အထက်ပါ code မှာ contract ရဲ့ အခြေခံ variable တွေကို တွေ့ရမှာဖြစ်ပါတယ်။ name၊ symbol နဲ့ decimals က token ရဲ့ အခြေခံအချက်အလက်တွေ ဖြစ်ပြီး၊ totalSupply က token အရေအတွက် စုစုပေါင်းကို သိမ်းဆည်းပါတယ်။ balanceOf mapping က address တစ်ခုချင်းစီမှာ ရှိတဲ့ token balance တွေကို သိမ်းဆည်းပြီး၊ allowance mapping ကတော့ third-party တွေကို ခွင့်ပြုထားတဲ့ token ပမာဏတွေကို သိမ်းဆည်းပါတယ်။

Transfer နဲ့ အခြေခံ function တွေကို ဆက်လက်ကြည့်ရအောင်။

function transfer(address to, uint256 value) public returns (bool) {
 require(balanceOf[msg.sender] >= value, "Insufficient balance");
 balanceOf[msg.sender] -= value;
 balanceOf[to] += value;
 emit Transfer(msg.sender, to, value);
 return true;
}

function approve(address spender, uint256 value) public returns (bool) {
 allowance[msg.sender][spender] = value;
 emit Approval(msg.sender, spender, value);
 return true;
}

function transferFrom(address from, address to, uint256 value) public returns (bool) {
 require(balanceOf[from] >= value, "Insufficient balance");
 require(allowance[from][msg.sender] >= value, "Insufficient allowance");
 balanceOf[from] -= value;
 balanceOf[to] += value;
 allowance[from][msg.sender] -= value;
 emit Transfer(from, to, value);
 return true;
}

transfer() function က token တွေကို တိုက်ရိုက်လွှဲပြောင်းဖို့သုံးပါတယ်။ လွှဲပြောင်းမယ့်သူမှာ လုံလောက်တဲ့ token ရှိမရှိ အရင်စစ်ပြီး၊ ရှိမှသာ လွှဲပြောင်းခွင့်ပြုပါတယ်။

approve() function က third-party တစ်ခုကို ကိုယ့်ရဲ့ token တွေကို သုံးခွင့်ပြုဖို့ အသုံးပြုပါတယ်။ အဲဒီ third-party က သတ်မှတ်ထားတဲ့ ပမာဏအထိသာ token တွေကို စီမံခွင့်ရမှာ ဖြစ်ပါတယ်။

transferFrom() function ကတော့ approve လုပ်ထားတဲ့ third-party က token တွေကို အမှန်တကယ် လွှဲပြောင်းတဲ့အခါ သုံးပါတယ်။ လွှဲပြောင်းမယ့် token ပမာဏက လက်ကျန် token ထက်မများဘူးလား၊ approve လုပ်ထားတဲ့ ပမာဏထက် မကျော်လွန်ဘူးလား စတာတွေကို စစ်ဆေးပါတယ်။

Event တွေကိုလည်း မှတ်သားထားသင့်ပါတယ်။ Transfer နဲ့ Approval event တွေဟာ token လွှဲပြောင်းမှုတွေနဲ့ ခွင့်ပြုချက်တွေကို blockchain ပေါ်မှာ မှတ်တမ်းတင်ထားပြီး၊ frontend application တွေက ဒီ event တွေကို နားထောင်ပြီး interface ကို update လုပ်နိုင်ပါတယ်။

Security အနေနဲ့ SafeMath library ကို အသုံးပြုသင့်ပါတယ်။ ဒါပေမယ့် Solidity version 0.8.0 နဲ့အထက်မှာ အဲဒီ library က built-in အနေနဲ့ ပါဝင်လာပြီ ဖြစ်ပါတယ်။ Reentrancy attack တွေကို ကာကွယ်ဖို့ checks-effects-interactions pattern ကို လိုက်နာသင့်ပါတယ်။

OpenZeppelin က ပေးထားတဲ့ ERC20 implementation ကိုလည်း အသုံးပြုနိုင်ပါတယ်။ သူ့မှာ security testing ပြုလုပ်ထားပြီး ဖြစ်လို့ ပိုပြီး စိတ်ချရပါတယ်။

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract MyToken is ERC20 {
 constructor() ERC20("My Token", "MTK") {
 _mint(msg.sender, 1000000 * 10 ** decimals());
 }
}

Smart contract ကို deploy လုပ်တဲ့အခါ gas fee ကုန်ကျမှုကို ထည့်သွင်းစဉ်းစားသင့်ပါတယ်။ Function တွေကို optimize လုပ်ခြင်းအားဖြင့် gas fee ကို လျှော့ချနိုင်ပါတယ်။ ဥပမာ — variable တွေကို memory ထဲမှာ သိမ်းတာထက် calldata သုံးခြင်းအားဖြင့် gas ကုန်ကျစရိတ် သက်သာပါတယ်။

Testing အပိုင်းမှာ unit test တွေရေးသားပြီး contract ရဲ့ functionality တွေကို စမ်းသပ်သင့်ပါတယ်။ Hardhat သို့မဟုတ် Truffle framework တွေကို အသုံးပြုပြီး test တွေရေးနိုင်ပါတယ်။ Audit လုပ်ဖို့လည်း မမေ့သင့်ပါဘူး။

Smart contract တွေကို immutable ဖြစ်တဲ့အတွက် deploy လုပ်ပြီးရင် ပြင်ဆင်လို့ မရတော့ပါဘူး။ ဒါကြောင့် deploy မလုပ်ခင် code ကို သေချာစစ်ဆေးသင့်ပါတယ်။ Upgradeable pattern တွေကိုလည်း စဉ်းစားကြည့်နိုင်ပါတယ်။

Original Article – https://medium.com/@minsithu_53495/erc-%E1%80%94%E1%80%BE%E1%80%84%E1%80%B7%E1%80%BA-erc-20-%E1%80%A1%E1%80%80%E1%80%BC%E1%80%B1%E1%80%AC%E1%80%84%E1%80%BA%E1%80%B8-610add024cb5