Transfery i zatwierdzenie tokenów ERC-20 z inteligentnego kontraktu Solidity

smart kontrakty

tokeny

Solidity

erc-20

Średnio zaawansowany

jdourlens

EthereumDev

7 kwietnia 2020

6 minuta czytania

W poprzednim samouczku zbadaliśmy anatomię tokena ERC-20 w Solidity na blockchainie Ethereum. W tym artykule zobaczymy, jak możemy użyć inteligentnego kontraktu do interakcji z tokenem, używając języka Solidity.

W ramach tego inteligentnego kontraktu stworzymy prostą, przykładową, zdecentralizowaną giełdę, na której użytkownik może wymieniać ether na nasz nowo wdrożony token ERC-20.

W tym samouczku użyjemy kodu, który napisaliśmy w poprzednim samouczku jako podstawy. Nasz DEX utworzy instancję kontraktu w swoim konstruktorze i wykona następujące operacje:

wymiana tokenów na ether
wymiana etheru na tokeny

Pracę nad kodem naszej zdecentralizowanej giełdy rozpoczniemy od dodania prostej bazy kodu ERC20:

1pragma solidity ^0.8.0;
2
3interface IERC20 {
4
5    function totalSupply() external view returns (uint256);
6    function balanceOf(address account) external view returns (uint256);
7    function allowance(address owner, address spender) external view returns (uint256);
8
9    function transfer(address recipient, uint256 amount) external returns (bool);
10    function approve(address spender, uint256 amount) external returns (bool);
11    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
12
13
14    event Transfer(address indexed from, address indexed to, uint256 value);
15    event Approval(address indexed owner, address indexed spender, uint256 value);
16}
17
18
19contract ERC20Basic is IERC20 {
20
21    string public constant name = "ERC20Basic";
22    string public constant symbol = "ERC";
23    uint8 public constant decimals = 18;
24
25
26    mapping(address => uint256) balances;
27
28    mapping(address => mapping (address => uint256)) allowed;
29
30    uint256 totalSupply_ = 10 ether;
31
32
33   constructor() {
34	balances[msg.sender] = totalSupply_;
35    }
36
37    function totalSupply() public override view returns (uint256) {
38	return totalSupply_;
39    }
40
41    function balanceOf(address tokenOwner) public override view returns (uint256) {
42        return balances[tokenOwner];
43    }
44
45    function transfer(address receiver, uint256 numTokens) public override returns (bool) {
46        require(numTokens <= balances[msg.sender]);
47        balances[msg.sender] = balances[msg.sender]-numTokens;
48        balances[receiver] = balances[receiver]+numTokens;
49        emit Transfer(msg.sender, receiver, numTokens);
50        return true;
51    }
52
53    function approve(address delegate, uint256 numTokens) public override returns (bool) {
54        allowed[msg.sender][delegate] = numTokens;
55        emit Approval(msg.sender, delegate, numTokens);
56        return true;
57    }
58
59    function allowance(address owner, address delegate) public override view returns (uint) {
60        return allowed[owner][delegate];
61    }
62
63    function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
64        require(numTokens <= balances[owner]);
65        require(numTokens <= allowed[owner][msg.sender]);
66
67        balances[owner] = balances[owner]-numTokens;
68        allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
69        balances[buyer] = balances[buyer]+numTokens;
70        emit Transfer(owner, buyer, numTokens);
71        return true;
72    }
73}
74
75

Nasz nowy inteligentny kontrakt DEX wdroży token ERC-20 i otrzyma całą jego podaż:

1contract DEX {
2
3    IERC20 public token;
4
5    event Bought(uint256 amount);
6    event Sold(uint256 amount);
7
8    constructor() {
9        token = new ERC20Basic();
10    }
11
12    function buy() payable public {
13        // DO ZROBIENIA
14    }
15
16    function sell(uint256 amount) public {
17        // DO ZROBIENIA
18    }
19
20}

Więc teraz mamy nasz DEX, który posiada całą dostępną rezerwę tokenów. Kontrakt ma dwie funkcje:

buy: użytkownik może wysyłać ether i otrzymywać w zamian tokeny
sell: użytkownik może wysłać tokeny, aby odzyskać ether

Funkcja `buy`

Zakodujmy funkcję buy. Najpierw będziemy musieli sprawdzić ilość etheru zawartą w komunikacie i zweryfikować, czy kontrakt posiada wystarczającą liczbę tokenów oraz czy komunikat zawiera jakąś ilość etheru. Jeśli kontrakt posiada wystarczającą liczbę tokenów, wyśle on odpowiednią liczbę tokenów do użytkownika i wyemituje zdarzenie Bought.

Zwróć uwagę, że jeśli w przypadku błędu wywołamy funkcję require, wysłany ether zostanie natychmiast zwrócony do użytkownika.

Dla uproszczenia wymieniamy 1 token na 1 wei.

1function buy() payable public {
2    uint256 amountTobuy = msg.value;
3    uint256 dexBalance = token.balanceOf(address(this));
4    require(amountTobuy > 0, "Musisz wysłać trochę etheru");
5    require(amountTobuy <= dexBalance, "Niewystarczająca liczba tokenów w rezerwie");
6    token.transfer(msg.sender, amountTobuy);
7    emit Bought(amountTobuy);
8}

W przypadku pomyślnego zakupu powinniśmy zobaczyć w transakcji dwa zdarzenia: Transfer tokena oraz zdarzenie Bought.

Funkcja `sell`

Funkcja odpowiedzialna za sprzedaż (sell) będzie w pierwszej kolejności wymagać od użytkownika zatwierdzenia kwoty poprzez wcześniejsze wywołanie funkcji approve. Zatwierdzenie transferu wymaga od użytkownika wywołania funkcji na instancji tokena ERC20Basic utworzonej przez DEX. Można to osiągnąć, najpierw wywołując funkcję token() kontraktu DEX, aby pobrać adres, pod którym kontrakt DEX wdrożył kontrakt ERC20Basic. Następnie tworzymy instancję tego kontraktu w naszej sesji i wywołujemy jego funkcję approve. Następnie możemy wywołać funkcję sell kontraktu DEX i wymienić nasze tokeny z powrotem na ether. Na przykład tak to wygląda w interaktywnej sesji brownie:

1#### Python w interaktywnej konsoli brownie...
2
3# wdróż DEX
4dex = DEX.deploy({'from':account1})
5
6# wywołaj funkcję buy, aby wymienić ether na tokeny
7# 1e18 to 1 ether wyrażony w wei
8dex.buy({'from': account2, 1e18})
9
10# pobierz adres wdrożenia tokena ERC20,
11# który został wdrożony podczas tworzenia kontraktu DEX
12# dex.token() zwraca adres wdrożonego tokena
13token = ERC20Basic.at(dex.token())
14
15# wywołaj funkcję approve tokena
16# zatwierdź adres dex jako 'spendera' (wydającego)
17# i określ, ile Twoich tokenów może on wydać
18token.approve(dex.address, 3e18, {'from':account2})
19

Następnie, po wywołaniu funkcji sell, sprawdzimy, czy transfer z adresu wywołującego na adres kontraktu powiódł się, a następnie odeślemy ether z powrotem na adres wywołującego.

1function sell(uint256 amount) public {
2    require(amount > 0, "Musisz sprzedać co najmniej jakąś liczbę tokenów");
3    uint256 allowance = token.allowance(msg.sender, address(this));
4    require(allowance >= amount, "Sprawdź przydział tokenów");
5    token.transferFrom(msg.sender, address(this), amount);
6    payable(msg.sender).transfer(amount);
7    emit Sold(amount);
8}

Jeśli wszystko zadziała poprawnie, w transakcji powinny być widoczne 2 zdarzenia (Transfer i Sold), a salda tokenów i etheru zostaną zaktualizowane.

W tym samouczku zobaczyliśmy, jak sprawdzić saldo i przydział (allowance) tokena ERC-20, a także jak wywołać funkcje Transfer i TransferFrom inteligentnego kontraktu ERC20 za pomocą interfejsu.

Po wykonaniu transakcji polecamy nasz samouczek JavaScript, aby dowiedzieć się, jak oczekiwać na transakcje i pobierać ich szczegóły (opens in a new tab) dla kontraktu, oraz samouczek dotyczący dekodowania zdarzeń (opens in a new tab) generowanych przez transfery tokenów lub inne, pod warunkiem posiadania ABI.

Oto kompletny kod do tego samouczka:

1pragma solidity ^0.8.0;
2
3interface IERC20 {
4
5    function totalSupply() external view returns (uint256);
6    function balanceOf(address account) external view returns (uint256);
7    function allowance(address owner, address spender) external view returns (uint256);
8
9    function transfer(address recipient, uint256 amount) external returns (bool);
10    function approve(address spender, uint256 amount) external returns (bool);
11    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
12
13
14    event Transfer(address indexed from, address indexed to, uint256 value);
15    event Approval(address indexed owner, address indexed spender, uint256 value);
16}
17
18
19contract ERC20Basic is IERC20 {
20
21    string public constant name = "ERC20Basic";
22    string public constant symbol = "ERC";
23    uint8 public constant decimals = 18;
24
25
26    mapping(address => uint256) balances;
27
28    mapping(address => mapping (address => uint256)) allowed;
29
30    uint256 totalSupply_ = 10 ether;
31
32
33   constructor() {
34	balances[msg.sender] = totalSupply_;
35    }
36
37    function totalSupply() public override view returns (uint256) {
38	return totalSupply_;
39    }
40
41    function balanceOf(address tokenOwner) public override view returns (uint256) {
42        return balances[tokenOwner];
43    }
44
45    function transfer(address receiver, uint256 numTokens) public override returns (bool) {
46        require(numTokens <= balances[msg.sender]);
47        balances[msg.sender] = balances[msg.sender]-numTokens;
48        balances[receiver] = balances[receiver]+numTokens;
49        emit Transfer(msg.sender, receiver, numTokens);
50        return true;
51    }
52
53    function approve(address delegate, uint256 numTokens) public override returns (bool) {
54        allowed[msg.sender][delegate] = numTokens;
55        emit Approval(msg.sender, delegate, numTokens);
56        return true;
57    }
58
59    function allowance(address owner, address delegate) public override view returns (uint) {
60        return allowed[owner][delegate];
61    }
62
63    function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
64        require(numTokens <= balances[owner]);
65        require(numTokens <= allowed[owner][msg.sender]);
66
67        balances[owner] = balances[owner]-numTokens;
68        allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
69        balances[buyer] = balances[buyer]+numTokens;
70        emit Transfer(owner, buyer, numTokens);
71        return true;
72    }
73}
74
75
76contract DEX {
77
78    event Bought(uint256 amount);
79    event Sold(uint256 amount);
80
81
82    IERC20 public token;
83
84    constructor() {
85        token = new ERC20Basic();
86    }
87
88    function buy() payable public {
89        uint256 amountTobuy = msg.value;
90        uint256 dexBalance = token.balanceOf(address(this));
91        require(amountTobuy > 0, "Musisz wysłać trochę etheru");
92        require(amountTobuy <= dexBalance, "Niewystarczająca liczba tokenów w rezerwie");
93        token.transfer(msg.sender, amountTobuy);
94        emit Bought(amountTobuy);
95    }
96
97    function sell(uint256 amount) public {
98        require(amount > 0, "Musisz sprzedać co najmniej jakąś liczbę tokenów");
99        uint256 allowance = token.allowance(msg.sender, address(this));
100        require(allowance >= amount, "Sprawdź przydział tokenów");
101        token.transferFrom(msg.sender, address(this), amount);
102        payable(msg.sender).transfer(amount);
103        emit Sold(amount);
104    }
105
106}

Strona ostatnio zaktualizowana: 3 marca 2026

+13

Transfery i zatwierdzenie tokenów ERC-20 z inteligentnego kontraktu Solidity

Funkcja buy

Funkcja sell

Czy ten samouczek był pomocny?

Funkcja `buy`

Funkcja `sell`