Понимание стандартов токенов в Ethereum (ERC20)

Создавать и размещать собственные токены в Интернете слишком просто. Блокчейн и смарт-контракты сделали это возможным. Да, вы не ослышались. Вы можете разместить свои собственные токены в Интернете. И это тоже без создания совершенно новой цепочки блоков, такой как Биткойн или Эфириум.

Эти токены — это просто фрагмент кода, работающий поверх блокчейна.

Вот краткое руководство по блокчейну.

pragma solidity 
^0.8.0;
  interface IERC20 { 
      event Transfer(address indexed from, address indexed to, uint256 value); 
      event Approval(address indexed owner, address indexed spender, uint256 value); 
      function totalSupply() external view returns (uint256); 
      function balanceOf(address account) external view returns (uint256); 
      function transfer(address to, 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 from, address to, uint256 amount) external returns (bool);
  }

<сильный>3. decimals() важно отметить, потому что Solidity не поддерживает плавающие числа, и для выполнения транзакций со значениями, такими как 1,5, 2,4 и т. д., мы должны разбить число на меньшие номиналы. Помните, как токен эфира можно разбить на более низкие номиналы, такие как Gwei, Finney и Wei. Обычно мы присваиваем 18 знаков после запятой, и это также рекомендуется.

функция decimals() возвращает общедоступное представление (uint8);

<сильный>4. totalSupply() Эта функция должна возвращать общее количество токенов на рынке. Общее предложение токена должно зависеть только от двух функций: чеканки или сжигания. Чеканка означает поставку вновь созданных токенов, а сжигание означает уничтожение токенов. Мы поговорим об обоих позже.

функция totalSupply() возвращает публичное представление (uint256);

<сильный>5. balanceOf() принимает адрес в качестве аргумента и возвращает баланс токена. Как он узнает о моем балансе? Мы определяем сопоставление внутри нашего контракта, которое отслеживает наш баланс, каждый раз, когда происходит транзакция токенов, это сопоставление должно обновляться, поскольку это будет единственный источник баланса. выглядит так:

сопоставление(адрес => uint ) внутреннего баланса;

Эта функция balanceOf просто возвращает значение из сопоставления.

функция balanceOf(address _owner)public viewreturns (баланс uint256);

<сильный>6. Transfer() — это функция, используемая для отправки токенов с одного адреса на другой. Принимает в качестве аргументов адрес, на который должны быть отправлены токены, и uint, представляющий собой количество отправляемых токенов. И он должен вычесть токены из msg.sender и добавить сумму получателю. Как работают вычитание и сложение? Как я уже говорил ранее о сопоставлении balance. Мы просто уменьшаем и увеличиваем количество токенов в отображении.

передача функции(адрес _to, uint256 _value)publicreturns (логический успех);

<сильный>7. TransferFrom() делает то же самое, что и функция transfer, но есть разница. Эта функция используется для отправки токенов с одного адреса на другой адрес по третьему адресу. Как кто-то может потратить мои токены? Это безопасно? Да, потому что любой адрес может потратить ваш токен только в том случае, если вы разрешили это сделать. Как мы делаем это? Вот о чем следующая функция.

функция transferFrom(address _from, address _to, uint256 _value)public возвращает (логический успех);

8. approve() используется для одобрения любой учетной записи на использование токенов из учетной записи, которая ее одобряет. Он принимает два аргумента: первый — это адрес транжиры, а второй — стоимость токенов, которые транжирщику разрешено тратить. Затем мы обновляем вложенное отображение с помощью этого ввода. Какое сопоставление? Сопоставление для утверждения записывается следующим образом: сопоставление (адрес=>сопоставление (адрес=>сумма)) внутреннее разрешено;

функция одобряет(адрес _spender, uint256 _value)public возвращает (логический успех);

9. allowance() используется для проверки оставшихся токенов для утвержденного адреса для расходования. Он просто возвращает чтение данных из сопоставления allowed.

функция разрешения (адрес _owner, адрес _spender) возвращает общедоступное представление (осталось uint256);

Это были функции, которые должны были быть определены при создании токена ERC20. Помимо этого, у нас есть два события, которые должны запускаться в нужное время. Они:

1. Перенос: каждый раз, когда происходит перенос токенов с одной учетной записи на другую, должно инициироваться это событие. Совершенно очевидно, что это должно генерироваться внутри функций transfer и transferFrom. Но есть еще две функции во время реализации, где генерируется это событие. Функции Mint и burn. Мы поговорим об этом через некоторое время. А пока просто помните, что при генерации этого события в функции mint адрес отправителя должен быть нулевым, а в функции burn получатель должен иметь нулевой адрес. Нулевой адрес выглядит так: 0x000000000000000000000000000000000000000000В солидности address(0) означает этот нулевой адрес.

Передача события (адрес проиндексирован _from, адрес проиндексирован _to, uint256 _value);

1. Утверждение. Это событие должно запускаться внутри функции approve каждый раз, когда кто-то утверждает какой-либо адрес.

Подтверждение события (адрес с индексом _owner, индекс с адресом _spender, uint256 _value);

Каждый токен ERC20 должен реализовывать эти функции в контракте.

Посмотрите на этот простой реализованный смарт-контракт.

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface ERC20Interface {

function allowance(address tokenOwner, address spender) public virtual view returns (uint remaining);
function balanceOf(address tokenOwner) public virtual view returns (uint balance);
function totalSupply() public view virtual returns  (uint);
function transferFrom(address from, address to, uint tokens) public virtual returns (bool success);
function transfer(address to, uint tokens) public virtual returns (bool success);
function approve(address spender, uint tokens) public virtual returns (bool success);

event Transfer(address indexed from, address indexed to, uint tokens);  
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);  
event Supply(address indexed to, uint indexed amount, uint remainingSupply);  

}

contract Token is ERC20Interface  {
string public name;
string public symbol;
uint8 public decimals;
uint256 public _totalSupply;
uint public maximumSupply;
address public owner;

mapping(address => uint) private balances;  
mapping(address => mapping(address => uint)) private  allowed;  

constructor()  {  
    name = "MyFirstToken";  
    symbol = "MFT";  
    decimals = 18;  
    _totalSupply =  5000000 * 10**18;  
    maximumSupply = 10000000 * 10**18;  
    owner= msg.sender;  

    balances[msg.sender] = _totalSupply;  
    emit Transfer(address(0), msg.sender, _totalSupply);  
}  

function  remainingToken() public view returns (uint remainingSupply) {  

    return ( maximumSupply - _totalSupply);  
}  


modifier ownable ()  {  
    require (msg.sender== owner," only owner can perform this");  
    _;  
}  

function totalSupply() public override view returns (uint) {  
    return _totalSupply ;  
}  

function balanceOf(address tokenOwner) public override view returns (uint balance) {  
    return balances[tokenOwner];  
}  

function allowance(address tokenOwner, address spender) public override view returns (uint remaining) {  
    return allowed[tokenOwner][spender];  
}  

function approve(address spender, uint tokens) public override returns (bool success)  {  
    allowed[msg.sender][spender] = tokens;  
    emit Approval(msg.sender, spender, tokens);  
    return true;  
}  

function transfer(address to, uint tokens) public override returns (bool success) {  
    balances[msg.sender] = (balances[msg.sender] -= tokens);  
    balances[to] = (balances[to] += tokens);  
    emit Transfer(msg.sender, to, tokens);  
    return true;  
}  

function transferFrom(address from, address to, uint tokens) public override returns (bool success) {  
    require(balances[from] >=tokens, "You don't have enough tokens");  
    require(allowed[from][msg.sender] >=tokens, "You are not allowed to send tokens");  
    balances[from] = (balances[from] -= tokens);  
    allowed[from][msg.sender] = (allowed[from][msg.sender] -= tokens);  
    balances[to] = (balances[to]+= tokens);  
    emit Transfer(from, to, tokens);  
    return true;  
}  

function mint (address to ,uint amount) public ownable {  
   require(_totalSupply + amount <= maximumSupply,"You are exceeding the maximum supply");  
   balances[to] += amount;  
   _totalSupply += amount;  
   emit Supply(to,amount,remainingToken());  
}  

function burn (uint amount) public {  
    require(balances[msg.sender] >= amount, "not enough balance to burn");  
    balances[msg.sender] -= amount;  
    emit Supply(msg.sender, amount, remainingToken());  
}         

Это действительно простая реализация, в которой вы можете видеть, что токен контракта наследуется от интерфейса и реализует каждую функцию, определенную внутри интерфейса. Обратите внимание, что есть две дополнительные функции mint и burn.

МИНТ

Функция mint предназначена для чеканки новых токенов. Когда вы увидите код внутри него, вы заметите, что он увеличивает баланс любого адреса. Это означает, что в этом кошельке чеканятся новые токены. Но почему мы генерируем здесь событие перехода? Это связано с тем, что чеканка рассматривается как передача токенов с нулевого адреса на заданный адрес.

СЖИГАТЬ

А как насчет функции burn? Функция burn на самом деле представляет собой передачу токенов, но получатель всегда имеет нулевой адрес. Почему так? Нулевой адрес используется как черная дыра в Ethereum, а это означает, что вряд ли удастся угадать закрытый ключ нулевого адреса. Давайте не будем слишком вдаваться в технические подробности, просто поймите, что всякий раз, когда вам нужно уничтожить какой-либо токен, то есть удалить токен с рынка, вы отправляете его на этот адрес, и бум, он исчез навсегда. сейчас никто не может получить доступ к этим токенам. Именно поэтому нулевой адрес содержит токены на миллионы долларов.

Это почти все о стандарте токенов ERC20. Это очень просто и легко.

Но это только для взаимозаменяемых токенов, а как насчет невзаимозаменяемых токенов NFT? ERC-721 является стандартом для NFT. Давайте поговорим об этом в следующем посте.

:::информация Также опубликовано здесь.

:::