ERC-223 தரநிலைக் குறி

அறிமுகம்

ERC-223 என்றால் என்ன?

ERC-223 என்பது ERC-20 தரநிலையைப் போன்ற fungible டோக்கன்களுக்கான ஒரு தரநிலையாகும். முக்கிய வேறுபாடு என்னவென்றால், ERC-223 டோக்கன் பயன்பாட்டு நிரலாக்க இடைமுகத்தை மட்டும் வரையறுக்காமல், அனுப்புநரிடமிருந்து பெறுநருக்கு டோக்கன்களை மாற்றுவதற்கான தர்க்கத்தையும் வரையறுக்கிறது. பெறுநரின் பக்கத்தில் டோக்கன் இடமாற்றங்களைக் கையாள அனுமதிக்கும் ஒரு தொடர்பு மாதிரியை இது அறிமுகப்படுத்துகிறது.

ERC-20 இலிருந்து வேறுபாடுகள்

ERC-223, ERC-20-இன் சில வரம்புகளை நிவர்த்தி செய்கிறது மற்றும் டோக்கன் ஒப்பந்தத்திற்கும் டோக்கன்களைப் பெறக்கூடிய ஒரு ஒப்பந்தத்திற்கும் இடையில் ஒரு புதிய தொடர்பு முறையை அறிமுகப்படுத்துகிறது. ERC-223 உடன் சாத்தியமான சில விஷயங்கள் ERC-20 உடன் சாத்தியமில்லை:

பெறுநரின் பக்கத்தில் டோக்கன் பரிமாற்றத்தைக் கையாளுதல்: ஒரு ERC-223 டோக்கன் டெபாசிட் செய்யப்படுகிறது என்பதை பெறுநர்களால் கண்டறிய முடியும்.
முறையற்ற முறையில் அனுப்பப்பட்ட டோக்கன்களை நிராகரித்தல்: ஒரு பயனர், டோக்கன்களைப் பெறக் கூடாத ஒப்பந்தத்திற்கு ERC-223 டோக்கன்களை அனுப்பினால், அந்த ஒப்பந்தம் பரிவர்த்தனையை நிராகரித்து, டோக்கன் இழப்பைத் தடுக்கும்.
பரிமாற்றங்களில் உள்ள மீதரவு: ERC-223 டோக்கன்கள் மீதரவை உள்ளடக்கலாம், இது டோக்கன் பரிவர்த்தனைகளுடன் தன்னிச்சையான தகவல்களை இணைக்க அனுமதிக்கிறது.

முன்னேற்றக் கட்டுரை

உள்ளடக்கம்

ERC-223 என்பது ஸ்மார்ட் ஒப்பந்தங்களுக்குள் உள்ள டோக்கன்களுக்காக ஒரு பயன்பாட்டு நிரலாக்க இடைமுகத்தை (API) செயல்படுத்தும் ஒரு டோக்கன் தரநிலையாகும். ERC-223 டோக்கன்களைப் பெற வேண்டிய ஒப்பந்தங்களுக்காக இது ஒரு பயன்பாட்டு நிரலாக்க இடைமுகத்தையும் (API) அறிவிக்கிறது. ERC-223 பெறுநர் பயன்பாட்டு நிரலாக்க இடைமுகத்தை (API) ஆதரிக்காத ஒப்பந்தங்களால் ERC-223 டோக்கன்களைப் பெற முடியாது, இது பயனர் பிழையைத் தடுக்கிறது.

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

இந்தச் செயல்பாடுகளை மட்டும் கொண்டிருக்க வேண்டிய கட்டாயம் இந்த ஒப்பந்தத்திற்கு இல்லை மற்றும் ஒரு உருவாக்குநர் வெவ்வேறு டோக்கன் தரநிலைகளிலிருந்து வேறு எந்த அம்சத்தையும் இந்த ஒப்பந்தத்தில் சேர்க்கலாம். உதாரணமாக, approve மற்றும் transferFrom செயல்பாடுகள் ERC-223 தரநிலையின் ஒரு பகுதியாக இல்லை, ஆனால் தேவைப்பட்டால் இந்த செயல்பாடுகளைச் செயல்படுத்தலாம்.

EIP-223opens in a new tab இலிருந்து:

முறைகள்

ERC-223 டோக்கன் பின்வரும் முறைகளைச் செயல்படுத்த வேண்டும்:

1function name() public view returns (string)
2function symbol() public view returns (string)
3function decimals() public view returns (uint8)
4function totalSupply() public view returns (uint256)
5function balanceOf(address _owner) public view returns (uint256 balance)
6function transfer(address _to, uint256 _value) public returns (bool success)
7function transfer(address _to, uint256 _value, bytes calldata _data) public returns (bool success)

ERC-223 டோக்கன்களைப் பெற வேண்டிய ஒரு ஒப்பந்தம் பின்வரும் முறையைச் செயல்படுத்த வேண்டும்:

1function tokenReceived(address _from, uint _value, bytes calldata _data)

tokenReceived(..) செயல்பாட்டைச் செயல்படுத்தாத ஒப்பந்தத்திற்கு ERC-223 டோக்கன்கள் அனுப்பப்பட்டால், பரிமாற்றம் தோல்வியடைய வேண்டும் மற்றும் டோக்கன்கள் அனுப்புநரின் இருப்பிலிருந்து நகர்த்தப்படக்கூடாது.

நிகழ்வுகள்

1event Transfer(address indexed _from, address indexed _to, uint256 _value, bytes calldata _data)

எடுத்துக்காட்டுகள்

ERC-223 டோக்கனின் பயன்பாட்டு நிரலாக்க இடைமுகம் (API) ERC-20-ஐப் போன்றது, எனவே UI மேம்பாட்டுக் கண்ணோட்டத்தில் எந்த வேறுபாடும் இல்லை. இங்குள்ள ஒரே விதிவிலக்கு என்னவென்றால், ERC-223 டோக்கன்களில் approve + transferFrom செயல்பாடுகள் இல்லாமல் இருக்கலாம், ஏனெனில் இவை இந்த தரநிலைக்கு விருப்பத்தேர்வானவை.

Solidity எடுத்துக்காட்டுகள்

ஒரு அடிப்படை ERC-223 டோக்கன் ஒப்பந்தம் எவ்வாறு செயல்படுகிறது என்பதை பின்வரும் எடுத்துக்காட்டு விளக்குகிறது:

1pragma solidity ^0.8.19;
2abstract contract IERC223Recipient {
3    function tokenReceived(address _from, uint _value, bytes memory _data) public virtual;
4}
5contract VeryBasicERC223Token {
6    event Transfer(address indexed from, address indexed to, uint value, bytes data);
7    string  private _name;
8    string  private _symbol;
9    uint8   private _decimals;
10    uint256 private _totalSupply;
11    mapping(address => uint256) private balances;
12    function name() public view returns (string memory) { return _name; }
13    function symbol() public view returns (string memory) {return _symbol; }
14    function decimals() public view returns (uint8) { return _decimals; }
15    function totalSupply() public view returns (uint256) { return _totalSupply; }
16    function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; }
17    function isContract(address account) internal view returns (bool) {
18        uint256 size;
19        assembly { size := extcodesize(account) }
20        return size > 0;
21    }
22    function transfer(address _to, uint _value, bytes calldata _data) public returns (bool success){
23        balances[msg.sender] = balances[msg.sender] - _value;
24        balances[_to] = balances[_to] + _value;
25        if(isContract(_to)) {
26            IERC223Recipient(_to).tokenReceived(msg.sender, _value, _data);
27        }
28        emit Transfer(msg.sender, _to, _value, _data);
29        return true;
30    }
31    function transfer(address _to, uint _value) public returns (bool success){
32        bytes memory _empty = hex"00000000";
33        balances[msg.sender] = balances[msg.sender] - _value;
34        balances[_to] = balances[_to] + _value;
35        if(isContract(_to)) {
36            IERC223Recipient(_to).tokenReceived(msg.sender, _value, _empty);
37        }
38        emit Transfer(msg.sender, _to, _value, _empty);
39        return true;
40    }
41}
அனைத்தையும் காட்டு

இப்போது, tokenA ஒரு ERC-223 டோக்கன் என்று கருதி, tokenA-இன் டெபாசிட்களை ஏற்க மற்றொரு ஒப்பந்தம் நமக்குத் தேவை. அந்த ஒப்பந்தம் tokenA-ஐ மட்டுமே ஏற்க வேண்டும் மற்றும் வேறு எந்த டோக்கன்களையும் நிராகரிக்க வேண்டும். ஒப்பந்தம் tokenA-ஐப் பெறும்போது, அது ஒரு Deposit() நிகழ்வை வெளியிட வேண்டும் மற்றும் உள் deposits மாறியின் மதிப்பை அதிகரிக்க வேண்டும்.

இதோ அந்தக் குறியீடு:

1contract RecipientContract is IERC223Recipient {
2    event Deposit(address whoSentTheTokens);
3    uint256 deposits = 0;
4    address tokenA; // நாம் ஏற்க விரும்பும் ஒரே டோக்கன்.
5    function tokenReceived(address _from, uint _value, bytes memory _data) public override
6    {
7        // இந்தச் செயல்பாட்டிற்குள் என்பதைப் புரிந்துகொள்வது அவசியம்
8        // msg.sender என்பது பெறப்படும் டோக்கனின் முகவரி,
9        // msg.value எப்போதுமே 0 ஆக இருக்கும், ஏனெனில் டோக்கன் ஒப்பந்தம் பெரும்பாலான சந்தர்ப்பங்களில் ஈதரை சொந்தமாக வைத்திருக்கவோ அல்லது அனுப்பவோ இல்லை,
10        // _from      என்பது டோக்கன் பரிமாற்றத்தை அனுப்புபவர்,
11        // _value     என்பது டெபாசிட் செய்யப்பட்ட டோக்கன்களின் அளவு.
12        require(msg.sender == tokenA);
13        deposits += _value;
14        emit Deposit(_from);
15    }
16}
அனைத்தையும் காட்டு

Frequently asked questions

நாம் சில tokenB-ஐ ஒப்பந்தத்திற்கு அனுப்பினால் என்ன நடக்கும்?

பரிவர்த்தனை தோல்வியடையும், மற்றும் டோக்கன்களின் பரிமாற்றம் நடக்காது. டோக்கன்கள் அனுப்புநரின் முகவரிக்குத் திருப்பி அனுப்பப்படும்.

இந்த ஒப்பந்தத்தில் நாம் எப்படி டெபாசிட் செய்வது?

RecipientContract-இன் முகவரியைக் குறிப்பிடும் ERC-223 டோக்கனின் transfer(address,uint256) அல்லது transfer(address,uint256,bytes) செயல்பாட்டை அழைக்கவும்.

நாம் ஒரு ERC-20 டோக்கனை இந்த ஒப்பந்தத்திற்கு மாற்றினால் என்ன நடக்கும்?

RecipientContract-க்கு ஒரு ERC-20 டோக்கன் அனுப்பப்பட்டால், டோக்கன்கள் மாற்றப்படும், ஆனால் அந்தப் பரிமாற்றம் அங்கீகரிக்கப்படாது (Deposit() நிகழ்வு எதுவும் வெளியிடப்படாது, மேலும் டெபாசிட் மதிப்பு மாறாது). தேவையற்ற ERC-20 டெபாசிட்களை வடிகட்டவோ அல்லது தடுக்கவோ முடியாது.

டோக்கன் டெபாசிட் முடிந்த பிறகு சில செயல்பாடுகளை இயக்க விரும்பினால் என்ன செய்வது?

அவ்வாறு செய்ய பல வழிகள் உள்ளன. இந்த எடுத்துக்காட்டில், ERC-223 பரிமாற்றங்களை ஈதர் பரிமாற்றங்களைப் போலவே ஆக்கும் முறையைப் பின்பற்றுவோம்:

1contract RecipientContract is IERC223Recipient {
2    event Foo();
3    event Bar(uint256 someNumber);
4    address tokenA; // நாம் ஏற்க விரும்பும் ஒரே டோக்கன்.
5    function tokenReceived(address _from, uint _value, bytes memory _data) public override
6    {
7        require(msg.sender == tokenA);
8        address(this).call(_data); // உள்வரும் பரிவர்த்தனையைக் கையாண்டு, அடுத்தடுத்த செயல்பாட்டு அழைப்பைச் செய்யவும்.
9    }
10    function foo() public
11    {
12        emit Foo();
13    }
14    function bar(uint256 _someNumber) public
15    {
16        emit Bar(_someNumber);
17    }
18}
அனைத்தையும் காட்டு

RecipientContract ஒரு ERC-223 டோக்கனைப் பெறும்போது, ஈதர் பரிவர்த்தனைகள் செயல்பாட்டு அழைப்புகளை பரிவர்த்தனை data-ஆகக் குறியாக்கம் செய்வதைப் போலவே, அந்த ஒப்பந்தமும் டோக்கன் பரிவர்த்தனையின் _data அளவுருவாகக் குறியாக்கம் செய்யப்பட்ட ஒரு செயல்பாட்டை இயக்கும். மேலும் தகவலுக்கு தரவுப் புலம்-த்தைப் படிக்கவும்.

மேலே உள்ள எடுத்துக்காட்டில், ஒரு ERC-223 டோக்கன் transfer(address,uin256,bytes calldata _data) செயல்பாட்டுடன் RecipientContract-இன் முகவரிக்கு மாற்றப்பட வேண்டும். தரவு அளவுரு 0xc2985578 (foo() செயல்பாட்டின் கையொப்பம்) ஆக இருந்தால், டோக்கன் டெபாசிட் பெறப்பட்ட பிறகு foo() செயல்பாடு அழைக்கப்பட்டு, Foo() நிகழ்வு வெளியிடப்படும்.

டோக்கன் பரிமாற்றத்தின் data-விலும் அளவுருக்களை குறியாக்கம் செய்யலாம், உதாரணமாக, _someNumber-க்கு 12345 மதிப்புடன் bar() செயல்பாட்டை நாம் அழைக்கலாம். இந்த நிலையில் data, 0x0423a13200000000000000000000000000000000000000000000000000000000000004d2 ஆக இருக்க வேண்டும், இதில் 0x0423a132 என்பது bar(uint256) செயல்பாட்டின் கையொப்பம் மற்றும் 00000000000000000000000000000000000000000000000000000000000004d2 என்பது uint256 ஆக 12345 ஆகும்.

வரம்புகள்

ERC-223, ERC-20 தரநிலையில் காணப்படும் பல சிக்கல்களை நிவர்த்தி செய்தாலும், அதற்கும் சில வரம்புகள் உள்ளன:

ஏற்றுக்கொள்ளுதல் மற்றும் இணக்கத்தன்மை: ERC-223 இன்னும் பரவலாக ஏற்றுக்கொள்ளப்படவில்லை, இது தற்போதுள்ள கருவிகள் மற்றும் தளங்களுடனான அதன் இணக்கத்தன்மையைக் கட்டுப்படுத்தக்கூடும்.
பழையவற்றுடன் இணக்கத்தன்மை: ERC-223, ERC-20 உடன் பழையவற்றிற்கு இணக்கத்தன்மை கொண்டதல்ல, அதாவது தற்போதுள்ள ERC-20 ஒப்பந்தங்கள் மற்றும் கருவிகள் மாற்றங்கள் இல்லாமல் ERC-223 டோக்கன்களுடன் வேலை செய்யாது.
கேஸ் செலவுகள்: ERC-223 பரிமாற்றங்களில் உள்ள கூடுதல் சோதனைகள் மற்றும் செயல்பாடுகள், ERC-20 பரிவர்த்தனைகளுடன் ஒப்பிடும்போது அதிக கேஸ் செலவுகளை ஏற்படுத்தக்கூடும்.