Erstellen Sie eine dezentrale Börse (DEX) für ERC-20-Token

Dies ist der erste Teil einer wahrscheinlich sehr langen Reihe von Beiträgen.
In diesem Beitrag erkläre ich, wie man einen einfachen dezentralen Austausch für einen ERC-20-Token erstellt.

Erwartungen

Dieser Beitrag setzt grundlegende Kenntnisse über Solidität, den ERC-Standard und die Erstellung eines grundlegenden ERC20-Tokens voraus

Erstellen des ERC20-Tokens

Wir erstellen ein einfaches ERC20-Token, indem wir die ERC20.sol von Openzeppelin. Unser Token wird benannt TSTtoken und es wird einen Gesamtvorrat von 1 Million haben.

// TSTtoken.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "

contract TSTtoken is ERC20 {

uint256 initialSupply = 1000000e18;
    constructor() ERC20("Test", "TST") {
        _mint(msg.sender, initialSupply);
    }
}

Als nächstes erstellen wir den Smart Contract für unseren DEX in DEX.sol.

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0; 

import "
import './TSTtoken.sol'; 

contract DEX { 
    IERC20 public token; 
    event Bought(uint256 amount); 
    event Sold(uint256 amount); 
    
    constructor(){ 
        token = new TSTtoken(); 
    } 
    
    function buy() payable public { 
         // TODO
    } 
 
    function sell(uint256 amount) public { 
        // TODO
    } 
}

Unser DEX-Vertrag hat zwei Funktionen

buy: Der Benutzer kann Ether senden und im Austausch TSTtoken erhalten

verkaufen: Der Benutzer kann TSTtoken senden und Ether zurückbekommen

Die Kauffunktion

Um die Kauffunktion zu codieren, müssen wir den Etherbetrag überprüfen, der in der Nachricht an den Vertrag gesendet wird (z. B. msg.value), und sicherstellen, dass der Vertrag genügend TSTtoken besitzt. Wenn der Vertrag über genügend TSTtoken verfügt, sendet er es an den Benutzer und gibt das aus Bought Veranstaltung.

Notiz:

Der Einfachheit halber tauschen wir 1 TSTtoken gegen 1 Wei

    function buy() payable public {
        uint256 amountTobuy = msg.value; 
        uint256 dexBalance = token.balanceOf(address(this)); 
        require(amountTobuy > 0, "You need to send some ether"); 
        require(amountTobuy <= dexBalance, "Not enough tokens in the reserve");
        token.transfer(msg.sender, amountTobuy); emit Bought(amountTobuy);
    }

Ich denke, die Kauffunktion ist ziemlich einfach

Die Verkaufsfunktion

Diese Funktion erfordert, dass der Benutzer den Verkaufsbetrag genehmigt hat, indem er die anruft ERC-20 approve Funktion.

Wenn die Verkaufsfunktion aufgerufen wird, rufen wir die auf ERC-20 transferFrom Funktion, um die Tokens von der Anruferadresse zur Vertragsadresse zu übertragen. Wenn die Übertragung erfolgreich ist, senden wir die entsprechende Menge Eth an die Anruferadresse zurück.

    function sell(uint256 amount) public { 
        require(amount > 0, "You need to sell at least some tokens"); 
        uint256 allowance = token.allowance(msg.sender, address(this));
        require(allowance >= amount, "Check the token allowance");
        token.transferFrom(msg.sender, address(this), amount);
        payable(msg.sender).transfer(amount); emit Sold(amount); 
    } 

Cool, wir haben gerade einen Smart Contract für einen sehr einfachen DEX geschrieben. Jetzt kann jeder unseren Token mit Eth kaufen und verkaufen. Hier ist der vollständige Code für die DEX.sol Datei.

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0; 
import "
import './TSTtoken.sol'; 

contract DEX { 

    IERC20 public token; 
    event Bought(uint256 amount); 
    event Sold(uint256 amount); 
    constructor() { 
        token = new TSTtoken(); 
    } 
    
    function buy() payable public {
        uint256 amountTobuy = msg.value; 
        uint256 dexBalance = token.balanceOf(address(this)); 
        require(amountTobuy > 0, "You need to send some ether"); 
        require(amountTobuy <= dexBalance, "Not enough tokens in the reserve");
        token.transfer(msg.sender, amountTobuy); emit Bought(amountTobuy);
    } 
    
    function sell(uint256 amount) public { 
        require(amount > 0, "You need to sell at least some tokens"); 
        uint256 allowance = token.allowance(msg.sender, address(this));
        require(allowance >= amount, "Check the token allowance");
        token.transferFrom(msg.sender, address(this), amount);
        payable(msg.sender).transfer(amount); emit Sold(amount); 
    } 
    
}

Möglichkeiten zur Verbesserung des DEX

  • Implementieren Sie einen Austausch von TSTtoken zu einem anderen ERC20-Token, z. B. DAI, UNI usw

  • Fügen Sie unsere Gebühr für den Kauf und Verkauf des Tokens hinzu

  • Fügen Sie die Liquidität für TSTtoken mit Transaktionsgebühren hinzu, die durch die Implementierung von Uniswap generiert werden addLiquidity/addLiquidityETH-Funktion

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *