முக்கிய உள்ளடக்கத்திற்குச் செல்லவும்

ஒரு Solidity ஸ்மார்ட் ஒப்பந்தத்திலிருந்து ERC-20 டோக்கன்களின் பரிமாற்றங்கள் மற்றும் ஒப்புதல்

ஸ்மார்ட் ஒப்பந்தங்கள்
டோக்கன்கள்
Solidity
erc-20
இடைநிலையாளர்
jdourlens
7 ஏப்ரல், 2020
6 நிமிட வாசிப்பு

முந்தைய பயிற்சியில் Ethereum பிளாக்செயினில் Solidity-இல் உள்ள ஒரு ERC-20 டோக்கனின் உடற்கூறியல் பற்றிப் படித்தோம். இந்தக் கட்டுரையில், Solidity மொழியைப் பயன்படுத்தி ஒரு டோக்கனுடன் தொடர்புகொள்ள ஒரு ஸ்மார்ட் ஒப்பந்தத்தை எவ்வாறு பயன்படுத்தலாம் என்பதைப் பார்ப்போம்.

இந்த ஸ்மார்ட் ஒப்பந்தத்திற்காக, புதிதாகப் பயன்படுத்தப்பட்ட ERC-20 டோக்கனுக்கு ஈதரை (ether) ஒரு பயனர் வர்த்தகம் செய்யக்கூடிய ஒரு உண்மையான மாதிரி பரவலாக்கப்பட்ட பரிமாற்றத்தை (decentralized exchange) உருவாக்குவோம்.

இந்தப் பயிற்சிக்காக, முந்தைய பயிற்சியில் நாம் எழுதிய குறியீட்டை அடிப்படையாகப் பயன்படுத்துவோம். நமது DEX அதன் கன்ஸ்ட்ரக்டரில் (constructor) ஒப்பந்தத்தின் ஒரு நிகழ்வை (instance) உருவாக்கி, பின்வரும் செயல்பாடுகளைச் செய்யும்:

  • டோக்கன்களை ஈதராக மாற்றுதல்
  • ஈதரை டோக்கன்களாக மாற்றுதல்

நமது எளிய 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
அனைத்தையும் காட்டு

நமது புதிய DEX ஸ்மார்ட் ஒப்பந்தம் ERC-20-ஐப் பயன்படுத்தி, வழங்கப்பட்ட அனைத்தையும் பெறும்:

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 // செய்ய வேண்டியவை
14 }
15
16 function sell(uint256 amount) public {
17 // செய்ய வேண்டியவை
18 }
19
20}
அனைத்தையும் காட்டு

எனவே இப்போது நம்மிடம் DEX உள்ளது, மேலும் அதில் அனைத்து டோக்கன் இருப்புகளும் உள்ளன. ஒப்பந்தத்தில் இரண்டு செயல்பாடுகள் (functions) உள்ளன:

  • buy: பயனர் ஈதரை அனுப்பி, அதற்குப் பதிலாக டோக்கன்களைப் பெறலாம்
  • sell: பயனர் டோக்கன்களை அனுப்பி, ஈதரைத் திரும்பப் பெற முடிவு செய்யலாம்

buy செயல்பாடு

buy செயல்பாட்டைக் குறியிடுவோம். முதலில் செய்தியில் உள்ள ஈதரின் அளவைச் சரிபார்த்து, ஒப்பந்தங்களில் போதுமான டோக்கன்கள் இருப்பதையும், செய்தியில் சிறிது ஈதர் இருப்பதையும் உறுதிசெய்ய வேண்டும். ஒப்பந்தத்தில் போதுமான டோக்கன்கள் இருந்தால், அது பயனருக்கு டோக்கன்களின் எண்ணிக்கையை அனுப்பி, Bought நிகழ்வை (event) வெளியிடும்.

பிழை ஏற்பட்டால் require செயல்பாட்டை அழைத்தால், அனுப்பப்பட்ட ஈதர் நேரடியாகத் திரும்பப் பெறப்பட்டு பயனருக்குத் திருப்பித் தரப்படும் என்பதை நினைவில் கொள்ளவும்.

விஷயங்களை எளிமையாக வைத்திருக்க, 1 Wei-க்கு 1 டோக்கனை மட்டுமே பரிமாறுகிறோம்.

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

வாங்குதல் வெற்றிகரமாக நடந்தால், பரிவர்த்தனையில் இரண்டு நிகழ்வுகளை நாம் காண வேண்டும்: டோக்கன் Transfer மற்றும் Bought நிகழ்வு.

பரிவர்த்தனையில் இரண்டு நிகழ்வுகள்: Transfer மற்றும் Bought

sell செயல்பாடு

விற்பனைக்குப் பொறுப்பான செயல்பாடு, முதலில் approve செயல்பாட்டை அழைப்பதன் மூலம் பயனர் அந்தத் தொகைக்கு ஒப்புதல் அளித்திருக்க வேண்டும். பரிமாற்றத்திற்கு ஒப்புதல் அளிக்க, DEX-ஆல் உருவாக்கப்பட்ட ERC20Basic டோக்கனைப் பயனர் அழைக்க வேண்டும். DEX token எனப்படும் ERC20Basic ஒப்பந்தத்தைப் பயன்படுத்திய முகவரியைப் பெற, முதலில் DEX ஒப்பந்தத்தின் token() செயல்பாட்டை அழைப்பதன் மூலம் இதை அடையலாம். பின்னர் நமது அமர்வில் (session) அந்த ஒப்பந்தத்தின் ஒரு நிகழ்வை உருவாக்கி, அதன் approve செயல்பாட்டை அழைக்கிறோம். அதன் பிறகு, DEX-இன் sell செயல்பாட்டை அழைத்து, நமது டோக்கன்களை மீண்டும் ஈதராக மாற்ற முடியும். எடுத்துக்காட்டாக, ஒரு ஊடாடும் brownie அமர்வில் இது இப்படித்தான் இருக்கும்:

1# ### ஊடாடும் பிரவுனி கன்சோலில் பைதான்...
2
3# DEX-ஐ நிலைநிறுத்தவும்
4dex = DEX.deploy({'from':account1})
5
6# ஈதரை டோக்கனாக மாற்ற buy செயல்பாட்டை அழைக்கவும்
7# 1e18 என்பது wei-யில் குறிப்பிடப்படும் 1 ஈதர் ஆகும்
8dex.buy({'from': account2, 1e18})
9
10# ERC20 டோக்கனுக்கான நிலைநிறுத்தப்பட்ட முகவரியைப் பெறவும்
11# இது DEX ஒப்பந்தம் உருவாக்கத்தின் போது நிலைநிறுத்தப்பட்டது
12# dex.token() டோக்கனுக்கான நிலைநிறுத்தப்பட்ட முகவரியை வழங்குகிறது
13token = ERC20Basic.at(dex.token())
14
15# டோக்கனின் approve செயல்பாட்டை அழைக்கவும்
16# dex முகவரியை செலவிடுபவராக அங்கீகரிக்கவும்
17# மேலும் இது உங்களின் எத்தனை டோக்கன்களை செலவிட அனுமதிக்கப்படுகிறது
18token.approve(dex.address, 3e18, {'from':account2})
19
அனைத்தையும் காட்டு

பின்னர் sell செயல்பாடு அழைக்கப்படும்போது, அழைப்பாளர் முகவரியிலிருந்து ஒப்பந்த முகவரிக்கு பரிமாற்றம் வெற்றிகரமாக நடந்ததா என்பதைச் சரிபார்த்து, ஈதர்களை மீண்டும் அழைப்பாளர் முகவரிக்கு அனுப்புவோம்.

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

எல்லாம் சரியாக வேலை செய்தால், பரிவர்த்தனையில் 2 நிகழ்வுகளை (ஒரு Transfer மற்றும் Sold) நீங்கள் காண வேண்டும், மேலும் உங்கள் டோக்கன் இருப்பு மற்றும் ஈதர் இருப்பு புதுப்பிக்கப்பட்டிருக்கும்.

பரிவர்த்தனையில் இரண்டு நிகழ்வுகள்: Transfer மற்றும் Sold

இந்தப் பயிற்சியிலிருந்து, ஒரு ERC-20 டோக்கனின் இருப்பு மற்றும் கொடுப்பனவை (allowance) எவ்வாறு சரிபார்ப்பது என்பதையும், இடைமுகத்தைப் (interface) பயன்படுத்தி ஒரு ERC20 ஸ்மார்ட் ஒப்பந்தத்தின் Transfer மற்றும் TransferFrom-ஐ எவ்வாறு அழைப்பது என்பதையும் பார்த்தோம்.

நீங்கள் ஒரு பரிவர்த்தனையைச் செய்தவுடன், உங்கள் ஒப்பந்தத்தில் செய்யப்பட்ட பரிவர்த்தனைகளுக்காகக் காத்திருந்து அவற்றைப் பற்றிய விவரங்களைப் பெற (opens in a new tab) ஒரு JavaScript பயிற்சி எங்களிடம் உள்ளது, மேலும் உங்களிடம் ABI இருக்கும் வரை டோக்கன் பரிமாற்றங்கள் அல்லது வேறு ஏதேனும் நிகழ்வுகளால் உருவாக்கப்பட்ட நிகழ்வுகளை டிகோட் செய்வதற்கான பயிற்சியும் (opens in a new tab) உள்ளது.

பயிற்சிக்கான முழுமையான குறியீடு இங்கே:

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, "You need to send some ether");
92 require(amountTobuy <= dexBalance, "Not enough tokens in the reserve");
93 token.transfer(msg.sender, amountTobuy);
94 emit Bought(amountTobuy);
95 }
96
97 function sell(uint256 amount) public {
98 require(amount > 0, "You need to sell at least some tokens");
99 uint256 allowance = token.allowance(msg.sender, address(this));
100 require(allowance >= amount, "Check the token allowance");
101 token.transferFrom(msg.sender, address(this), amount);
102 payable(msg.sender).transfer(amount);
103 emit Sold(amount);
104 }
105
106}
அனைத்தையும் காட்டு

பக்கம் கடைசியாகப் புதுப்பிக்கப்பட்டது: 3 மார்ச், 2026

இந்த வழிகாட்டி பயனுள்ளதாக இருந்ததா?