diff --git a/public/content/translations/ta/developers/docs/smart-contracts/anatomy/index.md b/public/content/translations/ta/developers/docs/smart-contracts/anatomy/index.md new file mode 100644 index 00000000000..246a3739136 --- /dev/null +++ b/public/content/translations/ta/developers/docs/smart-contracts/anatomy/index.md @@ -0,0 +1,657 @@ +--- +title: "ஸ்மார்ட் ஒப்பந்தங்களின் உடற்கூறியல்" +description: "ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் உடற்கூறியல் பற்றிய ஆழமான பார்வை – செயல்பாடுகள், தரவு மற்றும் மாறிகள்." +lang: ta +--- + +ஸ்மார்ட் ஒப்பந்தம் என்பது எத்தேரியத்தில் ஒரு முகவரியில் இயங்கும் ஒரு நிரலாகும். அவை ஒரு பரிவர்த்தனையைப் பெற்றவுடன் செயல்படுத்தக்கூடிய தரவு மற்றும் செயல்பாடுகளால் ஆனவை. ஒரு ஸ்மார்ட் ஒப்பந்தத்தை உருவாக்குவது என்ன என்பது பற்றிய மேலோட்டம் இங்கே உள்ளது. + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +முதலில் [ஸ்மார்ட் ஒப்பந்தங்கள்](/developers/docs/smart-contracts/) பற்றி நீங்கள் படித்திருப்பதை உறுதிப்படுத்திக் கொள்ளுங்கள். ஜாவாஸ்கிரிப்ட் அல்லது பைத்தான் போன்ற நிரலாக்க மொழிகளுடன் நீங்கள் ஏற்கனவே பரிச்சயமானவர் என்று இந்த ஆவணம் கருதுகிறது. + +## தரவு {#data} + +எந்தவொரு ஒப்பந்தத் தரவும் ஒரு இருப்பிடத்திற்கு ஒதுக்கப்பட வேண்டும்: ஒன்று `storage` அல்லது `memory`. ஒரு ஸ்மார்ட் ஒப்பந்தத்தில் சேமிப்பகத்தை மாற்றுவது செலவு மிக்கது, எனவே உங்கள் தரவு எங்கே இருக்க வேண்டும் என்பதை நீங்கள் கருத்தில் கொள்ள வேண்டும். + +### சேமிப்பகம் {#storage} + +தொடர்ச்சியான தரவு சேமிப்பகம் என குறிப்பிடப்படுகிறது மற்றும் நிலை மாறிகளால் குறிப்பிடப்படுகிறது. இந்த மதிப்புகள் பிளாக்செயினில் நிரந்தரமாக சேமிக்கப்படுகின்றன. நீங்கள் வகையை அறிவிக்க வேண்டும், இதனால் ஒப்பந்தம் தொகுக்கப்படும்போது பிளாக்செயினில் எவ்வளவு சேமிப்பிடம் தேவைப்படுகிறது என்பதை கண்காணிக்க முடியும். + +```solidity +// சொலிடிட்டி எடுத்துக்காட்டு +contract SimpleStorage { + uint storedData; // நிலை மாறி + // ... +} +``` + +```python +# வைப்பர் எடுத்துக்காட்டு +storedData: int128 +``` + +நீங்கள் ஏற்கனவே பொருள் சார்ந்த நிரலாக்க மொழிகளை நிரலாக்கம் செய்திருந்தால், பெரும்பாலான வகைகளை நீங்கள் அறிந்திருக்க வாய்ப்புள்ளது. இருப்பினும், நீங்கள் எத்தேரியம் உருவாக்கத்திற்குப் புதியவராக இருந்தால், `address` உங்களுக்குப் புதிதாக இருக்க வேண்டும். + +ஒரு `address` வகை ஒரு எத்தேரியம் முகவரியை வைத்திருக்க முடியும், இது 20 பைட்டுகள் அல்லது 160 பிட்டுகளுக்குச் சமம். இது முன்னணி 0x உடன் ஹெக்ஸாடெசிமல் குறியீட்டில் திரும்புகிறது. + +பிற வகைகள்: + +- பூலியன் +- முழு எண் +- நிலையான புள்ளி எண்கள் +- நிலையான அளவு பைட் வரிசைகள் +- மாறும் அளவிலான பைட் வரிசைகள் +- விகிதமுறு மற்றும் முழு எண் எழுத்துருக்கள் +- சரம் எழுத்துருக்கள் +- ஹெக்ஸாடெசிமல் எழுத்துருக்கள் +- எண்கள் + +மேலும் விளக்கத்திற்கு, இந்த ஆவணங்களைப் பாருங்கள்: + +- [வைப்பர் வகைகளைப் பார்க்கவும்](https://docs.vyperlang.org/en/v0.1.0-beta.6/types.html#value-types) +- [சொலிடிட்டி வகைகளைப் பார்க்கவும்](https://docs.soliditylang.org/en/latest/types.html#value-types) + +### நினைவகம் {#memory} + +ஒரு ஒப்பந்த செயல்பாட்டின் செயலாக்கத்தின் வாழ்நாளில் மட்டுமே சேமிக்கப்படும் மதிப்புகள் நினைவக மாறிகள் என்று அழைக்கப்படுகின்றன. இவை பிளாக்செயினில் நிரந்தரமாக சேமிக்கப்படாததால், அவற்றைப் பயன்படுத்துவது மிகவும் மலிவானது. + +EVM தரவை (சேமிப்பகம், நினைவகம் மற்றும் அடுக்கு) எவ்வாறு சேமிக்கிறது என்பதைப் பற்றி [சொலிடிட்டி ஆவணங்களில்](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#storage-memory-and-the-stack) மேலும் அறியவும். + +### சூழல் மாறிகள் {#environment-variables} + +உங்கள் ஒப்பந்தத்தில் நீங்கள் வரையறுக்கும் மாறிகளுக்கு கூடுதலாக, சில சிறப்பு உலகளாவிய மாறிகள் உள்ளன. அவை முதன்மையாக பிளாக்செயின் அல்லது தற்போதைய பரிவர்த்தனை பற்றிய தகவல்களை வழங்க பயன்படுத்தப்படுகின்றன. + +எடுத்துக்காட்டுகள்: + +| **பண்பு** | **நிலை மாறி** | **விளக்கம்** | +| ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- | +| `block.timestamp` | uint256 | தற்போதைய பிளாக் யுக நேரமுத்திரை | +| `msg.sender` | மிகவும் பொதுவாக, இது வெளிப்புறமாக சொந்தமான கணக்கு (EOA) அல்லது ஒப்பந்தத்தை குறிக்கிறது (இது இலக்கு முகவரி) பெறலாம் அல்லது பிளாக்செயினில் பரிமாற்றங்களை அனுப்பலாம் (மூல முகவரி). மேலும் குறிப்பாக, இது ஒரு ஈ. சி. டி. எஸ். ஏ பொது விசையின் கெக்காக் ஹாஷின் சரியான 160 பிட்கள் ஆகும் | செய்தியை அனுப்புபவர் (தற்போதைய அழைப்பு) | + +## செயல்பாடுகள் {#functions} + +மிகவும் எளிமையான சொற்களில், உள்வரும் பரிவர்த்தனைகளுக்கு பதிலளிக்கும் விதமாக செயல்பாடுகள் தகவல்களைப் பெறலாம் அல்லது அமைக்கலாம். + +செயல்பாட்டு அழைப்புகளில் இரண்டு வகைகள் உள்ளன: + +- `internal` – இவை ஒரு EVM அழைப்பை உருவாக்காது + - உள்ளக செயல்பாடுகள் மற்றும் நிலை மாறிகளை உள்வழியாக மட்டுமே அணுக முடியும் (அதாவது, தற்போதைய ஒப்பந்தத்திற்குள் அல்லது அதிலிருந்து பெறப்பட்ட ஒப்பந்தங்களிலிருந்து) +- `external` – இவை ஒரு EVM அழைப்பை உருவாக்குகின்றன + - வெளிப்புற செயல்பாடுகள் ஒப்பந்த இடைமுகத்தின் ஒரு பகுதியாகும், அதாவது அவற்றை மற்ற ஒப்பந்தங்களிலிருந்தும் பரிவர்த்தனைகள் வழியாகவும் அழைக்கலாம். ஒரு வெளிப்புற செயல்பாடு `f` ஐ உள்வழியாக அழைக்க முடியாது (அதாவது, `f()` வேலை செய்யாது, ஆனால் `this.f()` வேலை செய்யும்). + +அவை `public` அல்லது `private` ஆகவும் இருக்கலாம் + +- `public` செயல்பாடுகளை ஒப்பந்தத்திற்குள் இருந்தே உள்வழியாகவோ அல்லது செய்திகள் மூலம் வெளிப்புறமாகவோ அழைக்கப்படலாம் +- `private` செயல்பாடுகள் அவை வரையறுக்கப்பட்ட ஒப்பந்தத்திற்கு மட்டுமே தெரியும் மற்றும் பெறப்பட்ட ஒப்பந்தங்களில் தெரியாது + +செயல்பாடுகள் மற்றும் நிலை மாறிகள் இரண்டையும் பொது அல்லது தனியாராக ஆக்கலாம் + +ஒரு ஒப்பந்தத்தில் ஒரு நிலை மாறியைப் புதுப்பிப்பதற்கான ஒரு செயல்பாடு இங்கே உள்ளது: + +```solidity +// சொலிடிட்டி எடுத்துக்காட்டு +function update_name(string value) public { + dapp_name = value; +} +``` + +- `string` வகையின் `value` என்ற அளவுரு `update_name` என்ற செயல்பாட்டிற்கு அனுப்பப்படுகிறது +- இது `public` என அறிவிக்கப்பட்டுள்ளது, அதாவது யார் வேண்டுமானாலும் அதை அணுகலாம் +- இது `view` என அறிவிக்கப்படவில்லை, எனவே இது ஒப்பந்த நிலையை மாற்றியமைக்க முடியும் + +### காட்சி செயல்பாடுகள் {#view-functions} + +இந்த செயல்பாடுகள் ஒப்பந்தத்தின் தரவு நிலையை மாற்றியமைக்காது என்று உறுதியளிக்கின்றன. பொதுவான எடுத்துக்காட்டுகள் "getter" செயல்பாடுகள் ஆகும் – எடுத்துக்காட்டாக, ஒரு பயனரின் இருப்பைப் பெற இதைப் பயன்படுத்தலாம். + +```solidity +// சொலிடிட்டி எடுத்துக்காட்டு +function balanceOf(address _owner) public view returns (uint256 _balance) { + return ownerPizzaCount[_owner]; +} +``` + +```python +dappName: public(string) + +@view +@public +def readName() -> string: + return dappName +``` + +நிலையை மாற்றுவதாகக் கருதப்படுபவை: + +1. நிலை மாறிகளில் எழுதுதல். +2. [நிகழ்வுகளை வெளியிடுதல்](https://docs.soliditylang.org/en/v0.7.0/contracts.html#events). +3. [பிற ஒப்பந்தங்களை உருவாக்குதல்](https://docs.soliditylang.org/en/v0.7.0/control-structures.html#creating-contracts). +4. `selfdestruct`-ஐப் பயன்படுத்துதல். +5. அழைப்புகள் மூலம் ஈதரை அனுப்புதல். +6. `view` அல்லது `pure` எனக் குறிக்கப்படாத எந்தச் செயல்பாட்டையும் அழைத்தல். +7. தாழ்-நிலை அழைப்புகளைப் பயன்படுத்துதல். +8. குறிப்பிட்ட ஆப்கோடுகளைக் கொண்டிருக்கும் இன்லைன் அசெம்பிளியைப் பயன்படுத்துதல். + +### உருவாக்கிச் செயல்பாடுகள் {#constructor-functions} + +`constructor` செயல்பாடுகள் ஒப்பந்தம் முதலில் வரிசைப்படுத்தப்படும்போது ஒருமுறை மட்டுமே செயல்படுத்தப்படுகின்றன. பல வகுப்பு-அடிப்படையிலான நிரலாக்க மொழிகளில் உள்ள `constructor` போலவே, இந்தச் செயல்பாடுகள் பெரும்பாலும் நிலை மாறிகளை அவற்றின் குறிப்பிட்ட மதிப்புகளுக்கு துவக்குகின்றன. + +```solidity +// சொலிடிட்டி எடுத்துக்காட்டு +// ஒப்பந்தத்தின் தரவைத் துவக்கி, `owner`-ஐ அமைக்கிறது +// ஒப்பந்தத்தை உருவாக்கியவரின் முகவரிக்கு. +constructor() public { + // அனைத்து ஸ்மார்ட் ஒப்பந்தங்களும் அவற்றின் செயல்பாடுகளைத் தூண்டுவதற்கு வெளிப்புற பரிவர்த்தனைகளைச் சார்ந்துள்ளன. + // `msg` என்பது கொடுக்கப்பட்ட பரிவர்த்தனையில் தொடர்புடைய தரவை உள்ளடக்கிய ஒரு உலகளாவிய மாறி, + // அனுப்புநரின் முகவரி மற்றும் பரிவர்த்தனையில் சேர்க்கப்பட்டுள்ள ETH மதிப்பு போன்றவை. + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/units-and-global-variables.html#block-and-transaction-properties + owner = msg.sender; +} +``` + +```python +# வைப்பர் எடுத்துக்காட்டு + +@external +def __init__(_beneficiary: address, _bidding_time: uint256): + self.beneficiary = _beneficiary + self.auctionStart = block.timestamp + self.auctionEnd = self.auctionStart + _bidding_time +``` + +### உள்ளமைக்கப்பட்ட செயல்பாடுகள் {#built-in-functions} + +உங்கள் ஒப்பந்தத்தில் நீங்கள் வரையறுக்கும் மாறிகள் மற்றும் செயல்பாடுகளுக்கு கூடுதலாக, சில சிறப்பு உள்ளமைக்கப்பட்ட செயல்பாடுகள் உள்ளன. மிகவும் தெளிவான உதாரணம்: + +- `address.send()` – சொலிடிட்டி +- `send(address)` – வைப்பர் + +இவை ஒப்பந்தங்கள் பிற கணக்குகளுக்கு ETH அனுப்ப அனுமதிக்கின்றன. + +## செயல்பாடுகளை எழுதுதல் {#writing-functions} + +உங்கள் செயல்பாட்டிற்குத் தேவை: + +- அளவுரு மாறி மற்றும் வகை (அது அளவுருக்களை ஏற்றுக்கொண்டால்) +- உள்ளக/வெளிப்புற அறிவிப்பு +- pure/view/payable-இன் அறிவிப்பு +- திரும்பும் வகை (அது ஒரு மதிப்பைத் திருப்பினால்) + +```solidity +pragma solidity >=0.4.0 <=0.6.0; + +contract ExampleDapp { + string dapp_name; // நிலை மாறி + + // ஒப்பந்தம் வரிசைப்படுத்தப்படும்போது அழைக்கப்பட்டு மதிப்பை துவக்குகிறது + constructor() public { + dapp_name = "My Example dapp"; + } + + // பெறுவதற்கான செயல்பாடு + function read_name() public view returns(string) { + return dapp_name; + } + + // அமைப்பதற்கான செயல்பாடு + function update_name(string value) public { + dapp_name = value; + } +} +``` + +ஒரு முழுமையான ஒப்பந்தம் இதுபோல இருக்கலாம். இங்கே `constructor` செயல்பாடு `dapp_name` மாறிக்கு ஒரு ஆரம்ப மதிப்பை வழங்குகிறது. + +## நிகழ்வுகள் மற்றும் பதிவுகள் {#events-and-logs} + +நிகழ்வுகள் உங்கள் ஸ்மார்ட் ஒப்பந்தம் உங்கள் முன்பக்கம் அல்லது பிற சந்தா செலுத்தும் பயன்பாடுகளுடன் தொடர்பு கொள்ள உதவுகின்றன. ஒரு பரிவர்த்தனை சரிபார்க்கப்பட்டு ஒரு பிளாக்கில் சேர்க்கப்பட்டவுடன், ஸ்மார்ட் ஒப்பந்தங்கள் நிகழ்வுகளை வெளியிடலாம் மற்றும் தகவல்களைப் பதிவு செய்யலாம், அவற்றை முன்பக்கம் பின்னர் செயலாக்கிப் பயன்படுத்தலாம். + +## குறிப்புரைக்கப்பட்ட எடுத்துக்காட்டுகள் {#annotated-examples} + +இவை சொலிடிட்டியில் எழுதப்பட்ட சில எடுத்துக்காட்டுகள். நீங்கள் குறியீட்டுடன் விளையாட விரும்பினால், [Remix](http://remix.ethereum.org)-இல் அவற்றுடன் தொடர்பு கொள்ளலாம். + +### ஹலோ வேர்ல்ட் {#hello-world} + +```solidity +// சொலிடிட்டியின் பதிப்பைக் குறிப்பிடுகிறது, சொற்பொருள் பதிப்பைப் பயன்படுத்துகிறது. +// மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma +pragma solidity ^0.5.10; + +// `HelloWorld` என்ற பெயரில் ஒரு ஒப்பந்தத்தை வரையறுக்கிறது. +// ஒரு ஒப்பந்தம் என்பது செயல்பாடுகள் மற்றும் தரவுகளின் (அதன் நிலை) தொகுப்பாகும். +// வரிசைப்படுத்தப்பட்டதும், ஒரு ஒப்பந்தம் எத்தேரியம் பிளாக்செயினில் ஒரு குறிப்பிட்ட முகவரியில் இருக்கும். +// மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html +contract HelloWorld { + + // `string` வகையின் `message` என்ற நிலை மாறியை அறிவிக்கிறது. + // நிலை மாறிகள் என்பவை ஒப்பந்தச் சேமிப்பகத்தில் நிரந்தரமாக சேமிக்கப்படும் மதிப்புகளைக் கொண்ட மாறிகள். + // `public` என்ற திறவுச்சொல் மாறிகளை ஒரு ஒப்பந்தத்திற்கு வெளியே இருந்து அணுகக்கூடியதாக ஆக்குகிறது + // மேலும் மதிப்பை அணுகுவதற்காக மற்ற ஒப்பந்தங்கள் அல்லது வாடிக்கையாளர்கள் அழைக்கக்கூடிய ஒரு செயல்பாட்டை உருவாக்குகிறது. + string public message; + + // பல வகுப்பு அடிப்படையிலான பொருள் சார்ந்த மொழிகளைப் போலவே, ஒரு கன்ஸ்ட்ரக்டர் என்பது + // ஒப்பந்தம் உருவாக்கப்படும்போது மட்டுமே செயல்படுத்தப்படும் ஒரு சிறப்பு செயல்பாடு. + // ஒப்பந்தத்தின் தரவைத் துவக்க கன்ஸ்ட்ரக்டர்கள் பயன்படுத்தப்படுகின்றன. + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors + constructor(string memory initMessage) public { + // `initMessage` என்ற ஒரு சர வாதத்தை ஏற்றுக்கொண்டு மதிப்பை அமைக்கிறது + // ஒப்பந்தத்தின் `message` சேமிப்பக மாறிக்குள்). + message = initMessage; + } + + // ஒரு சர வாதத்தை ஏற்கும் ஒரு பொதுச் செயல்பாடு + // மற்றும் `message` சேமிப்பக மாறியைப் புதுப்பிக்கிறது. + function update(string memory newMessage) public { + message = newMessage; + } +} +``` + +### டோக்கன் {#token} + +```solidity +pragma solidity ^0.5.10; + +contract Token { + // ஒரு `address` என்பது மின்னஞ்சல் முகவரியுடன் ஒப்பிடத்தக்கது - இது எத்தேரியத்தில் ஒரு கணக்கை அடையாளம் காணப் பயன்படுகிறது. + // முகவரிகள் ஒரு ஸ்மார்ட் ஒப்பந்தம் அல்லது ஒரு வெளிப்புற (பயனர்) கணக்குகளைக் குறிக்கலாம். + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/types.html#address + address public owner; + + // ஒரு `mapping` என்பது அடிப்படையில் ஒரு ஹாஷ் அட்டவணை தரவுக் கட்டமைப்பாகும். + // இந்த `mapping` ஒரு கையொப்பமிடப்படாத முழு எண்ணை (டோக்கன் இருப்பு) ஒரு முகவரிக்கு (டோக்கன் வைத்திருப்பவர்) ஒதுக்குகிறது. + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/types.html#mapping-types + mapping (address => uint) public balances; + + // நிகழ்வுகள் பிளாக்செயினில் செயல்பாட்டைப் பதிவு செய்ய அனுமதிக்கின்றன. + // எத்தேரியம் வாடிக்கையாளர்கள் ஒப்பந்த நிலை மாற்றங்களுக்கு வினைபுரிய நிகழ்வுகளைக் கேட்கலாம். + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#events + event Transfer(address from, address to, uint amount); + + // ஒப்பந்தத்தின் தரவைத் துவக்கி, `owner`-ஐ அமைக்கிறது + // ஒப்பந்தத்தை உருவாக்கியவரின் முகவரிக்கு. + constructor() public { + // அனைத்து ஸ்மார்ட் ஒப்பந்தங்களும் அவற்றின் செயல்பாடுகளைத் தூண்டுவதற்கு வெளிப்புற பரிவர்த்தனைகளைச் சார்ந்துள்ளன. + // `msg` என்பது கொடுக்கப்பட்ட பரிவர்த்தனையில் தொடர்புடைய தரவை உள்ளடக்கிய ஒரு உலகளாவிய மாறி, + // அனுப்புநரின் முகவரி மற்றும் பரிவர்த்தனையில் சேர்க்கப்பட்டுள்ள ETH மதிப்பு போன்றவை. + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/units-and-global-variables.html#block-and-transaction-properties + owner = msg.sender; + } + + // புதிய டோக்கன்களின் ஒரு அளவை உருவாக்கி அவற்றை ஒரு முகவரிக்கு அனுப்புகிறது. + function mint(address receiver, uint amount) public { + // `require` என்பது சில நிபந்தனைகளைச் செயல்படுத்தப் பயன்படும் ஒரு கட்டுப்பாட்டுக் கட்டமைப்பாகும். + // ஒரு `require` அறிக்கை `false` என மதிப்பிடப்பட்டால், ஒரு விதிவிலக்கு தூண்டப்படுகிறது, + // இது தற்போதைய அழைப்பின் போது நிலையில் செய்யப்பட்ட அனைத்து மாற்றங்களையும் மாற்றியமைக்கிறது. + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/control-structures.html#error-handling-assert-require-revert-and-exceptions + + // ஒப்பந்த உரிமையாளர் மட்டுமே இந்தச் செயல்பாட்டை அழைக்க முடியும் + require(msg.sender == owner, "You are not the owner."); + + // டோக்கன்களின் அதிகபட்ச அளவைச் செயல்படுத்துகிறது + require(amount < 1e60, "Maximum issuance exceeded"); + + // `receiver`-இன் இருப்பை `amount` ஆல் அதிகரிக்கிறது + balances[receiver] += amount; + } + + // ஏற்கனவே உள்ள டோக்கன்களின் ஒரு அளவை எந்தவொரு அழைப்பாளரிடமிருந்தும் ஒரு முகவரிக்கு அனுப்புகிறது. + function transfer(address receiver, uint amount) public { + // அனுப்புநரிடம் அனுப்ப போதுமான டோக்கன்கள் இருக்க வேண்டும் + require(amount <= balances[msg.sender], "Insufficient balance."); + + // இரண்டு முகவரிகளின் டோக்கன் இருப்புகளைச் சரிசெய்கிறது + balances[msg.sender] -= amount; + balances[receiver] += amount; + + // முன்பு வரையறுக்கப்பட்ட நிகழ்வை வெளியிடுகிறது + emit Transfer(msg.sender, receiver, amount); + } +} +``` + +### தனித்துவமான டிஜிட்டல் சொத்து {#unique-digital-asset} + +```solidity +pragma solidity ^0.5.10; + +// மற்ற கோப்புகளிலிருந்து சின்னங்களை தற்போதைய ஒப்பந்தத்திற்குள் இறக்குமதி செய்கிறது. +// இந்த விஷயத்தில், OpenZeppelin-இல் இருந்து ஒரு தொடர் உதவி ஒப்பந்தங்கள். +// மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#importing-other-source-files + +import "../node_modules/@openzeppelin/contracts/token/ERC721/IERC721.sol"; +import "../node_modules/@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol"; +import "../node_modules/@openzeppelin/contracts/introspection/ERC165.sol"; +import "../node_modules/@openzeppelin/contracts/math/SafeMath.sol"; + +// `is` என்ற திறவுச்சொல் வெளிப்புற ஒப்பந்தங்களிலிருந்து செயல்பாடுகள் மற்றும் திறவுச்சொற்களைப் பெறப் பயன்படுகிறது. +// இந்த விஷயத்தில், `CryptoPizza` `IERC721` மற்றும் `ERC165` ஒப்பந்தங்களிலிருந்து பெறப்படுகிறது. +// மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#inheritance +contract CryptoPizza is IERC721, ERC165 { + // எண்கணித செயல்பாடுகளைப் பாதுகாப்பாகச் செய்ய OpenZeppelin-இன் SafeMath நூலகத்தைப் பயன்படுத்துகிறது. + // மேலும் அறிக: https://docs.openzeppelin.com/contracts/2.x/api/math#SafeMath + using SafeMath for uint256; + + // சொலிடிட்டியில் உள்ள நிலையான நிலை மாறிகள் மற்ற மொழிகளைப் போலவே இருக்கும் + // ஆனால் நீங்கள் தொகுக்கும் நேரத்தில் நிலையானதாக இருக்கும் ஒரு கோவையிலிருந்து ஒதுக்க வேண்டும். + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constant-state-variables + uint256 constant dnaDigits = 10; + uint256 constant dnaModulus = 10 ** dnaDigits; + bytes4 private constant _ERC721_RECEIVED = 0x150b7a02; + + // அமைப்பு வகைகள் உங்கள் சொந்த வகையை வரையறுக்க உங்களை அனுமதிக்கின்றன + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/types.html#structs + struct Pizza { + string name; + uint256 dna; + } + + // பிஸ்ஸா அமைப்புகளின் வெற்று வரிசையை உருவாக்குகிறது + Pizza[] public pizzas; + + // பிஸ்ஸா ஐடியிலிருந்து அதன் உரிமையாளரின் முகவரிக்கு மேப்பிங் + mapping(uint256 => address) public pizzaToOwner; + + // உரிமையாளரின் முகவரியிலிருந்து சொந்தமான டோக்கன்களின் எண்ணிக்கைக்கு மேப்பிங் + mapping(address => uint256) public ownerPizzaCount; + + // டோக்கன் ஐடியிலிருந்து அங்கீகரிக்கப்பட்ட முகவரிக்கு மேப்பிங் + mapping(uint256 => address) pizzaApprovals; + + // நீங்கள் மேப்பிங்குகளை உள்ளடக்கலாம், இந்த எடுத்துக்காட்டு உரிமையாளரை ஆபரேட்டர் ஒப்புதல்களுக்கு மேப் செய்கிறது + mapping(address => mapping(address => bool)) private operatorApprovals; + + // சரம் (பெயர்) மற்றும் டிஎன்ஏவிலிருந்து ஒரு சீரற்ற பிஸ்ஸாவை உருவாக்க உள்ளக செயல்பாடு + function _createPizza(string memory _name, uint256 _dna) + // `internal` என்ற திறவுச்சொல் இந்தச் செயல்பாடு மட்டுமே தெரியும் என்று பொருள் + // இந்த ஒப்பந்தம் மற்றும் இந்த ஒப்பந்தத்திலிருந்து பெறப்பட்ட ஒப்பந்தங்களுக்குள் + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#visibility-and-getters + internal + // `isUnique` என்பது பிஸ்ஸா ஏற்கனவே உள்ளதா என்று சரிபார்க்கும் ஒரு செயல்பாடு மாற்றியாகும் + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html#function-modifiers + isUnique(_name, _dna) + { + // பிஸ்ஸா வரிசையில் பிஸ்ஸாவைச் சேர்த்து ஐடியைப் பெறுகிறது + uint256 id = SafeMath.sub(pizzas.push(Pizza(_name, _dna)), 1); + + // பிஸ்ஸா உரிமையாளர் தற்போதைய பயனருடன் ஒரே மாதிரியாக இருக்கிறார் என்பதைச் சரிபார்க்கிறது + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/control-structures.html#error-handling-assert-require-revert-and-exceptions + + // முகவரி(0) என்பது பூஜ்ஜிய முகவரி என்பதை நினைவில் கொள்க, + // இது pizza[id] இன்னும் ஒரு குறிப்பிட்ட பயனருக்கு ஒதுக்கப்படவில்லை என்பதைக் குறிக்கிறது. + + assert(pizzaToOwner[id] == address(0)); + + // பிஸ்ஸாவை உரிமையாளருக்கு வரைபடமாக்குகிறது + pizzaToOwner[id] = msg.sender; + ownerPizzaCount[msg.sender] = SafeMath.add( + ownerPizzaCount[msg.sender], + 1 + ); + } + + // சரத்திலிருந்து (பெயர்) ஒரு சீரற்ற பிஸ்ஸாவை உருவாக்குகிறது + function createRandomPizza(string memory _name) public { + uint256 randDna = generateRandomDna(_name, msg.sender); + _createPizza(_name, randDna); + } + + // சரம் (பெயர்) மற்றும் உரிமையாளரின் (உருவாக்குபவர்) முகவரியிலிருந்து சீரற்ற டிஎன்ஏவை உருவாக்குகிறது + function generateRandomDna(string memory _str, address _owner) + public + // `pure` எனக் குறிக்கப்பட்ட செயல்பாடுகள் நிலையிலிருந்து படிக்கவோ அல்லது மாற்றவோ மாட்டோம் என்று உறுதியளிக்கின்றன + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#pure-functions + pure + returns (uint256) + { + // சரம் (பெயர்) + முகவரி (உரிமையாளர்) இலிருந்து சீரற்ற uint-ஐ உருவாக்குகிறது + uint256 rand = uint256(keccak256(abi.encodePacked(_str))) + + uint256(_owner); + rand = rand % dnaModulus; + return rand; + } + + // உரிமையாளரால் கண்டறியப்பட்ட பிஸ்ஸாக்களின் வரிசையைத் திருப்புகிறது + function getPizzasByOwner(address _owner) + public + // `view` எனக் குறிக்கப்பட்ட செயல்பாடுகள் நிலையை மாற்றியமைக்காது என்று உறுதியளிக்கின்றன + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#view-functions + view + returns (uint256[] memory) + { + // மதிப்புகளைச் சேமிப்பதற்காக `memory` சேமிப்பக இருப்பிடத்தைப் பயன்படுத்துகிறது + // இந்தச் செயல்பாட்டு அழைப்பின் வாழ்நாள் சுழற்சி. + // மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/introduction-to-smart-contracts.html#storage-memory-and-the-stack + uint256[] memory result = new uint256[](ownerPizzaCount[_owner]); + uint256 counter = 0; + for (uint256 i = 0; i < pizzas.length; i++) { + if (pizzaToOwner[i] == _owner) { + result[counter] = i; + counter++; + } + } + return result; + } + + // பிஸ்ஸா மற்றும் உரிமையை மற்றொரு முகவரிக்கு மாற்றுகிறது + function transferFrom(address _from, address _to, uint256 _pizzaId) public { + require(_from != address(0) && _to != address(0), "Invalid address."); + require(_exists(_pizzaId), "Pizza does not exist."); + require(_from != _to, "Cannot transfer to the same address."); + require(_isApprovedOrOwner(msg.sender, _pizzaId), "Address is not approved."); + + ownerPizzaCount[_to] = SafeMath.add(ownerPizzaCount[_to], 1); + ownerPizzaCount[_from] = SafeMath.sub(ownerPizzaCount[_from], 1); + pizzaToOwner[_pizzaId] = _to; + + // இறக்குமதி செய்யப்பட்ட IERC721 ஒப்பந்தத்தில் வரையறுக்கப்பட்ட நிகழ்வை வெளியிடுகிறது + emit Transfer(_from, _to, _pizzaId); + _clearApproval(_to, _pizzaId); + } + + /** + * கொடுக்கப்பட்ட டோக்கன் ஐடியின் உரிமையை மற்றொரு முகவரிக்கு பாதுகாப்பாக மாற்றுகிறது + * இலக்கு முகவரி ஒரு ஒப்பந்தமாக இருந்தால், அது `onERC721Received` என்பதை செயல்படுத்த வேண்டும், + * இது பாதுகாப்பான பரிமாற்றத்தின் போது அழைக்கப்பட்டு, மாய மதிப்பைத் திருப்புகிறது + * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; + * இல்லையெனில், பரிமாற்றம் மாற்றியமைக்கப்படுகிறது. + */ + function safeTransferFrom(address from, address to, uint256 pizzaId) + public + { + // solium-disable-next-line arg-overflow + this.safeTransferFrom(from, to, pizzaId, ""); + } + + /** + * கொடுக்கப்பட்ட டோக்கன் ஐடியின் உரிமையை மற்றொரு முகவரிக்கு பாதுகாப்பாக மாற்றுகிறது + * இலக்கு முகவரி ஒரு ஒப்பந்தமாக இருந்தால், அது `onERC721Received` என்பதை செயல்படுத்த வேண்டும், + * இது பாதுகாப்பான பரிமாற்றத்தின் போது அழைக்கப்பட்டு, மாய மதிப்பைத் திருப்புகிறது + * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; + * இல்லையெனில், பரிமாற்றம் மாற்றியமைக்கப்படுகிறது. + */ + function safeTransferFrom( + address from, + address to, + uint256 pizzaId, + bytes memory _data + ) public { + this.transferFrom(from, to, pizzaId); + require(_checkOnERC721Received(from, to, pizzaId, _data), "Must implement onERC721Received."); + } + + /** + * இலக்கு முகவரியில் `onERC721Received` ஐ அழைக்க உள்ளக செயல்பாடு + * இலக்கு முகவரி ஒரு ஒப்பந்தம் இல்லையென்றால் அழைப்பு செயல்படுத்தப்படாது + */ + function _checkOnERC721Received( + address from, + address to, + uint256 pizzaId, + bytes memory _data + ) internal returns (bool) { + if (!isContract(to)) { + return true; + } + + bytes4 retval = IERC721Receiver(to).onERC721Received( + msg.sender, + from, + pizzaId, + _data + ); + return (retval == _ERC721_RECEIVED); + } + + // ஒரு பிஸ்ஸாவை எரிக்கிறது - டோக்கனை முழுமையாக அழிக்கிறது + // `external` செயல்பாடு மாற்றி என்பது இந்தச் செயல்பாடு + // ஒப்பந்த இடைமுகத்தின் ஒரு பகுதியாகும், மற்ற ஒப்பந்தங்கள் அதை அழைக்கலாம் + function burn(uint256 _pizzaId) external { + require(msg.sender != address(0), "Invalid address."); + require(_exists(_pizzaId), "Pizza does not exist."); + require(_isApprovedOrOwner(msg.sender, _pizzaId), "Address is not approved."); + + ownerPizzaCount[msg.sender] = SafeMath.sub( + ownerPizzaCount[msg.sender], + 1 + ); + pizzaToOwner[_pizzaId] = address(0); + } + + // முகவரி மூலம் பிஸ்ஸாக்களின் எண்ணிக்கையைத் திருப்புகிறது + function balanceOf(address _owner) public view returns (uint256 _balance) { + return ownerPizzaCount[_owner]; + } + + // ஐடி மூலம் கண்டறியப்பட்ட பிஸ்ஸாவின் உரிமையாளரைத் திருப்புகிறது + function ownerOf(uint256 _pizzaId) public view returns (address _owner) { + address owner = pizzaToOwner[_pizzaId]; + require(owner != address(0), "Invalid Pizza ID."); + return owner; + } + + // பிஸ்ஸாவின் உரிமையை மாற்றுவதற்கு மற்றொரு முகவரியை அங்கீகரிக்கிறது + function approve(address _to, uint256 _pizzaId) public { + require(msg.sender == pizzaToOwner[_pizzaId], "Must be the Pizza owner."); + pizzaApprovals[_pizzaId] = _to; + emit Approval(msg.sender, _to, _pizzaId); + } + + // குறிப்பிட்ட பிஸ்ஸாவிற்கு அங்கீகரிக்கப்பட்ட முகவரியைத் திருப்புகிறது + function getApproved(uint256 _pizzaId) + public + view + returns (address operator) + { + require(_exists(_pizzaId), "Pizza does not exist."); + return pizzaApprovals[_pizzaId]; + } + + /** + * கொடுக்கப்பட்ட டோக்கன் ஐடியின் தற்போதைய ஒப்புதலை அழிக்க தனிப்பட்ட செயல்பாடு + * கொடுக்கப்பட்ட முகவரி உண்மையில் டோக்கனின் உரிமையாளர் இல்லையென்றால் மாற்றியமைக்கிறது + */ + function _clearApproval(address owner, uint256 _pizzaId) private { + require(pizzaToOwner[_pizzaId] == owner, "Must be pizza owner."); + require(_exists(_pizzaId), "Pizza does not exist."); + if (pizzaApprovals[_pizzaId] != address(0)) { + pizzaApprovals[_pizzaId] = address(0); + } + } + + /* + * கொடுக்கப்பட்ட ஆபரேட்டரின் ஒப்புதலை அமைக்கிறது அல்லது நீக்குகிறது + * ஒரு ஆபரேட்டர் தங்கள் சார்பாக அனுப்புநரின் அனைத்து டோக்கன்களையும் மாற்ற அனுமதிக்கப்படுகிறார் + */ + function setApprovalForAll(address to, bool approved) public { + require(to != msg.sender, "Cannot approve own address"); + operatorApprovals[msg.sender][to] = approved; + emit ApprovalForAll(msg.sender, to, approved); + } + + // கொடுக்கப்பட்ட உரிமையாளரால் ஒரு ஆபரேட்டர் அங்கீகரிக்கப்பட்டுள்ளாரா என்பதைக் கூறுகிறது + function isApprovedForAll(address owner, address operator) + public + view + returns (bool) + { + return operatorApprovals[owner][operator]; + } + + // பிஸ்ஸாவின் உரிமையை எடுக்கிறது - அங்கீகரிக்கப்பட்ட பயனர்களுக்கு மட்டுமே + function takeOwnership(uint256 _pizzaId) public { + require(_isApprovedOrOwner(msg.sender, _pizzaId), "Address is not approved."); + address owner = this.ownerOf(_pizzaId); + this.transferFrom(owner, msg.sender, _pizzaId); + } + + // பிஸ்ஸா இருக்கிறதா என்று சரிபார்க்கிறது + function _exists(uint256 pizzaId) internal view returns (bool) { + address owner = pizzaToOwner[pizzaId]; + return owner != address(0); + } + + // முகவரி உரிமையாளரா அல்லது பிஸ்ஸாவை மாற்ற அங்கீகரிக்கப்பட்டுள்ளதா என்று சரிபார்க்கிறது + function _isApprovedOrOwner(address spender, uint256 pizzaId) + internal + view + returns (bool) + { + address owner = pizzaToOwner[pizzaId]; + // Solium சரிபார்ப்பை முடக்கு, ஏனெனில் + // https://github.com/duaraghav8/Solium/issues/175 + // solium-disable-next-line operator-whitespace + return (spender == owner || + this.getApproved(pizzaId) == spender || + this.isApprovedForAll(owner, spender)); + } + + // பிஸ்ஸா தனித்துவமானதா மற்றும் இன்னும் இல்லை என்பதைச் சரிபார்க்கவும் + modifier isUnique(string memory _name, uint256 _dna) { + bool result = true; + for (uint256 i = 0; i < pizzas.length; i++) { + if ( + keccak256(abi.encodePacked(pizzas[i].name)) == + keccak256(abi.encodePacked(_name)) && + pizzas[i].dna == _dna + ) { + result = false; + } + } + require(result, "Pizza with such name already exists."); + _; + } + + // இலக்கு முகவரி ஒரு ஒப்பந்தமா இல்லையா என்பதைத் திருப்புகிறது + function isContract(address account) internal view returns (bool) { + uint256 size; + // தற்போது ஒரு முகவரியில் ஒரு ஒப்பந்தம் உள்ளதா என்பதை சரிபார்க்க இதைவிட சிறந்த வழி இல்லை + // அந்த முகவரியில் உள்ள குறியீட்டின் அளவை சரிபார்ப்பதை விட. + // இது எப்படி வேலை செய்கிறது என்பது பற்றிய மேலும் விவரங்களுக்கு https://ethereum.stackexchange.com/a/14016/36603-ஐப் பார்க்கவும். + // TODO செரினிட்டி வெளியீட்டிற்கு முன் இதை மீண்டும் சரிபார்க்கவும், ஏனெனில் அப்போது அனைத்து முகவரிகளும் + // ஒப்பந்தங்களாக இருக்கும். + // solium-disable-next-line security/no-inline-assembly + assembly { + size := extcodesize(account) + } + return size > 0; + } +} +``` + +## மேலும் வாசிக்க {#further-reading} + +ஸ்மார்ட் ஒப்பந்தங்கள் பற்றிய முழுமையான மேலோட்டத்திற்கு சொலிடிட்டி மற்றும் வைப்பரின் ஆவணங்களைப் பார்க்கவும்: + +- [சொலிடிட்டி](https://docs.soliditylang.org/) +- [வைப்பர்](https://docs.vyperlang.org/en/stable/) + +## தொடர்புடைய தலைப்புகள் {#related-topics} + +- [ஸ்மார்ட் ஒப்பந்தங்கள்](/developers/docs/smart-contracts/) +- [எத்தேரியம் மெய்நிகர் இயந்திரம்](/developers/docs/evm/) + +## தொடர்புடைய பயிற்சிகள் {#related-tutorials} + +- [ஒப்பந்த அளவு வரம்பை எதிர்த்துப் போராட ஒப்பந்தங்களைக் குறைத்தல்](/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/) _– உங்கள் ஸ்மார்ட் ஒப்பந்தத்தின் அளவைக் குறைப்பதற்கான சில நடைமுறை உதவிக்குறிப்புகள்._ +- [நிகழ்வுகளுடன் ஸ்மார்ட் ஒப்பந்தங்களிலிருந்து தரவைப் பதிவுசெய்தல்](/developers/tutorials/logging-events-smart-contracts/) _– ஸ்மார்ட் ஒப்பந்த நிகழ்வுகள் மற்றும் தரவைப் பதிவு செய்ய அவற்றை எவ்வாறு பயன்படுத்தலாம் என்பதற்கான ஒரு அறிமுகம்._ +- [சொலிடிட்டியில் இருந்து பிற ஒப்பந்தங்களுடன் தொடர்புகொள்வது](/developers/tutorials/interact-with-other-contracts-from-solidity/) _– ஏற்கனவே உள்ள ஒப்பந்தத்திலிருந்து ஒரு ஸ்மார்ட் ஒப்பந்தத்தை எவ்வாறு வரிசைப்படுத்துவது மற்றும் அதனுடன் தொடர்புகொள்வது._ diff --git a/public/content/translations/ta/developers/docs/smart-contracts/compiling/index.md b/public/content/translations/ta/developers/docs/smart-contracts/compiling/index.md new file mode 100644 index 00000000000..06d8d7a7c3a --- /dev/null +++ b/public/content/translations/ta/developers/docs/smart-contracts/compiling/index.md @@ -0,0 +1,282 @@ +--- +title: "ஸ்மார்ட் ஒப்பந்தங்களைத் தொகுத்தல்" +description: "நீங்கள் ஏன் ஸ்மார்ட் ஒப்பந்தங்களைத் தொகுக்க வேண்டும் மற்றும் தொகுத்தல் உண்மையில் என்ன செய்கிறது என்பதற்கான விளக்கம்." +lang: ta +incomplete: true +--- + +உங்கள் வலைப் பயன்பாடும் Ethereum மெய்நிகர் இயந்திரமும் (EVM) அதைப் புரிந்து கொள்ளும் வகையில் உங்கள் ஒப்பந்தத்தை நீங்கள் தொகுக்க வேண்டும். + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +தொகுப்பைப் பற்றி படிக்கும் முன் [ஸ்மார்ட் ஒப்பந்தங்கள்](/developers/docs/smart-contracts/) மற்றும் [Ethereum மெய்நிகர் இயந்திரம்](/developers/docs/evm/) பற்றிய எங்களின் அறிமுகத்தைப் படிப்பது உங்களுக்கு உதவியாக இருக்கும். + +## EVM {#the-evm} + +[EVM](/developers/docs/evm/) உங்கள் ஒப்பந்தத்தை இயக்க, அது **பைட் குறியீட்டில்** இருக்க வேண்டும். தொகுப்பு இதை மாற்றுகிறது: + +```solidity +pragma solidity 0.4.24; + +contract Greeter { + + function greet() public view returns (string memory) { + return "Hello"; + } + +} +``` + +**இப்படி** + +``` +PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x4 CALLDATASIZE LT PUSH2 0x41 JUMPI PUSH1 0x0 CALLDATALOAD PUSH29 0x100000000000000000000000000000000000000000000000000000000 SWAP1 DIV PUSH4 0xFFFFFFFF AND DUP1 PUSH4 0xCFAE3217 EQ PUSH2 0x46 JUMPI JUMPDEST PUSH1 0x0 DUP1 REVERT JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x52 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x5B PUSH2 0xD6 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 DUP1 PUSH1 0x20 ADD DUP3 DUP2 SUB DUP3 MSTORE DUP4 DUP2 DUP2 MLOAD DUP2 MSTORE PUSH1 0x20 ADD SWAP2 POP DUP1 MLOAD SWAP1 PUSH1 0x20 ADD SWAP1 DUP1 DUP4 DUP4 PUSH1 0x0 JUMPDEST DUP4 DUP2 LT ISZERO PUSH2 0x9B JUMPI DUP1 DUP3 ADD MLOAD DUP2 DUP5 ADD MSTORE PUSH1 0x20 DUP2 ADD SWAP1 POP PUSH2 0x80 JUMP JUMPDEST POP POP POP POP SWAP1 POP SWAP1 DUP2 ADD SWAP1 PUSH1 0x1F AND DUP1 ISZERO PUSH2 0xC8 JUMPI DUP1 DUP3 SUB DUP1 MLOAD PUSH1 0x1 DUP4 PUSH1 0x20 SUB PUSH2 0x100 EXP SUB NOT AND DUP2 MSTORE PUSH1 0x20 ADD SWAP2 POP JUMPDEST POP SWAP3 POP POP POP PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 RETURN JUMPDEST PUSH1 0x60 PUSH1 0x40 DUP1 MLOAD SWAP1 DUP2 ADD PUSH1 0x40 MSTORE DUP1 PUSH1 0x5 DUP2 MSTORE PUSH1 0x20 ADD PUSH32 0x48656C6C6F000000000000000000000000000000000000000000000000000000 DUP2 MSTORE POP SWAP1 POP SWAP1 JUMP STOP LOG1 PUSH6 0x627A7A723058 KECCAK256 SLT 0xec 0xe 0xf5 0xf8 SLT 0xc7 0x2d STATICCALL ADDRESS SHR 0xdb COINBASE 0xb1 BALANCE 0xe8 0xf8 DUP14 0xda 0xad DUP13 LOG1 0x4c 0xb4 0x26 0xc2 DELEGATECALL PUSH7 0x8994D3E002900 +``` + +இவை **ஆப்கோடுகள்** என்று அழைக்கப்படுகின்றன. EVM ஆப்கோடுகள் என்பவை Ethereum மெய்நிகர் இயந்திரம் (EVM) செயல்படுத்தக்கூடிய கீழ்நிலை வழிமுறைகளாகும். ஒவ்வொரு ஆப்கோடும் எண்கணித செயல்பாடுகள், தருக்க செயல்பாடுகள், தரவுக் கையாளுதல், கட்டுப்பாட்டு ஓட்டம் போன்ற ஒரு குறிப்பிட்ட செயல்பாட்டைக் குறிக்கிறது. + +[ஆப்கோடுகள் பற்றி மேலும்](/developers/docs/evm/opcodes/) + +## இணையப் பயன்பாடுகள் {#web-applications} + +தொகுப்பி **பயன்பாட்டு பைனரி இடைமுகத்தையும் (ABI)** உருவாக்கும். இது உங்கள் பயன்பாடு ஒப்பந்தத்தைப் புரிந்துகொள்வதற்கும், ஒப்பந்தத்தின் செயல்பாடுகளை அழைப்பதற்கும் தேவை. + +ABI என்பது ஒரு JSON கோப்பாகும், இது பயன்படுத்தப்பட்ட ஒப்பந்தம் மற்றும் அதன் ஸ்மார்ட் ஒப்பந்த செயல்பாடுகளை விவரிக்கிறது. இது web2 மற்றும் web3 ஆகியவற்றுக்கு இடையேயான இடைவெளியைக் குறைக்க உதவுகிறது + +உங்கள் இணையப் பயன்பாட்டின் இடைமுகத்தில் உங்கள் ஸ்மார்ட் ஒப்பந்தத்தை நீங்கள் அழைக்க ஒரு [JavaScript கிளையன்ட் நூலகம்](/developers/docs/apis/javascript/) **ABI**-ஐப் படிக்கும். + +கீழே ERC-20 டோக்கன் ஒப்பந்தத்திற்கான ABI உள்ளது. ERC-20 என்பது Ethereum-இல் நீங்கள் வர்த்தகம் செய்யக்கூடிய ஒரு டோக்கன் ஆகும். + +```json +[ + { + "constant": true, + "inputs": [], + "name": "name", + "outputs": [ + { + "name": "", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "_spender", + "type": "address" + }, + { + "name": "_value", + "type": "uint256" + } + ], + "name": "approve", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "totalSupply", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "_from", + "type": "address" + }, + { + "name": "_to", + "type": "address" + }, + { + "name": "_value", + "type": "uint256" + } + ], + "name": "transferFrom", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "decimals", + "outputs": [ + { + "name": "", + "type": "uint8" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "_owner", + "type": "address" + } + ], + "name": "balanceOf", + "outputs": [ + { + "name": "balance", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "symbol", + "outputs": [ + { + "name": "", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "_to", + "type": "address" + }, + { + "name": "_value", + "type": "uint256" + } + ], + "name": "transfer", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "_owner", + "type": "address" + }, + { + "name": "_spender", + "type": "address" + } + ], + "name": "allowance", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "payable": true, + "stateMutability": "payable", + "type": "fallback" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "name": "spender", + "type": "address" + }, + { + "indexed": false, + "name": "value", + "type": "uint256" + } + ], + "name": "Approval", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "name": "from", + "type": "address" + }, + { + "indexed": true, + "name": "to", + "type": "address" + }, + { + "indexed": false, + "name": "value", + "type": "uint256" + } + ], + "name": "Transfer", + "type": "event" + } +] +``` + +## மேலும் வாசிக்க {#further-reading} + +- [ABI விவரக்குறிப்பு](https://solidity.readthedocs.io/en/v0.7.0/abi-spec.html) _– Solidity_ + +## தொடர்புடைய தலைப்புகள் {#related-topics} + +- [JavaScript கிளையன்ட் நூலகங்கள்](/developers/docs/apis/javascript/) +- [Ethereum மெய்நிகர் இயந்திரம்](/developers/docs/evm/) diff --git a/public/content/translations/ta/developers/docs/smart-contracts/composability/index.md b/public/content/translations/ta/developers/docs/smart-contracts/composability/index.md new file mode 100644 index 00000000000..0b02ed4bf47 --- /dev/null +++ b/public/content/translations/ta/developers/docs/smart-contracts/composability/index.md @@ -0,0 +1,76 @@ +--- +title: "Smart contract தொகுப்புத்திறன்" +description: "ஏற்கனவே உள்ள கூறுகளை மீண்டும் பயன்படுத்துவதன் மூலம் சிக்கலான dapp-களை உருவாக்க லெகோ தொகுதிகளைப் போல Smart contract-களை எவ்வாறு இணைக்கலாம் என்பதை அறியவும்." +lang: ta +incomplete: true +--- + +## ஒரு சுருக்கமான அறிமுகம் {#a-brief-introduction} + +ஸ்மார்ட் ஒப்பந்தங்கள் எத்தேரியத்தில் பொதுவானவை மற்றும் திறந்த API-களாகக் கருதப்படலாம். ஒரு dapp டெவலப்பராக மாற, நீங்கள் உங்கள் சொந்த smart contract-ஐ எழுதத் தேவையில்லை, அவற்றுடன் எவ்வாறு தொடர்புகொள்வது என்பதை நீங்கள் அறிந்திருக்க வேண்டும். எடுத்துக்காட்டாக, உங்கள் செயலியில் உள்ள அனைத்து டோக்கன் பரிமாற்ற தர்க்கத்தையும் கையாள, ஒரு பரவலாக்கப்பட்ட பரிமாற்றமான [Uniswap](https://uniswap.exchange/swap)-இன் தற்போதைய smart contract-களை நீங்கள் பயன்படுத்தலாம் – நீங்கள் புதிதாகத் தொடங்கத் தேவையில்லை. அவர்களின் சில [v2](https://github.com/Uniswap/uniswap-v2-core/tree/master/contracts) மற்றும் [v3](https://github.com/Uniswap/uniswap-v3-core/tree/main/contracts) ஒப்பந்தங்களைப் பார்க்கவும். + +## தொகுப்புத்திறன் என்றால் என்ன? {#what-is-composability} + +தொகுப்புத்திறன் என்பது புதிய அமைப்புகள் அல்லது வெளியீடுகளை உருவாக்க தனித்துவமான கூறுகளை இணைப்பதாகும். மென்பொருள் மேம்பாட்டில், தொகுப்புத்திறன் என்பது டெவலப்பர்கள் புதிய பயன்பாடுகளை உருவாக்க ஏற்கனவே உள்ள மென்பொருள் கூறுகளை மீண்டும் பயன்படுத்தலாம் என்பதாகும். தொகுப்புத்திறனைப் புரிந்துகொள்வதற்கான ஒரு நல்ல வழி, தொகுக்கக்கூடிய கூறுகளை லெகோ தொகுதிகளாக நினைப்பதாகும். ஒவ்வொரு லெகோவையும் மற்றொன்றுடன் இணைக்க முடியும், வெவ்வேறு லெகோக்களை இணைப்பதன் மூலம் சிக்கலான கட்டமைப்புகளை உருவாக்க உங்களை அனுமதிக்கிறது. + +எத்தேரியத்தில், ஒவ்வொரு smart contract-ம் ஒரு வகை லெகோ ஆகும்—உங்கள் திட்டத்திற்கான கட்டுமானத் தொகுதிகளாக மற்ற திட்டங்களிலிருந்து smart contract-களைப் பயன்படுத்தலாம். இதன் பொருள் நீங்கள் சக்கரத்தை மீண்டும் கண்டுபிடிப்பதற்கோ அல்லது புதிதாக உருவாக்குவதற்கோ நேரத்தைச் செலவிட வேண்டியதில்லை. + +## தொகுப்புத்திறன் எவ்வாறு செயல்படுகிறது? {#how-does-composability-work} + +எத்தேரியம் smart contract-கள் பொது API-களைப் போன்றது, எனவே எவரும் ஒப்பந்தத்துடன் தொடர்பு கொள்ளலாம் அல்லது கூடுதல் செயல்பாட்டிற்காக அவற்றை dapp-களில் ஒருங்கிணைக்கலாம். Smart contract தொகுப்புத்திறன் பொதுவாக மூன்று கொள்கைகளில் செயல்படுகிறது: மட்டுத்தன்மை, சுயாட்சி மற்றும் கண்டறியும் தன்மை: + +**1. மட்டுத்தன்மை**: இது ஒரு குறிப்பிட்ட பணியைச் செய்வதற்கான தனிப்பட்ட கூறுகளின் திறன். எத்தேரியத்தில், ஒவ்வொரு smart contract-க்கும் ஒரு குறிப்பிட்ட பயன்பாட்டு வழக்கு உள்ளது (Uniswap எடுத்துக்காட்டில் காட்டப்பட்டுள்ளபடி). + +**2. சுயாட்சி**: தொகுக்கக்கூடிய கூறுகள் சுதந்திரமாக செயல்பட வேண்டும். எத்தேரியத்தில் உள்ள ஒவ்வொரு smart contract-ம் சுய-செயல்படுத்தக்கூடியது மற்றும் அமைப்பின் மற்ற பகுதிகளைச் சார்ந்து இல்லாமல் செயல்பட முடியும். + +**3. கண்டறியும் தன்மை**: டெவலப்பர்கள் வெளிப்புற ஒப்பந்தங்களை அழைக்கவோ அல்லது மென்பொருள் நூலகங்களை பயன்பாடுகளில் ஒருங்கிணைக்கவோ முடியாது, முந்தையவை பொதுவில் கிடைக்கவில்லை என்றால். வடிவமைப்பின்படி, smart contract-கள் திறந்த மூலமாகும்; எவரும் ஒரு smart contract-ஐ அழைக்கலாம் அல்லது ஒரு கோட்பேஸை ஃபோர்க் செய்யலாம். + +## தொகுப்புத்திறனின் நன்மைகள் {#benefits-of-composability} + +### குறுகிய மேம்பாட்டுச் சுழற்சி {#shorter-development-cycle} + +தொகுப்புத்திறன் [dapps](/apps/#what-are-dapps)-ஐ உருவாக்கும்போது டெவலப்பர்கள் செய்ய வேண்டிய வேலையைக் குறைக்கிறது. [நவல் ரவிகாந்த் சொல்வது போல்:](https://twitter.com/naval/status/1444366754650656770) "திறந்த மூலம் என்றால் ஒவ்வொரு சிக்கலும் ஒரு முறை தீர்க்கப்பட வேண்டும்." + +ஒரு சிக்கலைத் தீர்க்கும் ஒரு smart contract இருந்தால், மற்ற டெவலப்பர்கள் அதை மீண்டும் பயன்படுத்தலாம், எனவே அவர்கள் அதே சிக்கலைத் தீர்க்க வேண்டியதில்லை. இந்த வழியில், டெவலப்பர்கள் ஏற்கனவே உள்ள மென்பொருள் நூலகங்களை எடுத்து புதிய dapps-களை உருவாக்க கூடுதல் செயல்பாடுகளைச் சேர்க்கலாம். + +### பெரிய கண்டுபிடிப்பு {#greater-innovation} + +தொகுப்புத்திறன் புதுமை மற்றும் பரிசோதனையை ஊக்குவிக்கிறது, ஏனெனில் டெவலப்பர்கள் விரும்பிய முடிவுகளை உருவாக்க திறந்த மூலக் குறியீட்டை மீண்டும் பயன்படுத்த, மாற்றியமைக்க, நகலெடுக்க அல்லது ஒருங்கிணைக்க சுதந்திரமாக உள்ளனர். இதன் விளைவாக, மேம்பாட்டுக் குழுக்கள் அடிப்படை செயல்பாடுகளில் குறைந்த நேரத்தை செலவிடுகின்றன, மேலும் புதிய அம்சங்களுடன் பரிசோதனை செய்ய அதிக நேரத்தை ஒதுக்க முடியும். + +### சிறந்த பயனர் அனுபவம் {#better-user-experience} + +எத்தேரியம் சுற்றுச்சூழல் அமைப்பின் கூறுகளுக்கு இடையேயான இயங்குதன்மை பயனர் அனுபவத்தை மேம்படுத்துகிறது. பயன்பாடுகள் தொடர்பு கொள்ள முடியாத ஒரு துண்டு துண்டான சுற்றுச்சூழல் அமைப்பை விட, dapps வெளிப்புற smart contract-களை ஒருங்கிணைக்கும்போது பயனர்கள் அதிக செயல்பாடுகளை அணுக முடியும். + +இயங்குதிறனின் நன்மைகளை விளக்க, நடுவர் வர்த்தகத்தில் இருந்து ஒரு உதாரணத்தைப் பயன்படுத்துவோம்: + +`பரிமாற்றம் B`-ஐ விட `பரிமாற்றம் A`-இல் ஒரு டோக்கன் அதிக விலையில் வர்த்தகம் செய்யப்பட்டால், விலை வித்தியாசத்தைப் பயன்படுத்தி நீங்கள் லாபம் ஈட்டலாம். இருப்பினும், பரிவர்த்தனைக்கு நிதியளிக்க போதுமான மூலதனம் உங்களிடம் இருந்தால் மட்டுமே அதைச் செய்ய முடியும் (அதாவது, `பரிமாற்றம் B`-இலிருந்து டோக்கனை வாங்கி `பரிமாற்றம் A`-இல் விற்பது). + +வர்த்தகத்தைச் செய்ய போதுமான நிதி இல்லாத சூழ்நிலையில், ஒரு ஃபிளாஷ் கடன் சிறந்ததாக இருக்கலாம். [ஃபிளாஷ் கடன்கள்](/defi/#flash-loans) மிகவும் தொழில்நுட்பமானவை, ஆனால் அடிப்படை யோசனை என்னவென்றால், நீங்கள் சொத்துக்களை (பிணை இல்லாமல்) கடன் வாங்கலாம் மற்றும் ஒரே பரிவர்த்தனைக்குள் அதைத் திருப்பித் தரலாம். + +எங்கள் ஆரம்ப எடுத்துக்காட்டுக்குச் சென்றால், ஒரு நடுவர் வர்த்தகர் ஒரு பெரிய ஃபிளாஷ் கடனை எடுத்து, `பரிமாற்றம் B`-இலிருந்து டோக்கன்களை வாங்கி, அவற்றை `பரிமாற்றம் A`-இல் விற்று, மூலதனம் + வட்டியைத் திருப்பிச் செலுத்தி, லாபத்தை ஒரே பரிவர்த்தனையில் வைத்திருக்க முடியும். இந்த சிக்கலான தர்க்கத்திற்கு பல ஒப்பந்தங்களுக்கான அழைப்புகளை இணைக்க வேண்டும், smart contract-களுக்கு இயங்குதன்மை இல்லாவிட்டால் இது சாத்தியமில்லை. + +## எத்தேரியத்தில் தொகுப்புத்திறனின் எடுத்துக்காட்டுகள் {#composability-in-ethereum} + +### டோக்கன் பரிமாற்றங்கள் {#token-swaps} + +ETH-இல் செலுத்தப்பட வேண்டிய பரிவர்த்தனைகள் தேவைப்படும் ஒரு dapp-ஐ நீங்கள் உருவாக்கினால், டோக்கன் பரிமாற்ற தர்க்கத்தை ஒருங்கிணைப்பதன் மூலம் பயனர்களை மற்ற ERC-20 டோக்கன்களில் செலுத்த அனுமதிக்கலாம். ஒப்பந்தம் அழைக்கப்பட்ட செயல்பாட்டைச் செயல்படுத்தும் முன், குறியீடு தானாகவே பயனரின் டோக்கனை ETH ஆக மாற்றும். + +### ஆளுமை {#governance} + +ஒரு [DAO](/dao/)-விற்கு பெஸ்போக் ஆளுமை அமைப்புகளை உருவாக்குவது விலை உயர்ந்ததாகவும் நேரத்தைச் செலவழிக்கக்கூடியதாகவும் இருக்கலாம். அதற்கு பதிலாக, [Aragon Client](https://client.aragon.org/) போன்ற ஒரு திறந்த மூல ஆளுமை கருவித்தொகுப்பைப் பயன்படுத்தி, உங்கள் DAO-வை துவக்கி ஒரு ஆளுகை கட்டமைப்பை விரைவாக உருவாக்கலாம். + +### அடையாள மேலாண்மை {#identity-management} + +தனிப்பயன் அங்கீகார அமைப்பை உருவாக்குவதற்கு அல்லது மையப்படுத்தப்பட்ட வழங்குநர்களைச் சார்ந்திருப்பதற்குப் பதிலாக, பயனர்களுக்கான அங்கீகாரத்தை நிர்வகிக்க பரவலாக்கப்பட்ட அடையாள (DID) கருவிகளை நீங்கள் ஒருங்கிணைக்கலாம். [SpruceID](https://www.spruceid.com/) ஒரு உதாரணம் ஆகும், இது ஒரு திறந்த மூல கருவித்தொகுப்பாகும், இது "எத்தேரியம் மூலம் உள்நுழைக" என்ற செயல்பாட்டை வழங்குகிறது, இது பயனர்களை எத்தேரியம் பணப்பை மூலம் அடையாளங்களை அங்கீகரிக்க அனுமதிக்கிறது. + +## தொடர்புடைய பயிற்சிகள் {#related-tutorials} + +- [create-eth-app மூலம் உங்கள் dapp முகப்புப் பக்க மேம்பாட்டைத் தொடங்குங்கள்](/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/) _– பிரபலமான smart contract-களுடன் உடனடியாகப் பயன்படுத்தக்கூடிய செயலிகளை உருவாக்க create-eth-app-ஐ எவ்வாறு பயன்படுத்துவது என்பது பற்றிய ஒரு கண்ணோட்டம்._ + +## மேலும் வாசிக்க {#further-reading} + +_உங்களுக்கு உதவிய ஒரு சமூக வளம் பற்றி தெரியுமா?_ இந்தப் பக்கத்தைத் திருத்தி அதைச் சேர்க்கவும்!_ + +- [தொகுப்புத்திறன் என்பது புதுமை](https://a16zcrypto.com/posts/article/how-composability-unlocks-crypto-and-everything-else/) +- [Web3-க்கு ஏன் தொகுப்புத்திறன் முக்கியம்](https://hackernoon.com/why-composability-matters-for-web3) +- [தொகுப்புத்திறன் என்றால் என்ன?](https://blog.aragon.org/what-is-composability/#:~:text=Aragon,connect%20to%20every%20other%20piece.) diff --git a/public/content/translations/ta/developers/docs/smart-contracts/deploying/index.md b/public/content/translations/ta/developers/docs/smart-contracts/deploying/index.md new file mode 100644 index 00000000000..0bd35d80595 --- /dev/null +++ b/public/content/translations/ta/developers/docs/smart-contracts/deploying/index.md @@ -0,0 +1,81 @@ +--- +title: "ஸ்மார்ட் ஒப்பந்தங்களை பயன்படுத்துதல்" +description: "முன்நிபந்தனைகள், கருவிகள் மற்றும் பயன்படுத்தும் படிகள் உட்பட, Ethereum நெட்வொர்க்குகளில் ஸ்மார்ட் ஒப்பந்தங்களை எவ்வாறு பயன்படுத்துவது என்பதை அறிக." +lang: ta +--- + +ஒரு Ethereum நெட்வொர்க்கின் பயனர்களுக்குக் கிடைக்க, உங்கள் ஸ்மார்ட் ஒப்பந்தத்தை நீங்கள் பயன்படுத்த வேண்டும். + +ஒரு ஸ்மார்ட் ஒப்பந்தத்தைப் பயன்படுத்த, எந்தவொரு பெறுநரையும் குறிப்பிடாமல், ஸ்மார்ட் ஒப்பந்தத்தின் தொகுக்கப்பட்ட குறியீட்டைக் கொண்ட ஒரு Ethereum பரிவர்த்தனையை நீங்கள் அனுப்பினால் போதும். + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +ஸ்மார்ட் ஒப்பந்தங்களைப் பயன்படுத்துவதற்கு முன், நீங்கள் [Ethereum நெட்வொர்க்குகள்](/developers/docs/networks/), [பரிவர்த்தனைகள்](/developers/docs/transactions/) மற்றும் [ஸ்மார்ட் ஒப்பந்தங்களின் கட்டமைப்பு](/developers/docs/smart-contracts/anatomy/) ஆகியவற்றைப் புரிந்துகொள்ள வேண்டும். + +ஒப்பந்தங்கள் பிளாக்செயினில் சேமிக்கப்படுவதால், ஒரு ஒப்பந்தத்தைப் பயன்படுத்த ஈதர் (ETH) செலவாகும், எனவே நீங்கள் Ethereum-இல் உள்ள [எரிவாயு மற்றும் கட்டணங்கள்](/developers/docs/gas/) பற்றி அறிந்திருக்க வேண்டும். + +இறுதியாக, உங்கள் ஒப்பந்தத்தைப் பயன்படுத்துவதற்கு முன்பு அதை நீங்கள் தொகுக்க வேண்டும், எனவே [ஸ்மார்ட் ஒப்பந்தங்களைத் தொகுத்தல்](/developers/docs/smart-contracts/compiling/) பற்றி நீங்கள் படித்திருப்பதை உறுதிசெய்யவும். + +## ஒரு ஸ்மார்ட் ஒப்பந்தத்தை எவ்வாறு பயன்படுத்துவது {#how-to-deploy-a-smart-contract} + +### உங்களுக்கு என்ன தேவை {#what-youll-need} + +- உங்கள் ஒப்பந்தத்தின் பைட்குறியீடு – இது [தொகுத்தல்](/developers/docs/smart-contracts/compiling/) மூலம் உருவாக்கப்படுகிறது +- எரிவாயுவிற்கான ETH – மற்ற பரிவர்த்தனைகளைப் போலவே உங்கள் எரிவாயு வரம்பையும் நீங்கள் அமைப்பீர்கள், எனவே ஒரு எளிய ETH பரிமாற்றத்தை விட ஒப்பந்தப் பயன்பாட்டிற்கு அதிக எரிவாயு தேவை என்பதை அறிந்து கொள்ளுங்கள் +- ஒரு பயன்படுத்தும் ஸ்கிரிப்ட் அல்லது சொருகுப்பொருள் +- ஒரு [Ethereum முனைக்கு](/developers/docs/nodes-and-clients/) அணுகல், இது உங்கள் சொந்த முனையை இயக்குவதன் மூலம், ஒரு பொது முனைக்கு இணைப்பதன் மூலம் அல்லது ஒரு [முனை சேவையைப்](/developers/docs/nodes-and-clients/nodes-as-a-service/) பயன்படுத்தி ஒரு API விசை வழியாக இருக்கலாம் + +### ஒரு ஸ்மார்ட் ஒப்பந்தத்தை பயன்படுத்துவதற்கான படிகள் {#steps-to-deploy} + +சம்பந்தப்பட்ட குறிப்பிட்ட படிகள் கேள்விக்குரிய மேம்பாட்டுக் கட்டமைப்பைப் பொறுத்தது. எடுத்துக்காட்டாக, [உங்கள் ஒப்பந்தங்களைப் பயன்படுத்துவது குறித்த Hardhat-இன் ஆவணங்களையோ](https://hardhat.org/docs/tutorial/deploying) அல்லது [ஒரு ஸ்மார்ட் ஒப்பந்தத்தைப் பயன்படுத்துதல் மற்றும் சரிபார்த்தல் குறித்த Foundry-இன் ஆவணங்களையோ](https://book.getfoundry.sh/forge/deploying) நீங்கள் பார்க்கலாம். பயன்படுத்தப்பட்டவுடன், உங்கள் ஒப்பந்தத்திற்கு மற்ற [கணக்குகளைப்](/developers/docs/accounts/) போலவே ஒரு Ethereum முகவரி இருக்கும், மேலும் [மூலக் குறியீடு சரிபார்ப்புக் கருவிகளைப்](/developers/docs/smart-contracts/verifying/#source-code-verification-tools) பயன்படுத்தி சரிபார்க்கப்படலாம். + +## தொடர்புடைய கருவிகள் {#related-tools} + +**Remix - _Remix IDE, Ethereum போன்ற பிளாக்செயின்களுக்கான ஸ்மார்ட் ஒப்பந்தங்களை உருவாக்க, பயன்படுத்த மற்றும் நிர்வகிக்க அனுமதிக்கிறது_** + +- [Remix](https://remix.ethereum.org) + +**Tenderly - _ஸ்மார்ட் ஒப்பந்தங்களை உருவாக்க, சோதிக்க, கண்காணிக்க மற்றும் இயக்க, பிழைத்திருத்தம், கவனித்தல் மற்றும் உள்கட்டமைப்பு கட்டுமானத் தொகுதிகளை வழங்கும் Web3 மேம்பாட்டுத் தளம்_** + +- [tenderly.co](https://tenderly.co/) +- [Docs](https://docs.tenderly.co/) +- [GitHub](https://github.com/Tenderly) +- [Discord](https://discord.gg/eCWjuvt) + +**Hardhat - _உங்கள் Ethereum மென்பொருளைத் தொகுக்க, பயன்படுத்த, சோதிக்க மற்றும் பிழைதிருத்தம் செய்வதற்கான ஒரு மேம்பாட்டுச் சூழல்_** + +- [hardhat.org](https://hardhat.org/getting-started/) +- [உங்கள் ஒப்பந்தங்களைப் பயன்படுத்துவதற்கான ஆவணங்கள்](https://hardhat.org/docs/tutorial/deploying) +- [GitHub](https://github.com/nomiclabs/hardhat) +- [Discord](https://discord.com/invite/TETZs2KK4k) + +**thirdweb - _ஒற்றைக் கட்டளையைப் பயன்படுத்தி, எந்தவொரு ஒப்பந்தத்தையும் எந்தவொரு EVM இணக்கமான சங்கிலியிலும் எளிதாகப் பயன்படுத்தலாம்_** + +- [ஆவணம்](https://portal.thirdweb.com/deploy/) + +**Crossmint - _ஸ்மார்ட் ஒப்பந்தங்களைப் பயன்படுத்த, கிரெடிட் கார்டு மற்றும் குறுக்கு-சங்கிலிப் பணம் செலுத்தல்களைச் செயல்படுத்த, மற்றும் NFT-களை உருவாக்க, விநியோகிக்க, விற்க, சேமிக்க மற்றும் திருத்த API-களைப் பயன்படுத்தும் ஒரு பெருநிறுவனத் தர web3 மேம்பாட்டுத் தளம்._** + +- [crossmint.com](https://www.crossmint.com) +- [ஆவணங்கள்](https://docs.crossmint.com) +- [Discord](https://discord.com/invite/crossmint) +- [வலைப்பதிவு](https://blog.crossmint.com) + +## தொடர்புடைய பயிற்சிகள் {#related-tutorials} + +- [உங்கள் முதல் ஸ்மார்ட் ஒப்பந்தத்தைப் பயன்படுத்துதல்](/developers/tutorials/deploying-your-first-smart-contract/) _– ஒரு Ethereum சோதனை நெட்வொர்க்கில் உங்கள் முதல் ஸ்மார்ட் ஒப்பந்தத்தைப் பயன்படுத்துவதற்கான ஒரு அறிமுகம்._ +- [வணக்கம் உலகம் | ஸ்மார்ட் ஒப்பந்தப் பயிற்சி](/developers/tutorials/hello-world-smart-contract/) _– Ethereum-இல் ஒரு அடிப்படை ஸ்மார்ட் ஒப்பந்தத்தை உருவாக்கிப் பயன்படுத்த, பின்பற்ற எளிதான ஒரு பயிற்சி._ +- [சொலிடிட்டியில் இருந்து பிற ஒப்பந்தங்களுடன் தொடர்புகொள்வது](/developers/tutorials/interact-with-other-contracts-from-solidity/) _– ஏற்கனவே உள்ள ஒப்பந்தத்திலிருந்து ஒரு ஸ்மார்ட் ஒப்பந்தத்தை எவ்வாறு வரிசைப்படுத்துவது மற்றும் அதனுடன் தொடர்புகொள்வது._ +- [உங்கள் ஒப்பந்தத்தின் அளவைக் குறைப்பது எப்படி](/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/) _- உங்கள் ஒப்பந்தத்தின் அளவைக் குறைத்து, அதை வரம்புக்குள் வைத்து, எரிவாயுவில் சேமிப்பது எப்படி_ + +## மேலும் வாசிக்க {#further-reading} + +- [https://docs.openzeppelin.com/learn/deploying-and-interacting](https://docs.openzeppelin.com/learn/deploying-and-interacting) - _OpenZeppelin_ +- [Hardhat உடன் உங்கள் ஒப்பந்தங்களைப் பயன்படுத்துதல்](https://hardhat.org/docs/tutorial/deploying) - _Nomic Labs_ + +_உங்களுக்கு உதவிய ஒரு சமூக வளம் பற்றி தெரியுமா?_ இந்தப் பக்கத்தைத் திருத்தி அதைச் சேர்க்கவும்!_ + +## தொடர்புடைய தலைப்புகள் {#related-topics} + +- [உருவாக்க கட்டமைப்புகள்](/developers/docs/frameworks/) +- [ஒரு Ethereum முனையை இயக்கவும்](/developers/docs/nodes-and-clients/run-a-node/) +- [சேவையாக-முனைகள்](/developers/docs/nodes-and-clients/nodes-as-a-service) diff --git a/public/content/translations/ta/developers/docs/smart-contracts/formal-verification/index.md b/public/content/translations/ta/developers/docs/smart-contracts/formal-verification/index.md new file mode 100644 index 00000000000..e8ebd295afc --- /dev/null +++ b/public/content/translations/ta/developers/docs/smart-contracts/formal-verification/index.md @@ -0,0 +1,284 @@ +--- +title: "ஸ்மார்ட் ஒப்பந்தங்களின் ஃபார்மல் வெரிஃபிகேஷன்" +description: "Ethereum ஸ்மார்ட் ஒப்பந்தங்களுக்கான ஃபார்மல் வெரிஃபிகேஷனின் ஒரு மேலோட்டம்" +lang: ta +--- + +[ஸ்மார்ட் ஒப்பந்தங்கள்](/developers/docs/smart-contracts/) பரவலாக்கப்பட்ட, நம்பிக்கையைச் சாராத மற்றும் வலுவான பயன்பாடுகளை உருவாக்குவதை சாத்தியமாக்குகின்றன, இது புதிய பயன்பாட்டு நிகழ்வுகளை அறிமுகப்படுத்தி பயனர்களுக்கு மதிப்பை வழங்குகிறது. ஸ்மார்ட் ஒப்பந்தங்கள் அதிகமான மதிப்புகளைக் கையாளும் காரணமாக, பாதுகாப்பு developers-க்கான முக்கிய கவனம் ஆகும். + +[ஸ்மார்ட் ஒப்பந்த பாதுகாப்பை](/developers/docs/smart-contracts/security/) மேம்படுத்துவதற்கான பரிந்துரைக்கப்பட்ட நுட்பங்களில் ஃபார்மல் வெரிஃபிகேஷனும் ஒன்றாகும். ஃபார்மல் வெரிஃபிகேஷன், நிரல்களைக் குறிப்பிடுவதற்கும், வடிவமைப்பதற்கும், சரிபார்ப்பதற்கும் [முறையான முறைகளைப்](https://www.brookings.edu/techstream/formal-methods-as-a-path-toward-better-cybersecurity/) பயன்படுத்துகிறது, இது முக்கியமான வன்பொருள் மற்றும் மென்பொருள் அமைப்புகளின் சரியான தன்மையை உறுதிப்படுத்த பல ஆண்டுகளாகப் பயன்படுத்தப்படுகிறது. + +ஸ்மார்ட் ஒப்பந்தங்களில் அமலாக்கும்போது, formal verification ஒரு ஒப்பந்தத்தின் business logic-ஐ முன்பிரிவு செய்யப்பட்ட specification-க்கு உடன்படுகிறதா என்பதை நிரூபிக்க முடியும். Contract code-இன் சரியானதை மதிப்பீடு செய்யும் மற்ற முறைகளோடு ஒப்பிடுகையில், formal verification ஒரு ஸ்மார்ட் ஒப்பந்தம் செயல்திறனாகச் சரியானது என்பதற்கான வலுவான உறுதிகளை வழங்குகிறது. + +## Formal verification என்ன? {#what-is-formal-verification} + +Formal verification என்பது ஒரு முறைமைவின் சரியான தன்மையை ஒரு formal specification-க்கு ஒப்பிடுவதற்கான செயல்முறை ஆகும். எளிதாகக் சொல்லுங்கள், formal verification மூலம் ஒரு முறைமை ஒரு சில தேவைகளைப் பூர்த்தி செய்யவா என்பதை சரிபார்க்க முடியும் (அதாவது, இது நாங்கள் விரும்பும் அளவுக்குச் செயற்படுகிறதா). + +முறையமைப்பின் எதிர்பார்க்கப்படும் செயற்பாடுகள் (இந்தச் சந்தர்ப்பத்தில் ஒரு ஸ்மார்ட் ஒப்பந்தம்) formal modeling மூலம் விவரிக்கப்படுகின்றன, அதேசமயம் specification languages மூலம் formal properties உருவாக்கப்படுகின்றன. Formal verification techniques பின்னர், ஒரு ஒப்பந்தத்தின் அமலாக்கம் அதன் specification-க்கு ஏற்பதாக உள்ளதா என்பதைச் சரிபார்க்க முடியும் மற்றும் அதன் சரியானதன்மைக்குக் கணிதத சான்றை உருவாக்க முடியும். ஒரு ஒப்பந்தம் அதன் specification-ஐ பூர்த்தி செய்யும்போது, அதனை “செயல்திறனாகச் சரியானது”, செய்த முறைமையாகச் சரியானது”, அல்லது “உருவாக்கத்தில் சரியானது” எனக் குறிப்பிடப்படுகிறது. + +### ஃபார்மல் மாடல் என்றால் என்ன? {#what-is-a-formal-model} + +கணினி அறிவியலில், ஒரு [ஃபார்மல் மாடல்](https://en.wikipedia.org/wiki/Model_of_computation) என்பது ஒரு கணக்கீட்டு செயல்முறையின் கணித விளக்கமாகும். Programs-ஐ கணித செயல்பாடுகளாக (equations) சுருக்கமாக்குவதால், model உள்ளீடு கொடுக்கப்பட்டால் functions-க்கு outputs எப்படி கணிக்கப்படுகின்றன என்பதைக் குறிப்பிடுகிறது. + +Formal models என்பது ஒரு program-இன் behavior-ஐப் பற்றி ஆராய்வதற்கான ஒரு சுருக்கத்தை வழங்குகிறது. ஃபார்மல் மாடல்கள் இருப்பது ஒரு _ஃபார்மல் ஸ்பெசிஃபிகேஷனை_ உருவாக்குவதை அனுமதிக்கிறது, இது கேள்விக்குரிய மாதிரியின் விரும்பிய பண்புகளை விவரிக்கிறது. + +Smart contracts-இன் formal verification-க்கு மாறுபட்ட நுட்பங்கள் modeling செய்யப் பயன்படுத்தப்படுகின்றன. உதாரணமாக, சில models ஒரு smart contract-இன் மேம்பட்ட behavior-ஐப் பற்றிப் புரிந்துகொள்ள reasoning செய்யப் பயன்படுத்தப்படுகின்றன. இந்த modeling techniques, smart contracts-ஐ கருப்பு பெட்டி view ஆகக் கருதுகின்றன, இதை systems ஆகக் கருதுகின்றன, இதுவும் inputs-ஐ ஏற்றுக்கொண்டு அவற்றின் அடிப்படையில் கணக்கீடு செய்கிறது. + +மேம்பட்ட models-ஐ, smart contracts மற்றும் வெளிப்புற முகவரிகள் (externally owned accounts (EOAs), contract accounts, மற்றும் blockchain environment போன்ற) ஆகியவற்றின் உறவுகளுக்கு மையமாகக் கொண்டு focus செய்கின்றன. குறிப்பிட்ட பயனர் தொடர்புக்களுக்குப் பதிலளிக்கும்போது ஒப்பந்தம் எப்படி நடந்து கொள்ள வேண்டும் என்பதைக் குறிப்பிட்ட பண்புகளை வரையறுக்க இந்த மாதிரியான models உதவிகரமாக உள்ளன. + +மாறாக, மற்ற formal models ஒரு smart contract-இன் கீழ்மட்ட behavior-ஐ focus செய்கின்றன. மேம்பட்ட models ஒப்பந்தத்தின் செயல்பாட்டைப் பற்றிப் புரிந்துகொள்ள உதவியாயினும், அவை அமலாக்கத்தின் உட்புற செயல்பாடுகளின் விவரங்களைப் பதிவு செய்ய இயலாது. கீழ்மட்ட மாதிரிகள் நிரல் பகுப்பாய்விற்கு ஒரு வெள்ளை-பெட்டி பார்வையைப் பயன்படுத்துகின்றன மற்றும் ஸ்மார்ட் ஒப்பந்தப் பயன்பாடுகளின் கீழ்-நிலை பிரதிநிதித்துவங்களான நிரல் தடங்கள் மற்றும் [கட்டுப்பாட்டுப் பாய்வு வரைபடங்கள்](https://en.wikipedia.org/wiki/Control-flow_graph) போன்றவற்றைச் சார்ந்து, ஒரு ஒப்பந்தத்தின் செயல்பாட்டிற்குப் பொருத்தமான பண்புகளைப் பற்றி பகுத்தறிய உதவுகின்றன. + +கீழ்மட்ட மாதிரிகள் சிறந்ததாகக் கருதப்படுகின்றன, ஏனெனில் அவை Ethereum-இன் செயலாக்க சூழலில் (அதாவது, [EVM](/developers/docs/evm/)) ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் உண்மையான செயல்பாட்டைப் பிரதிநிதித்துவப்படுத்துகின்றன. கீழ்மட்ட modeling techniques குறிப்பாக smart contracts-இல் முக்கியமான பாதுகாப்பு பண்புகளை நிலைநிறுத்த மற்றும் சாத்தியமான குறைகளைக் கண்டறிவதில் மிகவும் பயனுள்ளதாக உள்ளன. + +### ஃபார்மல் ஸ்பெசிஃபிகேஷன் என்றால் என்ன? {#what-is-a-formal-specification} + +சாதாரண விளக்கம் என்பது ஒரு குறிப்பிட்ட அமைப்பு பூர்த்தி செய்ய வேண்டிய தொழில்நுட்ப தேவையை மட்டும் குறிக்கிறது. Programming-இல், specifications என்பது ஒரு program-இன் execution-ஐப் பற்றிய பொது எண்ணங்களை (அதாவது, program என்ன செய்ய வேண்டும் என்பதைக் குறிப்பிடும்). + +ஸ்மார்ட் ஒப்பந்தங்களின் பின்னணியில், ஃபார்மல் ஸ்பெசிஃபிகேஷன்கள் _பண்புகளைக்_ குறிக்கின்றன—அதாவது ஒரு ஒப்பந்தம் பூர்த்தி செய்ய வேண்டிய தேவைகளின் முறையான விளக்கங்கள். இந்த மாதிரியான பண்புகள் "invariants" என்று விவரிக்கப்படுகின்றன மற்றும் ஒப்பந்தத்தின் execution-ஐப் பற்றிய தார்க்கிகமான assertions ஆகும், இது எந்தவித விதிவிலக்குகள் இல்லாமல் ஒவ்வொரு சாத்தியமான சூழலிலும் உண்மையாகவே இருக்க வேண்டும். + +எனவே, ஒரு formal specification என்பது formal language-இல் எழுதப்பட்ட statements-க்களின் தொகுப்பாகக் கருதலாம், இது smart contract-இன் நோக்கத்திற்கான execution-ஐ விவரிக்கின்றது. Specifications ஒரு ஒப்பந்தத்தின் பண்புகளைக் குறிக்கின்றன மற்றும் ஒப்பந்தம் வெவ்வேறு சூழல்களில் எப்படி நடந்து கொள்ள வேண்டும் என்பதைக் குறிப்பிடுகின்றன. Formal verification-இன் நோக்கம், ஒரு smart contract இந்தப் பண்புகளை (invariants) கொண்டுள்ளதா என்பதையும், execution போது இந்தப் பண்புகள் மீறப்படவில்லையா என்பதையும் தீர்மானிப்பதே ஆகும். + +Formal specifications ஒரு smart contract-இன் பாதுகாப்பான அமலாக்கங்களை உருவாக்குவதில் மிகவும் முக்கியமானதாகும். Contracts இல் invariants-ஐச் செயல்படுத்தத் தவறினால் அல்லது execution-இல் அவற்றின் பண்புகள் மீறப்பட்டால், அது செயல்திறனை கெடுக்க அல்லது தீய நோக்கத்துடன் exploits ஏற்படுத்தும் சாத்தியம் உள்ளது. + +## ஸ்மார்ட் ஒப்பந்தங்களுக்கான ஃபார்மல் ஸ்பெசிஃபிகேஷன்களின் வகைகள் {#formal-specifications-for-smart-contracts} + +Formal specifications என்பது ஒரு program-இன் execution சரியானதாக உள்ளதா என்பதை mathematical reasoning மூலம் தீர்மானிக்க உதவுகிறது. Formal models போலவே, formal specifications ஒரு ஒப்பந்தத்தின் செயலாக்கத்தின் மேம்பட்ட properties அல்லது கீழ்மட்ட behavior-ஐப் பதிவுசெய்யக்கூடியவை. + +ஒரு நிரலின் பண்புகளைப் பற்றி முறையான பகுத்தறிவுக்கு அனுமதிக்கும் [நிரல் தர்க்கத்தின்](https://en.wikipedia.org/wiki/Logic_programming) கூறுகளைப் பயன்படுத்தி ஃபார்மல் ஸ்பெசிஃபிகேஷன்கள் பெறப்படுகின்றன. Program logic-ல், ஒரு program என்ன செய்ய வேண்டும் என்பதைக் குறிக்கும் formal rules இருக்கின்றன. ஃபார்மல் ஸ்பெசிஃபிகேஷன்களை உருவாக்குவதில் [அடையக்கூடிய தர்க்கம்](https://en.wikipedia.org/wiki/Reachability_problem), [தற்காலிக தர்க்கம்](https://en.wikipedia.org/wiki/Temporal_logic) மற்றும் [ஹோர் தர்க்கம்](https://en.wikipedia.org/wiki/Hoare_logic) உள்ளிட்ட பல்வேறு நிரல் தர்க்கங்கள் பயன்படுத்தப்படுகின்றன. + +ஸ்மார்ட் ஒப்பந்தங்களுக்கான ஃபார்மல் ஸ்பெசிஃபிகேஷன்களை **உயர்-நிலை** அல்லது **கீழ்-நிலை** விவரக்குறிப்புகள் என பரவலாக வகைப்படுத்தலாம். எந்த வகையில் இருந்தாலும், அந்த specification சரியான முறையில் விவரிக்கப்பட வேண்டும். + +### உயர்-நிலை விவரக்குறிப்புகள் {#high-level-specifications} + +High-level specification அல்லது "model-oriented specification" எனப்படும் ஒரு high-level behavior-ஐ விவரிக்கிறது. உயர்-நிலை விவரக்குறிப்புகள் ஒரு ஸ்மார்ட் ஒப்பந்தத்தை [வரையறுக்கப்பட்ட நிலை இயந்திரமாக](https://en.wikipedia.org/wiki/Finite-state_machine) (FSM) மாதிரியாக்குகின்றன, இது செயல்பாடுகளைச் செய்வதன் மூலம் நிலைகளுக்கு இடையில் மாறக்கூடியது, FSM மாதிரிக்கான முறையான பண்புகளை வரையறுக்க தற்காலிக தர்க்கம் பயன்படுத்தப்படுகிறது. + +[தற்காலிக தர்க்கங்கள்](https://en.wikipedia.org/wiki/Temporal_logic) என்பவை "காலத்தின் அடிப்படையில் தகுதிப்படுத்தப்பட்ட முன்மொழிவுகளைப் பற்றி பகுத்தறிவதற்கான விதிகள் (உதாரணமாக, "நான் _எப்போதும்_ பசியாக இருக்கிறேன்" அல்லது "நான் _இறுதியில்_ பசியாக இருப்பேன்")." . Formal verification-இல், temporal logics பயன்பாடு, state-machines ஆக model செய்யப்பட்ட அமைப்புகளின் சரியான behavior பற்றிய assertions-ஐ வெளிப்படுத்துவதற்காகப் பயன்படுத்தப்படுகிறது. குறிப்பாக, temporal logic என்பது ஒரு smart contract எதிர்காலத்தில் இருக்கக்கூடிய states மற்றும் அவை states இடையே எவ்வாறு மாற்றப்படுகின்றன என்பதைக் குறிக்கிறது. + +உயர்-நிலை விவரக்குறிப்புகள் பொதுவாக ஸ்மார்ட் ஒப்பந்தங்களுக்கான இரண்டு முக்கியமான தற்காலிக பண்புகளை உள்ளடக்குகின்றன: **பாதுகாப்பு** மற்றும் **லைவ்னஸ்**. Safety properties என்பது "தீங்கு செய்யக்கூடியது எதுவும் நடக்காது" என்ற கருத்தைப் பிரதிபலிக்கிறது மற்றும் பொதுவாக invariance-ஐ வெளிப்படுத்துகின்றன. ஒரு பாதுகாப்புப் பண்பு [முட்டுக்கட்டையிலிருந்து](https://www.techtarget.com/whatis/definition/deadlock) விடுபடுதல் போன்ற பொதுவான மென்பொருள் தேவைகளை வரையறுக்கலாம் அல்லது ஒப்பந்தங்களுக்கான டொமைன்-குறிப்பிட்ட பண்புகளை வெளிப்படுத்தலாம் (எ.கா., செயல்பாடுகளுக்கான அணுகல் கட்டுப்பாட்டின் மீதான மாறிலிகள், நிலை மாறிகளின் அனுமதிக்கப்பட்ட மதிப்புகள் அல்லது டோக்கன் இடமாற்றங்களுக்கான நிபந்தனைகள்). + +உதாரணமாக, ERC-20 டோக்கன் ஒப்பந்தங்களில் `transfer()` அல்லது `transferFrom()` பயன்படுத்துவதற்கான நிபந்தனைகளை உள்ளடக்கிய இந்த பாதுகாப்புத் தேவையைக் கவனியுங்கள்: _“அனுப்புநரின் இருப்பு, அனுப்பப்பட வேண்டிய டோக்கன்களின் கோரப்பட்ட அளவை விட ஒருபோதும் குறைவாக இருக்காது.”_. இந்த contract invariant-ஐ ஒரு natural-language விளக்கமாக இருந்து, அதை ஒரு formal (mathematical) specification-ஆக மாற்றி, அதன் செல்லுபடியை கடுமையாகச் சரிபார்க்க முடியும். + +Liveness properties என்பது “நல்லது எதாவது இறுதியில் நடக்கிறது” என்பதைக் கூறுகிறது மற்றும் ஒப்பந்தம் பல்வேறு நிலைகளுக்கு மாறும் திறனைப் பற்றிக் கவலைப்படுகிறது. ஒரு liveness property-க்கு எடுத்துக்காட்டு “liquidity” ஆகும், இது ஒப்பந்தம் தனது balances-ஐப் பயனர்களுக்குக் கோரிக்கையின் அடிப்படையில் மாற்றும் திறனைக் குறிக்கிறது. இந்தப் பண்பு மீறப்பட்டால், [பாரிட்டி வாலட் சம்பவத்தில்](https://www.cnbc.com/2017/11/08/accidental-bug-may-have-frozen-280-worth-of-ether-on-parity-wallet.html) நடந்தது போல, பயனர்கள் ஒப்பந்தத்தில் சேமிக்கப்பட்ட சொத்துக்களை எடுக்க முடியாமல் போகும். + +### கீழ்-நிலை விவரக்குறிப்புகள் {#low-level-specifications} + +High-level specifications ஒரு ஒப்பந்தத்தின் finite-state model-ஐ தொடக்கமாக எடுத்துக் கொண்டு, இந்த model-இன் விரும்பிய properties-ஐ வரையறுக்கிறது. மாறாக, Low-level specifications (அல்லது "property-oriented specifications") பெரும்பாலும் programs (smart contracts) ஆகியவற்றை கணிதக் கருவிகளின் தொகுப்பாக முறைமைகளாக மாடல் செய்து, இந்த முறைமைகளின் சரியான behavior-ஐ விவரிக்கின்றன. + +எளிமையாகச் சொன்னால், கீழ்-நிலை விவரக்குறிப்புகள் _நிரல் தடங்களை_ பகுப்பாய்வு செய்து, இந்த தடங்களின் மீது ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் பண்புகளை வரையறுக்க முயற்சிக்கின்றன. Traces என்பது ஒரு smart contract-இன் நிலையை மாற்றும் செயலாக்கங்களின் வரிசையைக் குறிக்கின்றன; எனவே, Low-level specifications ஒப்பந்தத்தின் உள் செயலாக்கத்திற்கான தேவைகளை விவரிக்க உதவுகிறது. + +Low-level formal specifications-ஐ Hoare-style properties அல்லது execution paths-இல் invariants என வழங்க முடியும். + +### ஹோர்-பாணி பண்புகள் {#hoare-style-properties} + +[ஹோர் தர்க்கம்](https://en.wikipedia.org/wiki/Hoare_logic) ஸ்மார்ட் ஒப்பந்தங்கள் உட்பட நிரல்களின் சரியான தன்மையைப் பற்றி பகுத்தறிவதற்கான முறையான விதிகளின் தொகுப்பை வழங்குகிறது. ஒரு ஹோர்-பாணி பண்பு `{P}c{Q}` என்ற ஹோர் மும்மையால் குறிப்பிடப்படுகிறது, இதில் `c` என்பது ஒரு நிரல் மற்றும் `P` மற்றும் `Q` ஆகியவை `c`-இன் (அதாவது, நிரலின்) நிலையின் மீதான பயனிலைகள் ஆகும், இவை முறையே _முன்நிபந்தனைகள்_ மற்றும் _பின்நிபந்தனைகள்_ என முறையாக விவரிக்கப்படுகின்றன. + +ஒரு பிரிகண்டிஷன் என்பது ஒரு ஃபங்க்ஷன்-இன் சரியான செயல்பாட்டிற்கான தேவையான நிபந்தனைகளை விவரிக்கும் ஒரு பிரடிகேட் ஆகும்; ஒப்பந்தத்திற்கு அழைக்கும் பயனர்கள் இந்த ரிக்வயர்மெண்ட்-ஐ பூர்த்தி செய்ய வேண்டும். ஒரு போஸ்ட்கண்டிஷன் என்பது ஒரு ஃபங்க்ஷன் சரியாகச் செயல்பட்டால்் அது நிலைநிறுத்தும் கண்டிஷன்-ஐ விவரிக்கும் ஒரு பிரடிகேட் ஆகும்; பயனர்கள் இந்த கண்டிஷன்-ஐ உண்மையென எதிர்பார்க்கலாம் ஃபங்க்ஷன்-ஐ அழைத்தபிறகுு. ஹோர் தர்க்கத்தில் ஒரு _மாறிலி_ என்பது ஒரு செயல்பாட்டின் செயலாக்கத்தால் பாதுகாக்கப்படும் ஒரு பயனிலையாகும் (அதாவது, அது மாறாது). + +ஹோர்-பாணி விவரக்குறிப்புகள் _பகுதி சரியான தன்மை_ அல்லது _முழுமையான சரியான தன்மை_ ஆகிய இரண்டில் ஒன்றை உறுதி செய்ய முடியும். ஒரு ஒப்பந்தத்தின் ஒரு ஃபங்க்ஷன் செயல்பாடு "பார்ஷியலாகச் சரியாக உள்ளது" என்றால், செயல்படுத்தும் முன்பு பிரிகண்டிஷன் உண்மையாக இருக்கும், மேலும் செயல்பாடு நிறைவடைந்தால், போஸ்ட்கண்டிஷன் உண்மையாக இருக்கும். டோட்டல் correctness-ஐ உறுதிப்படுத்தும் ப்ரூஃப் -ஐ பெற முடியும், பிரிகண்டிஷன் செயல்படுத்தும் முன்பு உண்மையாக இருக்கும், செயல்பாடு நிறைவடையும் என்பதற்கான கரண்டீ இருக்கும், மேலும் அது நிறைவடைந்தால், போஸ்ட்கண்டிஷன் உண்மையாக இருக்கும். + +டோட்டல் correctness-ஐ உறுதிப்படுத்தும் ப்ரூஃப் பெறுவது கடினம், ஏனெனில் சில செயல்பாடுகள் நிறைவடைய முன்னர் தாமதமாவது அல்லது முடிவடையாமலே போவது போன்ற பிரச்சனைகள் இருக்கலாம். அதுவே, செயல்பாடு முடிவடைவதா என்பது ஒரு அவசியம் என்ற கேள்விக்குப் பதிலளிக்க வேண்டும், ஏனெனில் Ethereum-இன் காஸ் மெக்கானிசம் முடிவற்ற ப்ரோக்ராம் லூப்கள்-ஐ தடுக்கிறது (செயல்பாடு வெற்றிகரமாக நிறைவடையும் அல்லது 'out-of-gas' பிழை காரணமாக முடிவடையும்). + +ஹோர் லாஜிக்-ஐப் பயன்படுத்தி உருவாக்கப்படும் ஸ்மார்ட் கான்ட்ராக்ட் ஸ்பெசிபிகேஷன்கள், ஒப்பந்தத்தில் உள்ள ஃபங்க்ஷன்கள் மற்றும் லூப்கள் செயல்பாடுகளுக்குப் பிரிகண்டிஷன்ஸ், போஸ்ட்கண்டிஷன்ஸ் மற்றும் இன்வாரியண்ட்ஸ் ஆகியவற்றைப் பெறுகின்றன. பிரிகண்டிஷன்ஸ் பெரும்பாலும் ஒரு ஃபங்க்ஷன்-க்கு தவறான உள்ளீடுகளை உடையதாக இருக்கலாம், போஸ்ட்கண்டிஷன்ஸ் அவ்வாறு உள்ளீடுகளுக்கான எதிர்பார்க்கப்பட்ட பதிலை விவரிக்கின்றன (எ.கா., குறிப்பிட்ட எக்ஸ்செப்ஷன்-ஐ தூக்கும்). இந்த முறையில், ஹோர்-ஸ்டைல் ப்ராபர்டீஸ் ஒப்பந்தத்தின் செயல்பாடுகளின் சரியானபொருளை உறுதிப்படுத்துவதில் பயனுள்ளதாக இருக்கும். + +பல பார்மல் வெரிபிகேஷன் அமைப்புகள், ஃபங்ஷன்களின் செமான்டிக் correctness-ஐ நிரூபிப்பதற்காக ஹோர்-ஸ்டைல் ஸ்பெசிபிகேஷன்களை பயன்படுத்துகின்றன. Solidity-இல் உள்ள `require` மற்றும் `assert` கூற்றுகளைப் பயன்படுத்தி, ஹோர்-பாணி பண்புகளை (உறுதிமொழிகளாக) நேரடியாக ஒப்பந்தக் குறியீட்டில் சேர்க்கவும் முடியும். + +`require` கூற்றுகள் ஒரு முன்நிபந்தனை அல்லது மாறிலியை வெளிப்படுத்துகின்றன மற்றும் பெரும்பாலும் பயனர் உள்ளீடுகளை சரிபார்க்கப் பயன்படுகின்றன, அதேசமயம் `assert` பாதுகாப்பிற்குத் தேவையான ஒரு பின்நிபந்தனையைப் பிடிக்கிறது. உதாரணமாக, செயல்பாடுகளுக்கான முறையான அணுகல் கட்டுப்பாடு (பாதுகாப்புப் பண்பின் ஒரு எடுத்துக்காட்டு) அழைக்கும் கணக்கின் அடையாளத்தின் மீதான முன்நிபந்தனைச் சோதனையாக `require` ஐப் பயன்படுத்துவதன் மூலம் அடைய முடியும். இதேபோல், ஒரு ஒப்பந்தத்தில் உள்ள நிலை மாறிகளின் அனுமதிக்கப்பட்ட மதிப்புகள் மீதான ஒரு மாறிலியை (எ.கா., புழக்கத்தில் உள்ள மொத்த டோக்கன்களின் எண்ணிக்கை) மீறுவதிலிருந்து பாதுகாக்க, செயல்பாட்டின் செயலாக்கத்திற்குப் பிறகு ஒப்பந்தத்தின் நிலையை உறுதிப்படுத்த `assert` ஐப் பயன்படுத்தலாம். + +### தட-நிலை பண்புகள் {#trace-level-properties} + +ட்ரேஸ்-பேஸ்டு ஸ்பெசிபிகேஷன்கள் ஒரு கான்ட்ராக்ட் பல்வேறு ஸ்டேட்களுக்கு இடையில் ட்ரான்சிஷன் செய்யும் செயல்பாடுகளை, மற்றும் இந்த ஆபரேஷன்கள் ஒன்றுக்கொன்று தொடர்புடையதை விவரிக்கின்றன. முன்னர் விளக்கப்பட்டபடி, ட்ரேஸ்கள் ஒரு குறிப்பிட்ட முறையில் ஒரு கான்ட்ராக்டின் ஸ்டேட்-ஐ மாற்றும் ஆபரேஷன்களின் தொடர்ச்சியாகும். + +இந்த அணுகுமுறை, சில முன்னறியப்பட்ட ஸ்டேட்கள் (அதாவது ஸ்டேட் வெரியபிள்ஸ் மூலம் விவரிக்கப்படும்) மற்றும் ஒரு செட் ஆஃப் பிரிஃடீடைன் ட்ரான்சிஷன்ஸ் (அதாவது கான்ட்ராக்ட் ஃபங்ஷன்கள் மூலம் விவரிக்கப்படும்) உடன் ஸ்மார்ட் கான்ட்ராக்ட்கள் ஸ்டேட்-ட்ரான்சிஷன் சிஸ்டம்ஸ் என மாடல் செய்யும் துறையில் நிரம்பி உள்ளது. மேலும், ஒரு [கட்டுப்பாட்டுப் பாய்வு வரைபடம்](https://www.geeksforgeeks.org/software-engineering-control-flow-graph-cfg/) (CFG), இது ஒரு நிரலின் செயலாக்கப் பாய்வின் வரைகலை பிரதிநிதித்துவம், பெரும்பாலும் ஒரு ஒப்பந்தத்தின் செயல்பாட்டு சொற்பொருளை விவரிக்கப் பயன்படுகிறது. இங்கே, ஒவ்வொரு ட்ரேஸ்-ம் ஒரு கான்ட்ரோல் ஃப்ளோ கிராப்-இல் பாத்-ஆக பிரதிநிதியாகும். + +பிரதானமாக, ட்ரேஸ்-லெவல் ஸ்பெசிபிகேஷன்கள் ஸ்மார்ட் கான்ட்ராக்ட்களின் ஆன்டர்னல் எக்ஸிக்யூஷன் மாதிரிகள்குறித்து கருத்து தெரிவிக்க பயன்படுத்தப்படுகின்றன. ட்ரேஸ்-லெவல் ஸ்பெசிபிகேஷன்களை உருவாக்குவதன் மூலம், நாம் ஒரு ஸ்மார்ட் கான்ட்ராக்டின் அட்மிஸிபில் எக்ஸிக்யூஷன் பாத்-களை (அதாவது, ஸ்டேட் ட்ரான்சிஷன்கள்) நிரூபிக்கின்றோம். சிம்பாலிக் எக்ஸிக்யூஷன் போன்றதொழில்நுட்பங்களைப் பயன்படுத்திி, செயல்பாடு ஒரு பார்மல் மாடல்-இல் வரையறுக்கப்படாதபாதையைப் பின்பற்றாதுு என்பதற்கான பார்மல் வெரிபிகேஷனை பெற முடியும். + +தட-நிலை பண்புகளை விவரிக்க, சில பொதுவில் அணுகக்கூடிய செயல்பாடுகளைக் கொண்ட ஒரு [DAO](/dao/) ஒப்பந்தத்தின் எடுத்துக்காட்டைப் பயன்படுத்துவோம். இங்கே, DAO கான்ட்ராக்ட் பயனர்கள் பின்வரும் செயல்பாடுகளைச் செய்ய அனுமதிக்கிறது என்று நாம் கருதுகிறோம்: + +- நிதிகளைச் சேமித்து வைப்பது + +- நிதிகளைச் சேமிக்காத பயனர்கள் ஒரு ப்ரபோசல்-க்கு வாக்களிக்க முடியாது + +- ஒரு ப்ரபோசல்-க்கு வாக்களிக்காத பயனர்கள் எப்போதும் தங்கள் நிதிகளைத் திரும்பப் பெற முடியும் + +எடுத்துக்காட்டாக, தட-நிலை பண்புகள் _"நிதி டெபாசிட் செய்யாத பயனர்கள் ஒரு முன்மொழிவுக்கு வாக்களிக்க முடியாது"_ அல்லது _"ஒரு முன்மொழிவுக்கு வாக்களிக்காத பயனர்கள் எப்போதும் பணத்தைத் திரும்பப் பெற முடியும்"_ என்பதாக இருக்கலாம். இந்த இரண்டு பண்புகளும் செயலாக்கத்தின் விருப்பமான வரிசைகளை உறுதிப்படுத்துகின்றன (நிதிகளை டெபாசிட் செய்வதற்கு _முன்பு_ வாக்களிப்பு நடக்க முடியாது மற்றும் ஒரு முன்மொழிவில் வாக்களித்த _பிறகு_ பணத்தைத் திரும்பப் பெறுதல் நடக்காது). + +## ஸ்மார்ட் ஒப்பந்தங்களின் ஃபார்மல் வெரிஃபிகேஷனுக்கான நுட்பங்கள் {#formal-verification-techniques} + +### மாடல் சரிபார்ப்பு {#model-checking} + +மாடல் செக்கிங் என்பது ஒரு பார்மல் வெரிபிகேஷன் தொழில்நுட்பமாகும், இதில் ஒரு ஆல்காரிதம் ஒரு ஸ்மார்ட் கான்ட்ராக்டின் பார்மல் மாடலை அதன் ஸ்பெசிபிகேஷனுடன் ஒப்பிடுகிறது. மாடல் செக்கிங்கில் ஸ்மார்ட் கான்ட்ராக்ட்கள் பெரும்பாலும் ஸ்டேட்-ட்ரான்சிஷன் சிஸ்டம்ஸ் எனப் பிரதிநிதிி செய்யப்படுகின்றன, மேலும் அனுமதிக்கப்பட்ட கான்ட்ராக்ட் ஸ்டேட்களில் உள்ள ப்ராபர்டீஸ் டெம்பரல் லாஜிக் பயன்படுத்தி வரையறுக்கப்படுகின்றன. + +மாடல் சரிபார்ப்புக்கு ஒரு அமைப்பின் (அதாவது, ஒரு ஒப்பந்தத்தின்) சுருக்கமான கணிதப் பிரதிநிதித்துவத்தை உருவாக்குவதும், இந்த அமைப்பின் பண்புகளை [முன்மொழிவு தர்க்கத்தில்](https://www.baeldung.com/cs/propositional-logic) வேரூன்றிய சூத்திரங்களைப் பயன்படுத்தி வெளிப்படுத்துவதும் தேவைப்படுகிறது. இதனால் மாடல் செக்கிங் ஆல்காரிதத்திற்கு வேலை சுலபமாகிறது, அதாவது ஒரு மாடல் ஒரு குறிப்பிட்ட லாஜிக்கல் ஃபார்முலாவை பூர்த்தி செய்கிறதா என்பதனை நிரூபிக்கிறது. + +மாடல் செக்கிங் பெரும்பாலும் ஸ்மார்ட் கான்ட்ராக்ட்களின் டெம்பரல் ப்ராபர்டீஸ்களை மதிப்பீடு செய்யப் பயன்படுத்தப்படுகிறது, இது கான்ட்ராக்டின் நேரத்தின் கணக்கை விவரிக்கின்றன. ஸ்மார்ட் ஒப்பந்தங்களுக்கான தற்காலிக பண்புகளில் _பாதுகாப்பு_ மற்றும் _லைவ்னஸ்_ ஆகியவை அடங்கும், அவற்றை நாங்கள் முன்பே விளக்கினோம். + +உதாரணமாக, அணுகல் கட்டுப்பாடு தொடர்பான ஒரு பாதுகாப்புப் பண்பு (எ.கா., _ஒப்பந்தத்தின் உரிமையாளர் மட்டுமே `selfdestruct`-ஐ அழைக்க முடியும்_) முறையான தர்க்கத்தில் எழுதப்படலாம். அதன் பின்னர், மாடல் செக்கிங் ஆல்காரிதம் அந்தக் கான்ட்ராக்ட் பார்மல் ஸ்பெசிபிகேஷனை பூர்த்தி செய்கிறதா என்பதை வெரிபி செய்யும். + +மாடல் செக்கிங் ஸ்டேட் ஸ்பேஸ் எக்ஸ்ப்ளோரேஷனை பயன்படுத்துகிறது, இதன் மூலம் ஸ்மார்ட் கான்ட்ராக்ட்களின் அனைத்து ஸ்டேட்களையும் உருவாக்கி, ப்ராபர்டி வியலிகளின் விளைவுகளாகக்கூடும் ரீசபிள் ஸ்டேட்களை கண்டுபிடிக்க முயல்கிறது. இருப்பினும், இது ஒரு முடிவிலி ஸ்டேட்களுக்குச் செலுத்தப்படும் (இது ஸ்டேட் எக்ஸ்ப்ளோஷன் பிரச்சினை என்று அழைக்கப்படுகிறது), எனவே மாடல் செக்கர்கள் அப்ஸ்ட்ராக்ஷன் தொழில்நுட்பங்களைப் பயன்படுத்தி ஸ்மார்ட் கான்ட்ராக்ட்களின் பயனுள்ள அனலிஸ்ஸை மேற்கொள்ளும். + +### தேற்றம் நிரூபணம் {#theorem-proving} + +தியோரம் ப்ரூவிங் என்பது ப்ரோக்ராம்களின் சரியானதையை கணித ரீதியாக ஆராயும் ஒரு முறை, இதில் ஸ்மார்ட் கான்ட்ராக்ட்களும் அடங்கும். இது ஒரு கான்ட்ராக்டின் ஸிஸ்டம் மற்றும் அதன் ஸ்பெசிபிகேஷன்களை கணித சூத்திரங்களாக (தார்மீக அறிக்கைகள்) மாற்றுவதைக் கொண்டுள்ளது. + +தியோரம் ப்ரூவிங்-ஐ பயன்படுத்துவதன் நோக்கம் இந்த அறிக்கைகளுக்கு இடையிலான தார்மீக சமநிலையை சரிபார்ப்பது. “தர்க்கரீதியான சமநிலை” ( “தர்க்கரீதியான இரு-தாக்கம்” என்றும் அழைக்கப்படுகிறது) என்பது இரண்டு கூற்றுகளுக்கு இடையேயான ஒரு வகை உறவாகும், இதன் மூலம் இரண்டாவது கூற்று உண்மையாக _இருந்தால் மட்டுமே_ முதல் கூற்று உண்மையாக இருக்கும். + +கான்ட்ராக்டின் மாடல் மற்றும் அதன் ப்ராபர்டீ பற்றிய அறிக்கைகளுக்கு இடையிலான தேவையான தார்மீக சமநிலை ஒரு தியோரமாக (தியோரம்) உருவாக்கப்படுகிறது. தியோரம் ப்ரூவர் இன் அனிப்ராணஸ் தலையில் ப்ரூவிங் மூலமாகத் தியோரத்தின் சரியானதையை சான்றுகள்மூலம் நிரூபிக்க முடியும். இதன் பொருள், ஒரு தியோரம் ப்ரூவர் ஒரு ஸ்மார்ட் கான்ட்ராக்டின் மாடல் அதன் ஸ்பெசிபிகேஷன்களுடன் பூரணமாகப் பொருந்துகிறது என்பதை துல்லியமாக நிரூபிக்க முடியும். + +மாடல் செக்கிங் கான்ட்ராக்ட்களை ட்ரான்சிஷன் சிஸ்டம்களாக ஸ்டேட்களில் மதிப்பீடு செய்கின்றபோது, தியோரம் ப்ரூவிங் முடிவில்லாத ஸ்டேட் சிஸ்டம்களின் அனலிஸ்ஸை நடத்த முடியும். இருப்பினும், இதனால் ஒரு ஆட்டோமேட்டட் தியோரம் ப்ரூவர் ஒரு லாஜிக்கல் பிரச்சினை "டிசைடபிள்" (தீர்க்கக்கூடியது) என்கிறதா என்பதை எப்போதும் அறிய முடியாது. + +இதனால், தியோரம் ப்ரூவிங்-இல் மனித உதவி தேவைப்படும், மேலும் தியோரம் ப்ரூவர் சரியான சான்றுகளைத் தீர்க்க வழிகாட்டத் தேவைப்படும். மனித முயற்சி தியோரம் ப்ரூவிங்கில் அதிகம் உள்ளதால், இது மாடல் செக்கிங்கைவிட மிகவும் செலவானதாகும், ஏனெனில் மாடல் செக்கிங் முழுமையாக ஆட்டோமேட்டட் ஆகும். + +### குறியீட்டு செயலாக்கம் {#symbolic-execution} + +குறியீட்டு செயலாக்கம் என்பது _உறுதியான மதிப்புகளுக்குப்_ (எ.கா., `x == 5`) பதிலாக _குறியீட்டு மதிப்புகளைப்_ (எ.கா., `x > 5`) பயன்படுத்தி செயல்பாடுகளைச் செயல்படுத்துவதன் மூலம் ஒரு ஸ்மார்ட் ஒப்பந்தத்தைப் பகுப்பாய்வு செய்யும் ஒரு முறையாகும். இது ஒரு பார்மல் வெரிபிகேஷன் தொழில்நுட்பமாகும், மேலும் இது கான்ட்ராக்ட்டின் கோடின் ட்ரேஸ்-லெவல் ப்ராபர்டீக்களை பூரணமாக ஆராய்வதற்காகப் பயன்படுத்தப்படுகிறது. + +குறியீட்டு செயலாக்கம் ஒரு செயலாக்கத் தடத்தை குறியீட்டு உள்ளீட்டு மதிப்புகளின் மீதான ஒரு கணித சூத்திரமாகப் பிரதிபலிக்கிறது, இது _பாதை பயனிலை_ என்றும் அழைக்கப்படுகிறது. ஒரு பாதை பயனிலை "திருப்திகரமாக" உள்ளதா (அதாவது, சூத்திரத்தை திருப்திப்படுத்தக்கூடிய ஒரு மதிப்பு உள்ளது) என்பதைச் சரிபார்க்க [SMT தீர்ப்பான்](https://en.wikipedia.org/wiki/Satisfiability_modulo_theories) பயன்படுத்தப்படுகிறது. ஒரு வல்னரபிள் பாத் சாட்டிஸ்பெய்ப்பிளா என்றால், எஸ்எம்டி சால்வர்அந்தப் பாதைக்குு வழிவகுக்கும் ஒரு கான்க்ரீட் மதிப்பை உருவாக்கும். + +ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் செயல்பாடு `uint` மதிப்பை (`x`) உள்ளீடாக எடுத்துக்கொள்கிறது மற்றும் `x` ஆனது `5`-ஐ விட அதிகமாகவும் `10`-ஐ விட குறைவாகவும் இருக்கும்போது திரும்புகிறது என்று வைத்துக்கொள்வோம். ஒரு சாதாரண சோதனை முறையைப் பயன்படுத்தி பிழையைத் தூண்டும் `x`-இன் மதிப்பைக் கண்டறிவதற்கு, பிழையைத் தூண்டும் உள்ளீட்டைக் கண்டறிவதற்கான உத்தரவாதமின்றி டஜன் கணக்கான சோதனை நிகழ்வுகளை (அல்லது அதற்கு மேற்பட்டவை) இயக்க வேண்டும். + +மாறாக, ஒரு குறியீட்டு செயலாக்கக் கருவி செயல்பாட்டை குறியீட்டு மதிப்புடன் செயல்படுத்தும்: `X > 5 ∧ X < 10` (அதாவது, `x` 5-ஐ விட பெரியது மற்றும் `x` 10-ஐ விட சிறியது). தொடர்புடைய பாதை பயனிலை `x = X > 5 ∧ X < 10` பின்னர் தீர்ப்பதற்காக ஒரு SMT தீர்ப்பானுக்கு வழங்கப்படும். ஒரு குறிப்பிட்ட மதிப்பு `x = X > 5 ∧ X < 10` என்ற சூத்திரத்தை திருப்திப்படுத்தினால், SMT தீர்ப்பான் அதைக் கணக்கிடும்—உதாரணமாக, தீர்ப்பான் `x`-இன் மதிப்பாக `7`-ஐ உருவாக்கலாம். + +சிம்பாலிக் எக்சிக்யூஷன் ஒரு ப்ரோக்ராமுக்கு இன்புட்களை நம்புகிறது, மேலும் அனைத்து அடையக்கூடிய ஸ்டேட்களை ஆராய இன்புட்களின் தொகுப்பு முடிவில்லாதது, எனவே இது இன்னும் ஒரு சோதனை முறை ஆகும். எனினும், உதாரணமாகக் காட்டப்பட்டுள்ளபடி, சிம்பாலிக் எக்சிக்யூஷன் ப்ராபர்டீ மீறுதல்களை தூண்டும் இன்புட்களை கண்டறிவதற்காக வழக்கமான சோதனைக்கான உந்துதலாகும். + +மேலும், சிம்பாலிக் எக்சிக்யூஷன் மற்ற ப்ராபர்டி-ஆதாரமுடைய தொழில்நுட்பங்களுடன் (உதாரணமாக, பஜ்சிங்) ஒப்பிடுகையில் குறைவான பாசிட்டிவ்களை உருவாக்குகிறது, இது ஒரு பங்க்ஷனுக்கு இன்புட்களை சீரற்ற முறையில் உருவாக்கும். சிம்பாலிக் எக்சிக்யூஷன் போது ஒரு பிழை ஸ்டேட் தூண்டப்பட்டால், அந்தப் பிழையைத் தூண்டும் கான்க்ரீட் மதிப்பை உருவாக்கிச் சிக்கலை மீண்டும் உருவாக்க முடியும். + +சிம்பாலிக் எக்சிக்யூஷன் சில அளவிற்கு கணித சரிபார்ப்பை வழங்கவும் முடியும். ஓவர்ஃப்லோ பாதுகாப்புடன் கான்ட்ராக்ட் பங்க்ஷனின் பின்வரும் எடுத்துக்காட்டைப் பாருங்கள்: + +``` +function safe_add(uint x, uint y) returns(uint z){ + + z = x + y; + require(z>=x); + require(z>=y); + + return z; +} +``` + +முழு எண் ஓவர்ஃப்ளோவிற்கு வழிவகுக்கும் ஒரு செயலாக்கத் தடம் `z = x + y மற்றும் (z >= x) மற்றும் (z >= y) மற்றும் (z < x அல்லது z < y)` என்ற சூத்திரத்தை திருப்திப்படுத்த வேண்டும். அத்தகைய சூத்திரத்தை தீர்ப்பது சாத்தியமில்லை, எனவே இது `safe_add` செயல்பாடு ஒருபோதும் ஓவர்ஃப்ளோ ஆகாது என்பதற்கான கணித ஆதாரமாக செயல்படுகிறது. + +### ஏன் ஸ்மார்ட் கான்ட்ராக்ட்களுக்கு பார்மல் வெரிபிகேஷனை பயன்படுத்த வேண்டும்? ஃபார்மல் வெரிஃபிகேஷனின் நன்மைகள் {#benefits-of-formal-verification} + +#### நம்பகத்தன்மைக்கான தேவை {#need-for-reliability} + +பார்மல் வெரிபிகேஷன் அது தோல்வியுற்றால், பலத்த பாதகங்கள் (இறப்பு, காயம், அல்லது நிதி அழிவு) ஏற்படும் காப்பு-முக்கியமான சிஸ்டம்களின் சரியான தன்மையை மதிப்பீடு செய்யப் பயன்படுத்தப்படுகிறது. ஸ்மார்ட் ஒப்பந்தங்கள் மிகப்பெரிய மதிப்பைக் கட்டுப்படுத்தும் உயர்-மதிப்பு பயன்பாடுகள், மற்றும் வடிவமைப்பில் ஏற்படும் எளிய பிழைகள் [பயனர்களுக்கு மீளமுடியாத இழப்புகளுக்கு](https://www.freecodecamp.org/news/a-hacker-stole-31m-of-ether-how-it-happened-and-what-it-means-for-ethereum-9e5dc29e33ce/amp/) வழிவகுக்கும். ஊடகத்தில் செயல்படுவதை ஆரம்பிக்கும் முன்பு கான்ட்ராக்ட்டை பார்மலாகச் சரிபார்க்க செய்வதன் மூலம், அது ப்ளாக்செயினில் செயல்படும்போது எதிர்பார்த்த செயல்திறனை வழங்கும் உறுதிகளை அதிகரிக்க முடியும். + +நம்பகத்துவம் என்பது எந்தவொரு ஸ்மார்ட் கான்ட்ராக்ட்டிற்கும் மிகவும் தேவையான தரமாகும், குறிப்பாக ஈதேரியமின் விர்சுவல் மெஷினில் (EVM) போட்ட கோடு பொதுவாக அமைதி ஆகவே இருக்கும். பிறகு புதியதாக்கங்கள் எளிதில் கிடைக்காததால், கான்ட்ராக்ட்களின் நம்பகத்துவத்தை உறுதிப்படுத்த தேவையாக உள்ளது. பார்மல் வெரிபிகேஷன் இண்டீஜர் அண்டர்ஃப்ளோ மற்றும் ஓவர்ஃப்ளோ, ரீ-என்ட்ரன்சி, மற்றும் போர்வை குறையாத எக்சிக்யூஷன் ஆகியவற்றைப் கண்டுபிடிக்கக் கூடியது, இது ஆடியட்டர்கள் மற்றும் சோதகர்களால் தவறவிடப்படும் சிக்கல்களைக் கண்டுபிடிக்க உதவுகிறது. + +#### செயல்பாட்டு சரியான தன்மையை நிரூபித்தல் {#prove-functional-correctness} + +பிரோகிராம் சோதனை என்பது ஒரு ஸ்மார்ட் கான்ட்ராக்ட் சில தேவைகளைப் பூர்த்தி செய்கிறதா என்பதை நிரூபிக்கப் பொதுவாகப் பயன்படுத்தப்படும் முறை. இது ஒரு கான்ட்ராக்டைப் தரவுகளின் மாதிரியுடன் இயக்கி, அதன் செயல்பாட்டைப் நன்கு பகுப்பாய்வு செய்ய அடிப்படையாகக் கொண்டுள்ளது. மாதிரி தரவுகளுக்கான எதிர்பார்க்கப்படும் முடிவுகளைக் கான்ட்ராக்ட் வழங்கினால், அதற்கான அடிப்படையா சான்று கிடைக்கிறது. + +ஆனால், இந்த முறை மாதிரியில்உள்ள தரவுகளுக்குத் தவிர உள்ளீட்டு மதிப்புகளின் சரியான செயல்பாட்டை நிரூபிக்க முடியாது. எனவே, ஒரு ஒப்பந்தத்தைச் சோதிப்பது பிழைகளைக் கண்டறிய உதவலாம் (அதாவது, சில குறியீட்டுப் பாதைகள் செயலாக்கத்தின் போது விரும்பிய முடிவுகளைத் தராமல் போனால்), ஆனால் **அது பிழைகள் இல்லை என்பதை உறுதியாக நிரூபிக்க முடியாது**. + +மாறாக, ஃபார்மல் வெரிஃபிகேஷன் ஒரு ஸ்மார்ட் ஒப்பந்தம் எண்ணற்ற செயலாக்க வரம்புகளுக்கான தேவைகளைப் பூர்த்தி செய்கிறது என்பதை ஒப்பந்தத்தை இயக்காமலேயே முறையாக நிரூபிக்க முடியும். இது முறைப்படி செயல்பாட்டுப் பின்பற்றல், மாதிரிகளுக்கான மற்றும் மாதிரிகள் அளிக்கும், கான்ட்ராக்டின் செயல்பாடுகளை வரையறுக்க மூலமாகக் கொண்டு, ஒரு பார்மலின் (கணித) மாதிரியைஉருவாக்கத் தேவையாகிறதுு. அதன் பிறகு, முறைப்படி நம்பகத்துவத்தை சரிபார்க்க, கான்ட்ராக்டின் மாதிரியுடன் அதன் விளக்கத்தின் இடையிலான நிலைத்தன்மையை சரிபார்க்க முறைமுறையை பின்பற்றலாம். + +பார்மல் வெரிபிகேஷன் மூலம், ஒரு கான்ட்ராக்டின் வணிக பின்பற்றலின் தேவைகளைப் பூர்த்தி செய்கிறதா என்பதை சரிபார்க்கும் கேள்வி ஒரு கணிதக் கருத்து ஆகும், இது நிரூபிக்க அல்லது நிராகரிக்க முடியும். ஒரு கருத்தை முறையாக நிரூபிக்க மூலம், முடிவுகளை ஒரு சரியான எண்ணிக்கையுடன் காணலாம். இதன் மூலம், பார்மல் வெரிபிகேஷன் ஒரு கான்ட்ராக்டு செயல்பாட்டில் ஒரு சிறந்த வாய்ப்புகளை வழங்குகிறது. + +#### சிறந்த சரிபார்ப்பு இலக்குகள் {#ideal-verification-targets} + +ஒரு சோதனை இலக்கு, அலுவலகமாகச் சோதிக்கப்படும் அமைப்பை விவரிக்கிறது. பார்மல் வெரிபிகேஷன் சிறந்தது "எம்பெடிட் சிஸ்டம்" (சிறிய, எளிய மென்பொருள் பகுதிகள், பெரிய அமைப்பின் ஒரு பகுதியாக இருப்பவை). இவை சிறந்த பிறந்த பிரிவுகளுக்கு மிகவும் உதவியாக உள்ளன, ஏனெனில் குறைந்த சட்டங்களுள்ள பிறந்த பிரிவுகளில் மூலங்களைச் சோதிக்க வழிமுறைகளை மாற்றுவது எளிதாக இருக்கும். + +ஸ்மார்ட் கான்ட்ராக்டுகள்—சில அளவுக்கு—இரு தேவைகளையும் பூர்த்தி செய்கின்றன. எடுத்துக்காட்டாக, எத்தியரியம் கான்ட்ராக்டுகளின் சிறிய அளவுஅவற்றைப் பார்மல்் வெரிபிகேஷன் க்கு உகந்ததாகவும். எவிஎம் எளியவிதிகளைப் பின்பற்றுவதால், எவிஎம் இயக்கத்தில் கணித சொந்தப் சொல்ல்களை பரிசீலனை செய்ய எளிதாகும். + +### வேகமான மேம்பாட்டுச் சுழற்சி {#faster-development-cycle} + +பார்மல் வெரிபிகேஷன் முறைகள், மாடல் சோதனை மற்றும் சின்ன மதிப்பு மாதிரிகள், ஸ்மார்ட் கான்ட்ராக்ட் குறியீட்டின் ஒப்பீட்டு பரிசீலனையை (சோதனை அல்லது ஆய்வில்) பொதுவாகவே திறமையானவையாக உள்ளன. ஏனெனில் ஃபார்மல் வெரிஃபிகேஷன் குறியீட்டு மதிப்புகளைச் சார்ந்து உறுதிமொழிகளைச் சோதிக்கிறது ("ஒரு பயனர் _n_ ஈதரை எடுக்க முயற்சித்தால் என்ன ஆகும்?") சோதனை அறிக்கைகள் ("ஒரு பயனர் 5 எத்தர் எடுக்க முயற்சிக்கிறாரா?" என்ற கேள்வியைப் போல) மாறுபடுகிறது. + +சின்ன மதிப்பு மாறிலிகள் பல வகையான கொன்றிக்கோல் மதிப்புகளை மூடுகிறன, எனவே பார்மல் வெரிபிகேஷன் முறைகள் குறுகிய நேரத்தில் மேலதிக குறியீட்டு வரம்புகளை உறுதியாக வழங்குவதாக வாக்குறுதி அளிக்கின்றன. சவால்களைச் சரியாக அணுகும்போது, பார்மல் வெரிபிகேஷன் மென்பொருள் உருவாக்கத்திற்கான அந்த வளர்ச்சி சுற்றை வேகமாகச் செய்யலாம். + +பார்மல் வெரிபிகேஷன் தரவை உருவாக்கும் செயல்முறையை மேம்படுத்துவதற்கும் கட்டுமான குறைபாடுகளைக் குறைப்பதற்கும் உதவுகிறது. குறைபாடுகளைச் சரிசெய்ய கான்ட்ராக்டுகளை (சாத்தியமான இடங்களில்) மேம்படுத்துவது குறியீட்டுப் அடிப்படையை மாற்றுவதற்கும் மேலும் உழைப்பைச் செலவிடுவதற்கும் தேவைப்படுகிறது. பார்மல் வெரிபிகேஷன் கான்ட்ராக்ட் உருவாக்கங்களில் பல பிழைகளைக் கண்டறிந்து, சோதிக்கையாளர்கள் மற்றும் ஆய்வாளர்கள் புறக்கணிக்கக்கூடிய குறைகள் சரிசெய்ய எதிர்ப்புத் தருகிறது. + +## ஃபார்மல் வெரிஃபிகேஷனின் குறைபாடுகள் {#drawbacks-of-formal-verification} + +### கையேடு உழைப்பின் செலவு {#cost-of-manual-labor} + +பார்மல் வெரிபிகேஷன், குறிப்பாக மனிதர் சரிபார்த்தலை வழிநடத்துவதன் மூலம் சரியானதாக்கல் சான்றுகளைப் பெறுவது, மிகுந்த கைமுறையியல் உழைப்பை தேவையாகக் கொண்டது. மேலும, பார்மல் ஸ்பெசிபிகேஷன் உருவாக்குவது ஒரு சிக்கலான செயலாகும், இது உயர்ந்த திறமையைப் போதிக்கின்றது. + +இந்த அம்சங்கள் (உழைப்பு மற்றும் திறமை) பார்மல் வெரிபிகேஷன் முறையைச் சாதாரணமாகச் சோதனை மற்றும் ஆய்வு போன்ற வழிமுறைகளுடன் ஒப்பிடும்போது, அதிகமாகத் தேவைப்படும் மற்றும் விலை உயர்ந்ததாக மாற்றுகின்றன. இருப்பினும், ஸ்மார்ட் கான்ட்ராக்ட் செயல்படுத்தல்களில் பிழைகளைச் சந்திக்கும் செலவைப் பொருட்படுத்திக் கொண்டால், முழுமையான வெரிபிகேஷன் ஆய்விற்கு செலவழிக்க முடியுமல்ல. + +### தவறான எதிர்மறைகள் {#false-negatives} + +பார்மல் வெரிபிகேஷன் என்பது ஸ்மார்ட் கான்ட்ராக்ட் இன் செயல்பாடு பார்மல் ஸ்பெசிபிகேஷன்க்கு பொருந்துகிறதா என்பதை மட்டுமே சோதிக்க முடியும். எனவே, ஸ்பெசிபிகேஷன் ஸ்மார்ட் கான்ட்ராக்ட் இன் எதிர்பார்க்கப்படும் செயல்பாடுகளைச் சரியாக விவரிக்கிறது என்பதை உறுதி செய்ய முக்கியமாக உள்ளது. + +ஸ்பெசிபிகேஷன்கள் சரியாக எழுதப்படவில்லை என்றால், சொந்த மிகவும் பிழைகள் (வலுக்கட்டாயமாகச் செயல்பாடுகளைக் குறிக்கும்) பார்மல் வெரிபிகேஷன் ஆய்வினால் கண்டறிய முடியாது. இந்த நிலைமைக்கு, ஒரு விக்கிபேட்டர் கான்ட்ராக்ட் பிழையற்றது என்று தவறாக நினைக்கக்கூடும். + +### செயல்திறன் சிக்கல்கள் {#performance-issues} + +பார்மல் வெரிபிகேஷன் பல செயல்திறன் பிரச்சினைகளைச் சந்திக்கிறது. உதாரணமாக, மோடல் சோதனை மற்றும் சிம்பாலிக்கல் சோதனை முன்னணியில் உள்ள நிலை மற்றும் பாதை விரிசல் பிரச்சினைகள், முறைகளைப் பாதிக்கக்கூடும். மேலும், பார்மல் வெரிபிகேஷன் கருவிகள் பொதுவாக எஸ். எம். டி (SMT) சொல்வர்களும் பிற கட்டுப்பாட்டு சொல்வர்களும் அடிப்படை அடிப்படையில் பயன்படுத்துகின்றன, மேலும் இந்தச் சொல்வர்கள் கணினி நிதானமான செயல்முறைகளை நம்புகின்றன. + +மேலும், ஒரு நிரல் ஒருபோதும் முடிவடையாமல் போகக்கூடும் என்பதால், நிரல் சரிபார்ப்பாளர்களால் ஒரு பண்பு (தர்க்கரீதியான சூத்திரமாக விவரிக்கப்பட்டது) திருப்திப்படுத்தப்பட முடியுமா இல்லையா என்பதை தீர்மானிக்க எப்போதும் சாத்தியமில்லை ("[முடிவெடுக்கும் சிக்கல்](https://en.wikipedia.org/wiki/Decision_problem)"). எனவே, சில பரிமாணங்களைக் கான்ட்ராக்ட் க்காக நிரூபிக்க முடியாது, கூடவே அது நன்றாக விவரிக்கப்படுமானால். + +## Ethereum ஸ்மார்ட் ஒப்பந்தங்களுக்கான ஃபார்மல் வெரிஃபிகேஷன் கருவிகள் {#formal-verification-tools} + +### ஃபார்மல் ஸ்பெசிஃபிகேஷன்களை உருவாக்குவதற்கான விவரக்குறிப்பு மொழிகள் {#specification-languages} + +**Act**: __Act சேமிப்பகப் புதுப்பிப்புகள், முன்/பின் நிபந்தனைகள் மற்றும் ஒப்பந்த மாறிலிகள் ஆகியவற்றின் விவரக்குறிப்பை அனுமதிக்கிறது. அதன் கருவித் தொகுப்பில் Coq, SMT தீர்ப்பான்கள் அல்லது hevm வழியாக பல பண்புகளை நிரூபிக்கக்கூடிய சான்று பேக்கெண்டுகளும் உள்ளன.__ + +- [GitHub](https://github.com/ethereum/act) +- [ஆவணங்கள்](https://github.com/argotorg/act) + +**Scribble** - __Scribble விவரக்குறிப்பு மொழியில் உள்ள குறியீட்டு சிறுகுறிப்புகளை, விவரக்குறிப்பைச் சரிபார்க்கும் உறுதியான உறுதிமொழிகளாக மாற்றுகிறது.__ + +- [ஆவணங்கள்](https://docs.scribble.codes/) + +**Dafny** - __Dafny என்பது ஒரு சரிபார்ப்புக்கு-தயாரான நிரலாக்க மொழியாகும், இது குறியீட்டின் சரியான தன்மையைப் பற்றி பகுத்தறியவும் நிரூபிக்கவும் உயர்-நிலை சிறுகுறிப்புகளை நம்பியுள்ளது.__ + +- [GitHub](https://github.com/dafny-lang/dafny) + +### சரியான தன்மையை சரிபார்ப்பதற்கான நிரல் சரிபார்ப்பாளர்கள் {#program-verifiers} + +**Certora Prover** - _Certora Prover என்பது ஸ்மார்ட் ஒப்பந்தங்களில் குறியீட்டின் சரியான தன்மையைச் சரிபார்ப்பதற்கான ஒரு தானியங்கி ஃபார்மல் வெரிஃபிகேஷன் கருவியாகும். விவரக்குறிப்புகள் CVL (Certora Verification Language) இல் எழுதப்பட்டுள்ளன, நிலையான பகுப்பாய்வு மற்றும் கட்டுப்பாடு-தீர்த்தல் ஆகியவற்றின் கலவையைப் பயன்படுத்தி பண்பு மீறல்கள் கண்டறியப்படுகின்றன._ + +- [இணையதளம்](https://www.certora.com/) +- [ஆவணங்கள்](https://docs.certora.com/en/latest/index.html) + +**Solidity SMTChecker** - __Solidity-யின் SMTChecker என்பது SMT (Satisfiability Modulo Theories) மற்றும் ஹார்ன் தீர்த்தல் ஆகியவற்றை அடிப்படையாகக் கொண்ட ஒரு உள்ளமைக்கப்பட்ட மாடல் சரிபார்ப்பான் ஆகும். இது ஒரு ஒப்பந்தத்தின் மூலக் குறியீடு தொகுக்கும் போது விவரக்குறிப்புகளுடன் பொருந்துகிறதா என்பதை உறுதிப்படுத்துகிறது மற்றும் பாதுகாப்புப் பண்புகளின் மீறல்களை நிலையான முறையில் சரிபார்க்கிறது.__ + +- [GitHub](https://github.com/ethereum/solidity) + +**solc-verify** - __solc-verify என்பது Solidity கம்பைலரின் நீட்டிக்கப்பட்ட பதிப்பாகும், இது சிறுகுறிப்புகள் மற்றும் மாடுலர் நிரல் சரிபார்ப்பைப் பயன்படுத்தி Solidity குறியீட்டில் தானியங்கு ஃபார்மல் வெரிஃபிகேஷனைச் செய்ய முடியும்.__ + +- [GitHub](https://github.com/SRI-CSL/solidity) + +**KEVM** - __KEVM என்பது K கட்டமைப்பில் எழுதப்பட்ட Ethereum Virtual Machine (EVM)-இன் ஒரு முறையான சொற்பொருளாகும். KEVM இயக்கக்கூடியது மற்றும் அடையக்கூடிய தர்க்கத்தைப் பயன்படுத்தி சில பண்பு-தொடர்பான உறுதிமொழிகளை நிரூபிக்க முடியும்.__ + +- [GitHub](https://github.com/runtimeverification/evm-semantics) +- [ஆவணங்கள்](https://jellopaper.org/) + +### தேற்றம் நிரூபணத்திற்கான தர்க்கரீதியான கட்டமைப்புகள் {#theorem-provers} + +**Isabelle** - _Isabelle/HOL என்பது ஒரு சான்று உதவியாளராகும், இது கணித சூத்திரங்களை ஒரு முறையான மொழியில் வெளிப்படுத்த அனுமதிக்கிறது மற்றும் அந்த சூத்திரங்களை நிரூபிக்க கருவிகளை வழங்குகிறது. முக்கிய பயன்பாடு கணிதச் சான்றுகளின் முறைப்படுத்தல் மற்றும் குறிப்பாக ஃபார்மல் வெரிஃபிகேஷன் ஆகும், இதில் கணினி வன்பொருள் அல்லது மென்பொருளின் சரியான தன்மையை நிரூபித்தல் மற்றும் கணினி மொழிகள் மற்றும் நெறிமுறைகளின் பண்புகளை நிரூபித்தல் ஆகியவை அடங்கும்._ + +- [GitHub](https://github.com/isabelle-prover) +- [ஆவணங்கள்](https://isabelle.in.tum.de/documentation.html) + +**Rocq** - _Rocq என்பது ஒரு ஊடாடும் தேற்றம் நிரூபியாகும், இது தேற்றங்களைப் பயன்படுத்தி நிரல்களை வரையறுக்கவும் மற்றும் சரியான தன்மையின் இயந்திரத்தால் சரிபார்க்கப்பட்ட சான்றுகளை ஊடாடும் வகையில் உருவாக்கவும் உங்களை அனுமதிக்கிறது._ + +- [GitHub](https://github.com/rocq-prover/rocq) +- [ஆவணங்கள்](https://rocq-prover.org/docs) + +### ஸ்மார்ட் ஒப்பந்தங்களில் பாதிப்புக்குள்ளாகும் வடிவங்களைக் கண்டறிவதற்கான குறியீட்டு செயலாக்க-அடிப்படையிலான கருவிகள் {#symbolic-execution-tools} + +**Manticore** - __குறியீட்டு செயலாக்கத்தை அடிப்படையாகக் கொண்ட EVM பைட் குறியீட்டைப் பகுப்பாய்வு செய்வதற்கான ஒரு கருவி_._ + +- [GitHub](https://github.com/trailofbits/manticore) +- [ஆவணங்கள்](https://github.com/trailofbits/manticore/wiki) + +**hevm** - __hevm என்பது EVM பைட் குறியீட்டிற்கான ஒரு குறியீட்டு செயலாக்க இயந்திரம் மற்றும் சமநிலை சரிபார்ப்பான் ஆகும்.__ + +- [GitHub](https://github.com/dapphub/dapptools/tree/master/src/hevm) + +**Mythril** - _Ethereum ஸ்மார்ட் ஒப்பந்தங்களில் உள்ள பாதிப்புகளைக் கண்டறிவதற்கான ஒரு குறியீட்டு செயலாக்கக் கருவி_ + +- [GitHub](https://github.com/ConsenSys/mythril-classic) +- [ஆவணங்கள்](https://mythril-classic.readthedocs.io/en/develop/) + +## மேலும் வாசிக்க {#further-reading} + +- [ஸ்மார்ட் ஒப்பந்தங்களின் ஃபார்மல் வெரிஃபிகேஷன் எவ்வாறு செயல்படுகிறது](https://runtimeverification.com/blog/how-formal-verification-of-smart-contracts-works/) +- [ஃபார்மல் வெரிஃபிகேஷன் எவ்வாறு குறைபாடற்ற ஸ்மார்ட் ஒப்பந்தங்களை உறுதிசெய்ய முடியும்](https://media.consensys.net/how-formal-verification-can-ensure-flawless-smart-contracts-cbda8ad99bd1) +- [Ethereum சூழல் அமைப்பில் உள்ள ஃபார்மல் வெரிஃபிகேஷன் திட்டங்களின் ஒரு மேலோட்டம்](https://github.com/leonardoalt/ethereum_formal_verification_overview) +- [Ethereum 2.0 டெபாசிட் ஸ்மார்ட் ஒப்பந்தத்தின் முழுமையான ஃபார்மல் வெரிஃபிகேஷன்](https://runtimeverification.com/blog/end-to-end-formal-verification-of-ethereum-2-0-deposit-smart-contract/) +- [உலகின் மிகவும் பிரபலமான ஸ்மார்ட் ஒப்பந்தத்தை முறையாக சரிபார்த்தல்](https://www.zellic.io/blog/formal-verification-weth) +- [SMTChecker மற்றும் ஃபார்மல் வெரிஃபிகேஷன்](https://docs.soliditylang.org/en/v0.8.15/smtchecker.html) diff --git a/public/content/translations/ta/developers/docs/smart-contracts/index.md b/public/content/translations/ta/developers/docs/smart-contracts/index.md new file mode 100644 index 00000000000..b71dafec7ac --- /dev/null +++ b/public/content/translations/ta/developers/docs/smart-contracts/index.md @@ -0,0 +1,112 @@ +--- +title: "ஸ்மார்ட் ஒப்பந்தங்கள் அறிமுகம்" +description: "ஸ்மார்ட் ஒப்பந்தங்களின் ஒரு கண்ணோட்டம், அவற்றின் தனித்துவமான குணாதிசயங்கள் மற்றும் வரம்புகளில் கவனம் செலுத்துகிறது." +lang: ta +--- + +## ஸ்மார்ட் ஒப்பந்தம் என்றால் என்ன? {#what-is-a-smart-contract} + +ஒரு "ஸ்மார்ட் ஒப்பந்தம்" என்பது எத்தேரியம் பிளாக்செயினில் இயங்கும் ஒரு நிரலாகும். இது எத்தேரியம் பிளாக்செயினில் ஒரு குறிப்பிட்ட முகவரியில் இருக்கும் குறியீடு (அதன் செயல்பாடுகள்) மற்றும் தரவு (அதன் நிலை) ஆகியவற்றின் தொகுப்பாகும். + +ஸ்மார்ட் ஒப்பந்தங்கள் ஒரு வகையான [எத்தேரியம் கணக்கு](/developers/docs/accounts/) ஆகும். அதாவது, அவற்றுக்கு ஒரு இருப்பு உள்ளது மற்றும் பரிவர்த்தனைகளின் இலக்காக இருக்க முடியும். இருப்பினும் அவை ஒரு பயனரால் கட்டுப்படுத்தப்படவில்லை, மாறாக அவை நெட்வொர்க்கில் பயன்படுத்தப்பட்டு, திட்டமிட்டபடி இயங்குகின்றன. பயனர் கணக்குகள் ஒரு ஸ்மார்ட் ஒப்பந்தத்தில் வரையறுக்கப்பட்ட ஒரு செயல்பாட்டைச் செயல்படுத்தும் பரிவர்த்தனைகளைச் சமர்ப்பிப்பதன் மூலம் அந்த ஸ்மார்ட் ஒப்பந்தத்துடன் தொடர்பு கொள்ளலாம். ஸ்மார்ட் ஒப்பந்தங்கள், ஒரு வழக்கமான ஒப்பந்தத்தைப் போலவே, விதிகளை வரையறுத்து, குறியீட்டின் வழியாக அவற்றை தானாகவே செயல்படுத்த முடியும். ஸ்மார்ட் ஒப்பந்தங்களை இயல்பாக நீக்க முடியாது, மேலும் அவற்றுடனான தொடர்புகள் மாற்ற முடியாதவை. + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +நீங்கள் இப்போதுதான் தொடங்குகிறீர்கள் அல்லது ஒரு குறைவான தொழில்நுட்ப அறிமுகத்தைத் தேடுகிறீர்கள் என்றால், எங்கள் [ஸ்மார்ட் ஒப்பந்தங்களுக்கான அறிமுகம்](/smart-contracts/) என்பதைப் பரிந்துரைக்கிறோம். + +ஸ்மார்ட் ஒப்பந்தங்களின் உலகில் நுழைவதற்கு முன், [கணக்குகள்](/developers/docs/accounts/), [பரிவர்த்தனைகள்](/developers/docs/transactions/) மற்றும் [எத்தேரியம் மெய்நிகர் இயந்திரம்](/developers/docs/evm/) ஆகியவற்றைப் பற்றிப் படித்திருப்பதை உறுதிப்படுத்திக் கொள்ளுங்கள். + +## ஒரு டிஜிட்டல் விற்பனை இயந்திரம் {#a-digital-vending-machine} + +[நிக் ஸாபோ](https://unenumerated.blogspot.com/) விவரித்தபடி, ஒரு ஸ்மார்ட் ஒப்பந்தத்திற்கான சிறந்த உருவகம் ஒரு விற்பனை இயந்திரம் ஆகும். சரியான உள்ளீடுகளுடன், ஒரு குறிப்பிட்ட வெளியீடு உத்தரவாதம் அளிக்கப்படுகிறது. + +ஒரு விற்பனை இயந்திரத்திலிருந்து சிற்றுண்டியைப் பெற: + +``` +பணம் + சிற்றுண்டித் தேர்வு = சிற்றுண்டி விநியோகிக்கப்பட்டது +``` + +இந்த தர்க்கம் விற்பனை இயந்திரத்தில் நிரல்படுத்தப்பட்டுள்ளது. + +ஒரு ஸ்மார்ட் ஒப்பந்தம், ஒரு விற்பனை இயந்திரத்தைப் போலவே, அதனுள் தர்க்கம் நிரல்படுத்தப்பட்டுள்ளது. சொலிடிட்டியில் எழுதப்பட்ட ஒரு ஸ்மார்ட் ஒப்பந்தமாக இருந்தால் இந்த விற்பனை இயந்திரம் எப்படி இருக்கும் என்பதற்கு இதோ ஒரு எளிய உதாரணம்: + +```solidity +pragma solidity 0.8.7; + +contract VendingMachine { + + // ஒப்பந்தத்தின் நிலை மாறிகளை அறிவிக்கவும் + address public owner; + mapping (address => uint) public cupcakeBalances; + + // 'VendingMachine' ஒப்பந்தம் பயன்படுத்தப்படும்போது: + // 1. ஒப்பந்தத்தின் உரிமையாளராகப் பயன்படுத்தும் முகவரியை அமைக்கவும் + // 2. பயன்படுத்தப்பட்ட ஸ்மார்ட் ஒப்பந்தத்தின் கப் கேக் இருப்பை 100 ஆக அமைக்கவும் + constructor() { + owner = msg.sender; + cupcakeBalances[address(this)] = 100; + } + + // ஸ்மார்ட் ஒப்பந்தத்தின் கப் கேக் இருப்பை அதிகரிக்க உரிமையாளரை அனுமதிக்கவும் + function refill(uint amount) public { + require(msg.sender == owner, "உரிமையாளர் மட்டுமே மீண்டும் நிரப்ப முடியும்."); + cupcakeBalances[address(this)] += amount; + } + + // கப் கேக்குகளை வாங்க யாரையும் அனுமதிக்கவும் + function purchase(uint amount) public payable { + require(msg.value >= amount * 1 ether, "ஒரு கப் கேக்கிற்கு குறைந்தது 1 ETH செலுத்த வேண்டும்"); + require(cupcakeBalances[address(this)] >= amount, "இந்தப் பரிவர்த்தனையை முடிக்க கையிருப்பில் போதுமான கப் கேக்குகள் இல்லை"); + cupcakeBalances[address(this)] -= amount; + cupcakeBalances[msg.sender] += amount; + } +} +``` + +ஒரு விற்பனை இயந்திரம் விற்பனையாளர் ஊழியரின் தேவையை நீக்குவது போல, ஸ்மார்ட் ஒப்பந்தங்கள் பல தொழில்களில் உள்ள இடைத்தரகர்களை மாற்றியமைக்க முடியும். + +## அனுமதியற்றது {#permissionless} + +யார் வேண்டுமானாலும் ஒரு ஸ்மார்ட் ஒப்பந்தத்தை எழுதி அதை நெட்வொர்க்கில் பயன்படுத்தலாம். நீங்கள் ஒரு [ஸ்மார்ட் ஒப்பந்த மொழியில்](/developers/docs/smart-contracts/languages/) குறியீடு எழுதக் கற்றுக்கொண்டு, உங்கள் ஒப்பந்தத்தைப் பயன்படுத்த போதுமான ETH வைத்திருந்தால் போதும். ஒரு ஸ்மார்ட் ஒப்பந்தத்தைப் பயன்படுத்துவது தொழில்நுட்ப ரீதியாக ஒரு பரிவர்த்தனை ஆகும், எனவே ஒரு எளிய ETH பரிமாற்றத்திற்கு எரிவாயு செலுத்துவது போலவே இதற்கும் [எரிவாயு](/developers/docs/gas/) செலுத்த வேண்டும். இருப்பினும், ஒப்பந்தப் பயன்பாட்டிற்கான எரிவாயு செலவுகள் மிக அதிகமாகும். + +எத்தேரியம், ஸ்மார்ட் ஒப்பந்தங்களை எழுதுவதற்கு டெவலப்பர்-நட்பு மொழிகளைக் கொண்டுள்ளது: + +- Solidity +- Vyper + +[மொழிகளைப் பற்றி மேலும்](/developers/docs/smart-contracts/languages/) + +இருப்பினும், அவை பயன்படுத்தப்படுவதற்கு முன்பு தொகுக்கப்பட வேண்டும், அப்போதுதான் எத்தேரியத்தின் மெய்நிகர் இயந்திரம் ஒப்பந்தத்தை விளக்கி சேமிக்க முடியும். [தொகுத்தல் பற்றி மேலும்](/developers/docs/smart-contracts/compiling/) + +## தொகுப்புத்திறன் {#composability} + +ஸ்மார்ட் ஒப்பந்தங்கள் எத்தேரியத்தில் பொதுவானவை மற்றும் திறந்த API-களாகக் கருதப்படலாம். அதாவது, சாத்தியமானதை பெரிதும் விரிவுபடுத்த உங்கள் சொந்த ஸ்மார்ட் ஒப்பந்தத்தில் மற்ற ஸ்மார்ட் ஒப்பந்தங்களை நீங்கள் அழைக்கலாம். ஒப்பந்தங்களால் மற்ற ஒப்பந்தங்களையும் பயன்படுத்த முடியும். + +[ஸ்மார்ட் ஒப்பந்தத் தொகுப்புத்திறன்](/developers/docs/smart-contracts/composability/) பற்றி மேலும் அறிக. + +## வரம்புகள் {#limitations} + +ஸ்மார்ட் ஒப்பந்தங்கள் தனியாக "நிஜ-உலக" நிகழ்வுகள் பற்றிய தகவல்களைப் பெற முடியாது, ஏனெனில் அவைகளால் ஆஃப்செயின் மூலங்களிலிருந்து தரவைப் பெற முடியாது. அதாவது நிஜ உலகில் நடக்கும் நிகழ்வுகளுக்கு அவைகளால் பதிலளிக்க முடியாது. இது வடிவமைப்பின்படியானது. வெளிப்புறத் தகவல்களைச் சார்ந்திருப்பது ஒருமித்த கருத்தை அபாயத்திற்குள்ளாக்கலாம், இது பாதுகாப்பு மற்றும் பரவலாக்கத்திற்கு முக்கியமானது. + +இருப்பினும், பிளாக்செயின் பயன்பாடுகள் ஆஃப்செயின் தரவைப் பயன்படுத்த முடிவது முக்கியம். இதற்கான தீர்வு [ஆரக்கிள்கள்](/developers/docs/oracles/) ஆகும், அவை ஆஃப்செயின் தரவை உட்கொண்டு அதை ஸ்மார்ட் ஒப்பந்தங்களுக்குக் கிடைக்கச் செய்யும் கருவிகளாகும். + +ஸ்மார்ட் ஒப்பந்தங்களின் மற்றொரு வரம்பு அதிகபட்ச ஒப்பந்த அளவு ஆகும். ஒரு ஸ்மார்ட் ஒப்பந்தம் அதிகபட்சமாக 24KB இருக்கலாம் அல்லது அது எரிவாயு தீர்ந்துவிடும். [வைர வடிவத்தைப்](https://eips.ethereum.org/EIPS/eip-2535) பயன்படுத்துவதன் மூலம் இதைத் தவிர்க்கலாம். + +## மல்டிசிக் ஒப்பந்தங்கள் {#multisig} + +மல்டிசிக் (பல-கையொப்பம்) ஒப்பந்தங்கள் என்பவை ஒரு பரிவர்த்தனையைச் செயல்படுத்த பல செல்லுபடியாகும் கையொப்பங்கள் தேவைப்படும் ஸ்மார்ட் ஒப்பந்தக் கணக்குகள் ஆகும். கணிசமான அளவு ஈதர் அல்லது பிற டோக்கன்களை வைத்திருக்கும் ஒப்பந்தங்களுக்கு ஒற்றைத் தோல்விப் புள்ளிகளைத் தவிர்ப்பதற்கு இது மிகவும் பயனுள்ளதாக இருக்கும். மல்டிசிக்குகள் ஒப்பந்தச் செயலாக்கம் மற்றும் திறவுகோல் நிர்வாகத்திற்கான பொறுப்பை பல தரப்பினரிடையே பிரிக்கின்றன மற்றும் ஒரு தனிப்பட்ட திறவுகோலை இழப்பதால் நிதியை மாற்றமுடியாமல் இழப்பதைத் தடுக்கின்றன. இந்தக் காரணங்களுக்காக, மல்டிசிக் ஒப்பந்தங்களை எளிய DAO நிர்வாகத்திற்காகப் பயன்படுத்தலாம். செயல்படுத்துவதற்கு மல்டிசிக்குகளுக்கு M சாத்தியமான ஏற்றுக்கொள்ளக்கூடிய கையொப்பங்களிலிருந்து N கையொப்பங்கள் தேவை (இங்கு N ≤ M, மற்றும் M > 1). `N = 3, M = 5` மற்றும் `N = 4, M = 7` ஆகியவை பொதுவாகப் பயன்படுத்தப்படுகின்றன. ஒரு 4/7 மல்டிசிக்கிற்கு ஏழு சாத்தியமான செல்லுபடியாகும் கையொப்பங்களில் நான்கு தேவை. மூன்று கையொப்பங்கள் தொலைந்து போனாலும் நிதியை மீட்டெடுக்க முடியும் என்பதே இதன் பொருள். இந்த விஷயத்தில், ஒப்பந்தம் செயல்படுத்தப்படுவதற்கு பெரும்பான்மையான திறவுகோல் வைத்திருப்பவர்கள் ஒப்புக்கொண்டு கையெழுத்திட வேண்டும் என்றும் இது பொருள்படும். + +## ஸ்மார்ட் ஒப்பந்த வளங்கள் {#smart-contract-resources} + +**OpenZeppelin ஒப்பந்தங்கள் -** **_பாதுகாப்பான ஸ்மார்ட் ஒப்பந்த மேம்பாட்டிற்கான நூலகம்._** + +- [openzeppelin.com/contracts/](https://openzeppelin.com/contracts/) +- [GitHub](https://github.com/OpenZeppelin/openzeppelin-contracts) +- [சமூக மன்றம்](https://forum.openzeppelin.com/c/general/16) + +## மேலும் வாசிக்க {#further-reading} + +- [Coinbase: ஸ்மார்ட் ஒப்பந்தம் என்றால் என்ன?](https://www.coinbase.com/learn/crypto-basics/what-is-a-smart-contract) +- [Chainlink: ஸ்மார்ட் ஒப்பந்தம் என்றால் என்ன?](https://chain.link/education/smart-contracts) +- [வீடியோ: எளிமையாக விளக்கப்பட்டது - ஸ்மார்ட் ஒப்பந்தங்கள்](https://youtu.be/ZE2HxTmxfrI) +- [Cyfrin Updraft: Web3 கற்றல் மற்றும் தணிக்கை தளம்](https://updraft.cyfrin.io) diff --git a/public/content/translations/ta/developers/docs/smart-contracts/languages/index.md b/public/content/translations/ta/developers/docs/smart-contracts/languages/index.md new file mode 100644 index 00000000000..1a916361f89 --- /dev/null +++ b/public/content/translations/ta/developers/docs/smart-contracts/languages/index.md @@ -0,0 +1,340 @@ +--- +title: "ஸ்மார்ட் ஒப்பந்த மொழிகள்" +description: "இரண்டு முக்கிய ஸ்மார்ட் ஒப்பந்த மொழிகளான – Solidity மற்றும் Vyper ஆகியவற்றின் மேலோட்டம் மற்றும் ஒப்பீடு." +lang: ta +--- + +Ethereum பற்றிய ஒரு சிறந்த அம்சம் என்னவென்றால், ஸ்மார்ட் ஒப்பந்தங்களை ஒப்பீட்டளவில் உருவாக்குநர்களுக்கு-நட்பான மொழிகளைப் பயன்படுத்தி நிரல்படுத்தலாம். நீங்கள் Python அல்லது ஏதேனும் [நெளி-அடைப்புக்குறி மொழியில்](https://wikipedia.org/wiki/List_of_programming_languages_by_type#Curly-bracket_languages) அனுபவம் வாய்ந்தவராக இருந்தால், பழக்கமான தொடரியல் கொண்ட மொழியைக் காணலாம். + +மிகவும் செயலில் உள்ள மற்றும் பராமரிக்கப்படும் இரண்டு மொழிகள்: + +- Solidity +- Vyper + +Remix IDE ஆனது Solidity மற்றும் Vyper இரண்டிலும் ஒப்பந்தங்களை உருவாக்குவதற்கும் சோதிப்பதற்கும் ஒரு விரிவான மேம்பாட்டு சூழலை வழங்குகிறது. குறியீட்டு முறையைத் தொடங்க [உலாவியில் உள்ள Remix IDEஐ முயற்சிக்கவும்](https://remix.ethereum.org). + +அதிக அனுபவம் வாய்ந்த உருவாக்குநர்கள் (டெவலப்பர்கள்) [Ethereum மெய்நிகர் இயந்திரத்திற்கான](/developers/docs/evm/) இடைநிலை மொழியான Yul அல்லது Yul-இன் நீட்டிப்பான Yul+ ஐப் பயன்படுத்த விரும்பலாம். + +நீங்கள் ஆர்வமாக இருந்து, இன்னும் அதிக வளர்ச்சியில் இருக்கும் புதிய மொழிகளைச் சோதிக்க உதவ விரும்பினால், தற்போது ஆரம்ப நிலையில் உள்ள வளர்ந்து வரும் ஸ்மார்ட் ஒப்பந்த மொழியான Fe-ஐ நீங்கள் பரிசோதனை செய்யலாம். + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +நிரலாக்க மொழிகள், குறிப்பாக ஜாவாஸ்கிரிப்ட் அல்லது பைதான் பற்றிய முந்தைய அறிவு, ஸ்மார்ட் ஒப்பந்த மொழிகளில் உள்ள வேறுபாடுகளைப் புரிந்துகொள்ள உங்களுக்கு உதவும். மொழி ஒப்பீடுகளில் ஆழமாகச் செல்வதற்கு முன், ஸ்மார்ட் ஒப்பந்தங்களை ஒரு கருத்தாகப் புரிந்துகொள்ளுமாறு நாங்கள் பரிந்துரைக்கிறோம். [ஸ்மார்ட் ஒப்பந்தங்களுக்கான அறிமுகம்](/developers/docs/smart-contracts/). + +## Solidity {#solidity} + +- ஸ்மார்ட் ஒப்பந்தங்களை செயல்படுத்துவதற்கான பொருள் சார்ந்த, உயர் மட்ட மொழி. +- C++ ஆல் மிகவும் ஆழமாகப் பாதிக்கப்பட்ட நெளி-அடைப்புக்குறி மொழி. +- நிலையாகத் தட்டச்சு செய்யப்பட்டது (ஒரு மாறியின் வகை தொகுக்கும் நேரத்தில் அறியப்படுகிறது). +- ஆதரிக்கிறது: + - மரபுரிமை (நீங்கள் பிற ஒப்பந்தங்களை நீட்டிக்கலாம்). + - நூலகங்கள் (நீங்கள் வெவ்வேறு ஒப்பந்தங்களிலிருந்து அழைக்கக்கூடிய மீண்டும் பயன்படுத்தக்கூடிய குறியீட்டை உருவாக்கலாம் - மற்ற பொருள் சார்ந்த நிரலாக்க மொழிகளில் ஒரு நிலையான வகுப்பில் உள்ள நிலையான செயல்பாடுகளைப் போல). + - சிக்கலான பயனர் வரையறுத்த வகைகள். + +### முக்கிய இணைப்புகள் {#important-links} + +- [ஆவணங்கள்](https://docs.soliditylang.org/en/latest/) +- [Solidity மொழி நுழைவாயில்](https://soliditylang.org/) +- [எடுத்துக்காட்டு மூலம் Solidity](https://docs.soliditylang.org/en/latest/solidity-by-example.html) +- [GitHub](https://github.com/ethereum/solidity/) +- [Solidity Gitter அரட்டை அறை](https://gitter.im/ethereum/solidity) [Solidity Matrix அரட்டை அறைக்கு](https://matrix.to/#/#ethereum_solidity:gitter.im) இணைக்கப்பட்டுள்ளது +- [ஏமாற்றுத் தாள்](https://reference.auditless.com/cheatsheet) +- [Solidity வலைப்பதிவு](https://blog.soliditylang.org/) +- [Solidity Twitter](https://twitter.com/solidity_lang) + +### எடுத்துக்காட்டு ஒப்பந்தம் {#example-contract} + +```solidity +// SPDX-உரிமம்-அடையாளங்காட்டி: GPL-3.0 +pragma solidity >= 0.7.0; + +contract Coin { + // "public" என்ற முக்கியச் சொல் மாறிகளை + // மற்ற ஒப்பந்தங்களிலிருந்து அணுகக்கூடியதாக ஆக்குகிறது + address public minter; + mapping (address => uint) public balances; + + // நீங்கள் அறிவிக்கும் குறிப்பிட்ட ஒப்பந்த மாற்றங்களுக்குப் + // பயனளிக்க நிகழ்வுகள் வாடிக்கையாளர்களை அனுமதிக்கின்றன + event Sent(address from, address to, uint amount); + + // ஒப்பந்தம் உருவாக்கப்படும் போது மட்டுமே + // கட்டமைப்புக் குறியீடு இயக்கப்படும் + constructor() { + minter = msg.sender; + } + + // புதிதாக உருவாக்கப்பட்ட நாணயங்களின் ஒரு தொகையை ஒரு முகவரிக்கு அனுப்புகிறது + // ஒப்பந்தத்தை உருவாக்கியவரால் மட்டுமே அழைக்க முடியும் + function mint(address receiver, uint amount) public { + require(msg.sender == minter); + require(amount < 1e60); + balances[receiver] += amount; + } + + // ஏற்கனவே உள்ள நாணயங்களின் தொகையை + // எந்த அழைப்பாளரிடமிருந்தும் ஒரு முகவரிக்கு அனுப்புகிறது + function send(address receiver, uint amount) public { + require(amount <= balances[msg.sender], "போதுமான இருப்பு இல்லை."); + balances[msg.sender] -= amount; + balances[receiver] += amount; + emit Sent(msg.sender, receiver, amount); + } +} +``` + +இந்த எடுத்துக்காட்டு Solidity ஒப்பந்த தொடரியல் எப்படி இருக்கும் என்பதைப் பற்றிய ஒரு உணர்வைத் தரும். செயல்பாடுகள் மற்றும் மாறிகள் பற்றிய விரிவான விளக்கத்திற்கு, [ஆவணங்களைப் பார்க்கவும்](https://docs.soliditylang.org/en/latest/contracts.html). + +## Vyper {#vyper} + +- Pythonic நிரலாக்க மொழி +- அலகுகளுக்கான ஆதரவு உட்பட (எ. கா. நேர முத்திரை, வினாடிகள், wei, வினாடிக்கு wei, வினாடிக்கு சதுர மீட்டர்) +- சிறிய மற்றும் புரிந்துகொள்ளக்கூடிய தொகுப்பிக் குறியீடு +- திறமையான பைட் குறியீடு உருவாக்கம் +- ஒப்பந்தங்களை மிகவும் பாதுகாப்பானதாகவும், தணிக்கை செய்வதை எளிதாகவும் மாற்றும் நோக்கத்துடன் Solidity-ஐ விட வேண்டுமென்றே குறைவான அம்சங்களைக் கொண்டுள்ளது. Vyper ஆதரிக்காது: + - மாற்றமைப்பான்கள் + - மரபுரிமை + - இன்லைன் அசெம்பிளி + - செயல்பாட்டை ஓவர்லோடிங் செய்தல் + - ஆபரேட்டர் ஓவர்லோடிங் + - சுழல்நிலை அழைப்பு + - முடிவற்ற நீள சுழற்சிகள் + - பைனரி நிலையான புள்ளிகள் + +மேலும் தகவலுக்கு, [Vyper காரணத்தைப் படிக்கவும்](https://vyper.readthedocs.io/en/latest/index.html). + +### முக்கிய இணைப்புகள் {#important-links-1} + +- [ஆவணங்கள்](https://vyper.readthedocs.io) +- [எடுத்துக்காட்டு மூலம் Vyper](https://vyper.readthedocs.io/en/latest/vyper-by-example.html) +- [எடுத்துக்காட்டு மூலம் மேலும் Vyper](https://vyper-by-example.org/) +- [GitHub](https://github.com/vyperlang/vyper) +- [Vyper சமூக Discord அரட்டை](https://discord.gg/SdvKC79cJk) +- [ஏமாற்றுத் தாள்](https://reference.auditless.com/cheatsheet) +- [Vyper க்கான ஸ்மார்ட் ஒப்பந்த மேம்பாட்டு கட்டமைப்புகள் மற்றும் கருவிகள்](/developers/docs/programming-languages/python/) +- [VyperPunk - Vyper ஸ்மார்ட் ஒப்பந்தங்களைப் பாதுகாக்கவும் ஹேக் செய்யவும் கற்றுக்கொள்ளுங்கள்](https://github.com/SupremacyTeam/VyperPunk) +- [மேம்பாட்டிற்கான Vyper Hub](https://github.com/zcor/vyper-dev) +- [Vyper சிறந்த ஹிட்ஸ் ஸ்மார்ட் ஒப்பந்த எடுத்துக்காட்டுகள்](https://github.com/pynchmeister/vyper-greatest-hits/tree/main/contracts) +- [அற்புதமான Vyper தொகுக்கப்பட்ட வளங்கள்](https://github.com/spadebuilders/awesome-vyper) + +### எடுத்துக்காட்டு {#example} + +```python +# திறந்த ஏலம் + +# ஏல அளவுருக்கள் + +# பயனாளி அதிக ஏலம் எடுத்தவரிடமிருந்து பணத்தைப் பெறுகிறார் + +beneficiary: public(address) +auctionStart: public(uint256) +auctionEnd: public(uint256) + +# ஏலத்தின் தற்போதைய நிலை + +highestBidder: public(address) +highestBid: public(uint256) + +# முடிவில் உண்மை என அமைக்கப்பட்டது, எந்த மாற்றத்தையும் அனுமதிக்காது + +ended: public(bool) + +# திரும்பப் பெறும் முறையைப் பின்பற்ற, திருப்பிச் செலுத்தப்பட்ட ஏலங்களைக் கண்காணிக்கவும் + +pendingReturns: public(HashMap[address, uint256]) + +# `_bidding_time` விநாடிகள் ஏல நேரத்துடன் # பயனாளி முகவரி `_beneficiary` சார்பாக + +# ஒரு எளிய ஏலத்தை உருவாக்கவும். + +@external +def __init__(_beneficiary: address, _bidding_time: uint256): + self.beneficiary = _beneficiary + self.auctionStart = block.timestamp + self.auctionEnd = self.auctionStart + _bidding_time + +# இந்த பரிவர்த்தனையுடன் அனுப்பப்பட்ட மதிப்புடன் + +# ஏலத்தில் ஏலம் எடுக்கவும். + +# ஏலத்தில் வெற்றி பெறாவிட்டால் மட்டுமே + +# மதிப்பு திருப்பித் தரப்படும். + +@external +@payable +def bid(): + # ஏலக் காலம் முடிந்துவிட்டதா எனச் சரிபார்க்கவும். + assert block.timestamp < self.auctionEnd + # ஏலம் போதுமான அளவு அதிகமாக உள்ளதா எனச் சரிபார்க்கவும் + assert msg.value > self.highestBid + # முந்தைய அதிக ஏலதாரருக்கான பணத்தைத் திரும்பப் பெறுவதைக் கண்காணிக்கவும் + self.pendingReturns[self.highestBidder] += self.highestBid + # புதிய அதிக ஏலத்தைக் கண்காணிக்கவும் + self.highestBidder = msg.sender + self.highestBid = msg.value + +# முன்னர் திருப்பிச் செலுத்தப்பட்ட ஏலத்தை திரும்பப் பெறவும். திரும்பப் பெறும் முறை + +# பாதுகாப்புச் சிக்கலைத் தவிர்ப்பதற்காக இங்கு பயன்படுத்தப்படுகிறது. பணத்தைத் திரும்பப்பெறுதல் நேரடியாக + +# bid()-இன் ஒரு பகுதியாக அனுப்பப்பட்டால், ஒரு தீங்கிழைக்கும் ஏல ஒப்பந்தம் அந்தப் + +# பணத்தைத் திரும்பப் பெறுவதைத் தடுக்கலாம், இதனால் புதிய அதிக ஏலங்கள் வருவதைத் தடுக்கலாம். + +@external +def withdraw(): + pending_amount: uint256 = self.pendingReturns[msg.sender] + self.pendingReturns[msg.sender] = 0 + send(msg.sender, pending_amount) + +# ஏலத்தை முடித்து, அதிக ஏலத்தை + +# பயனாளிக்கு அனுப்பவும். + +@external +def endAuction(): + # மற்ற ஒப்பந்தங்களுடன் தொடர்பு கொள்ளும் செயல்பாடுகளை கட்டமைப்பது ஒரு நல்ல வழிகாட்டியாகும் + # (அதாவது, அவை செயல்பாடுகளை அழைக்கின்றன அல்லது ஈதரை அனுப்புகின்றன) + # மூன்று கட்டங்களாக: + # 1. நிபந்தனைகளைச் சரிபார்த்தல் + # 2. செயல்களைச் செய்தல் (சாத்தியமான மாற்றும் நிபந்தனைகள்) + # 3. மற்ற ஒப்பந்தங்களுடன் தொடர்புகொள்வது + # இந்த கட்டங்கள் கலந்திருந்தால், மற்ற ஒப்பந்தம் + # தற்போதைய ஒப்பந்தத்திற்கு மீண்டும் அழைத்து நிலையை மாற்றலாம் அல்லது விளைவுகளை ஏற்படுத்தலாம் + # (ஈதர் செலுத்துதல்) பலமுறை செய்யப்பட வேண்டும். + # உள்நாட்டில் அழைக்கப்படும் செயல்பாடுகளில் வெளிப்புற ஒப்பந்தங்களுடனான தொடர்பு அடங்கும் என்றால், + # அவையும் வெளிப்புற ஒப்பந்தங்களுடனான தொடர்பு என்று + # கருதப்பட வேண்டும். + + # 1. நிபந்தனைகள் + # ஏலத்தின் இறுதி நேரம் வந்துவிட்டதா எனச் சரிபார்க்கவும் + assert block.timestamp >= self.auctionEnd + # இந்தச் செயல்பாடு ஏற்கனவே அழைக்கப்பட்டுள்ளதா எனச் சரிபார்க்கவும் + assert not self.ended + + # 2. விளைவுகள் + self.ended = True + + # 3. தொடர்பு + send(self.beneficiary, self.highestBid) +``` + +இந்த எடுத்துக்காட்டு Vyper ஒப்பந்த தொடரியல் எப்படி இருக்கும் என்பதைப் பற்றிய ஒரு உணர்வைத் தரும். செயல்பாடுகள் மற்றும் மாறிகள் பற்றிய விரிவான விளக்கத்திற்கு, [ஆவணங்களைப் பார்க்கவும்](https://vyper.readthedocs.io/en/latest/vyper-by-example.html#simple-open-auction). + +## Yul மற்றும் Yul+ {#yul} + +நீங்கள் Ethereum-க்கு புதியவராகவும், இன்னும் ஸ்மார்ட் ஒப்பந்த மொழிகளுடன் எந்த குறியீட்டு முறையையும் செய்யவில்லை என்றால், Solidity அல்லது Vyper உடன் தொடங்க நாங்கள் பரிந்துரைக்கிறோம். ஸ்மார்ட் ஒப்பந்த பாதுகாப்பு சிறந்த நடைமுறைகள் மற்றும் EVM உடன் பணிபுரியும் பிரத்தியேகங்கள் உங்களுக்குப் பழக்கமானவுடன் மட்டுமே Yul அல்லது Yul+ ஐப் பார்க்கவும். + +**Yul** + +- Ethereum க்கான இடைநிலை மொழி. +- [EVM](/developers/docs/evm) மற்றும் [Ewasm](https://github.com/ewasm), ஒரு Ethereum சுவையூட்டப்பட்ட WebAssembly ஐ ஆதரிக்கிறது, மேலும் இரு தளங்களின் பயன்படுத்தக்கூடிய பொதுவான வகுப்பாக வடிவமைக்கப்பட்டுள்ளது. +- EVM மற்றும் Ewasm தளங்களுக்கு சமமாக பயனளிக்கக்கூடிய உயர் மட்ட தேர்வுமுறை நிலைகளுக்கான நல்ல இலக்கு. + +**Yul+** + +- Yul-க்கான குறைந்த-நிலை, அதிக செயல்திறன் கொண்ட நீட்டிப்பு. +- ஆரம்பத்தில் ஒரு [ஆப்டிமிஸ்டிக் ரோலப்](/developers/docs/scaling/optimistic-rollups/) ஒப்பந்தத்திற்காக வடிவமைக்கப்பட்டது. +- Yul+ ஆனது Yul க்கான ஒரு சோதனை மேம்படுத்தல் முன்மொழிவாகக் கருதப்படலாம், அதில் புதிய அம்சங்களைச் சேர்க்கிறது. + +### முக்கிய இணைப்புகள் {#important-links-2} + +- [Yul ஆவணங்கள்](https://docs.soliditylang.org/en/latest/yul.html) +- [Yul+ ஆவணங்கள்](https://github.com/fuellabs/yulp) +- [Yul+ அறிமுக இடுகை](https://medium.com/@fuellabs/introducing-yul-a-new-low-level-language-for-ethereum-aa64ce89512f) + +### எடுத்துக்காட்டு ஒப்பந்தம் {#example-contract-2} + +பின்வரும் எளிய எடுத்துக்காட்டு ஒரு சக்தி செயல்பாட்டை செயல்படுத்துகிறது. `solc --strict-assembly --bin input.yul` ஐப் பயன்படுத்தி இதைத் தொகுக்கலாம். எடுத்துக்காட்டு +input.yul கோப்பில் சேமிக்கப்பட வேண்டும். + +``` +{ + function power(base, exponent) -> result + { + switch exponent + case 0 { result := 1 } + case 1 { result := base } + default + { + result := power(mul(base, base), div(exponent, 2)) + if mod(exponent, 2) { result := mul(base, result) } + } + } + let res := power(calldataload(0), calldataload(32)) + mstore(0, res) + return(0, 32) +} +``` + +நீங்கள் ஏற்கனவே ஸ்மார்ட் ஒப்பந்தங்களில் நன்கு அனுபவம் பெற்றிருந்தால், Yul இல் ஒரு முழு ERC20 செயலாக்கத்தை [இங்கே](https://solidity.readthedocs.io/en/latest/yul.html#complete-erc20-example) காணலாம். + +## Fe {#fe} + +- Ethereum மெய்நிகர் இயந்திரத்திற்கான (EVM) நிலையாகத் தட்டச்சு செய்யப்பட்ட மொழி. +- Python மற்றும் Rust ஆல் ஈர்க்கப்பட்டது. +- Ethereum சூழலுக்குப் புதிய உருவாக்குநர்களுக்கு (டெவலப்பர்களுக்கு) கூட -- கற்றுக்கொள்வதை எளிதாக்குவதை நோக்கமாகக் கொண்டுள்ளது. +- Fe மேம்பாடு இன்னும் ஆரம்ப கட்டத்தில் உள்ளது, இந்த மொழி ஜனவரி 2021 இல் அதன் ஆல்பா வெளியீட்டைக் கொண்டிருந்தது. + +### முக்கிய இணைப்புகள் {#important-links-3} + +- [GitHub](https://github.com/ethereum/fe) +- [Fe அறிவிப்பு](https://snakecharmers.ethereum.org/fe-a-new-language-for-the-ethereum-ecosystem/) +- [Fe 2021 சாலை வரைபடம்](https://notes.ethereum.org/LVhaTF30SJOpkbG1iVw1jg) +- [Fe Discord அரட்டை](https://discord.com/invite/ywpkAXFjZH) +- [Fe Twitter](https://twitter.com/official_fe) + +### எடுத்துக்காட்டு ஒப்பந்தம் {#example-contract-3} + +பின்வருவது Fe இல் செயல்படுத்தப்பட்ட ஒரு எளிய ஒப்பந்தம். + +``` +type BookMsg = bytes[100] + +contract GuestBook: + pub guest_book: map + + event Signed: + book_msg: BookMsg + + pub def sign(book_msg: BookMsg): + self.guest_book[msg.sender] = book_msg + + emit Signed(book_msg=book_msg) + + pub def get_msg(addr: address) -> BookMsg: + return self.guest_book[addr].to_mem() +``` + +## எப்படித் தேர்ந்தெடுப்பது {#how-to-choose} + +மற்ற எந்த நிரலாக்க மொழியைப் போலவே, இது பெரும்பாலும் சரியான வேலைக்கு சரியான கருவியைத் தேர்ந்தெடுப்பது மற்றும் தனிப்பட்ட விருப்பத்தேர்வுகளைப் பற்றியது. + +நீங்கள் இன்னும் எந்த மொழியையும் முயற்சிக்கவில்லை என்றால், கருத்தில் கொள்ள வேண்டிய சில விஷயங்கள் இங்கே உள்ளன: + +### Solidity பற்றி என்ன சிறந்தது? {#solidity-advantages} + +- நீங்கள் ஒரு தொடக்கக்காரராக இருந்தால், பல பயிற்சிகள் மற்றும் கற்றல் கருவிகள் உள்ளன. [குறியீட்டு மூலம் கற்கவும்](/developers/learning-tools/) பிரிவில் அதைப் பற்றி மேலும் பார்க்கவும். +- நல்ல உருவாக்குநர் கருவி கிடைக்கிறது. +- Solidity ஒரு பெரிய உருவாக்குநர் சமூகத்தைக் கொண்டுள்ளது, அதாவது உங்கள் கேள்விகளுக்கான பதில்களை மிக விரைவாகக் கண்டுபிடிப்பீர்கள். + +### Vyper பற்றி என்ன சிறந்தது? {#vyper-advatages} + +- ஸ்மார்ட் ஒப்பந்தங்களை எழுத விரும்பும் Python டெவலப்பர்களுக்குத் தொடங்குவதற்கான சிறந்த வழி. +- Vyper குறைவான அம்சங்களைக் கொண்டுள்ளது, இது யோசனைகளை விரைவாக முன்மாதிரி செய்வதற்கு சிறந்ததாக அமைகிறது. +- Vyper தணிக்கை செய்வது எளிதாகவும், மனிதர்களால் அதிகபட்சமாகப் படிக்கக்கூடியதாகவும் இருப்பதை நோக்கமாகக் கொண்டுள்ளது. + +### Yul மற்றும் Yul+ பற்றி என்ன சிறந்தது? {#yul-advantages} + +- எளிமையான மற்றும் செயல்பாட்டு குறைந்த-நிலை மொழி. +- மூல EVM-க்கு மிக நெருக்கமாகச் செல்ல அனுமதிக்கிறது, இது உங்கள் ஒப்பந்தங்களின் எரிவாயு பயன்பாட்டை மேம்படுத்த உதவும். + +## மொழி ஒப்பீடுகள் {#language-comparisons} + +அடிப்படை தொடரியல், ஒப்பந்த வாழ்க்கைச் சுழற்சி, இடைமுகங்கள், ஆபரேட்டர்கள், தரவுக் கட்டமைப்புகள், செயல்பாடுகள், கட்டுப்பாட்டு ஓட்டம் மற்றும் பலவற்றின் ஒப்பீடுகளுக்கு ஆடிட்லெஸ்ஸின் இந்த [ஏமாற்றுத் தாளைப்](https://reference.auditless.com/cheatsheet/) பார்க்கவும் + +## மேலும் வாசிக்க {#further-reading} + +- [OpenZeppelin வழங்கும் Solidity ஒப்பந்தங்கள் நூலகம்](https://docs.openzeppelin.com/contracts/5.x/) +- [எடுத்துக்காட்டு மூலம் Solidity](https://solidity-by-example.org) diff --git a/public/content/translations/ta/developers/docs/smart-contracts/libraries/index.md b/public/content/translations/ta/developers/docs/smart-contracts/libraries/index.md new file mode 100644 index 00000000000..64b9b57f992 --- /dev/null +++ b/public/content/translations/ta/developers/docs/smart-contracts/libraries/index.md @@ -0,0 +1,117 @@ +--- +title: "ஸ்மார்ட் ஒப்பந்த நூலகங்கள்" +description: "உங்கள் எத்தேரியம் மேம்பாட்டுத் திட்டங்களை விரைவுபடுத்த, மீண்டும் பயன்படுத்தக்கூடிய ஸ்மார்ட் ஒப்பந்த நூலகங்களையும் கட்டமைப்புக் கூறுகளையும் கண்டறியுங்கள்." +lang: ta +--- + +உங்கள் திட்டத்தில் உள்ள ஒவ்வொரு ஸ்மார்ட் ஒப்பந்தத்தையும் நீங்கள் புதிதாக எழுதத் தேவையில்லை. பல திறந்த மூல ஸ்மார்ட் ஒப்பந்த நூலகங்கள் உள்ளன, அவை உங்கள் திட்டத்திற்கு மீண்டும் பயன்படுத்தக்கூடிய கட்டமைப்புக் கூறுகளை வழங்குகின்றன, இது நீங்கள் மீண்டும் புதிதாக அனைத்தையும் செய்வதிலிருந்து உங்களைக் காப்பாற்றும். + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +ஸ்மார்ட் ஒப்பந்த நூலகங்களுக்குள் செல்வதற்கு முன், ஸ்மார்ட் ஒப்பந்தத்தின் கட்டமைப்பைப் பற்றி நன்கு புரிந்துகொள்வது நல்லது. நீங்கள் இன்னும் அவ்வாறு செய்யவில்லை என்றால், [ஸ்மார்ட் ஒப்பந்த உடற்கூறியல்](/developers/docs/smart-contracts/anatomy/) பகுதிக்குச் செல்லவும். + +## ஒரு நூலகத்தில் என்ன இருக்கிறது {#whats-in-a-library} + +ஸ்மார்ட் ஒப்பந்த நூலகங்களில் நீங்கள் வழக்கமாக இரண்டு வகையான கட்டமைப்புக் கூறுகளைக் காணலாம்: உங்கள் ஒப்பந்தங்களில் நீங்கள் சேர்க்கக்கூடிய மீண்டும் பயன்படுத்தக்கூடிய செயல்பாடுகள் மற்றும் பல்வேறு தரநிலைகளின் செயலாக்கங்கள். + +### செயல்பாடுகள் {#behaviors} + +ஸ்மார்ட் ஒப்பந்தங்களை எழுதும்போது, ஒரு ஒப்பந்தத்தில் பாதுகாக்கப்பட்ட செயல்பாடுகளைச் செய்வதற்கு _நிர்வாகி_ முகவரியை ஒதுக்குவது அல்லது எதிர்பாராத சிக்கல் ஏற்பட்டால் அவசரகால _இடைநிறுத்த_ பொத்தானைச் சேர்ப்பது போன்ற ஒரே மாதிரியான வடிவங்களை நீங்கள் மீண்டும் மீண்டும் எழுதுவதற்கான நல்ல வாய்ப்பு உள்ளது. + +ஸ்மார்ட் ஒப்பந்த நூலகங்கள் பொதுவாக இந்தச் செயல்பாடுகளின் மறுபயன்பாட்டுக்குரிய செயலாக்கங்களை சொலிடிட்டியில் உள்ள [நூலகங்கள்](https://solidity.readthedocs.io/en/v0.7.2/contracts.html#libraries) அல்லது [மரபுரிமை](https://solidity.readthedocs.io/en/v0.7.2/contracts.html#inheritance) வழியாக வழங்குகின்றன. + +உதாரணமாக, [OpenZeppelin Contracts library](https://github.com/OpenZeppelin/openzeppelin-contracts) இலிருந்து [`Ownable` ஒப்பந்தத்தின்](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.2.0/contracts/access/Ownable.sol) எளிமைப்படுத்தப்பட்ட பதிப்பு கீழே கொடுக்கப்பட்டுள்ளது. இது ஒரு ஒப்பந்தத்தின் உரிமையாளராக ஒரு முகவரியை நியமிக்கிறது, மேலும் அந்த உரிமையாளருக்கு மட்டுமே ஒரு முறைக்கான அணுகலைக் கட்டுப்படுத்த ஒரு மாற்றியை வழங்குகிறது. + +```solidity +contract Ownable { + address public owner; + + constructor() internal { + owner = msg.sender; + } + + modifier onlyOwner() { + require(owner == msg.sender, "Ownable: அழைப்பவர் உரிமையாளர் அல்ல"); + _; + } +} +``` + +உங்கள் ஒப்பந்தத்தில் இது போன்ற ஒரு கட்டமைப்புக் கூறினைப் பயன்படுத்த, நீங்கள் முதலில் அதை இறக்குமதி செய்ய வேண்டும், பின்னர் உங்கள் சொந்த ஒப்பந்தங்களில் அதை நீட்டிக்க வேண்டும். அடிப்படை `Ownable` ஒப்பந்தத்தால் வழங்கப்படும் மாற்றியைப் பயன்படுத்தி உங்கள் சொந்த செயல்பாடுகளைப் பாதுகாக்க இது உங்களை அனுமதிக்கும். + +```solidity +import ".../Ownable.sol"; // இறக்குமதி செய்யப்பட்ட நூலகத்திற்கான பாதை + +contract MyContract is Ownable { + // பின்வரும் செயல்பாட்டை உரிமையாளர் மட்டுமே அழைக்க முடியும் + function secured() onlyOwner public { + msg.sender.transfer(1 ether); + } +} +``` + +மற்றொரு பிரபலமான உதாரணம் [SafeMath](https://docs.openzeppelin.com/contracts/3.x/utilities#math) அல்லது [DsMath](https://dappsys.readthedocs.io/en/latest/ds_math.html). இவை மொழியால் வழங்கப்படாத, வழிதல் சரிபார்ப்புகளுடன் கூடிய எண்கணிதச் செயல்பாடுகளை வழங்கும் நூலகங்கள் (அடிப்படை ஒப்பந்தங்களைப் போலல்லாமல்) ஆகும். பேரழிவு தரும் விளைவுகளை ஏற்படுத்தக்கூடிய வழிதல்களுக்கு எதிராக உங்கள் ஒப்பந்தத்தைப் பாதுகாக்க, இயல்பான எண்கணித செயல்பாடுகளுக்குப் பதிலாக இந்த நூலகங்களில் ஒன்றைப் பயன்படுத்துவது ஒரு நல்ல நடைமுறையாகும்! + +### தரநிலைகள் {#standards} + +[இணைதிறன் மற்றும் இயங்குதன்மை](/developers/docs/smart-contracts/composability/) ஆகியவற்றை எளிதாக்க, எத்தேரியம் சமூகம் **ERC** களின் வடிவத்தில் பல தரநிலைகளை வரையறுத்துள்ளது. [தரநிலைகள்](/developers/docs/standards/) பிரிவில் அவற்றைப் பற்றி மேலும் படிக்கலாம். + +உங்கள் ஒப்பந்தங்களின் ஒரு பகுதியாக ERC-ஐச் சேர்க்கும்போது, சொந்தமாக ஒன்றை உருவாக்க முயற்சிப்பதை விட, நிலையான செயலாக்கங்களைத் தேடுவது நல்லது. பல ஸ்மார்ட் ஒப்பந்த நூலகங்கள் மிகவும் பிரபலமான ERC-களுக்கான செயலாக்கங்களை உள்ளடக்கியுள்ளன. உதாரணமாக, எங்கும் காணப்படும் [ERC20 பரிமாற்றக்கூடிய டோக்கன் தரநிலையை](/developers/tutorials/understand-the-erc-20-token-smart-contract/) [HQ20](https://github.com/HQ20/contracts/blob/master/contracts/token/README.md), [DappSys](https://github.com/dapphub/ds-token/) மற்றும் [OpenZeppelin](https://docs.openzeppelin.com/contracts/3.x/erc20) ஆகியவற்றில் காணலாம். கூடுதலாக, சில ERC-கள் ERC-யின் ஒரு பகுதியாக நியமன செயலாக்கங்களையும் வழங்குகின்றன. + +சில ERC-கள் தனித்தியங்கும் அல்ல, ஆனால் மற்ற ERC-களுக்கான சேர்த்தல்களாகும் என்பது குறிப்பிடத்தக்கது. உதாரணமாக, [ERC2612](https://eips.ethereum.org/EIPS/eip-2612) அதன் பயன்பாட்டை மேம்படுத்துவதற்காக ERC20-க்கு ஒரு நீட்டிப்பைச் சேர்க்கிறது. + +## ஒரு நூலகத்தைச் சேர்ப்பது எப்படி {#how-to} + +உங்கள் திட்டத்தில் ஒரு நூலகத்தைச் சேர்ப்பது குறித்த குறிப்பிட்ட வழிமுறைகளுக்கு, நீங்கள் சேர்க்கும் நூலகத்தின் ஆவணங்களை எப்போதும் பார்க்கவும். பல சொலிடிட்டி ஒப்பந்த நூலகங்கள் `npm` ஐப் பயன்படுத்தி தொகுக்கப்பட்டுள்ளன, எனவே நீங்கள் அவற்றை `npm install` செய்யலாம். ஒப்பந்தங்களைத் [தொகுப்பதற்கான](/developers/docs/smart-contracts/compiling/) பெரும்பாலான கருவிகள், ஸ்மார்ட் ஒப்பந்த நூலகங்களுக்கு உங்கள் `node_modules` கோப்புறையைப் பார்க்கும், எனவே நீங்கள் பின்வருவனவற்றைச் செய்யலாம்: + +```solidity +// இது உங்கள் node_modules-லிருந்து @openzeppelin/contracts நூலகத்தை ஏற்றும் +import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; + +contract MyNFT is ERC721 { + constructor() ERC721("MyNFT", "MNFT") public { } +} +``` + +நீங்கள் எந்த முறையைப் பயன்படுத்தினாலும், ஒரு நூலகத்தைச் சேர்க்கும்போது, [மொழிப்](/developers/docs/smart-contracts/languages/) பதிப்பை எப்போதும் கவனத்தில் கொள்ளுங்கள். உதாரணமாக, உங்கள் ஒப்பந்தங்களை சொலிடிட்டி 0.5 இல் எழுதுகிறீர்கள் என்றால், சொலிடிட்டி 0.6 க்கான நூலகத்தைப் பயன்படுத்த முடியாது. + +## எப்போது பயன்படுத்த வேண்டும் {#when-to-use} + +உங்கள் திட்டத்திற்கு ஸ்மார்ட் ஒப்பந்த நூலகத்தைப் பயன்படுத்துவதால் பல நன்மைகள் உள்ளன. முதலாவதாக, நீங்களே குறியீடு எழுதுவதற்குப் பதிலாக, உங்கள் கணினியில் சேர்க்கக்கூடிய, பயன்படுத்தத் தயாராக உள்ள கட்டமைப்புக் கூறுகளை வழங்குவதன் மூலம் இது உங்கள் நேரத்தை மிச்சப்படுத்துகிறது. + +பாதுகாப்பும் ஒரு பெரிய நன்மையாகும். திறந்த மூல ஸ்மார்ட் ஒப்பந்த நூலகங்களும் பெரும்பாலும் தீவிரமாக ஆராயப்படுகின்றன. பல திட்டங்கள் அவற்றைச் சார்ந்து இருப்பதால், அவற்றை நிலையான மதிப்பாய்வின் கீழ் வைத்திருக்க சமூகத்தால் ஒரு வலுவான ஊக்கம் உள்ளது. மீண்டும் பயன்படுத்தக்கூடிய ஒப்பந்த நூலகங்களைக் காட்டிலும் பயன்பாட்டுக் குறியீட்டில் பிழைகளைக் கண்டறிவது மிகவும் பொதுவானது. சில நூலகங்கள் கூடுதல் பாதுகாப்பிற்காக [வெளிப்புற தணிக்கைகளுக்கும்](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/audits) உட்படுகின்றன. + +இருப்பினும், ஸ்மார்ட் ஒப்பந்த நூலகங்களைப் பயன்படுத்துவது, உங்களுக்குப் பரிச்சயமில்லாத குறியீட்டை உங்கள் திட்டத்தில் சேர்ப்பதற்கான அபாயத்தைக் கொண்டுள்ளது. ஒரு ஒப்பந்தத்தை இறக்குமதி செய்து அதை நேரடியாக உங்கள் திட்டத்தில் சேர்ப்பது எளிதாகத் தோன்றலாம், ஆனால் அந்த ஒப்பந்தம் என்ன செய்கிறது என்பதைப் பற்றிய நல்ல புரிதல் இல்லாமல், எதிர்பாராத நடத்தை காரணமாக உங்கள் கணினியில் நீங்கள் கவனக்குறைவாக ஒரு சிக்கலை அறிமுகப்படுத்தலாம். நீங்கள் இறக்குமதி செய்யும் குறியீட்டின் ஆவணங்களைப் படிக்க மறவாதீர்கள், பின்னர் அதை உங்கள் திட்டத்தின் ஒரு பகுதியாக மாற்றுவதற்கு முன்பு குறியீட்டையே மதிப்பாய்வு செய்யுங்கள்! + +கடைசியாக, ஒரு நூலகத்தைச் சேர்க்க வேண்டுமா என்று தீர்மானிக்கும்போது, அதன் ஒட்டுமொத்த பயன்பாட்டைக் கருத்தில் கொள்ளுங்கள். பரவலாக ஏற்றுக்கொள்ளப்பட்ட ஒன்று ஒரு பெரிய சமூகத்தைக் கொண்டிருப்பதன் நன்மைகளைக் கொண்டுள்ளது மற்றும் சிக்கல்களுக்காக அதை மேலும் பலர் ஆராய்வார்கள். ஸ்மார்ட் ஒப்பந்தங்களைக் கொண்டு உருவாக்கும்போது பாதுகாப்பு உங்கள் முதன்மைக் கவனமாக இருக்க வேண்டும்! + +## தொடர்புடைய கருவிகள் {#related-tools} + +**OpenZeppelin ஒப்பந்தங்கள் -** **_பாதுகாப்பான ஸ்மார்ட் ஒப்பந்த மேம்பாட்டிற்கான மிகவும் பிரபலமான நூலகம்._** + +- [ஆவணம்](https://docs.openzeppelin.com/contracts/) +- [GitHub](https://github.com/OpenZeppelin/openzeppelin-contracts) +- [சமூக மன்றம்](https://forum.openzeppelin.com/c/general/16) + +**DappSys -** **_ஸ்மார்ட்-ஒப்பந்தங்களுக்கான பாதுகாப்பான, எளிய, நெகிழ்வான கட்டமைப்புக் கூறுகள்._** + +- [ஆவணம்](https://dappsys.readthedocs.io/) +- [GitHub](https://github.com/dapphub/dappsys) + +**HQ20 -** **_நிஜ உலகிற்கான முழு அம்சங்களுடன் கூடிய பரவலாக்கப்பட்ட பயன்பாடுகளை உருவாக்க உங்களுக்கு உதவும் ஒப்பந்தங்கள், நூலகங்கள் மற்றும் எடுத்துக்காட்டுகளுடன் கூடிய ஒரு சொலிடிட்டி திட்டம்._** + +- [GitHub](https://github.com/HQ20/contracts) + +**thirdweb Solidity SDK -** **_தனிப்பயன் ஸ்மார்ட் ஒப்பந்தங்களைத் திறமையாக உருவாக்கத் தேவையான கருவிகளை வழங்குகிறது_** + +- [ஆவணம்](https://portal.thirdweb.com/contracts/build/overview) +- [GitHub](https://github.com/thirdweb-dev/contracts) + +## தொடர்புடைய பயிற்சிகள் {#related-tutorials} + +- [எத்தேரியம் உருவாக்குநர்களுக்கான பாதுகாப்புக் கருத்தில் கொள்ளவேண்டியவை](/developers/docs/smart-contracts/security/) _– நூலகப் பயன்பாடு உட்பட, ஸ்மார்ட் ஒப்பந்தங்களை உருவாக்கும்போது பாதுகாப்புக் கருத்தாய்வுகள் பற்றிய ஒரு பயிற்சி._ +- [ERC-20 டோக்கன் ஸ்மார்ட் ஒப்பந்தத்தைப் புரிந்து கொள்ளுங்கள்](/developers/tutorials/understand-the-erc-20-token-smart-contract/) _-பல நூலகங்களால் வழங்கப்படும் ERC20 தரநிலை குறித்த பயிற்சி._ + +## மேலும் வாசிக்க {#further-reading} + +_உங்களுக்கு உதவிய ஒரு சமூக வளம் பற்றி தெரியுமா?_ இந்தப் பக்கத்தைத் திருத்தி அதைச் சேர்க்கவும்!_ diff --git a/public/content/translations/ta/developers/docs/smart-contracts/naming/index.md b/public/content/translations/ta/developers/docs/smart-contracts/naming/index.md new file mode 100644 index 00000000000..18e6714dd3b --- /dev/null +++ b/public/content/translations/ta/developers/docs/smart-contracts/naming/index.md @@ -0,0 +1,101 @@ +--- +title: "ஸ்மார்ட் ஒப்பந்தங்களுக்குப் பெயரிடுதல்" +description: "ENS உடன் எத்தேரியம் ஸ்மார்ட் ஒப்பந்தங்களுக்கு பெயரிடுவதற்கான சிறந்த நடைமுறைகள்" +lang: ta +--- + +ஸ்மார்ட் ஒப்பந்தங்கள் எத்தேரியத்தின் பரவலாக்கப்பட்ட உள்கட்டமைப்பின் ஒரு மூலக்கல்லாகும், இது தன்னாட்சிப் பயன்பாடுகள் மற்றும் நெறிமுறைகளை செயல்படுத்துகிறது. ஆனால் ஒப்பந்தத் திறன்கள் உருவாகும்போது கூட, பயனர்களும் உருவாக்குநர்களும் இந்த ஒப்பந்தங்களைக் கண்டறிந்து குறிப்பிடுவதற்கு மூல ஹெக்ஸாடெசிமல் முகவரிகளை இன்னும் நம்பியுள்ளனர். + +[எத்தேரியம் பெயர் சேவை (ENS)](https://ens.domains/) உடன் ஸ்மார்ட் ஒப்பந்தங்களுக்குப் பெயரிடுவது ஹெக்ஸாடெசிமல் ஒப்பந்த முகவரிகளை நீக்குவதன் மூலம் பயனர் அனுபவத்தை மேம்படுத்துகிறது மற்றும் முகவரி விஷமூட்டல் மற்றும் ஏமாற்றுத் தாக்குதல்கள் போன்ற தாக்குதல்களிலிருந்து ஆபத்தைக் குறைக்கிறது. இந்த வழிகாட்டி ஸ்மார்ட் ஒப்பந்தங்களுக்குப் பெயரிடுவது ஏன் முக்கியம், அதை எவ்வாறு செயல்படுத்தலாம், மற்றும் செயல்முறையை எளிதாக்கவும், உருவாக்குநர்கள் இந்த நடைமுறையைப் பின்பற்ற உதவவும் [Enscribe](https://www.enscribe.xyz) போன்ற கருவிகள் கிடைப்பதையும் விளக்குகிறது. + +## ஏன் ஸ்மார்ட் ஒப்பந்தங்களுக்குப் பெயரிட வேண்டும்? {#why-name-contracts} + +### மனிதனால் படிக்கக்கூடிய அடையாளங்காட்டிகள் {#human-readable-identifiers} + +`0x8f8e...f9e3` போன்ற ஒளிபுகா ஒப்பந்த முகவரிகளுடன் தொடர்புகொள்வதற்குப் பதிலாக, உருவாக்குநர்களும் பயனர்களும் `v2.myapp.eth` போன்ற மனிதனால் படிக்கக்கூடிய பெயர்களைப் பயன்படுத்தலாம். இது ஸ்மார்ட் ஒப்பந்தத் தொடர்புகளை எளிதாக்குகிறது. + +எத்தேரியம் முகவரிகளுக்கு ஒரு பரவலாக்கப்பட்ட பெயரிடும் சேவையை வழங்கும் [எத்தேரியம் பெயர் சேவை](https://ens.domains/) மூலம் இது சாத்தியமாகிறது. `104.18.176.152` போன்ற ஒரு IP முகவரி வழியாக அணுகுவதற்குப் பதிலாக ethereum.org போன்ற ஒரு பெயரைப் பயன்படுத்தி இணையப் பயனர்கள் நெட்வொர்க் முகவரிகளை அணுகுவதற்கு டொமைன் பெயர் சேவை (DNS) எவ்வாறு உதவுகிறதோ, அதைப் போன்றது இது. + +### மேம்படுத்தப்பட்ட பாதுகாப்பு மற்றும் நம்பிக்கை {#improved-security-and-trust} + +பெயரிடப்பட்ட ஒப்பந்தங்கள் தவறான முகவரிக்கு தற்செயலான பரிவர்த்தனைகளைக் குறைக்க உதவுகின்றன. குறிப்பிட்ட பயன்பாடுகள் அல்லது பிராண்டுகளுடன் இணைக்கப்பட்ட ஒப்பந்தங்களை அடையாளம் காணவும் அவை பயனர்களுக்கு உதவுகின்றன. இது ஒரு அடுக்கு நற்பெயர் நம்பிக்கையைச் சேர்க்கிறது, குறிப்பாக `uniswap.eth` போன்ற நன்கு அறியப்பட்ட பெற்றோர் டொமைன்களுடன் பெயர்கள் இணைக்கப்படும்போது. + +எத்தேரியம் முகவரியின் 42-எழுத்து நீளம் காரணமாக, ஓரிரு எழுத்துகள் மாற்றப்பட்ட முகவரிகளில் சிறிய மாற்றங்களை பயனர்கள் அடையாளம் காண்பது மிகவும் கடினம். எடுத்துக்காட்டாக, `0x58068646C148E313CB414E85d2Fe89dDc3426870` போன்ற ஒரு முகவரி பொதுவாக பணப்பைகள் போன்ற பயனர் எதிர்கொள்ளும் பயன்பாடுகளால் `0x580...870` என சுருக்கப்படும். ஓரிரு எழுத்துகள் மாற்றப்பட்ட ஒரு தீங்கிழைக்கும் முகவரியை ஒரு பயனர் கவனிப்பது சாத்தியமில்லை. + +இந்த வகையான நுட்பம் முகவரி ஏமாற்றுதல் மற்றும் விஷமூட்டல் தாக்குதல்களால் பயன்படுத்தப்படுகிறது, இதில் பயனர்கள் சரியான முகவரியுடன் தொடர்புகொள்கிறார்கள் அல்லது நிதி அனுப்புகிறார்கள் என்று நம்ப வைக்கப்படுகிறார்கள், ஆனால் உண்மையில் அந்த முகவரி சரியான முகவரியைப் போலவே இருந்தாலும், அது ஒன்றல்ல. + +பணப்பைகள் மற்றும் ஒப்பந்தங்களுக்கான ENS பெயர்கள் இந்த வகையான தாக்குதல்களுக்கு எதிராகப் பாதுகாக்கின்றன. DNS ஏமாற்றுத் தாக்குதல்களைப் போலவே, ENS ஏமாற்றுத் தாக்குதல்களும் நடத்தப்படலாம், இருப்பினும், ஒரு பயனர் ஹெக்ஸாடெசிமல் முகவரியில் ஒரு சிறிய மாற்றத்தைக் கவனிப்பதை விட ENS பெயரில் ஒரு எழுத்துப்பிழையைக் கவனிப்பதற்கான வாய்ப்பு அதிகம். + +### பணப்பைகள் மற்றும் எக்ஸ்ப்ளோரர்களுக்கான சிறந்த UX {#better-ux} + +ஒரு ஸ்மார்ட் ஒப்பந்தம் ENS பெயருடன் கட்டமைக்கப்படும்போது, பணப்பைகள் மற்றும் பிளாக்செயின் எக்ஸ்ப்ளோரர்கள் போன்ற பயன்பாடுகள் ஹெக்ஸாடெசிமல் முகவரிகளுக்குப் பதிலாக ஸ்மார்ட் ஒப்பந்தங்களுக்கான ENS பெயர்களைக் காண்பிக்க முடியும். இது பயனர்களுக்கு ஒரு குறிப்பிடத்தக்க பயனர் அனுபவ (UX) மேம்பாட்டை வழங்குகிறது. + +எடுத்துக்காட்டாக, Uniswap போன்ற ஒரு பயன்பாட்டுடன் தொடர்பு கொள்ளும்போது, அவர்கள் தொடர்பு கொள்ளும் செயலி `uniswap.org` இணையதளத்தில் ஹோஸ்ட் செய்யப்பட்டுள்ளது என்பதை பயனர்கள் பொதுவாகக் காண்பார்கள், ஆனால் Uniswap தங்கள் ஸ்மார்ட் ஒப்பந்தங்களுக்கு ENS உடன் பெயரிடவில்லை என்றால், அவர்களுக்கு ஒரு ஹெக்ஸாடெசிமல் ஒப்பந்த முகவரி வழங்கப்படும். ஒப்பந்தத்திற்குப் பெயரிடப்பட்டிருந்தால், அதற்குப் பதிலாக அவர்கள் `v4.contracts.uniswap.eth` ஐக் காணலாம், இது மிகவும் பயனுள்ளது. + +## வரிசைப்படுத்தலின் போது பெயரிடுதல் மற்றும் வரிசைப்படுத்தலுக்குப் பிறகு பெயரிடுதல் {#when-to-name} + +ஸ்மார்ட் ஒப்பந்தங்களுக்குப் பெயரிடக்கூடிய இரண்டு தருணங்கள் உள்ளன: + +- **வரிசைப்படுத்தல் நேரத்தில்**: ஒப்பந்தம் வரிசைப்படுத்தப்படும்போது அதற்கு ஒரு ENS பெயரை ஒதுக்குதல். +- **வரிசைப்படுத்தலுக்குப் பிறகு**: ஏற்கனவே உள்ள ஒப்பந்த முகவரியை ஒரு புதிய ENS பெயருடன் மேப் செய்தல். + +ENS பதிவுகளை உருவாக்கவும் அமைக்கவும் முடியும் வகையில் இரண்டு அணுகுமுறைகளும் ஒரு ENS டொமைனின் உரிமையாளர் அல்லது மேலாளர் அணுகலைக் கொண்டிருப்பதை நம்பியுள்ளன. + +## ஒப்பந்தங்களுக்கு ENS பெயரிடல் எவ்வாறு செயல்படுகிறது {#how-ens-naming-works} + +ENS பெயர்கள் ஆன்செயினில் சேமிக்கப்பட்டு, ENS தீர்மானிகள் வழியாக எத்தேரியம் முகவரிகளுக்குத் தீர்க்கப்படுகின்றன. ஒரு ஸ்மார்ட் ஒப்பந்தத்திற்குப் பெயரிட: + +1. ஒரு பெற்றோர் ENS டொமைனைப் பதிவு செய்யவும் அல்லது கட்டுப்படுத்தவும் (எ.கா. `myapp.eth`) +2. ஒரு துணை டொமைனை உருவாக்கவும் (எ.கா. `v1.myapp.eth`) +3. துணை டொமைனின் `address` பதிவை ஒப்பந்த முகவரிக்கு அமைக்கவும் +4. அதன் முகவரி வழியாக பெயரைக் கண்டறிய அனுமதிக்கும் வகையில், ஒப்பந்தத்தின் தலைகீழ் பதிவை ENS க்கு அமைக்கவும் + +ENS பெயர்கள் படிநிலை மற்றும் வரம்பற்ற துணைப் பெயர்களை ஆதரிக்கின்றன. இந்தப் பதிவுகளை அமைப்பது பொதுவாக ENS பதிவேடு மற்றும் பொதுத் தீர்மானி ஒப்பந்தங்களுடன் தொடர்புகொள்வதை உள்ளடக்கியது. + +## ஒப்பந்தங்களுக்குப் பெயரிடுவதற்கான கருவிகள் {#tools} + +ஸ்மார்ட் ஒப்பந்தங்களுக்குப் பெயரிட இரண்டு அணுகுமுறைகள் உள்ளன. சில கைமுறைப் படிகளுடன் [ENS செயலி](https://app.ens.domains) ஐப் பயன்படுத்துதல் அல்லது [Enscribe](https://www.enscribe.xyz) ஐப் பயன்படுத்துதல். இவை கீழே கோடிட்டுக் காட்டப்பட்டுள்ளன. + +### கைமுறை ENS அமைப்பு {#manual-ens-setup} + +[ENS செயலி](https://app.ens.domains) ஐப் பயன்படுத்தி, உருவாக்குநர்கள் கைமுறையாக துணைப் பெயர்களை உருவாக்கி, முன்னோக்கு முகவரிப் பதிவுகளை அமைக்கலாம். இருப்பினும், ENS செயலி வழியாக பெயருக்கான தலைகீழ் பதிவை அமைப்பதன் மூலம் அவர்கள் ஒரு ஸ்மார்ட் ஒப்பந்தத்திற்கு முதன்மைப் பெயரை அமைக்க முடியாது. [ENS ஆவணங்களில்](https://docs.ens.domains/web/naming-contracts/) உள்ளடக்கப்பட்டுள்ள கைமுறைப் படிகள் எடுக்கப்பட வேண்டும். + +### Enscribe {#enscribe} + +[Enscribe](https://www.enscribe.xyz) ENS உடன் ஸ்மார்ட் ஒப்பந்தப் பெயரிடலை எளிதாக்குகிறது, மேலும் ஸ்மார்ட் ஒப்பந்தங்களில் பயனர் நம்பிக்கையை மேம்படுத்துகிறது. இது வழங்குகிறது: + +- **அணு வரிசைப்படுத்தல் மற்றும் பெயரிடுதல்**: ஒரு புதிய ஒப்பந்தத்தை வரிசைப்படுத்தும்போது ஒரு ENS பெயரை ஒதுக்குங்கள் +- **வரிசைப்படுத்தலுக்குப் பிந்தைய பெயரிடுதல்**: ஏற்கனவே வரிசைப்படுத்தப்பட்ட ஒப்பந்தங்களுக்கு பெயர்களை இணைக்கவும் +- **பல-செயின் ஆதரவு**: ENS ஆதரிக்கப்படும் எத்தேரியம் மற்றும் L2 நெட்வொர்க்குகளில் செயல்படுகிறது +- **ஒப்பந்த சரிபார்ப்புத் தரவு**: பயனர்களுக்கான நம்பிக்கையை அதிகரிக்க பல மூலங்களிலிருந்து இழுக்கப்பட்ட ஒப்பந்த சரிபார்ப்புத் தரவை உள்ளடக்கியது + +பயனரால் வழங்கப்பட்ட ENS பெயர்களை Enscribe ஆதரிக்கிறது, அல்லது பயனரிடம் ENS பெயர் இல்லையென்றால் அதன் சொந்த டொமைன்களை ஆதரிக்கிறது. + +ஸ்மார்ட் ஒப்பந்தங்களுக்குப் பெயரிட மற்றும் பார்க்கத் தொடங்க [Enscribe App](https://app.enscribe.xyz) ஐ நீங்கள் அணுகலாம். + +## சிறந்த நடைமுறைகள் {#best-practices} + +- **தெளிவான, பதிப்பிடப்பட்ட பெயர்களைப் பயன்படுத்தவும்** `v1.myapp.eth` போன்ற, ஒப்பந்த மேம்படுத்தல்களை வெளிப்படையானதாக மாற்ற +- **தலைகீழ் பதிவுகளை அமைக்கவும்** பணப்பைகள் மற்றும் பிளாக்செயின் எக்ஸ்ப்ளோரர்கள் போன்ற செயலிகளில் தெரிவுநிலைக்காக ஒப்பந்தங்களை ENS பெயர்களுடன் இணைக்க. +- **காலாவதிகளை நெருக்கமாகக் கண்காணிக்கவும்** உரிமையில் தற்செயலான மாற்றங்களைத் தடுக்க விரும்பினால் +- **ஒப்பந்த மூலத்தைச் சரிபார்க்கவும்** அதனால் பயனர்கள் பெயரிடப்பட்ட ஒப்பந்தம் எதிர்பார்த்தபடி செயல்படுகிறது என்று நம்பலாம் + +## Risks {#risks} + +ஸ்மார்ட் ஒப்பந்தங்களுக்குப் பெயரிடுவது எத்தேரியம் பயனர்களுக்கு குறிப்பிடத்தக்க நன்மைகளை வழங்குகிறது, இருப்பினும், ENS டொமைன்களின் உரிமையாளர்கள் அவற்றின் நிர்வாகத்தைப் பொறுத்தவரை விழிப்புடன் இருக்க வேண்டும். குறிப்பிடத்தக்க அபாயங்கள் பின்வருமாறு: + +- **காலாவதி**: DNS பெயர்களைப் போலவே, ENS பெயர்களின் பதிவுகளும் வரையறுக்கப்பட்ட கால அளவைக் கொண்டவை. எனவே உரிமையாளர்கள் தங்கள் டொமைன்களின் காலாவதி தேதிகளைக் கண்காணித்து, அவை காலாவதியாகும் முன்னரே அவற்றை நன்கு புதுப்பிப்பது மிகவும் முக்கியம். ENS செயலி மற்றும் Enscribe இரண்டும் காலாவதி நெருங்கும் போது டொமைன் உரிமையாளர்களுக்கு காட்சி குறிகாட்டிகளை வழங்குகின்றன. +- **உரிமையில் மாற்றம்**: ENS பதிவுகள் எத்தேரியத்தில் NFT களாக குறிப்பிடப்படுகின்றன, அங்கு ஒரு குறிப்பிட்ட `.eth` டொமைனின் உரிமையாளர் தொடர்புடைய NFT ஐ தங்கள் வசம் வைத்திருப்பார். எனவே ஒரு வேறுபட்ட கணக்கு இந்த NFT இன் உரிமையை எடுத்துக் கொண்டால், புதிய உரிமையாளர் எந்த ENS பதிவுகளையும் அவர்கள் விரும்பியபடி மாற்றலாம். + +இது போன்ற அபாயங்களைக் குறைக்க, `.eth` 2ஆம் நிலை டொமைன்களுக்கான (2LD) உரிமையாளர் கணக்கு ஒரு பல கையொப்பப் பணப்பை மூலம் பாதுகாக்கப்பட வேண்டும், மேலும் ஒப்பந்தப் பெயரிடலை நிர்வகிக்க துணை டொமைன்கள் உருவாக்கப்பட வேண்டும். அந்த வழியில், துணை டொமைன் மட்டத்தில் உரிமையில் தற்செயலான அல்லது தீங்கிழைக்கும் மாற்றங்கள் ஏற்பட்டால், அவற்றை 2LD உரிமையாளர் மேலெழுதலாம். + +## ஒப்பந்தப் பெயரிடலின் எதிர்காலம் {#future} + +இணையத்தில் டொமைன் பெயர்கள் IP முகவரிகளை மாற்றியதைப் போலவே, ஒப்பந்தப் பெயரிடல் dApp உருவாக்கத்திற்கான ஒரு சிறந்த நடைமுறையாக மாறி வருகிறது. பணப்பைகள், எக்ஸ்ப்ளோரர்கள் மற்றும் டாஷ்போர்டுகள் போன்ற அதிக உள்கட்டமைப்புகள் ஒப்பந்தங்களுக்கான ENS தீர்மானத்தை ஒருங்கிணைக்கும்போது, பெயரிடப்பட்ட ஒப்பந்தங்கள் பாதுகாப்பை மேம்படுத்தி, சுற்றுச்சூழல் முழுவதும் பிழைகளைக் குறைக்கும். + +ஸ்மார்ட் ஒப்பந்தங்களை எளிதாக அடையாளம் காணவும், அவற்றைப் பற்றி பகுத்தறியவும் செய்வதன் மூலம், பெயரிடல் எத்தேரியத்தில் உள்ள பயனர்களுக்கும் செயலிகளுக்கும் இடையிலான இடைவெளியைக் குறைக்க உதவுகிறது, இது பயனர்களுக்கு பாதுகாப்பு மற்றும் UX இரண்டையும் மேம்படுத்துகிறது. + +## மேலும் வாசிக்க {#further-reading} + +- [ENS உடன் ஸ்மார்ட் ஒப்பந்தங்களுக்கு பெயரிடுதல்](https://docs.ens.domains/web/naming-contracts/) +- [Enscribe உடன் ஸ்மார்ட் ஒப்பந்தங்களுக்கு பெயரிடுதல்](https://www.enscribe.xyz/docs). diff --git a/public/content/translations/ta/developers/docs/smart-contracts/security/index.md b/public/content/translations/ta/developers/docs/smart-contracts/security/index.md new file mode 100644 index 00000000000..8fe57551034 --- /dev/null +++ b/public/content/translations/ta/developers/docs/smart-contracts/security/index.md @@ -0,0 +1,575 @@ +--- +title: "ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பு" +description: "பாதுகாப்பான எத்தேரியம் ஸ்மார்ட் ஒப்பந்தங்களை உருவாக்குவதற்கான வழிகாட்டுதல்களின் கண்ணோட்டம்" +lang: ta +--- + +ஸ்மார்ட் ஒப்பந்தங்கள் மிகவும் நெகிழ்வானவை, மேலும் அதிக அளவிலான மதிப்பு மற்றும் தரவைக் கட்டுப்படுத்தும் திறன் கொண்டவை, அதே நேரத்தில் பிளாக்செயினில் பயன்படுத்தப்பட்ட குறியீட்டின் அடிப்படையில் மாற்ற முடியாத தர்க்கத்தை இயக்குகின்றன. நம்பிக்கையற்ற மற்றும் பரவலாக்கப்பட்ட பயன்பாடுகளின் துடிப்பான சூழல் அமைப்பை இது உருவாக்கியுள்ளது. இது மரபுவழி அமைப்புகளைக் காட்டிலும் பல நன்மைகளை வழங்குகிறது. ஸ்மார்ட் ஒப்பந்தங்களில் உள்ள பாதிப்புகளைப் பயன்படுத்திக் கொண்டு லாபம் ஈட்ட விரும்பும் தாக்குபவர்களுக்கு அவை வாய்ப்புகளையும் அளிக்கின்றன. + +எத்தேரியம் போன்ற பொது பிளாக்செயின்கள், ஸ்மார்ட் ஒப்பந்தங்களைப் பாதுகாக்கும் சிக்கலை மேலும் சிக்கலாக்குகின்றன. வரிசைப்படுத்தப்பட்ட ஒப்பந்தக் குறியீட்டைப் பாதுகாப்பு குறைபாடுகளை சரிசெய்ய _வழக்கமாக_ மாற்ற முடியாது, அதேசமயம் ஸ்மார்ட் ஒப்பந்தங்களிலிருந்து திருடப்பட்ட சொத்துக்களைக் கண்காணிப்பது மிகவும் கடினம் மற்றும் மாற்றமுடியாத தன்மை காரணமாக பெரும்பாலும் மீளமுடியாது. + +புள்ளிவிவரங்கள் மாறுபட்டாலும், ஸ்மார்ட் ஒப்பந்தங்களில் உள்ள பாதுகாப்புக் குறைபாடுகள் காரணமாகத் திருடப்பட்ட அல்லது இழந்த மொத்த மதிப்பின் அளவு $1 பில்லியனுக்கும் அதிகமாக இருக்கும் என்று மதிப்பிடப்பட்டுள்ளது. [DAO ஹேக்](https://hackingdistributed.com/2016/06/18/analysis-of-the-dao-exploit/) (3.6M ETH திருடப்பட்டது, இன்றைய விலையில் $1B மதிப்புக்கு மேல்), [பாரிட்டி மல்டி-சிக் வாலட் ஹேக்](https://www.coindesk.com/markets/2017/07/19/30-million-ether-reported-stolen-due-to-parity-wallet-breach) (ஹேக்கர்களால் $30M இழப்பு), மற்றும் [பாரிட்டி ஃபிரோசன் வாலட் பிரச்சினை](https://www.theguardian.com/technology/2017/nov/08/cryptocurrency-300m-dollars-stolen-bug-ether) (என்றென்றைக்குமாக $300M க்கும் அதிகமான ETH முடக்கப்பட்டது) போன்ற உயர்மட்ட சம்பவங்கள் இதில் அடங்கும். + +மேற்கூறிய சிக்கல்கள், பாதுகாப்பான, வலுவான மற்றும் நெகிழக்கூடிய ஸ்மார்ட் ஒப்பந்தங்களை உருவாக்குவதில் உருவாக்குநர்கள் முயற்சி செய்வது அவசியமாகிறது. ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பு ஒரு தீவிரமான வணிகமாகும், மேலும் ஒவ்வொரு உருவாக்குநரும் கற்றுக்கொள்வது நல்லது. இந்த வழிகாட்டி எத்தேரியம் உருவாக்குநர்களுக்கான பாதுகாப்புக் கருத்தாய்வுகளை உள்ளடக்கும் மற்றும் ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பை மேம்படுத்துவதற்கான வளங்களை ஆராயும். + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +பாதுகாப்பைக் கையாள்வதற்கு முன், [ஸ்மார்ட் ஒப்பந்த உருவாக்கத்தின் அடிப்படைகளை](/developers/docs/smart-contracts/) நீங்கள் நன்கு அறிந்திருப்பதை உறுதிப்படுத்திக் கொள்ளுங்கள். + +## பாதுகாப்பான எத்தேரியம் ஸ்மார்ட் ஒப்பந்தங்களை உருவாக்குவதற்கான வழிகாட்டுதல்கள் {#smart-contract-security-guidelines} + +### 1. சரியான அணுகல் கட்டுப்பாடுகளை வடிவமைத்தல் {#design-proper-access-controls} + +ஸ்மார்ட் ஒப்பந்தங்களில், `public` அல்லது `external` எனக் குறிக்கப்பட்ட செயல்பாடுகளை வெளிப்புறச் சொந்தக் கணக்குகள் (EOA-க்கள்) அல்லது ஒப்பந்தக் கணக்குகள் மூலம் அழைக்கலாம். மற்றவர்கள் உங்கள் ஒப்பந்தத்துடன் தொடர்பு கொள்ள விரும்பினால், செயல்பாடுகளுக்கு பொதுத் தெரிவுநிலையைக் குறிப்பிடுவது அவசியம். இருப்பினும், `private` எனக் குறிக்கப்பட்ட செயல்பாடுகளை ஸ்மார்ட் ஒப்பந்தத்திற்குள் உள்ள செயல்பாடுகளால் மட்டுமே அழைக்க முடியும், வெளிப்புற கணக்குகளால் அல்ல. ஒவ்வொரு நெட்வொர்க் பங்கேற்பாளருக்கும் ஒப்பந்த செயல்பாடுகளுக்கான அணுகலை வழங்குவது சிக்கல்களை ஏற்படுத்தும், குறிப்பாக யாரேனும் முக்கியமான செயல்பாடுகளைச் செய்ய முடியும் என்றால் (எ.கா., புதிய டோக்கன்களை உருவாக்குதல்). + +ஸ்மார்ட் ஒப்பந்தச் செயல்பாடுகளின் அங்கீகரிக்கப்படாத பயன்பாட்டைத் தடுக்க, பாதுகாப்பான அணுகல் கட்டுப்பாடுகளைச் செயல்படுத்துவது அவசியம். அணுகல் கட்டுப்பாட்டு வழிமுறைகள், ஒப்பந்தத்தை நிர்வகிப்பதற்குக் காரணமான கணக்குகள் போன்ற அங்கீகரிக்கப்பட்ட நிறுவனங்களுக்கு ஒரு ஸ்மார்ட் ஒப்பந்தத்தில் சில செயல்பாடுகளைப் பயன்படுத்துவதற்கான திறனைக் கட்டுப்படுத்துகின்றன. ஸ்மார்ட் ஒப்பந்தங்களில் அணுகல் கட்டுப்பாட்டைச் செயல்படுத்த **சொந்தமாக்கக்கூடிய பேட்டர்ன்** மற்றும் **பங்கு அடிப்படையிலான கட்டுப்பாடு** ஆகிய இரண்டு பேட்டர்ன்கள் பயனுள்ளதாக இருக்கும்: + +#### சொந்தமாக்கக்கூடிய பேட்டர்ன் {#ownable-pattern} + +சொந்தமாக்கக்கூடிய பேட்டர்னில், ஒப்பந்த-உருவாக்கச் செயல்பாட்டின் போது ஒரு முகவரி ஒப்பந்தத்தின் “உரிமையாளராக” அமைக்கப்படுகிறது. பாதுகாக்கப்பட்ட செயல்பாடுகளுக்கு `OnlyOwner` மாற்றி ஒதுக்கப்பட்டுள்ளது, இது செயல்பாட்டைச் செயல்படுத்தும் முன், அழைக்கும் முகவரியின் அடையாளத்தை ஒப்பந்தம் அங்கீகரிப்பதை உறுதி செய்கிறது. ஒப்பந்த உரிமையாளரைத் தவிர மற்ற முகவரிகளிலிருந்து பாதுகாக்கப்பட்ட செயல்பாடுகளுக்கான அழைப்புகள் எப்போதும் மாற்றியமைக்கப்படும், இது தேவையற்ற அணுகலைத் தடுக்கிறது. + +#### பங்கு அடிப்படையிலான அணுகல் கட்டுப்பாடு {#role-based-access-control} + +ஸ்மார்ட் ஒப்பந்தத்தில் ஒரு ஒற்றை முகவரியை `உரிமையாளராக` பதிவு செய்வது மையப்படுத்தலின் அபாயத்தை அறிமுகப்படுத்துகிறது மற்றும் ஒற்றைத் தோல்விப் புள்ளியைக் குறிக்கிறது. உரிமையாளரின் கணக்குத் திறவுகோல்கள் சிதைக்கப்பட்டால், தாக்குபவர்கள் சொந்தமான ஒப்பந்தத்தைத் தாக்கலாம். இதனால்தான் பல நிர்வாகக் கணக்குகளுடன் பங்கு அடிப்படையிலான அணுகல் கட்டுப்பாட்டு பேட்டர்னைப் பயன்படுத்துவது ஒரு சிறந்த தேர்வாக இருக்கலாம். + +பங்கு அடிப்படையிலான அணுகல் கட்டுப்பாட்டில், முக்கியமான செயல்பாடுகளுக்கான அணுகல் நம்பகமான பங்கேற்பாளர்களின் தொகுப்பிற்கு இடையில் விநியோகிக்கப்படுகிறது. உதாரணமாக, ஒரு கணக்கு டோக்கன்களை உருவாக்குவதற்குப் பொறுப்பாக இருக்கலாம், மற்றொரு கணக்கு மேம்படுத்தல்களைச் செய்கிறது அல்லது ஒப்பந்தத்தை இடைநிறுத்துகிறது. இந்த வழியில் அணுகல் கட்டுப்பாட்டைப் பரவலாக்குவது தோல்வியின் ஒற்றைப் புள்ளிகளை நீக்குகிறது மற்றும் பயனர்களுக்கான நம்பிக்கை அனுமானங்களைக் குறைக்கிறது. + +##### பல-கையொப்பப் பணப்பைகளைப் பயன்படுத்துதல் + +பாதுகாப்பான அணுகல் கட்டுப்பாட்டைச் செயல்படுத்துவதற்கான மற்றொரு அணுகுமுறை, ஒரு ஒப்பந்தத்தை நிர்வகிக்க [பல-கையொப்பக் கணக்கைப்](/developers/docs/smart-contracts/#multisig) பயன்படுத்துவதாகும். ஒரு வழக்கமான EOA போலல்லாமல், பல-கையொப்பக் கணக்குகள் பல நிறுவனங்களுக்குச் சொந்தமானவை மற்றும் பரிவர்த்தனைகளைச் செயல்படுத்த குறைந்தபட்ச கணக்குகளின் கையொப்பங்கள் தேவை—உதாரணமாக 5-இல் 3. + +இலக்கு ஒப்பந்தத்தில் செயல்களுக்கு பல தரப்பினரின் ஒப்புதல் தேவைப்படுவதால், அணுகல் கட்டுப்பாட்டிற்கு ஒரு மல்டிசிக் பயன்படுத்துவது கூடுதல் பாதுகாப்பு அடுக்கை அறிமுகப்படுத்துகிறது. சொந்தமாக்கக்கூடிய பேட்டர்னைப் பயன்படுத்துவது அவசியமானால் இது மிகவும் பயனுள்ளதாக இருக்கும், ஏனெனில் இது ஒரு தாக்குபவர் அல்லது முரட்டுத்தனமான உள் நபர் முக்கியமான ஒப்பந்த செயல்பாடுகளைத் தீங்கிழைக்கும் நோக்கங்களுக்காகக் கையாளுவதை மிகவும் கடினமாக்குகிறது. + +### 2. ஒப்பந்தச் செயல்பாடுகளைப் பாதுகாக்க require(), assert() மற்றும் revert() அறிக்கைகளைப் பயன்படுத்தவும் {#use-require-assert-revert} + +குறிப்பிட்டுள்ளபடி, உங்கள் ஸ்மார்ட் ஒப்பந்தம் பிளாக்செயினில் பயன்படுத்தப்பட்டவுடன், எவரும் பொதுச் செயல்பாடுகளை அழைக்கலாம். வெளிப்புற கணக்குகள் ஒரு ஒப்பந்தத்துடன் எவ்வாறு தொடர்பு கொள்ளும் என்பதை உங்களால் முன்கூட்டியே அறிய முடியாததால், வரிசைப்படுத்துவதற்கு முன்பு சிக்கலான செயல்பாடுகளுக்கு எதிராக உள் பாதுகாப்புகளைச் செயல்படுத்துவது சிறந்தது. செயல்படுத்தல் சில தேவைகளைப் பூர்த்தி செய்யத் தவறினால், விதிவிலக்குகளைத் தூண்டுவதற்கும் மற்றும் நிலை மாற்றங்களைத் திருப்புவதற்கும் `require()`, `assert()` மற்றும் `revert()` அறிக்கைகளைப் பயன்படுத்தி ஸ்மார்ட் ஒப்பந்தங்களில் சரியான நடத்தையை நீங்கள் செயல்படுத்தலாம். + +**`require()`**: `require` செயல்பாடுகளின் தொடக்கத்தில் வரையறுக்கப்பட்டு, அழைக்கப்பட்ட செயல்பாடு செயல்படுத்தப்படுவதற்கு முன்பு முன்வரையறுக்கப்பட்ட நிபந்தனைகள் பூர்த்தி செய்யப்படுவதை உறுதி செய்கிறது. ஒரு `require` அறிக்கை பயனர் உள்ளீடுகளைச் சரிபார்க்க, நிலை மாறிகளைச் சரிபார்க்க அல்லது ஒரு செயல்பாட்டைத் தொடர்வதற்கு முன் அழைக்கும் கணக்கின் அடையாளத்தை அங்கீகரிக்கப் பயன்படுத்தப்படலாம். + +**`assert()`**: உங்கள் குறியீட்டில் உள்ள உள் பிழைகளைக் கண்டறியவும், “மாறிகளின்” மீறல்களைச் சரிபார்க்கவும் `assert()` பயன்படுத்தப்படுகிறது. ஒரு மாறாநிலை என்பது ஒரு ஒப்பந்தத்தின் நிலையைப் பற்றிய ஒரு தர்க்கரீதியான கூற்றாகும், இது அனைத்து செயல்பாடுகளுக்கும் உண்மையாக இருக்க வேண்டும். ஒரு டோக்கன் ஒப்பந்தத்தின் அதிகபட்ச மொத்த வழங்கல் அல்லது இருப்பு ஒரு எடுத்துக்காட்டு மாறிலியாகும். `assert()` ஐப் பயன்படுத்துவது உங்கள் ஒப்பந்தம் ஒருபோதும் பாதிப்புக்குள்ளாகும் நிலையை அடையாது என்பதை உறுதிசெய்கிறது, அவ்வாறு செய்தால், நிலை மாறிகளில் செய்யப்படும் அனைத்து மாற்றங்களும் பின்வாங்கப்படும். + +**`revert()`**: தேவைப்படும் நிபந்தனை பூர்த்தி செய்யப்படாவிட்டால் விதிவிலக்கைத் தூண்டும் if-else அறிக்கையில் `revert()` பயன்படுத்தப்படலாம். கீழே உள்ள மாதிரி ஒப்பந்தம் செயல்பாடுகளைச் செயல்படுத்துவதைப் பாதுகாக்க `revert()` ஐப் பயன்படுத்துகிறது: + +``` +pragma solidity ^0.8.4; + +contract VendingMachine { + address owner; + error Unauthorized(); + function buy(uint amount) public payable { + if (amount > msg.value / 2 ether) + revert("போதுமான ஈதர் வழங்கப்படவில்லை."); + // கொள்முதலைச் செய்யவும். + } + function withdraw() public { + if (msg.sender != owner) + revert Unauthorized(); + + payable(msg.sender).transfer(address(this).balance); + } +} +``` + +### ஒரு நல்ல கதை. ஸ்மார்ட் ஒப்பந்தங்களைச் சோதித்து குறியீட்டின் சரியான தன்மையை சரிபார்க்கவும் {#test-smart-contracts-and-verify-code-correctness} + +[எத்தேரியம் மெய்நிகர் இயந்திரத்தில்](/developers/docs/evm/) இயங்கும் குறியீட்டின் மாற்ற முடியாத தன்மை, ஸ்மார்ட் ஒப்பந்தங்களுக்கு மேம்பாட்டுக் கட்டத்தில் உயர் மட்ட தர மதிப்பீடு தேவை என்பதைக் குறிக்கிறது. உங்கள் ஒப்பந்தத்தை விரிவாகச் சோதித்து, எதிர்பாராத முடிவுகளுக்காக அதைக் கவனிப்பது பாதுகாப்பை வெகுவாக மேம்படுத்தும் மற்றும் நீண்ட காலத்திற்கு உங்கள் பயனர்களைப் பாதுகாக்கும். + +பயனர்களிடமிருந்து ஒப்பந்தம் பெறும் என்று எதிர்பார்க்கப்படும் போலி தரவைப் பயன்படுத்தி சிறிய யூனிட் சோதனைகளை எழுதுவதே வழக்கமான முறையாகும். [அலகு சோதனை](/developers/docs/smart-contracts/testing/#unit-testing) சில செயல்பாடுகளின் செயல்பாட்டைச் சோதிப்பதற்கும் ஸ்மார்ட் ஒப்பந்தம் எதிர்பார்த்தபடி செயல்படுவதை உறுதி செய்வதற்கும் நல்லது. + +துரதிர்ஷ்டவசமாக, தனிமைப்படுத்தப்பட்டுப் பயன்படுத்தும்போது ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பை மேம்படுத்துவதற்கு அலகு சோதனை குறைந்தபட்ச செயல்திறன் கொண்டது. ஒரு அலகு சோதனை, ஒரு செயல்பாடு போலித் தரவுகளுக்குச் சரியாகச் செயல்படுகிறது என்பதை நிரூபிக்கலாம், ஆனால் எழுதப்பட்ட சோதனைகளைப் போலவே அலகு சோதனைகளும் பயனுள்ளதாக இருக்கும். இது உங்கள் ஸ்மார்ட் ஒப்பந்தத்தின் பாதுகாப்பை உடைக்கக்கூடிய விளிம்பு நிலைகளையும் பாதிப்புகளையும் கண்டறிவதை கடினமாக்குகிறது. + +[நிலையான மற்றும் மாறும் பகுப்பாய்வைப்](/developers/docs/smart-contracts/testing/#static-dynamic-analysis) பயன்படுத்தி செய்யப்படும் சொத்து அடிப்படையிலான சோதனையுடன் அலகு சோதனையை இணைப்பது ஒரு சிறந்த அணுகுமுறையாகும். நிலையான பகுப்பாய்வு, அடையக்கூடிய நிரல் நிலைகள் மற்றும் செயல்பாட்டுப் பாதைகளை ஆய்வு செய்ய [கட்டுப்பாட்டு ஓட்ட வரைபடங்கள்](https://en.wikipedia.org/wiki/Control-flow_graph) மற்றும் [சுருக்க தொடரியல் மரங்கள்](https://deepsource.io/glossary/ast/) போன்ற கீழ்மட்டப் பிரதிநிதித்துவங்களைச் சார்ந்துள்ளது. இதற்கிடையில், [ஸ்மார்ட் ஒப்பந்த ஃபஸ்ஸிங்](https://www.cyfrin.io/blog/smart-contract-fuzzing-and-invariants-testing-foundry) போன்ற மாறும் பகுப்பாய்வு நுட்பங்கள், பாதுகாப்புப் பண்புகளை மீறும் செயல்பாடுகளைக் கண்டறிய சீரற்ற உள்ளீட்டு மதிப்புகளுடன் ஒப்பந்தக் குறியீட்டைச் செயல்படுத்துகின்றன. + +[முறையான சரிபார்ப்பு](/developers/docs/smart-contracts/formal-verification) என்பது ஸ்மார்ட் ஒப்பந்தங்களில் பாதுகாப்புப் பண்புகளைச் சரிபார்க்கும் மற்றொரு நுட்பமாகும். சாதாரண சோதனையைப் போலல்லாமல், முறையான சரிபார்ப்பு ஒரு ஸ்மார்ட் ஒப்பந்தத்தில் பிழைகள் இல்லாததை உறுதியாக நிரூபிக்க முடியும். விரும்பிய பாதுகாப்புப் பண்புகளைப் பிடிக்கும் ஒரு முறையான விவரக்குறிப்பை உருவாக்குவதன் மூலமும், ஒப்பந்தங்களின் முறையான மாதிரி இந்த விவரக்குறிப்பைப் பின்பற்றுகிறது என்பதை நிரூபிப்பதன் மூலமும் இது அடையப்படுகிறது. + +### 4. உங்கள் குறியீட்டைச் சுதந்திரமாக மதிப்பாய்வு செய்யக் கோரவும் {#get-independent-code-reviews} + +உங்கள் ஒப்பந்தத்தைச் சோதித்த பிறகு, ஏதேனும் பாதுகாப்புச் சிக்கல்களுக்கு மூலக் குறியீட்டைச் சரிபார்க்க மற்றவர்களைக் கேட்பது நல்லது. சோதனையானது ஒரு ஸ்மார்ட் ஒப்பந்தத்தில் உள்ள ஒவ்வொரு குறைபாட்டையும் வெளிக்கொணராது, ஆனால் ஒரு சுதந்திரமான மதிப்பாய்வைப் பெறுவது பாதிப்புகளைக் கண்டறியும் வாய்ப்பை அதிகரிக்கிறது. + +#### தணிக்கைகள் {#audits} + +ஒரு ஸ்மார்ட் ஒப்பந்தத் தணிக்கையை நியமிப்பது ஒரு சுயாதீனக் குறியீடு மதிப்பாய்வை நடத்துவதற்கான ஒரு வழியாகும். ஸ்மார்ட் ஒப்பந்தங்கள் பாதுகாப்பானவை மற்றும் தரக்குறைபாடுகள் மற்றும் வடிவமைப்பு பிழைகள் இல்லாமல் இருப்பதை உறுதி செய்வதில் தணிக்கையாளர்கள் முக்கிய பங்கு வகிக்கின்றனர். + +அப்படியிருந்தும், தணிக்கைகளை ஒரு சில்வர் புல்லட்டாகக் கருதுவதை நீங்கள் தவிர்க்க வேண்டும். ஸ்மார்ட் ஒப்பந்தத் தணிக்கைகள் ஒவ்வொரு பிழையையும் பிடிக்காது, மேலும் அவை பெரும்பாலும் கூடுதல் சுற்று மதிப்பாய்வுகளை வழங்குவதற்காக வடிவமைக்கப்பட்டுள்ளன, இது ஆரம்ப மேம்பாடு மற்றும் சோதனையின் போது உருவாக்குநர்களால் தவறவிட்ட சிக்கல்களைக் கண்டறிய உதவும். குறியீட்டைச் சரியாக ஆவணப்படுத்துதல் மற்றும் இன்லைன் கருத்துகளைச் சேர்ப்பது போன்ற தணிக்கையாளர்களுடன் பணிபுரிவதற்கான சிறந்த நடைமுறைகளையும் நீங்கள் பின்பற்ற வேண்டும். இது ஒரு ஸ்மார்ட் ஒப்பந்தத் தணிக்கையின் பலனை அதிகரிக்கச் செய்யும். + +- [ஸ்மார்ட் ஒப்பந்த தணிக்கை குறிப்புகள் & தந்திரங்கள்](https://twitter.com/tinchoabbate/status/1400170232904400897) - _@tinchoabbate_ +- [உங்கள் தணிக்கையிலிருந்து அதிகப் பலனைப் பெறுங்கள்](https://inference.ag/blog/2023-08-14-tips/) - _Inference_ + +#### பிழை சன்மானங்கள் {#bug-bounties} + +ஒரு பிழை சன்மானத் திட்டத்தை அமைப்பது வெளிப்புறக் குறியீடு மதிப்பாய்வுகளைச் செயல்படுத்துவதற்கான மற்றொரு அணுகுமுறையாகும். ஒரு பிழை சன்மானம் என்பது ஒரு பயன்பாட்டில் உள்ள பாதிப்புகளைக் கண்டறியும் நபர்களுக்கு (பொதுவாக வொயிட்ஹேட் ஹேக்கர்கள்) வழங்கப்படும் நிதி வெகுமதியாகும். + +சரியாகப் பயன்படுத்தினால், பிழை சன்மானங்கள் ஹேக்கர் சமூகத்தின் உறுப்பினர்களுக்கு உங்கள் குறியீட்டில் முக்கியமான குறைபாடுகளை ஆய்வு செய்ய ஊக்கமளிக்கின்றன. எத்தேரியத்தில் இயங்கும் [அடுக்கு 2](/layer-2/) நெறிமுறையான [Optimism](https://www.optimism.io/) இல் ஒரு தாக்குபவர் வரம்பற்ற ஈதரை உருவாக்க அனுமதிக்கும் “முடிவற்ற பணப் பிழை” ஒரு நிஜ வாழ்க்கை உதாரணமாகும். அதிர்ஷ்டவசமாக, ஒரு வொயிட்ஹேட் ஹேக்கர் [குறைபாட்டைக் கண்டுபிடித்து](https://www.saurik.com/optimism.html) குழுவுக்குத் தெரிவித்தார், [இந்தச் செயல்பாட்டில் பெரும் ஊதியத்தைப் பெற்றார்](https://cryptoslate.com/critical-bug-in-ethereum-l2-optimism-2m-bounty-paid/). + +பங்குகளில் உள்ள நிதிகளின் அளவிற்கு விகிதாசாரத்தில் ஒரு பிழை சன்மானத் திட்டத்தின் ஊதியத்தை அமைப்பது ஒரு பயனுள்ள உத்தியாகும். “[ஸ்கேலிங் பிழை சன்மானம்](https://medium.com/immunefi/a-defi-security-standard-the-scaling-bug-bounty-9b83dfdc1ba7)” என விவரிக்கப்படும் இந்த அணுகுமுறை, பாதிப்புகளைச் சுரண்டுவதற்குப் பதிலாகப் பொறுப்புடன் வெளிப்படுத்த தனிநபர்களுக்கு நிதிச் சலுகைகளை வழங்குகிறது. + +### Visual Direction • உள்ளடக்கம். ஸ்மார்ட் ஒப்பந்த மேம்பாட்டின் போது சிறந்த நடைமுறைகளைப் பின்பற்றவும் {#follow-smart-contract-development-best-practices} + +தணிக்கைகள் மற்றும் பிழை சன்மானங்கள் இருப்பது உயர்தரக் குறியீட்டை எழுதுவதற்கான உங்கள் பொறுப்பிலிருந்து உங்களை மன்னிக்காது. நல்ல ஸ்மார்ட் ஒப்பந்த பாதுகாப்பு சரியான வடிவமைப்பு மற்றும் மேம்பாட்டு செயல்முறைகளைப் பின்பற்றுவதில் தொடங்குகிறது: + +- git போன்ற பதிப்புக் கட்டுப்பாட்டு அமைப்பில் அனைத்துக் குறியீட்டையும் சேமிக்கவும் + +- புல் கோரிக்கைகள் வழியாக அனைத்து குறியீடு மாற்றங்களையும் செய்யவும் + +- புல் கோரிக்கைகளுக்குக் குறைந்தபட்சம் ஒரு சுயாதீன மதிப்பாய்வாளர் இருப்பதை உறுதிசெய்யவும்—நீங்கள் ஒரு திட்டத்தில் தனியாக வேலை செய்தால், மற்ற உருவாக்குநர்களைக் கண்டுபிடித்து குறியீடு மதிப்பாய்வுகளைப் பரிமாறிக்கொள்ளுங்கள் + +- ஸ்மார்ட் ஒப்பந்தங்களைச் சோதித்தல், தொகுத்தல் மற்றும் வரிசைப்படுத்துதல் ஆகியவற்றிற்காக ஒரு [மேம்பாட்டுச் சூழலைப்](/developers/docs/frameworks/) பயன்படுத்தவும் + +- [Cyfrin Aderyn](https://github.com/Cyfrin/aderyn), Mythril மற்றும் Slither போன்ற அடிப்படைக் குறியீடு பகுப்பாய்வுக் கருவிகள் மூலம் உங்கள் குறியீட்டை இயக்கவும். சிறப்பாக, ஒவ்வொரு புல் கோரிக்கையும் ஒன்றிணைக்கப்படுவதற்கு முன்பு இதைச் செய்து, வெளியீட்டில் உள்ள வேறுபாடுகளை ஒப்பிட வேண்டும். + +- உங்கள் குறியீடு பிழைகள் இல்லாமல் தொகுக்கப்படுவதையும், Solidity தொகுப்பி எந்த எச்சரிக்கைகளையும் வெளியிடவில்லை என்பதையும் உறுதிசெய்யவும் + +- உங்கள் குறியீட்டைச் சரியாக ஆவணப்படுத்தவும் ([NatSpec](https://solidity.readthedocs.io/en/develop/natspec-format.html) ஐப் பயன்படுத்தி) மற்றும் ஒப்பந்தக் கட்டமைப்பைப் பற்றிய விவரங்களை எளிதில் புரிந்துகொள்ளக்கூடிய மொழியில் விவரிக்கவும். இது மற்றவர்கள் உங்கள் குறியீட்டைத் தணிக்கை செய்வதையும் மதிப்பாய்வு செய்வதையும் எளிதாக்கும். + +### 6. வலுவான பேரழிவு மீட்புத் திட்டங்களைச் செயல்படுத்தவும் {#implement-disaster-recovery-plans} + +பாதுகாப்பான அணுகல் கட்டுப்பாடுகளை வடிவமைத்தல், செயல்பாட்டு மாற்றிகளைச் செயல்படுத்துதல் மற்றும் பிற பரிந்துரைகள் ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பை மேம்படுத்தலாம், ஆனால் அவை தீங்கிழைக்கும் சுரண்டல்களின் சாத்தியக்கூறுகளை நிராகரிக்க முடியாது. பாதுகாப்பான ஸ்மார்ட் ஒப்பந்தங்களை உருவாக்குவதற்கு “தோல்விக்குத் தயாராவது” மற்றும் தாக்குதல்களுக்கு திறம்பட பதிலளிக்க ஒரு பின்னடைவுத் திட்டம் தேவை. ஒரு சரியான பேரழிவு மீட்புத் திட்டம் பின்வரும் சில அல்லது அனைத்து கூறுகளையும் உள்ளடக்கும்: + +#### ஒப்பந்த மேம்படுத்தல்கள் {#contract-upgrades} + +எத்தேரியம் ஸ்மார்ட் ஒப்பந்தங்கள் இயல்பாகவே மாற்ற முடியாதவை என்றாலும், மேம்படுத்தல் பேட்டர்ன்களைப் பயன்படுத்தி சில அளவு மாற்றத்தன்மையை அடைய முடியும். ஒரு முக்கியமான குறைபாடு உங்கள் பழைய ஒப்பந்தத்தைப் பயன்படுத்த முடியாததாக மாற்றும் சந்தர்ப்பங்களில் ஒப்பந்தங்களை மேம்படுத்துவது அவசியமாகும், மேலும் புதிய தர்க்கத்தை வரிசைப்படுத்துவது மிகவும் சாத்தியமான விருப்பமாகும். + +ஒப்பந்த மேம்படுத்தல் வழிமுறைகள் வித்தியாசமாகச் செயல்படுகின்றன, ஆனால் “ப்ராக்ஸி பேட்டர்ன்” என்பது ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்துவதற்கான மிகவும் பிரபலமான அணுகுமுறைகளில் ஒன்றாகும். [ப்ராக்ஸி பேட்டர்ன்கள்](https://www.cyfrin.io/blog/upgradeable-proxy-smart-contract-pattern) ஒரு பயன்பாட்டின் நிலை மற்றும் தர்க்கத்தை _இரண்டு_ ஒப்பந்தங்களுக்கு இடையில் பிரிக்கிறது. முதல் ஒப்பந்தம் (‘ப்ராக்ஸி ஒப்பந்தம்’ என அழைக்கப்படுகிறது) நிலை மாறிகளை (எ.கா., பயனர் இருப்பு) சேமிக்கிறது, அதேசமயம் இரண்டாவது ஒப்பந்தம் (‘லாஜிக் ஒப்பந்தம்’ என அழைக்கப்படுகிறது) ஒப்பந்தச் செயல்பாடுகளைச் செயல்படுத்தும் குறியீட்டைக் கொண்டுள்ளது. + +கணக்குகள் ப்ராக்ஸி ஒப்பந்தத்துடன் தொடர்பு கொள்கின்றன, இது [`delegatecall()`](https://docs.soliditylang.org/en/v0.8.16/introduction-to-smart-contracts.html?highlight=delegatecall#delegatecall-callcode-and-libraries) குறைந்த-நிலை அழைப்பைப் பயன்படுத்தி அனைத்து செயல்பாட்டு அழைப்புகளையும் தர்க்க ஒப்பந்தத்திற்கு அனுப்புகிறது. ஒரு வழக்கமான செய்தி அழைப்பைப் போலல்லாமல், `delegatecall()` தர்க்க ஒப்பந்தத்தின் முகவரியில் இயங்கும் குறியீடு அழைக்கும் ஒப்பந்தத்தின் சூழலில் செயல்படுத்தப்படுவதை உறுதி செய்கிறது. இதன் பொருள் தர்க்க ஒப்பந்தம் எப்போதும் ப்ராக்ஸியின் சேமிப்பகத்தில் எழுதும் (அதன் சொந்த சேமிப்பகத்திற்கு பதிலாக) மற்றும் `msg.sender` மற்றும் `msg.value` இன் அசல் மதிப்புகள் பாதுகாக்கப்படும். + +தர்க்க ஒப்பந்தத்திற்கான அழைப்புகளைப் பிரதிநிதித்துவப்படுத்த, அதன் முகவரியை ப்ராக்ஸி ஒப்பந்தத்தின் சேமிப்பகத்தில் சேமிக்க வேண்டும். எனவே, ஒப்பந்தத்தின் தர்க்கத்தை மேம்படுத்துவது மற்றொரு தர்க்க ஒப்பந்தத்தை வரிசைப்படுத்தி புதிய முகவரியை ப்ராக்ஸி ஒப்பந்தத்தில் சேமிப்பதாகும். ப்ராக்ஸி ஒப்பந்தத்திற்கான அடுத்தடுத்த அழைப்புகள் தானாகவே புதிய தர்க்க ஒப்பந்தத்திற்கு அனுப்பப்படுவதால், நீங்கள் குறியீட்டை மாற்றாமல் ஒப்பந்தத்தை “மேம்படுத்தி” இருப்பீர்கள். + +[ஒப்பந்தங்களை மேம்படுத்துவது பற்றி மேலும் அறிய](/developers/docs/smart-contracts/upgrading/). + +#### அவசர நிறுத்தங்கள் {#emergency-stops} + +குறிப்பிட்டபடி, விரிவான தணிக்கை மற்றும் சோதனை ஒரு ஸ்மார்ட் ஒப்பந்தத்தில் உள்ள அனைத்துப் பிழைகளையும் கண்டறிய முடியாது. வரிசைப்படுத்தப்பட்ட பிறகு உங்கள் குறியீட்டில் ஒரு பாதிப்பு தோன்றினால், ஒப்பந்த முகவரியில் இயங்கும் குறியீட்டை மாற்ற முடியாததால் அதை சரிசெய்வது சாத்தியமில்லை. மேலும், மேம்படுத்தல் வழிமுறைகள் (எ.கா., ப்ராக்ஸி பேட்டர்ன்கள்) செயல்படுத்த நேரம் எடுக்கலாம் (அவை பெரும்பாலும் வெவ்வேறு தரப்பினரிடமிருந்து ஒப்புதல் தேவைப்படும்), இது தாக்குபவர்களுக்கு அதிக சேதத்தை ஏற்படுத்த அதிக நேரத்தை மட்டுமே அளிக்கிறது. + +அணுசக்தி விருப்பம் என்பது ஒரு ஒப்பந்தத்தில் உள்ள பாதிப்புக்குள்ளான செயல்பாடுகளுக்கான அழைப்புகளைத் தடுக்கும் “அவசர நிறுத்த” செயல்பாட்டைச் செயல்படுத்துவதாகும். அவசர நிறுத்தங்கள் பொதுவாக பின்வரும் கூறுகளைக் கொண்டிருக்கும்: + +1. ஸ்மார்ட் ஒப்பந்தம் நிறுத்தப்பட்ட நிலையில் உள்ளதா இல்லையா என்பதைக் குறிக்கும் ஒரு உலகளாவிய பூலியன் மாறி. ஒப்பந்தத்தை அமைக்கும் போது இந்த மாறி `false` என அமைக்கப்படும், ஆனால் ஒப்பந்தம் நிறுத்தப்பட்டவுடன் `true` ஆக மாறும். + +2. பூலியன் மாறியை அவற்றின் செயல்பாட்டில் குறிப்பிடும் செயல்பாடுகள். ஸ்மார்ட் ஒப்பந்தம் நிறுத்தப்படாதபோது இத்தகைய செயல்பாடுகளை அணுக முடியும், மேலும் அவசர நிறுத்த அம்சம் தூண்டப்படும்போது அணுக முடியாததாகிவிடும். + +3. பூலியன் மாறியை `true` என அமைக்கும் அவசர நிறுத்தச் செயல்பாட்டிற்கான அணுகலைக் கொண்ட ஒரு நிறுவனம். தீங்கிழைக்கும் செயல்களைத் தடுக்க, இந்தச் செயல்பாட்டிற்கான அழைப்புகளை நம்பகமான முகவரிக்கு (எ.கா., ஒப்பந்த உரிமையாளர்) கட்டுப்படுத்தலாம். + +ஒப்பந்தம் அவசர நிறுத்தத்தை செயல்படுத்தியவுடன், சில செயல்பாடுகளை அழைக்க முடியாது. உலகளாவிய மாறியைக் குறிப்பிடும் ஒரு மாற்றியில் தேர்ந்தெடுக்கப்பட்ட செயல்பாடுகளை மூடுவதன் மூலம் இது அடையப்படுகிறது. ஒப்பந்தங்களில் இந்த பேட்டர்னின் செயல்பாட்டை விவரிக்கும் [ஒரு உதாரணம்](https://github.com/fravoll/solidity-patterns/blob/master/EmergencyStop/EmergencyStop.sol) கீழே உள்ளது: + +```solidity +// இந்தக் குறியீடு தொழில்ரீதியாகத் தணிக்கை செய்யப்படவில்லை மற்றும் பாதுகாப்பு அல்லது சரியானது குறித்து எந்த வாக்குறுதியும் அளிக்கவில்லை. உங்கள் சொந்த ஆபத்தில் பயன்படுத்தவும். + +contract EmergencyStop { + + bool isStopped = false; + + modifier stoppedInEmergency { + require(!isStopped); + _; + } + + modifier onlyWhenStopped { + require(isStopped); + _; + } + + modifier onlyAuthorized { + // msg.sender இன் அங்கீகாரத்தை இங்கே சரிபார்க்கவும் + _; + } + + function stopContract() public onlyAuthorized { + isStopped = true; + } + + function resumeContract() public onlyAuthorized { + isStopped = false; + } + + function deposit() public payable stoppedInEmergency { + // வைப்புத் தர்க்கம் இங்கே நடக்கிறது + } + + function emergencyWithdraw() public onlyWhenStopped { + // அவசரக்காலப் பணம் எடுத்தல் இங்கே நடக்கிறது + } +} +``` + +இந்த எடுத்துக்காட்டு அவசர நிறுத்தங்களின் அடிப்படை அம்சங்களைக் காட்டுகிறது: + +- `isStopped` என்பது ஒரு பூலியன் ஆகும், இது தொடக்கத்தில் `false` ஆகவும், ஒப்பந்தம் அவசர பயன்முறைக்கு நுழையும்போது `true` ஆகவும் மதிப்பிடுகிறது. + +- செயல்பாட்டு மாற்றிகள் `onlyWhenStopped` மற்றும் `stoppedInEmergency` `isStopped` மாறியைச் சரிபார்க்கின்றன. ஒப்பந்தம் பாதிப்புக்குள்ளாகும் போது அணுக முடியாத செயல்பாடுகளைக் கட்டுப்படுத்த `stoppedInEmergency` பயன்படுத்தப்படுகிறது (எ.கா., `deposit()`). இந்தச் செயல்பாடுகளுக்கான அழைப்புகள் வெறுமனே மாற்றியமைக்கப்படும். + +அவசரகாலத்தில் அழைக்கப்பட வேண்டிய செயல்பாடுகளுக்கு `onlyWhenStopped` பயன்படுத்தப்படுகிறது (எ.கா., `emergencyWithdraw()`). இத்தகைய செயல்பாடுகள் நிலைமையைத் தீர்க்க உதவும், எனவே அவை “கட்டுப்படுத்தப்பட்ட செயல்பாடுகள்” பட்டியலிலிருந்து விலக்கப்பட்டுள்ளன. + +ஒரு அவசர நிறுத்தச் செயல்பாட்டைப் பயன்படுத்துவது உங்கள் ஸ்மார்ட் ஒப்பந்தத்தில் உள்ள தீவிர பாதிப்புகளைச் சமாளிக்க ஒரு பயனுள்ள நிறுத்தத்தை வழங்குகிறது. இருப்பினும், சுய-சேவை காரணங்களுக்காக அதைச் செயல்படுத்த வேண்டாம் என்று உருவாக்குநர்களை நம்புவதற்கான தேவையை இது பயனர்களுக்கு அதிகரிக்கிறது. இந்த முடிவுக்கு, அவசர நிறுத்தத்தின் கட்டுப்பாட்டை ஒரு ஆன்செயின் வாக்களிப்பு பொறிமுறை, டைம்லாக் அல்லது ஒரு மல்டிசிக் வாலட்டிலிருந்து ஒப்புதலுக்கு உட்படுத்துவதன் மூலம் பரவலாக்குவது சாத்தியமான தீர்வுகளாகும். + +#### நிகழ்வு கண்காணிப்பு {#event-monitoring} + +[நிகழ்வுகள்](https://docs.soliditylang.org/en/v0.8.15/contracts.html#events) ஸ்மார்ட் ஒப்பந்தச் செயல்பாடுகளுக்கான அழைப்புகளைக் கண்காணிக்கவும் மற்றும் நிலை மாறிகளில் ஏற்படும் மாற்றங்களைக் கண்காணிக்கவும் உங்களை அனுமதிக்கின்றன. ஏதேனும் ஒரு தரப்பினர் பாதுகாப்பு-முக்கியமான நடவடிக்கையை எடுக்கும் போதெல்லாம் (எ.கா., நிதிகளைத் திரும்பப் பெறுதல்) ஒரு நிகழ்வை வெளியிடுவதற்கு உங்கள் ஸ்மார்ட் ஒப்பந்தத்தை நிரலாக்குவது சிறந்தது. + +நிகழ்வுகளைப் பதிவுசெய்வதும், அவற்றை ஆஃப்செயினில் கண்காணிப்பதும் ஒப்பந்தச் செயல்பாடுகள் பற்றிய நுண்ணறிவுகளை வழங்குகிறது மற்றும் தீங்கிழைக்கும் செயல்களை விரைவாகக் கண்டறிய உதவுகிறது. இதன் பொருள், உங்கள் குழு ஹேக்குகளுக்கு விரைவாக பதிலளிக்க முடியும் மற்றும் செயல்பாடுகளை இடைநிறுத்துவது அல்லது மேம்படுத்துவது போன்ற பயனர்களின் மீதான தாக்கத்தைக் குறைக்க நடவடிக்கை எடுக்க முடியும். + +யாராவது உங்கள் ஒப்பந்தங்களுடன் தொடர்பு கொள்ளும்போதெல்லாம் தானாகவே விழிப்பூட்டல்களை அனுப்பும் ஒரு ஆஃப்-தி-ஷெல்ஃப் கண்காணிப்புக் கருவியையும் நீங்கள் தேர்வு செய்யலாம். பரிவர்த்தனை அளவு, செயல்பாட்டு அழைப்புகளின் அதிர்வெண் அல்லது சம்பந்தப்பட்ட குறிப்பிட்ட செயல்பாடுகள் போன்ற வெவ்வேறு தூண்டுதல்களின் அடிப்படையில் தனிப்பயன் விழிப்பூட்டல்களை உருவாக்க இந்தக் கருவிகள் உங்களை அனுமதிக்கும். உதாரணமாக, ஒரு பரிவர்த்தனையில் திரும்பப் பெறப்பட்ட தொகை ஒரு குறிப்பிட்ட வரம்பைத் தாண்டும்போது வரும் ஒரு விழிப்பூட்டலை நீங்கள் நிரல்படுத்தலாம். + +### 7. பாதுகாப்பான ஆளுகை அமைப்புகளை வடிவமைத்தல் {#design-secure-governance-systems} + +முக்கிய ஸ்மார்ட் ஒப்பந்தங்களின் கட்டுப்பாட்டை சமூக உறுப்பினர்களிடம் ஒப்படைப்பதன் மூலம் உங்கள் விண்ணப்பத்தைப் பரவலாக்க நீங்கள் விரும்பலாம். இந்த வழக்கில், ஸ்மார்ட் ஒப்பந்த அமைப்பில் ஒரு ஆளுகை தொகுதி இருக்கும்—இது ஒரு ஆன்செயின் ஆளுகை அமைப்பு மூலம் நிர்வாக நடவடிக்கைகளை அங்கீகரிக்க சமூக உறுப்பினர்களை அனுமதிக்கும் ஒரு பொறிமுறையாகும். உதாரணமாக, டோக்கன் வைத்திருப்பவர்களால் ஒரு புதிய செயலாக்கத்திற்கு ஒரு ப்ராக்ஸி ஒப்பந்தத்தை மேம்படுத்துவதற்கான முன்மொழிவுக்கு வாக்களிக்கப்படலாம். + +பரவலாக்கப்பட்ட ஆளுகை நன்மை பயக்கும், குறிப்பாக இது உருவாக்குநர்கள் மற்றும் இறுதிப் பயனர்களின் நலன்களை சீரமைப்பதால். ஆயினும்கூட, ஸ்மார்ட் ஒப்பந்த ஆளுகை வழிமுறைகள் தவறாகச் செயல்படுத்தப்பட்டால் புதிய அபாயங்களை அறிமுகப்படுத்தலாம். ஒரு தாக்குபவர் [ஃபிளாஷ் கடனைப்](/defi/#flash-loans) பெற்று, தீங்கிழைக்கும் முன்மொழிவை முன்னெடுத்துச் செல்வதன் மூலம் மிகப்பெரிய வாக்களிப்பு சக்தியைப் (கையிருப்பில் உள்ள டோக்கன்களின் எண்ணிக்கையில் அளவிடப்படுகிறது) பெறுவது ஒரு நம்பத்தகுந்த சூழ்நிலையாகும். + +ஆன்செயின் ஆளுகை தொடர்பான சிக்கல்களைத் தடுப்பதற்கான ஒரு வழி [ஒரு டைம்லாக்கைப் பயன்படுத்துவது](https://blog.openzeppelin.com/protect-your-users-with-smart-contract-timelocks/). ஒரு குறிப்பிட்ட அளவு நேரம் கடக்கும் வரை ஒரு ஸ்மார்ட் ஒப்பந்தம் சில செயல்களைச் செய்வதைத் டைம்லாக் தடுக்கிறது. ஒவ்வொரு டோக்கனுக்கும் அது எவ்வளவு காலம் பூட்டப்பட்டிருக்கிறது என்பதன் அடிப்படையில் ஒரு “வாக்களிப்பு எடையை” ஒதுக்குவது, அல்லது தற்போதைய தொகுப்புக்குப் பதிலாக ஒரு வரலாற்று காலகட்டத்தில் (உதாரணமாக, கடந்த காலத்தில் 2-3 தொகுதிகள்) ஒரு முகவரியின் வாக்களிப்பு சக்தியை அளவிடுவது ஆகியவை பிற உத்திகள் ஆகும். இரண்டு முறைகளும் ஆன்செயின் வாக்குகளை மாற்றுவதற்காக வாக்களிப்பு சக்தியை விரைவாகக் குவிக்கும் வாய்ப்பைக் குறைக்கின்றன. + +பகிரப்பட்ட இணைப்புகளில் [பாதுகாப்பான ஆளுகை அமைப்புகளை வடிவமைப்பது](https://blog.openzeppelin.com/smart-contract-security-guidelines-4-strategies-for-safer-governance-systems/), [DAOக்களில் வெவ்வேறு வாக்களிப்பு வழிமுறைகள்](https://hackernoon.com/governance-is-the-holy-grail-for-daos), மற்றும் [DeFi ஐப் பயன்படுத்தும் பொதுவான DAO தாக்குதல் வெக்டர்கள்](https://dacian.me/dao-governance-defi-attacks) பற்றி மேலும் அறியலாம். + +### 8. குறியீட்டில் உள்ள சிக்கலை குறைந்தபட்சமாகக் குறைக்கவும் {#reduce-code-complexity} + +பாரம்பரிய மென்பொருள் உருவாக்குநர்கள் KISS (“அதை எளிமையாக வைத்திரு, முட்டாளே”) கொள்கையை நன்கு அறிந்திருக்கிறார்கள், இது மென்பொருள் வடிவமைப்பில் தேவையற்ற சிக்கலை அறிமுகப்படுத்துவதற்கு எதிராக அறிவுறுத்துகிறது. இது “சிக்கலான அமைப்புகள் சிக்கலான வழிகளில் தோல்வியடைகின்றன” மற்றும் அதிக விலையுள்ள பிழைகளுக்கு ஆளாகின்றன என்ற நீண்டகால சிந்தனையைப் பின்பற்றுகிறது. + +ஸ்மார்ட் ஒப்பந்தங்கள் அதிக அளவிலான மதிப்பைக் கட்டுப்படுத்தும் திறன் கொண்டவை என்பதால், ஸ்மார்ட் ஒப்பந்தங்களை எழுதும் போது விஷயங்களை எளிமையாக வைத்திருப்பது குறிப்பிட்ட முக்கியத்துவம் வாய்ந்தது. ஸ்மார்ட் ஒப்பந்தங்களை எழுதும் போது எளிமையை அடைவதற்கான ஒரு உதவிக்குறிப்பு, முடிந்தால், [OpenZeppelin ஒப்பந்தங்கள்](https://docs.openzeppelin.com/contracts/5.x/) போன்ற ஏற்கனவே உள்ள நூலகங்களை மீண்டும் பயன்படுத்துவதாகும். இந்த நூலகங்கள் உருவாக்குநர்களால் விரிவாகத் தணிக்கை செய்யப்பட்டு சோதிக்கப்பட்டிருப்பதால், அவற்றைப் பயன்படுத்துவது புதிதாகச் செயல்பாடுகளை எழுதுவதன் மூலம் பிழைகளை அறிமுகப்படுத்தும் வாய்ப்புகளைக் குறைக்கிறது. + +மற்றொரு பொதுவான அறிவுரை சிறிய செயல்பாடுகளை எழுதுவதும், பல ஒப்பந்தங்களில் வணிக தர்க்கத்தைப் பிரிப்பதன் மூலம் ஒப்பந்தங்களை மாடுலராக வைத்திருப்பதும் ஆகும். எளிமையான குறியீட்டை எழுதுவது ஒரு ஸ்மார்ட் ஒப்பந்தத்தில் தாக்குதல் பரப்பைக் குறைப்பது மட்டுமல்லாமல், ஒட்டுமொத்த அமைப்பின் சரியானது பற்றி பகுத்தறிவு செய்வதையும், சாத்தியமான வடிவமைப்புப் பிழைகளை முன்கூட்டியே கண்டறிவதையும் எளிதாக்குகிறது. + +### 9. பொதுவான ஸ்மார்ட் ஒப்பந்தப் பாதிப்புகளுக்கு எதிராகப் பாதுகாக்கவும் {#mitigate-common-smart-contract-vulnerabilities} + +#### மறு நுழைவு {#reentrancy} + +EVM ஒருமைப்பாட்டை அனுமதிக்காது, அதாவது ஒரு செய்தி அழைப்பில் ஈடுபட்டுள்ள இரண்டு ஒப்பந்தங்கள் ஒரே நேரத்தில் இயங்க முடியாது. ஒரு வெளிப்புற அழைப்பு அழைக்கும் ஒப்பந்தத்தின் செயல்பாட்டையும் நினைவகத்தையும் அழைப்பு திரும்பும் வரை இடைநிறுத்துகிறது, அந்த நேரத்தில் செயல்பாடு சாதாரணமாகத் தொடர்கிறது. இந்த செயல்முறையை மற்றொரு ஒப்பந்தத்திற்கு [கட்டுப்பாட்டு ஓட்டத்தை](https://www.computerhope.com/jargon/c/contflow.htm) மாற்றுவது என்று முறையாக விவரிக்கலாம். + +பெரும்பாலும் பாதிப்பில்லாததாக இருந்தாலும், நம்பத்தகாத ஒப்பந்தங்களுக்குக் கட்டுப்பாட்டு ஓட்டத்தை மாற்றுவது மறு நுழைவு போன்ற சிக்கல்களை ஏற்படுத்தும். அசல் செயல்பாட்டு அழைப்பு முடிவடைவதற்கு முன்பு, ஒரு தீங்கிழைக்கும் ஒப்பந்தம் பாதிக்கப்படக்கூடிய ஒப்பந்தத்திற்கு மீண்டும் அழைக்கும் போது மறு நுழைவுத் தாக்குதல் ஏற்படுகிறது. இந்த வகை தாக்குதல் ஒரு எடுத்துக்காட்டுடன் சிறப்பாக விளக்கப்படுகிறது. + +யாரும் ஈதரை டெபாசிட் செய்யவும் திரும்பப் பெறவும் அனுமதிக்கும் ஒரு எளிய ஸ்மார்ட் ஒப்பந்தத்தைக் (‘பாதிக்கப்பட்டவர்’) கவனியுங்கள்: + +```solidity +// இந்த ஒப்பந்தம் பாதிக்கப்படக்கூடியது. உற்பத்தியில் பயன்படுத்த வேண்டாம் + +contract Victim { + mapping (address => uint256) public balances; + + function deposit() external payable { + balances[msg.sender] += msg.value; + } + + function withdraw() external { + uint256 amount = balances[msg.sender]; + (bool success, ) = msg.sender.call.value(amount)(""); + require(success); + balances[msg.sender] = 0; + } +} +``` + +இந்த ஒப்பந்தம், பயனர்கள் ஒப்பந்தத்தில் முன்பு டெபாசிட் செய்த ETH-ஐத் திரும்பப் பெற `withdraw()` செயல்பாட்டை வெளிப்படுத்துகிறது. திரும்பப் பெறுதலைச் செயலாக்கும் போது, ஒப்பந்தம் பின்வரும் செயல்பாடுகளைச் செய்கிறது: + +1. பயனரின் ETH இருப்பைச் சரிபார்க்கிறது +2. அழைக்கும் முகவரிக்கு நிதியை அனுப்புகிறது +3. பயனரிடமிருந்து கூடுதல் திரும்பப் பெறுவதைத் தடுக்க, அவர்களின் இருப்பை 0 ஆக மீட்டமைக்கிறது + +`Victim` ஒப்பந்தத்தில் உள்ள `withdraw()` செயல்பாடு “சோதனைகள்-செயல்பாடுகள்-விளைவுகள்” பேட்டர்னைப் பின்பற்றுகிறது. இது பரிவர்த்தனையின் _விளைவுகளை_ (அதாவது பயனரின் இருப்பைக் குறைத்தல்) பயன்படுத்துவதற்கு முன்பு, செயல்பாட்டிற்குத் தேவையான நிபந்தனைகள் பூர்த்தி செய்யப்படுகிறதா (அதாவது, பயனருக்கு நேர்மறையான ETH இருப்பு உள்ளது) என்பதைச் _சரிபார்த்து_, அழைப்பாளரின் முகவரிக்கு ETH ஐ அனுப்புவதன் மூலம் _தொடர்பு கொள்கிறது_. + +`withdraw()` வெளிப்புறமாகச் சொந்தமான கணக்கிலிருந்து (EOA) அழைக்கப்பட்டால், செயல்பாடு எதிர்பார்த்தபடி செயல்படும்: `msg.sender.call.value()` ETH-ஐ அழைப்பாளருக்கு அனுப்புகிறது. இருப்பினும், `msg.sender` ஒரு ஸ்மார்ட் ஒப்பந்தக் கணக்காக இருந்து `withdraw()`ஐ அழைத்தால், `msg.sender.call.value()` ஐப் பயன்படுத்தி நிதியை அனுப்புவது அந்த முகவரியில் சேமிக்கப்பட்ட குறியீட்டை இயக்கவும் தூண்டும். + +ஒப்பந்த முகவரியில் பயன்படுத்தப்பட்ட குறியீடு இது என்று கற்பனை செய்து பாருங்கள்: + +```solidity + contract Attacker { + function beginAttack() external payable { + Victim(victim_address).deposit.value(1 ether)(); + Victim(victim_address).withdraw(); + } + + function() external payable { + if (gasleft() > 40000) { + Victim(victim_address).withdraw(); + } + } +} +``` + +இந்த ஒப்பந்தம் மூன்று விஷயங்களைச் செய்ய வடிவமைக்கப்பட்டுள்ளது: + +1. மற்றொரு கணக்கிலிருந்து (தாக்குபவரின் EOA ஆக இருக்கலாம்) ஒரு வைப்புத்தொகையை ஏற்கவும் +2. பாதிக்கப்பட்ட ஒப்பந்தத்தில் 1 ETH ஐ டெபாசிட் செய்யவும் +3. ஸ்மார்ட் ஒப்பந்தத்தில் சேமிக்கப்பட்ட 1 ETH-ஐத் திரும்பப் பெறவும் + +இங்கே எதுவும் தவறில்லை, `msg.sender.call.value` இலிருந்து மீதமுள்ள எரிவாயு 40,000 க்கும் அதிகமாக இருந்தால், `Attacker` `Victim` இல் மீண்டும் `withdraw()` என்று அழைக்கும் மற்றொரு செயல்பாட்டைக் கொண்டிருப்பதைத் தவிர. இது `Attacker` க்கு `Victim` ஐ மீண்டும் உள்ளிட்டு, `withdraw` இன் முதல் அழைப்பு முடிவடைவதற்கு _முன்பு_ அதிக நிதியைத் திரும்பப் பெறும் திறனை அளிக்கிறது. சுழற்சி இதுபோல் தெரிகிறது: + +```solidity +- Attacker's EOA 1 ETH உடன் `Attacker.beginAttack()` ஐ அழைக்கிறது +- `Attacker.beginAttack()` `Victim` இல் 1 ETH ஐ டெபாசிட் செய்கிறது +- `Attacker` `Victim` இல் `withdraw()` ஐ அழைக்கிறது +- `Victim` `Attacker` இன் இருப்பைச் சரிபார்க்கிறது (1 ETH) +- `Victim` `Attacker` க்கு 1 ETH ஐ அனுப்புகிறது (இது இயல்புநிலை செயல்பாட்டைத் தூண்டுகிறது) +- `Attacker` மீண்டும் `Victim.withdraw()` ஐ அழைக்கிறது (முதல் திரும்பப் பெறுதலில் இருந்து `Victim` `Attacker` இன் இருப்பைக் குறைக்கவில்லை என்பதை நினைவில் கொள்ளவும்) +- `Victim` `Attacker` இன் இருப்பைச் சரிபார்க்கிறது (இது இன்னும் 1 ETH ஆகும், ஏனெனில் இது முதல் அழைப்பின் விளைவுகளைப் பயன்படுத்தவில்லை) +- `Victim` `Attacker` க்கு 1 ETH ஐ அனுப்புகிறது (இது இயல்புநிலை செயல்பாட்டைத் தூண்டுகிறது மற்றும் `Attacker` `withdraw` செயல்பாட்டை மீண்டும் உள்ளிட அனுமதிக்கிறது) +- `Attacker` இன் எரிவாயு தீரும் வரை இந்த செயல்முறை மீண்டும் மீண்டும் நிகழ்கிறது, அந்த நேரத்தில் `msg.sender.call.value` கூடுதல் திரும்பப் பெறுதல்களைத் தூண்டாமல் திரும்புகிறது +- `Victim` இறுதியாக முதல் பரிவர்த்தனையின் (மற்றும் அடுத்தடுத்தவற்றின்) முடிவுகளை அதன் நிலைக்குப் பயன்படுத்துகிறது, எனவே `Attacker` இன் இருப்பு 0 ஆக அமைக்கப்படுகிறது +``` + +செயல்பாடு முடிவடையும் வரை அழைப்பவரின் இருப்பு 0 ஆக அமைக்கப்படாததால், அடுத்தடுத்த அழைப்புகள் வெற்றி பெறும் மற்றும் அழைப்பாளர் தங்கள் இருப்பை பலமுறை திரும்பப் பெற அனுமதிக்கும் என்பதே சுருக்கமாகும். [2016 DAO ஹேக்கில்](https://www.coindesk.com/learn/understanding-the-dao-attack) நடந்தது போல, இந்த வகையான தாக்குதல் ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் நிதியை வெளியேற்றப் பயன்படுத்தப்படலாம். [மறு நுழைவு சுரண்டல்களின் பொதுப் பட்டியல்கள்](https://github.com/pcaversaccio/reentrancy-attacks) காட்டுவது போல், மறு நுழைவுத் தாக்குதல்கள் இன்றும் ஸ்மார்ட் ஒப்பந்தங்களுக்கு ஒரு முக்கியமான பிரச்சினையாக உள்ளன. + +##### மறு நுழைவுத் தாக்குதல்களைத் தடுப்பது எப்படி + +மறு நுழைவைக் கையாள்வதற்கான ஒரு அணுகுமுறை [சோதனைகள்-விளைவுகள்-தொடர்புகள் பேட்டர்னைப்](https://docs.soliditylang.org/en/develop/security-considerations.html#use-the-checks-effects-interactions-pattern) பின்பற்றுவதாகும். இந்த பேட்டர்ன், செயல்பாடுகளைச் செயல்படுத்தும் வரிசையை ஒழுங்குபடுத்துகிறது, இதில் செயல்பாட்டைத் தொடர்வதற்கு முன்பு தேவையான சோதனைகளைச் செய்யும் குறியீடு முதலில் வரும், அதைத் தொடர்ந்து ஒப்பந்த நிலையை மாற்றும் குறியீடு, மற்ற ஒப்பந்தங்கள் அல்லது EOAக்களுடன் தொடர்பு கொள்ளும் குறியீடு கடைசியாக வரும். + +சோதனைகள்-விளைவு-தொடர்பு பேட்டர்ன் கீழே காட்டப்பட்டுள்ள `Victim` ஒப்பந்தத்தின் திருத்தப்பட்ட பதிப்பில் பயன்படுத்தப்படுகிறது: + +```solidity +contract NoLongerAVictim { + function withdraw() external { + uint256 amount = balances[msg.sender]; + balances[msg.sender] = 0; + (bool success, ) = msg.sender.call.value(amount)(""); + require(success); + } +} +``` + +இந்த ஒப்பந்தம் பயனரின் இருப்பைச் _சோதனை_ செய்கிறது, `withdraw()` செயல்பாட்டின் _விளைவுகளைப்_ பயன்படுத்துகிறது (பயனரின் இருப்பை 0 ஆக மீட்டமைப்பதன் மூலம்), மற்றும் _தொடர்பு_ கொள்ளத் தொடர்கிறது (பயனரின் முகவரிக்கு ETH ஐ அனுப்புகிறது). வெளிப்புற அழைப்புக்கு முன்பு ஒப்பந்தம் அதன் சேமிப்பகத்தை புதுப்பிப்பதை இது உறுதி செய்கிறது, இது முதல் தாக்குதலைச் சாத்தியமாக்கிய மறு நுழைவு நிலையை நீக்குகிறது. `Attacker` ஒப்பந்தம் இன்னும் `NoLongerAVictim` ஐ மீண்டும் அழைக்கலாம், ஆனால் `balances[msg.sender]` 0 ஆக அமைக்கப்பட்டிருப்பதால், கூடுதல் திரும்பப் பெறுதல்கள் ஒரு பிழையை ஏற்படுத்தும். + +மற்றொரு விருப்பம், ஒரு செயல்பாட்டு அழைப்பு முடியும் வரை ஒரு ஒப்பந்தத்தின் நிலையின் ஒரு பகுதியை பூட்டி வைக்கும் பரஸ்பர விலக்கு பூட்டைப் (பொதுவாக "மியூடெக்ஸ்" என விவரிக்கப்படுகிறது) பயன்படுத்துவதாகும். செயல்பாடு செயல்படுவதற்கு முன்பு `true` ஆக அமைக்கப்பட்டு, அழைப்பு முடிந்ததும் `false` ஆக மாறும் ஒரு பூலியன் மாறியைப் பயன்படுத்தி இது செயல்படுத்தப்படுகிறது. கீழே உள்ள எடுத்துக்காட்டில் காணப்படுவது போல், ஒரு மியூடெக்ஸைப் பயன்படுத்துவது அசல் அழைப்பு இன்னும் செயலாக்கப்படும்போது ஒரு செயல்பாட்டை மறுபிரவேச அழைப்புகளிலிருந்து பாதுகாக்கிறது, இது மறு நுழைவை திறம்பட நிறுத்துகிறது. + +```solidity +pragma solidity ^0.7.0; + +contract MutexPattern { + bool locked = false; + mapping(address => uint256) public balances; + + modifier noReentrancy() { + require(!locked, "மறு நுழைவிலிருந்து தடுக்கப்பட்டது."); + locked = true; + _; + locked = false; + } + // இந்த செயல்பாடு ஒரு மியூடெக்ஸால் பாதுகாக்கப்படுகிறது, எனவே `msg.sender.call` இலிருந்து வரும் மறு நுழைவு அழைப்புகள் மீண்டும் `திரும்பப் பெற` அழைக்க முடியாது. + // `திரும்பப் பெறும்` கூற்று `உண்மை` என மதிப்பிடுகிறது ஆனால் இன்னும் மாற்றியமைப்பில் `பூட்டப்பட்டது = தவறு` என்ற கூற்றை மதிப்பிடுகிறது + function withdraw(uint _amount) public payable noReentrancy returns(bool) { + require(balances[msg.sender] >= _amount, "திரும்பப் பெற இருப்பு இல்லை."); + + balances[msg.sender] -= _amount; + (bool success, ) = msg.sender.call{value: _amount}(""); + require(success); + + return true; + } +} +``` + +கணக்குகளுக்கு நிதியை அனுப்பும் "புஷ் பேமெண்ட்ஸ்" முறைக்கு பதிலாக, ஸ்மார்ட் ஒப்பந்தங்களிலிருந்து பயனர்கள் நிதியைத் திரும்பப் பெற வேண்டிய [புல் பேமெண்ட்ஸ்](https://docs.openzeppelin.com/contracts/5.x/api/security#PullPayment) முறையையும் நீங்கள் பயன்படுத்தலாம். இது அறியப்படாத முகவரிகளில் தற்செயலாகக் குறியீட்டைத் தூண்டும் வாய்ப்பை நீக்குகிறது (மேலும் சில சேவை மறுப்புத் தாக்குதல்களையும் தடுக்கலாம்). + +#### முழு எண் அண்டர்ஃப்ளோஸ் மற்றும் ஓவர்ஃப்ளோஸ் {#integer-underflows-and-overflows} + +ஒரு எண்கணிதச் செயல்பாட்டின் முடிவுகள் ஏற்றுக்கொள்ளக்கூடிய மதிப்புகளின் வரம்பிற்கு வெளியே விழும்போது, ஒரு முழு எண் ஓவர்ஃப்ளோ ஏற்படுகிறது, இதனால் அது மிகக் குறைந்த பிரதிநிதித்துவப்படுத்தக்கூடிய மதிப்புக்கு "ரோல் ஓவர்" ஆகிறது. உதாரணமாக, ஒரு `uint8` 2^8-1=255 வரையிலான மதிப்புகளை மட்டுமே சேமிக்க முடியும். `255` ஐ விட அதிகமான மதிப்புகளுக்கு வழிவகுக்கும் எண்கணித செயல்பாடுகள் ஓவர்ஃப்ளோ ஆகி, `uint` ஐ `0` ஆக மீட்டமைக்கும், இது ஒரு காரின் ஓடோமீட்டர் அதிகபட்ச மைலேஜை (999999) அடைந்தவுடன் 0 ஆக மீட்டமைப்பதைப் போன்றது. + +முழு எண் அண்டர்ஃப்ளோஸ் இதே போன்ற காரணங்களுக்காக நிகழ்கிறது: ஒரு எண்கணித செயல்பாட்டின் முடிவுகள் ஏற்றுக்கொள்ளக்கூடிய வரம்பிற்குக் கீழே விழுகின்றன. நீங்கள் ஒரு `uint8` இல் `0` ஐக் குறைக்க முயன்றால், முடிவு வெறுமனே அதிகபட்ச பிரதிநிதித்துவப்படுத்தக்கூடிய மதிப்புக்கு (`255`) உருளும். + +முழு எண் ஓவர்ஃப்ளோக்கள் மற்றும் அண்டர்ஃப்ளோக்கள் இரண்டும் ஒரு ஒப்பந்தத்தின் நிலை மாறிகளில் எதிர்பாராத மாற்றங்களுக்கு வழிவகுக்கும் மற்றும் திட்டமிடப்படாத செயல்பாட்டிற்கு வழிவகுக்கும். ஒரு தாக்குபவர் செல்லாத செயல்பாட்டைச் செய்ய ஒரு ஸ்மார்ட் ஒப்பந்தத்தில் எண்கணித ஓவர்ஃப்ளோவை எவ்வாறு பயன்படுத்தலாம் என்பதைக் காட்டும் ஒரு எடுத்துக்காட்டு கீழே உள்ளது: + +``` +pragma solidity ^0.7.6; + +// இந்த ஒப்பந்தம் ஒரு நேரப் பெட்டகமாக செயல்பட வடிவமைக்கப்பட்டுள்ளது. +// பயனர் இந்த ஒப்பந்தத்தில் டெபாசிட் செய்யலாம் ஆனால் குறைந்தது ஒரு வாரத்திற்கு திரும்பப் பெற முடியாது. +// பயனர் 1 வார காத்திருப்பு காலத்திற்கு அப்பால் காத்திருப்பு நேரத்தை நீட்டிக்கலாம். + +/* +1. டைம்லாக்கைப் பயன்படுத்தவும் +2. டைம்லாக் முகவரியுடன் தாக்குதலைப் பயன்படுத்தவும் +3. 1 ஈதரை அனுப்பி அட்டாக்.அட்டாக் என்று அழைக்கவும். நீங்கள் உடனடியாக உங்கள் ஈதரைத் +திரும்பப் பெற முடியும். + +என்ன நடந்தது? +தாக்குதல் டைம்லாக்.லாக்டைம் ஓவர்ஃப்ளோ ஆக காரணமாகியது மற்றும் 1 வார காத்திருப்பு காலத்திற்கு முன்பு +திரும்பப் பெற முடிந்தது. +*/ + +contract TimeLock { + mapping(address => uint) public balances; + mapping(address => uint) public lockTime; + + function deposit() external payable { + balances[msg.sender] += msg.value; + lockTime[msg.sender] = block.timestamp + 1 weeks; + } + + function increaseLockTime(uint _secondsToIncrease) public { + lockTime[msg.sender] += _secondsToIncrease; + } + + function withdraw() public { + require(balances[msg.sender] > 0, "போதிய நிதி இல்லை"); + require(block.timestamp > lockTime[msg.sender], "பூட்டு நேரம் காலாவதியாகவில்லை"); + + uint amount = balances[msg.sender]; + balances[msg.sender] = 0; + + (bool sent, ) = msg.sender.call{value: amount}(""); + require(sent, "ஈதரை அனுப்பத் தவறிவிட்டது"); + } +} + +contract Attack { + TimeLock timeLock; + + constructor(TimeLock _timeLock) { + timeLock = TimeLock(_timeLock); + } + + fallback() external payable {} + + function attack() public payable { + timeLock.deposit{value: msg.value}(); + /* + if t = தற்போதைய பூட்டு நேரம் என்றால், நாம் x + t = 2**256 = 0 என்று ஒரு x ஐக் கண்டுபிடிக்க வேண்டும் + எனவே x = -t + 2**256 = வகை(uint).max + 1 + எனவே x = வகை(uint).max + 1 - t + */ + timeLock.increaseLockTime( + type(uint).max + 1 - timeLock.lockTime(address(this)) + ); + timeLock.withdraw(); + } +} +``` + +##### முழு எண் அண்டர்ஃப்ளோஸ் மற்றும் ஓவர்ஃப்ளோக்களைத் தடுப்பது எப்படி + +பதிப்பு 0.8.0 முதல், Solidity தொகுப்பி முழு எண் அண்டர்ஃப்ளோஸ் மற்றும் ஓவர்ஃப்ளோக்களுக்கு வழிவகுக்கும் குறியீட்டை நிராகரிக்கிறது. இருப்பினும், குறைந்த தொகுப்பி பதிப்புடன் தொகுக்கப்பட்ட ஒப்பந்தங்கள் எண்கணித செயல்பாடுகளை உள்ளடக்கிய செயல்பாடுகளில் சோதனைகளைச் செய்ய வேண்டும் அல்லது அண்டர்ஃப்ளோ/ஓவர்ஃப்ளோவைச் சரிபார்க்கும் ஒரு நூலகத்தைப் (எ.கா., [SafeMath](https://docs.openzeppelin.com/contracts/2.x/api/math)) பயன்படுத்த வேண்டும். + +#### ஆரக்கிள் கையாளுதல் {#oracle-manipulation} + +[ஆரக்கிள்கள்](/developers/docs/oracles/) ஆஃப்செயின் தகவலைப் பெற்று, ஸ்மார்ட் ஒப்பந்தங்கள் பயன்படுத்த ஆன்செயினில் அனுப்புகின்றன. ஆரக்கிள்களுடன், மூலதனச் சந்தைகள் போன்ற ஆஃப்செயின் அமைப்புகளுடன் இயங்கக்கூடிய ஸ்மார்ட் ஒப்பந்தங்களை நீங்கள் வடிவமைக்கலாம், இது அவற்றின் பயன்பாட்டை பெரிதும் விரிவுபடுத்துகிறது. + +ஆனால் ஆரக்கிள் சிதைந்து, தவறான தகவலை ஆன்செயினில் அனுப்பினால், ஸ்மார்ட் ஒப்பந்தங்கள் தவறான உள்ளீடுகளின் அடிப்படையில் செயல்படும், இது சிக்கல்களை ஏற்படுத்தும். இது “ஆரக்கிள் சிக்கலின்” அடிப்படையாகும், இது ஒரு பிளாக்செயின் ஆரக்கிளிலிருந்து வரும் தகவல் துல்லியமானது, புதுப்பித்தப்பட்டது மற்றும் சரியான நேரத்தில் இருப்பதை உறுதி செய்யும் பணியைப் பற்றியது. + +ஒரு சொத்தின் உடனடி விலையைப் பெற, பரவலாக்கப்பட்ட பரிமாற்றம் போன்ற ஒரு ஆன்செயின் ஆரக்கிளைப் பயன்படுத்துவது தொடர்பான பாதுகாப்புக் கவலையாகும். [பரவலாக்கப்பட்ட நிதி (DeFi)](/defi/) துறையில் கடன் வழங்கும் தளங்கள், ஒரு பயனர் எவ்வளவு கடன் வாங்க முடியும் என்பதைத் தீர்மானிக்க, அவர்களின் பிணையத்தின் மதிப்பைத் தீர்மானிக்க இதை அடிக்கடி செய்கின்றன. + +DEX விலைகள் பெரும்பாலும் துல்லியமானவை, பெரும்பாலும் சந்தைகளில் சமநிலையை மீட்டெடுக்கும் நடுவர்களால். இருப்பினும், அவை கையாளுதலுக்குத் திறந்தவை, குறிப்பாக ஆன்செயின் ஆரக்கிள் வரலாற்று வர்த்தக முறைகளின் அடிப்படையில் சொத்து விலைகளைக் கணக்கிட்டால் (வழக்கமாக இதுவே நடக்கும்). + +உதாரணமாக, ஒரு தாக்குபவர் உங்கள் கடன் ஒப்பந்தத்துடன் தொடர்பு கொள்வதற்கு முன்பு, ஒரு ஃபிளாஷ் கடனை எடுத்து ஒரு சொத்தின் உடனடி விலையை செயற்கையாக உயர்த்தலாம். சொத்தின் விலைக்காக DEX-ஐ வினவினால், இயல்பை விட அதிகமான மதிப்பு திரும்பும் (தாக்குபவரின் பெரிய “வாங்க ஆணை” சொத்தின் தேவையைத் திசைதிருப்புவதால்), இது அவர்கள் வாங்க வேண்டியதை விட அதிகமாகக் கடன் வாங்க அனுமதிக்கிறது. இத்தகைய "ஃபிளாஷ் கடன் தாக்குதல்கள்" DeFi பயன்பாடுகளில் விலை ஆரக்கிள்கள் மீதான சார்புநிலையைச் சுரண்டப் பயன்படுத்தப்பட்டுள்ளன, இது நெறிமுறைகளுக்கு மில்லியன் கணக்கான நிதியை இழக்கச் செய்துள்ளது. + +##### ஆரக்கிள் கையாளுதலைத் தடுப்பது எப்படி + +[ஆரக்கிள் கையாளுதலைத் தவிர்க்க](https://www.cyfrin.io/blog/price-oracle-manipultion-attacks-with-examples) குறைந்தபட்சத் தேவை, பல மூலங்களிலிருந்து தகவல்களை வினவும் ஒரு பரவலாக்கப்பட்ட ஆரக்கிள் நெட்வொர்க்கைப் பயன்படுத்துவதாகும், இது தோல்வியின் ஒற்றைப் புள்ளிகளைத் தவிர்க்கும். பெரும்பாலான சந்தர்ப்பங்களில், பரவலாக்கப்பட்ட ஆரக்கிள்கள் சரியான தகவலைப் புகாரளிக்க ஆரக்கிள் முனைகளை ஊக்குவிக்க உள்ளமைக்கப்பட்ட கிரிப்டோகனாமிக் ஊக்கத்தொகைகளைக் கொண்டுள்ளன, இது அவற்றை மையப்படுத்தப்பட்ட ஆரக்கிள்களை விடப் பாதுகாப்பானதாக ஆக்குகிறது. + +சொத்து விலைகளுக்காக ஒரு ஆன்செயின் ஆரக்கிளை வினவ நீங்கள் திட்டமிட்டால், நேர-எடையிடப்பட்ட சராசரி விலை (TWAP) பொறிமுறையைச் செயல்படுத்தும் ஒன்றைப் பயன்படுத்துவதைக் கவனியுங்கள். ஒரு [TWAP ஆரக்கிள்](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/oracles) ஒரு சொத்தின் விலையை இரண்டு வெவ்வேறு நேரங்களில் (நீங்கள் மாற்றியமைக்கலாம்) வினவி, பெறப்பட்ட சராசரியின் அடிப்படையில் உடனடி விலையைக் கணக்கிடுகிறது. நீண்ட காலத்தைத் தேர்ந்தெடுப்பது உங்கள் நெறிமுறையைப் விலை கையாளுதலுக்கு எதிராகப் பாதுகாக்கிறது, ஏனெனில் சமீபத்தில் செயல்படுத்தப்பட்ட பெரிய ஆர்டர்கள் சொத்து விலைகளைப் பாதிக்காது. + +## உருவாக்குநர்களுக்கான ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பு வளங்கள் {#smart-contract-security-resources-for-developers} + +### ஸ்மார்ட் ஒப்பந்தங்களை ஆய்வு செய்வதற்கும் குறியீடு சரியானது என்பதைச் சரிபார்ப்பதற்கும் கருவிகள் {#code-analysis-tools} + +- **[சோதனைக் கருவிகள் மற்றும் நூலகங்கள்](/developers/docs/smart-contracts/testing/#testing-tools-and-libraries)** - _ஸ்மார்ட் ஒப்பந்தங்களில் யூனிட் சோதனைகள், நிலையான பகுப்பாய்வு மற்றும் மாறும் பகுப்பாய்வு ஆகியவற்றைச் செய்வதற்கான தொழில்-தரமான கருவிகள் மற்றும் நூலகங்களின் தொகுப்பு._ + +- **[முறையான சரிபார்ப்புக் கருவிகள்](/developers/docs/smart-contracts/formal-verification/#formal-verification-tools)** - _ஸ்மார்ட் ஒப்பந்தங்களில் செயல்பாட்டுச் சரியானது என்பதைச் சரிபார்ப்பதற்கும் மாறாநிலைகளைச் சரிபார்ப்பதற்கும் கருவிகள்._ + +- **[ஸ்மார்ட் ஒப்பந்தத் தணிக்கை சேவைகள்](/developers/docs/smart-contracts/testing/#smart-contract-auditing-services)** - _எத்தேரியம் மேம்பாட்டுத் திட்டங்களுக்கு ஸ்மார்ட் ஒப்பந்தத் தணிக்கை சேவைகளை வழங்கும் நிறுவனங்களின் பட்டியல்._ + +- **[பிழை சன்மான தளங்கள்](/developers/docs/smart-contracts/testing/#bug-bounty-platforms)** - _பிழை சன்மானங்களை ஒருங்கிணைப்பதற்கும் ஸ்மார்ட் ஒப்பந்தங்களில் முக்கியமான பாதிப்புகளைப் பொறுப்புடன் வெளிப்படுத்துவதற்கும் வெகுமதி அளிப்பதற்கான தளங்கள்._ + +- **[Fork Checker](https://forkchecker.hashex.org/)** - _ஒரு ஃபோர்க் செய்யப்பட்ட ஒப்பந்தம் தொடர்பான அனைத்து தகவல்களையும் சரிபார்க்க ஒரு இலவச ஆன்லைன் கருவி._ + +- **[ABI Encoder](https://abi.hashex.org/)** - _உங்கள் Solidity ஒப்பந்தச் செயல்பாடுகள் மற்றும் கட்டமைப்பாளர் வாதங்களை குறியாக்கம் செய்வதற்கான ஒரு இலவச ஆன்லைன் சேவை._ + +- **[Aderyn](https://github.com/Cyfrin/aderyn)** - _Solidity நிலையான பகுப்பாய்வி, சுருக்க தொடரியல் மரங்களை (AST) கடந்து சந்தேகத்திற்கிடமான பாதிப்புகளைக் கண்டறிந்து, எளிதில் நுகரக்கூடிய மார்க் டவுன் வடிவத்தில் சிக்கல்களை அச்சிடுகிறது._ + +### ஸ்மார்ட் ஒப்பந்தங்களைக் கண்காணிப்பதற்கான கருவிகள் {#smart-contract-monitoring-tools} + +- **[Tenderly Real-Time Alerting](https://tenderly.co/monitoring)** - _உங்கள் ஸ்மார்ட் ஒப்பந்தங்கள் அல்லது பணப்பைகளில் அசாதாரணமான அல்லது எதிர்பாராத நிகழ்வுகள் நடக்கும்போது நிகழ்நேர அறிவிப்புகளைப் பெறுவதற்கான ஒரு கருவி._ + +### ஸ்மார்ட் ஒப்பந்தங்களின் பாதுகாப்பான நிர்வாகத்திற்கான கருவிகள் {#smart-contract-administration-tools} + +- **[Safe](https://safe.global/)** - _எத்தேரியத்தில் இயங்கும் ஸ்மார்ட் ஒப்பந்த பணப்பை, ஒரு பரிவர்த்தனை நடைபெறுவதற்கு முன்பு குறைந்தபட்சம் ஒரு குறிப்பிட்ட எண்ணிக்கையிலான நபர்கள் ஒப்புதல் அளிக்க வேண்டும் (M-of-N)._ + +- **[OpenZeppelin ஒப்பந்தங்கள்](https://docs.openzeppelin.com/contracts/5.x/)** - _ஒப்பந்த உரிமம், மேம்படுத்தல்கள், அணுகல் கட்டுப்பாடுகள், ஆளுகை, இடைநிறுத்தம் மற்றும் பலவற்றை உள்ளடக்கிய நிர்வாக அம்சங்களைச் செயல்படுத்துவதற்கான ஒப்பந்த நூலகங்கள்._ + +### ஸ்மார்ட் ஒப்பந்தத் தணிக்கை சேவைகள் {#smart-contract-auditing-services} + +- **[ConsenSys Diligence](https://diligence.consensys.io/)** - _ஸ்மார்ட் ஒப்பந்தத் தணிக்கை சேவை, பிளாக்செயின் சுற்றுச்சூழல் அமைப்பு முழுவதும் உள்ள திட்டங்களுக்கு அவற்றின் நெறிமுறைகள் வெளியீட்டிற்குத் தயாராக இருப்பதையும், பயனர்களைப் பாதுகாப்பதற்காக உருவாக்கப்பட்டிருப்பதையும் உறுதிப்படுத்த உதவுகிறது._ + +- **[CertiK](https://www.certik.com/)** - _ஸ்மார்ட் ஒப்பந்தங்கள் மற்றும் பிளாக்செயின் நெட்வொர்க்குகளில் அதிநவீன முறையான சரிபார்ப்புத் தொழில்நுட்பத்தைப் பயன்படுத்துவதில் முன்னோடியாக இருக்கும் பிளாக்செயின் பாதுகாப்பு நிறுவனம்._ + +- **[Trail of Bits](https://www.trailofbits.com/)** - _சைபர் பாதுகாப்பு நிறுவனம், இடரைக் குறைப்பதற்கும் குறியீட்டை வலுப்படுத்துவதற்கும் தாக்குபவர் மனநிலையுடன் பாதுகாப்பு ஆராய்ச்சியை இணைக்கிறது._ + +- **[PeckShield](https://peckshield.com/)** - _முழு பிளாக்செயின் சுற்றுச்சூழல் அமைப்பின் பாதுகாப்பு, தனியுரிமை மற்றும் பயன்பாட்டிற்கான தயாரிப்புகள் மற்றும் சேவைகளை வழங்கும் பிளாக்செயின் பாதுகாப்பு நிறுவனம்._ + +- **[QuantStamp](https://quantstamp.com/)** - _பாதுகாப்பு மற்றும் இடர் மதிப்பீட்டுச் சேவைகள் மூலம் பிளாக்செயின் தொழில்நுட்பத்தின் பிரதான தத்தெடுப்பை எளிதாக்கும் தணிக்கை சேவை._ + +- **[OpenZeppelin](https://www.openzeppelin.com/security-audits)** - _பரவலாக்கப்பட்ட அமைப்புகளுக்கு பாதுகாப்புத் தணிக்கைகளை வழங்கும் ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பு நிறுவனம்._ + +- **[Runtime Verification](https://runtimeverification.com/)** - _ஸ்மார்ட் ஒப்பந்தங்களின் முறையான மாடலிங் மற்றும் சரிபார்ப்பில் நிபுணத்துவம் பெற்ற பாதுகாப்பு நிறுவனம்._ + +- **[Hacken](https://hacken.io)** - _Web3 சைபர் பாதுகாப்பு தணிக்கையாளர், பிளாக்செயின் பாதுகாப்பிற்கு 360-டிகிரி அணுகுமுறையைக் கொண்டு வருகிறார்._ + +- **[Nethermind](https://www.nethermind.io/smart-contract-audits)** - _Solidity மற்றும் Cairo தணிக்கை சேவைகள், எத்தேரியம் மற்றும் ஸ்டார்க்நெட்டில் ஸ்மார்ட் ஒப்பந்தங்களின் ஒருமைப்பாட்டையும் பயனர்களின் பாதுகாப்பையும் உறுதி செய்கின்றன._ + +- **[HashEx](https://hashex.org/)** - _HashEx பிளாக்செயின் மற்றும் ஸ்மார்ட் ஒப்பந்தத் தணிக்கையில் கவனம் செலுத்துகிறது, இது கிரிப்டோகரன்சிகளின் பாதுகாப்பை உறுதி செய்கிறது, ஸ்மார்ட் ஒப்பந்த மேம்பாடு, ஊடுருவல் சோதனை, பிளாக்செயின் ஆலோசனை போன்ற சேவைகளை வழங்குகிறது._ + +- **[Code4rena](https://code4rena.com/)** - _போட்டித் தணிக்கைத் தளம், ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பு வல்லுநர்களை பாதிப்புகளைக் கண்டறியவும், web3 ஐ மிகவும் பாதுகாப்பானதாக மாற்றவும் ஊக்குவிக்கிறது._ + +- **[CodeHawks](https://codehawks.com/)** - _போட்டித் தணிக்கைத் தளம், பாதுகாப்பு ஆராய்ச்சியாளர்களுக்கான ஸ்மார்ட் ஒப்பந்தத் தணிக்கைப் போட்டிகளை நடத்துகிறது._ + +- **[Cyfrin](https://cyfrin.io)** - _Web3 பாதுகாப்பு சக்தி மையம், தயாரிப்புகள் மற்றும் ஸ்மார்ட் ஒப்பந்தத் தணிக்கை சேவைகள் மூலம் கிரிப்டோ பாதுகாப்பை வளர்க்கிறது._ + +- **[ImmuneBytes](https://immunebytes.com/smart-contract-audit/)** - _அனுபவம் வாய்ந்த தணிக்கையாளர்கள் மற்றும் சிறந்த கருவிகளின் குழு மூலம் பிளாக்செயின் அமைப்புகளுக்கு பாதுகாப்புத் தணிக்கைகளை வழங்கும் Web3 பாதுகாப்பு நிறுவனம்._ + +- **[Oxorio](https://oxor.io/)** - _கிரிப்டோ நிறுவனங்கள் மற்றும் DeFi திட்டங்களுக்கான EVM, Solidity, ZK, கிராஸ்-செயின் தொழில்நுட்பத்தில் நிபுணத்துவத்துடன் ஸ்மார்ட் ஒப்பந்தத் தணிக்கைகள் மற்றும் பிளாக்செயின் பாதுகாப்புச் சேவைகள்._ + +- **[Inference](https://inference.ag/)** - _பாதுகாப்புத் தணிக்கை நிறுவனம், EVM-அடிப்படையிலான பிளாக்செயின்களுக்கான ஸ்மார்ட் ஒப்பந்தத் தணிக்கையில் நிபுணத்துவம் பெற்றது. அதன் நிபுணர் தணிக்கையாளர்களுக்கு நன்றி, அவர்கள் சாத்தியமான சிக்கல்களைக் கண்டறிந்து, வரிசைப்படுத்துவதற்கு முன்பு அவற்றைச் சரிசெய்யச் செயல்படக்கூடிய தீர்வுகளைப் பரிந்துரைக்கின்றனர். + +### பிழை சன்மான தளங்கள் {#bug-bounty-platforms} + +- **[Immunefi](https://immunefi.com/)** - _ஸ்மார்ட் ஒப்பந்தங்கள் மற்றும் DeFi திட்டங்களுக்கான பிழை சன்மானத் தளம், அங்கு பாதுகாப்பு ஆராய்ச்சியாளர்கள் குறியீட்டை மதிப்பாய்வு செய்கிறார்கள், பாதிப்புகளை வெளிப்படுத்துகிறார்கள், பணம் பெறுகிறார்கள், மற்றும் கிரிப்டோவை பாதுகாப்பானதாக மாற்றுகிறார்கள்._ + +- **[HackerOne](https://www.hackerone.com/)** - _வணிகங்களை ஊடுருவல் சோதனையாளர்கள் மற்றும் சைபர் பாதுகாப்பு ஆராய்ச்சியாளர்களுடன் இணைக்கும் பாதிப்பு ஒருங்கிணைப்பு மற்றும் பிழை சன்மானத் தளம்._ + +- **[HackenProof](https://hackenproof.com/)** - _கிரிப்டோ திட்டங்களுக்கான (DeFi, ஸ்மார்ட் ஒப்பந்தங்கள், பணப்பைகள், CEX மற்றும் பல) நிபுணர் பிழை சன்மானத் தளம், அங்கு பாதுகாப்பு வல்லுநர்கள் சோதனை சேவைகளை வழங்குகிறார்கள் மற்றும் ஆராய்ச்சியாளர்கள் தொடர்புடைய, சரிபார்க்கப்பட்ட பிழை அறிக்கைகளுக்குப் பணம் பெறுகிறார்கள்._ + +- **[Sherlock](https://www.sherlock.xyz/)** - _Web3 இல் ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பிற்கான காப்பீட்டாளர், தணிக்கையாளர்களுக்கான கொடுப்பனவுகள் ஸ்மார்ட் ஒப்பந்தங்கள் மூலம் நிர்வகிக்கப்படுகின்றன, இது தொடர்புடைய பிழைகள் நியாயமாகச் செலுத்தப்படுவதைப் பாதுகாக்கிறது._ + +- **[CodeHawks](https://www.codehawks.com/)** - _போட்டி பிழை சன்மான தளம், தணிக்கையாளர்கள் பாதுகாப்புப் போட்டிகள் மற்றும் சவால்களில் பங்கேற்கிறார்கள், மற்றும் (விரைவில்) தங்கள் சொந்த தனியார் தணிக்கைகளிலும்._ + +### அறியப்பட்ட ஸ்மார்ட் ஒப்பந்த பாதிப்புகள் மற்றும் சுரண்டல்களின் வெளியீடுகள் {#common-smart-contract-vulnerabilities-and-exploits} + +- **[ConsenSys: ஸ்மார்ட் ஒப்பந்த அறியப்பட்ட தாக்குதல்கள்](https://consensysdiligence.github.io/smart-contract-best-practices/attacks/)** - _மிகவும் குறிப்பிடத்தக்க ஒப்பந்தப் பாதிப்புகளின் தொடக்கநிலை-நட்பு விளக்கம், பெரும்பாலான சந்தர்ப்பங்களில் மாதிரி குறியீட்டுடன்._ + +- **[SWC Registry](https://swcregistry.io/)** - _எத்தேரியம் ஸ்மார்ட் ஒப்பந்தங்களுக்குப் பொருந்தும் பொதுவான பலவீனம் கணக்கெடுப்பு (CWE) உருப்படிகளின் தொகுக்கப்பட்ட பட்டியல்._ + +- **[Rekt](https://rekt.news/)** - _உயர்மட்ட கிரிப்டோ ஹேக்குகள் மற்றும் சுரண்டல்களின் வழக்கமாகப் புதுப்பிக்கப்பட்ட வெளியீடு, விரிவான பிந்தைய மரண அறிக்கைகளுடன்._ + +### ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பைக் கற்றுக்கொள்வதற்கான சவால்கள் {#challenges-for-learning-smart-contract-security} + +- **[Awesome BlockSec CTF](https://github.com/blockthreat/blocksec-ctfs)** - _பிளாக்செயின் பாதுகாப்பு போர்வைகள், சவால்கள் மற்றும் [Capture The Flag](https://www.webopedia.com/definitions/ctf-event/amp/) போட்டிகள் மற்றும் தீர்வு எழுத்துக்களின் தொகுக்கப்பட்ட பட்டியல்._ + +- **[Damn Vulnerable DeFi](https://www.damnvulnerabledefi.xyz/)** - _DeFi ஸ்மார்ட் ஒப்பந்தங்களின் தாக்குதல் பாதுகாப்பைக் கற்றுக்கொள்வதற்கும், பிழை-வேட்டை மற்றும் பாதுகாப்புத் தணிக்கையில் திறன்களை வளர்ப்பதற்கும் போர்க்களம்._ + +- **[Ethernaut](https://ethernaut.openzeppelin.com/)** - _Web3/Solidity-அடிப்படையிலான போர்க்களம், ஒவ்வொரு நிலையும் 'ஹேக்' செய்யப்பட வேண்டிய ஒரு ஸ்மார்ட் ஒப்பந்தமாகும்._ + +- **[HackenProof x HackTheBox](https://app.hackthebox.com/tracks/HackenProof-Track)** - _ஸ்மார்ட் ஒப்பந்த ஹேக்கிங் சவால், ஒரு கற்பனை சாகசத்தில் அமைக்கப்பட்டது. சவாலை வெற்றிகரமாக முடிப்பது ஒரு தனியார் பிழை சன்மானத் திட்டத்திற்கான அணுகலையும் வழங்குகிறது. + +### ஸ்மார்ட் ஒப்பந்தங்களைப் பாதுகாப்பதற்கான சிறந்த நடைமுறைகள் {#smart-contract-security-best-practices} + +- **[ConsenSys: எத்தேரியம் ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பு சிறந்த நடைமுறைகள்](https://consensys.github.io/smart-contract-best-practices/)** - _எத்தேரியம் ஸ்மார்ட் ஒப்பந்தங்களைப் பாதுகாப்பதற்கான வழிகாட்டுதல்களின் விரிவான பட்டியல்._ + +- **[Nascent: எளிய பாதுகாப்பு கருவித்தொகுப்பு](https://github.com/nascentxyz/simple-security-toolkit)** - _ஸ்மார்ட் ஒப்பந்த மேம்பாட்டிற்கான நடைமுறை பாதுகாப்பு-கவனம் செலுத்தும் வழிகாட்டிகள் மற்றும் சரிபார்ப்புப் பட்டியல்களின் தொகுப்பு._ + +- **[Solidity Patterns](https://fravoll.github.io/solidity-patterns/)** - _ஸ்மார்ட் ஒப்பந்த நிரலாக்க மொழி Solidity க்கான பாதுகாப்பான பேட்டர்ன்கள் மற்றும் சிறந்த நடைமுறைகளின் பயனுள்ள தொகுப்பு._ + +- **[Solidity Docs: பாதுகாப்புக் கருத்தாய்வுகள்](https://docs.soliditylang.org/en/v0.8.16/security-considerations.html)** - _Solidity உடன் பாதுகாப்பான ஸ்மார்ட் ஒப்பந்தங்களை எழுதுவதற்கான வழிகாட்டுதல்கள்._ + +- **[ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பு சரிபார்ப்புத் தரம்](https://github.com/securing/SCSVS)** - _உருவாக்குநர்கள், கட்டிடக் கலைஞர்கள், பாதுகாப்பு மதிப்பாய்வாளர்கள் மற்றும் விற்பனையாளர்களுக்கான ஸ்மார்ட் ஒப்பந்தங்களின் பாதுகாப்பைத் தரப்படுத்துவதற்காக உருவாக்கப்பட்ட பதினான்கு-பகுதி சரிபார்ப்புப் பட்டியல்._ + +- **[ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பு மற்றும் தணிக்கையைக் கற்றுக்கொள்ளுங்கள்](https://updraft.cyfrin.io/courses/security)** - _இறுதி ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பு மற்றும் தணிக்கை பாடநெறி, தங்கள் பாதுகாப்பு சிறந்த நடைமுறைகளை மேம்படுத்த மற்றும் பாதுகாப்பு ஆராய்ச்சியாளர்களாக மாற விரும்பும் ஸ்மார்ட் ஒப்பந்த உருவாக்குநர்களுக்காக உருவாக்கப்பட்டது._ + +### ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பு குறித்த பயிற்சிகள் {#tutorials-on-smart-contract-security} + +- [பாதுகாப்பான ஸ்மார்ட் ஒப்பந்தங்களை எழுதுவது எப்படி](/developers/tutorials/secure-development-workflow/) + +- [ஸ்மார்ட் ஒப்பந்தப் பிழைகளைக் கண்டறிய Slither ஐ எவ்வாறு பயன்படுத்துவது](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/) + +- [ஸ்மார்ட் ஒப்பந்தப் பிழைகளைக் கண்டறிய Manticore ஐ எவ்வாறு பயன்படுத்துவது](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/) + +- [ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பு வழிகாட்டுதல்கள்](/developers/tutorials/smart-contract-security-guidelines/) + +- [உங்கள் டோக்கன் ஒப்பந்தத்தை தன்னிச்சையான டோக்கன்களுடன் பாதுகாப்பாக ஒருங்கிணைப்பது எப்படி](/developers/tutorials/token-integration-checklist/) + +- [Cyfrin Updraft - ஸ்மார்ட் ஒப்பந்தங்கள் பாதுகாப்பு மற்றும் தணிக்கை முழு பாடநெறி](https://updraft.cyfrin.io/courses/security) diff --git a/public/content/translations/ta/developers/docs/smart-contracts/testing/index.md b/public/content/translations/ta/developers/docs/smart-contracts/testing/index.md new file mode 100644 index 00000000000..af99f4966cb --- /dev/null +++ b/public/content/translations/ta/developers/docs/smart-contracts/testing/index.md @@ -0,0 +1,310 @@ +--- +title: "ஸ்மார்ட் ஒப்பந்தங்களை சோதித்தல்" +description: "எத்தேரியம் ஸ்மார்ட் ஒப்பந்தங்களை சோதிப்பதற்கான நுட்பங்கள் மற்றும் பரிசீலனைகளின் கண்ணோட்டம்." +lang: ta +--- + +பொது பிளாக்செயின்கள் மாதிரியான எதீரியம் இராதிகையாய் இருப்பதால், ஸ்மார்ட் கான்ட்ராக்ட்குறியீட்டைப் பாதுகாப்புு பிறகு மாற்றுவது கடினமாகிவிடுகிறது. [ஒப்பந்த மேம்படுத்தல் வடிவங்கள்](/developers/docs/smart-contracts/upgrading/) "மெய்நிகர் மேம்படுத்தல்களை" செய்ய உள்ளன, ஆனால் இவற்றைச் செயல்படுத்துவது கடினம் மற்றும் சமூக ஒருமித்த கருத்து தேவைப்படுகிறது. மேலும், ஒரு பிழை கண்டுபிடிக்கப்பட்ட பின்னரே ஒரு மேம்படுத்தல் அதை சரிசெய்ய முடியும்—ஒரு தாக்குபவர் முதலில் பாதிப்பைக் கண்டறிந்தால், உங்கள் ஸ்மார்ட் ஒப்பந்தம் சுரண்டப்படும் அபாயத்தில் உள்ளது. + +இந்த காரணங்களுக்காக, Mainnet-இல் [பகிர்தல்](/developers/docs/smart-contracts/deploying/) செய்வதற்கு முன் ஸ்மார்ட் ஒப்பந்தங்களைச் சோதிப்பது [பாதுகாப்பிற்கான](/developers/docs/smart-contracts/security/) குறைந்தபட்சத் தேவையாகும். கான்ட்ராக்ட் சோதனை மற்றும் குறியீட்டு சரியான செயல்பாட்டை மதிப்பீடு செய்யப் பல முறைகள் உள்ளன; நீங்கள் தேர்வு செய்யும் முறை உங்கள் தேவைகளைப் பொறுத்தது. எதுவாயினும், பல்வேறு கருவிகள் மற்றும் அணுகுமுறைகளை உள்ளடக்கிய சோதனை தொகுப்பு, குறியீட்டில் சிறிய மற்றும் பெரிய பாதுகாப்பு குறைபாடுகளைப் பிடிக்கச் சிறந்ததாக இருக்கும். + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +இந்தப் பக்கம் எதீரியம் நெட்வொர்க்கில் தயாரிக்கையா முன்பு ஸ்மார்ட் கான்ட்ராக்ட்களை எப்படி சோதிக்க வேண்டும் என்பதை விளக்குகிறது. நீங்கள் [ஸ்மார்ட் ஒப்பந்தங்களுடன்](/developers/docs/smart-contracts/) பரிச்சயமானவர் என்று இது கருதுகிறது. + +## ஸ்மார்ட் கான்ட்ராக்ட் சோதனை என்ன? ஸ்மார்ட் ஒப்பந்த சோதனை என்றால் என்ன? {#what-is-smart-contract-testing} + +ஸ்மார்ட் கான்ட்ராக்ட் சோதனை என்பது ஒரு ஸ்மார்ட் கான்ட்ராக்ட் குறியீட்டு எதிர்பார்த்தப்படி செயல்படுமா என்பதை சோதனை செய்யும் செயல்முறை ஆகும். சோதனை ஒரு குறிப்பிட்ட ஸ்மார்ட் கான்ட்ராக்ட் நம்பகத்தன்மை, பயன்பாடு மற்றும் பாதுகாப்பு தேவைகளைப் பூர்த்தி செய்கின்றதா என்பதை சரிபார்க்க உதவுகிறது. + +போன்ற முறைகள் மாறுபடும், பெரும்பாலான சோதனை முறைகள் ஒரு ஸ்மார்ட் கான்ட்ராக்ட் குறியீட்டை எதிர்பார்க்கப்படும் தரவுப் பகுதியுடன் செயல்படுத்த தேவையாகிறது. கான்ட்ராக்ட் மாதிரியான தரவுகளுக்குச் சரியான முடிவுகளை வழங்கினால், இது சரியான முறையில் செயல்படுகிறது என்று எண்ணப்படுகிறது. பெரும்பாலான சோதனை கருவிகள், ஒரு ஒப்பந்தத்தின் செயலாக்கம் எதிர்பார்க்கப்படும் முடிவுகளுடன் பொருந்துகிறதா என்பதைச் சரிபார்க்க [சோதனை நிகழ்வுகளை](https://en.m.wikipedia.org/wiki/Test_case) எழுதுவதற்கும் செயல்படுத்துவதற்கும் ஆதாரங்களை வழங்குகின்றன. + +### ஸ்மார்ட் கான்ட்ராக்ட்களை சோதிப்பதேன் முக்கியம்? ஸ்மார்ட் ஒப்பந்தங்களை சோதிப்பதன் முக்கியத்துவம் {#importance-of-testing-smart-contracts} + +ஸ்மார்ட் ஒப்பந்தங்கள் பெரும்பாலும் அதிக மதிப்புள்ள நிதிச் சொத்துக்களை நிர்வகிப்பதால், சிறிய நிரலாக்கப் பிழைகள் [பயனர்களுக்கு பெரும் இழப்புகளுக்கு](https://rekt.news/leaderboard/) வழிவகுக்கலாம் மற்றும் வழிவகுக்கின்றன. ஆனால், கடுமையான சோதனை ஒரு ஸ்மார்ட் கான்ட்ராக்ட் குறியீட்டில் உள்ள குறைகள் மற்றும் சிக்கல்களை எளிதில் கண்டுபிடிக்க உதவுகிறது, மேலும் மெயின்நெட்ஜ் அறிமுகத்திற்கு முன்பு அவற்றைச் சரிசெய்வதற்கு வாய்ப்பளிக்கிறது. + +ஒரு பிழை கண்டுபிடிக்கப்பட்டால் ஒரு ஒப்பந்தத்தை மேம்படுத்துவது சாத்தியம் என்றாலும், மேம்படுத்தல்கள் சிக்கலானவை மற்றும் தவறாகக் கையாளப்பட்டால் [பிழைகளுக்கு வழிவகுக்கும்](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/). கான்ட்ராக்ட்டை மேம்படுத்துவது இராதிகை கோட்பாட்டை மீறுவதுடன், பயனாளர்களுக்குக் கூடுதல் நம்பிக்கை பாரங்களை ஏற்படுத்துகிறது. அதற்குப் பதிலாக, ஸ்மார்ட் கான்ட்ராக்ட்களின் பாதுகாப்பு சிக்கல்களைக் குறைப்பதற்கும், வழங்கப்பட்ட பிறகு சிக்கலான தர்க்க மேம்பாடுகளை மேற்கொள்ளத் தேவையைக் குறைப்பதற்கும், உங்கள் கான்ட்ராக்ட்டை சோதனை செய்யும் முழுமையான திட்டம் முக்கியம். + +## ஸ்மார்ட் ஒப்பந்தங்களைச் சோதிப்பதற்கான முறைகள் {#methods-for-testing-smart-contracts} + +எத்தேரியம் ஸ்மார்ட் ஒப்பந்தங்களைச் சோதிப்பதற்கான முறைகள் இரண்டு பரந்த வகைகளின் கீழ் வருகின்றன: **தானியங்கு சோதனை** மற்றும் **கைமுறை சோதனை**. தானியங்கி சோதனை மற்றும் கைமுறை சோதனை தனித்தன்மை வாய்ந்த நன்மைகள் மற்றும் அதற்குரிய பரிமாற்றங்களை வழங்குகின்றன, ஆனால் இரண்டையும் இணைத்து உங்கள் கான்ட்ராக்ட்டை பகுப்பாய்வு செய்ய வலுவான திட்டத்தை உருவாக்க முடியும். + +### தானியங்கு சோதனை {#automated-testing} + +தானியங்கி சோதனை என்பது ஒரு ஸ்மார்ட் கான்ட்ராக்ட் குறியீட்டின் செயல்பாட்டில் பிழைகளைத் தானாகவே சரிபார்க்கும் கருவிகளைப் பயன்படுத்துவது. ஒப்பந்த செயல்பாடுகளை மதிப்பீடு செய்வதற்கு வழிகாட்ட [ஸ்கிரிப்ட்களை](https://www.techtarget.com/whatis/definition/script?amp=1) பயன்படுத்துவதிலிருந்து தானியங்கு சோதனையின் நன்மை வருகிறது. ஸ்கிரிப்ட்டு சோதனைகள் குறைந்த மனித தலையீட்டுடன் மீண்டும் மீண்டும்இயக்கத் திட்டமிடப்படலாம், இது தானியங்கிசோதனையைக் கைமுறைை சோதனை அணுகுமுறைகளுடன் ஒப்பிடும்போது மிகச் சிறந்ததாக ஆக்குகிறது. + +தானியங்கி சோதனை குறிப்பாகச் சோதனைகள் திரும்பத் திரும்பச் செய்ய வேண்டிய, நேரம் ஆறுவது, கைமுறையாகச் செய்ய முடியாத, மனித பிழைகளுக்கு ஆளாகக்கூடிய, அல்லது முக்கியமான கான்ட்ராக்ட் செயல்பாடுகளை மதிப்பீடு செய்வதில் பிரச்சினைகளை உள்ளடக்கியவற்றில் பயனுள்ளதாக இருக்கிறது. ஆனால் தானியங்கு சோதனைக் கருவிகளில் குறைபாடுகள் இருக்கலாம்—அவை சில பிழைகளைத் தவறவிடக்கூடும் மற்றும் பல [தவறான நேர்மறைகளை](https://www.contrastsecurity.com/glossary/false-positive) உருவாக்கக்கூடும். எனவே, ஸ்மார்ட் கான்ட்ராக்ட்களுக்காகத் தானியங்கி சோதனையைக் கைமுறை சோதனையுடன் இணைத்துப் பயன்படுத்துவது மிகச்சிறந்தது. + +### கைமுறை சோதனை {#manual-testing} + +கைமுறை சோதனை என்பது மனித உதவியுடன் செய்யப்படும் சோதனை முறையாகும். இதில், ஸ்மார்ட் கான்ட்ராக்ட்டின் சரியான செயல்பாட்டைப் பகுப்பாய்வு செய்யும்போது, உங்கள் சோதனை தொகுப்பில் உள்ள ஒவ்வொரு சோதனை வழக்கையும் ஒன்றின் பின் ஒன்றாகச் செயற்படுத்துவது அடங்கும். இது ஒரே சமயத்தில் பல தனிமைப்படுத்தப்பட்ட சோதனைகளைச் செயற்படுத்தி, தோல்வியடைந்த மற்றும் வெற்றிகரமாக முடிந்த சோதனைகளின் அறிக்கையைப் பெறும் தானியங்கி சோதனைக்கு மாறாகும். + +கைமுறை சோதனை ஒரே மனிதரால் மேற்கொள்ளப்படலாம், இது பல்வேறு சோதனை சூழ்நிலைகளைக் உள்ளடக்கிய எழுதப்பட்ட சோதனை திட்டத்தைப் பின்பற்றுகிறது. மேலும், பல மனிதர்கள் அல்லது குழுக்கள் கைமுறை சோதனையின் ஒரு பகுதியாக, குறிப்பிட்ட காலத்திற்கு ஒரு ஸ்மார்ட் கான்ட்ராக்ட்டுடன் தொடர்பு கொள்ள முடியும். சோதனையாளர்கள் கான்ட்ராக்ட்டின் உண்மையான நடத்தை எதிர்பார்க்கப்படும் நடத்தை இடத்தில் ஒப்பிட்டு, எந்தவொரு வேறுபாட்டையும் பிழையாகக் குறிக்கின்றனர். + +திறமையான கைமுறை சோதனை நிறைய வளங்கள் (திறமை, நேரம், பணம், மற்றும் முயற்சி) தேவைப்படுகின்றன, மேலும், மனித பிழை காரணமாகச் சோதனைகளைச் செயல்படுத்தும்போது சில பிழைகளைத் தவறவிடுவது சாத்தியமாகும். ஆனால், கைமுறை சோதனை நன்மைகளை வழங்கவும் செய்யும்—உதாரணமாக, ஒரு மனித சோதனையாளர் (உதாரணமாக, ஒரு ஆடிட்டர்) ஒரு தானியங்கி சோதனை கருவி தவறவிட்ட கடைசி நிலை சமயங்களைக் கண்டறிய உணர்ச்சிப்பூர்வமாகச் செயல்படலாம். + +## ஸ்மார்ட் ஒப்பந்தங்களுக்கான தானியங்கு சோதனை {#automated-testing-for-smart-contracts} + +### அலகு சோதனை {#unit-testing-for-smart-contracts} + +தானியங்கி சோதனை என்பது ஒவ்வொரு கான்ட்ராக்டின் செயல்பாடுகளைத் தனியாக மதிப்பீடு செய்து, ஒவ்வொரு உபகரணமும் சரியாகச் செயல்படுகிறதா என்பதைப் பரிசோதிக்கும் முறை ஆகும். சிறந்த யூனிட் சோதனைகள் எளிமையானவையாக, விரைவாக ஓடக்கூடியவையாக இருக்க வேண்டும் மற்றும் சோதனைகள் தோல்வியடைந்தால் எது தவறாக நடந்தது என்பதை தெளிவாகக் குறிப்பிட வேண்டும். + +யூனிட் சோதனைகள் ஒரு கான்ட்ராக்ட்டின் செயல்பாடுகள் எதிர்பார்க்கப்படும் மதிப்புகளைத் திருப்பி அனுப்புகிறதா என்பதையும், செயல்பாடு முடிந்த பிறகு கான்ட்ராக்டின் நிலையான மேம்பாடுகள் சரியாக மேம்படுத்தப்படுகிறதா என்பதையும் சோதிப்பதில் பயன்படுகின்றன. மேலும், ஒரு கான்ட்ராக்டின் கோட்பேஸ் இல் மாற்றங்களைச் செய்வதற்குப் பிறகு யூனிட் சோதனைகளை இயக்குவது புதிய தருக்கத்தை சேர்ப்பது பிழைகளை அறிமுகப்படுத்துகிறதா என்பதை உறுதிசெய்கிறது. சிறந்த யூனிட் சோதனைகளை இயக்கச் சில வழிமுறைகள் பின்வருமாறு: + +#### ஸ்மார்ட் ஒப்பந்தங்களை அலகு சோதனை செய்வதற்கான வழிகாட்டுதல்கள் {#unit-testing-guidelines} + +##### 1. உங்கள் கான்ட்ராக்டின் வணிக தருக்கமும் வேலைநிறுவகமும் புரிந்து கொள்ளுங்கள் + +யூனிட் சோதனைகளை எழுதுவதற்கு முன், ஒரு ஸ்மார்ட் கான்ட்ராக்ட் என்ன செயல்பாடுகளை வழங்குகிறது மற்றும் பயனாளர்கள் அவற்றை எப்படி அணுகி பயன்படுத்துவார்கள் என்பதைப் புரிந்துகொள்வது உதவுகிறது. செல்லுபடியாகும் பயனர் உள்ளீடுகளுக்கு ஒரு ஒப்பந்தத்தில் உள்ள செயல்பாடுகள் சரியான வெளியீட்டைத் தருகின்றனவா என்பதைத் தீர்மானிக்கும் [மகிழ்ச்சியான பாதை சோதனைகளை](https://en.m.wikipedia.org/wiki/Happy_path) இயக்குவதற்கு இது மிகவும் பயனுள்ளதாக இருக்கும். இந்தக் கருத்தை [ஒரு ஏல ஒப்பந்தத்தின்](https://docs.soliditylang.org/en/v0.8.17/solidity-by-example.html?highlight=Auction%20contract#simple-open-auction) இந்த (சுருக்கமான) உதாரணத்தைப் பயன்படுத்தி விளக்குவோம் + +```solidity +constructor( + uint biddingTime, + address payable beneficiaryAddress + ) { + beneficiary = beneficiaryAddress; + auctionEndTime = block.timestamp + biddingTime; + } + +function bid() external payable { + + if (block.timestamp > auctionEndTime) + revert AuctionAlreadyEnded(); + + if (msg.value <= highestBid) + revert BidNotHighEnough(highestBid); + + if (highestBid != 0) { + pendingReturns[highestBidder] += highestBid; + } + highestBidder = msg.sender; + highestBid = msg.value; + emit HighestBidIncreased(msg.sender, msg.value); + } + + function withdraw() external returns (bool) { + uint amount = pendingReturns[msg.sender]; + if (amount > 0) { + pendingReturns[msg.sender] = 0; + + if (!payable(msg.sender).send(amount)) { + pendingReturns[msg.sender] = amount; + return false; + } + } + return true; + } + +function auctionEnd() external { + if (block.timestamp < auctionEndTime) + revert AuctionNotYetEnded(); + if (ended) + revert AuctionEndAlreadyCalled(); + + ended = true; + emit AuctionEnded(highestBidder, highestBid); + + beneficiary.transfer(highestBid); + } +} +``` + +இது ஒரு எளிய ஏல கான்ட்ராக்ட் ஆகும், இது ஏல நேரத்தின்போது வரப்போகும் முறுகைகளைப் பெறுவதற்காக வடிவமைக்கப்பட்டுள்ளது. `highestBid` அதிகரித்தால், முந்தைய அதிக ஏலதாரர் தனது பணத்தைப் பெறுகிறார்; ஏல காலம் முடிந்தவுடன், `beneficiary` ஒப்பந்தத்தை அழைத்து தனது பணத்தைப் பெறுகிறார். + +யூனிட் சோதனைகள் இவ்வகை கான்ட்ராக்டின் மீது பயனாளர்கள் அடிக்கடி அழைக்கும் பல்வேறு செயல்பாடுகளைப் பரிசோதிக்கும் வகையில் இருக்கும். ஏலம் நடந்துகொண்டிருக்கும் போது ஒரு பயனர் ஏலம் எடுக்க முடியுமா (அதாவது, `bid()` க்கான அழைப்புகள் வெற்றி பெறுகின்றன) என்பதைச் சரிபார்க்கும் ஒரு அலகு சோதனை அல்லது தற்போதைய `highestBid`-ஐ விட அதிக ஏலம் எடுக்க முடியுமா என்பதைச் சரிபார்க்கும் ஒரு அலகு சோதனை ஒரு உதாரணமாகும். + +ஒரு கான்ட்ராக்டின் செயல்பாட்டு வேலைநிறுவகத்தை புரிந்துகொள்ளுவது, செயல்பாடுகள் தேவைகளைப் பூர்த்தி செய்கிறாரா எனச் சோதிக்க உதவும் யூனிட் சோதனைகளை எழுதவும் உதவுகிறது. எடுத்துக்காட்டாக, ஏலம் முடிந்ததும் பயனர்கள் ஏலம் எடுக்க முடியாது என்று ஏல ஒப்பந்தம் குறிப்பிடுகிறது (அதாவது, `auctionEndTime` ஆனது `block.timestamp`-ஐ விட குறைவாக இருக்கும்போது). எனவே, ஒரு டெவலப்பர் ஏலம் முடிந்ததும் `bid()` செயல்பாட்டிற்கான அழைப்புகள் வெற்றி பெறுமா அல்லது தோல்வியடையுமா என்பதைச் சரிபார்க்கும் ஒரு அலகு சோதனையை இயக்கலாம் (அதாவது, `auctionEndTime` > `block.timestamp` ஆக இருக்கும்போது). + +##### 2. கான்ட்ராக்ட் செயல்பாட்டிற்கு தொடர்பான அனைத்து நிரூபணங்களையும் மதிப்பீடு செய்யவும் + +ஒரு கான்ட்ராக்டின் செயல்பாடுபற்றிய எந்தவொரு நிரூபணங்களையும் ஆவணப்படுத்துவது முக்கியம் மற்றும் அந்த நிரூபணங்கள் சரியாக உள்ளதா எனச் சோதிக்க யூனிட் சோதனைகளை எழுதவும். எதிர்பாராத செயல்பாட்டிற்கு பாதுகாப்பு அளிப்பதற்கு மட்டுமல்லாமல், அறிக்கைகளைச் சோதிப்பது ஒரு ஸ்மார்ட் கான்ட்ராக்ட்டின் பாதுகாப்பு மாதிரியை உணர உதவும் செயல்பாடுகளைப் பரிசோதிக்க உங்களை வலியுறுத்தும். ஒரு பயனுள்ள குறிப்பு என்னவென்றால், "மகிழ்ச்சியான பயனர் சோதனைகளை" மீறி, ஒரு செயல்பாடு தவறான உள்ளீடுகளுக்குத் தோல்வியடைகிறதா எனச் சோதிக்கும் எதிர்மறை சோதனைகளை எழுதுவது. + +பல யூனிட் சோதனை கட்டமைப்புகள் உங்களுக்கு நிரூபணங்களை உருவாக்க அனுமதிக்கின்றன—அதாவது, கான்ட்ராக்ட் என்ன செய்ய முடியும் மற்றும் செய்ய முடியாது என்பதைக் குறிப்பிடும் எளிய கூற்றுகள்—சோதனைகளை இயக்கி அவை செயல்பாட்டின் கீழ் நீடிக்கிறதா என்பதைக் காணலாம். முந்தைய ஏல கான்ட்ராக்ட்டில் பணிபுரியும் ஒரு டெவலப்பர், அதன் நடத்தைபற்றிக் கீழ்க்காணும் நிரூபணங்களை செய்யலாம் மற்றும் எதிர்மறை சோதனைகளை இயக்குவதற்கு முன்னால் அவற்றைச் சோதிக்க முடியும்: + +- பயனாளர்கள், ஏல முடிந்த பிறகு அல்லது முதல்படிச் செய்யப்படாமல் இருக்கும்போது பிட் செய்ய முடியாது. + +- பிட் ஏற்கத் தக்க தொகை கீழே இருந்தால் ஏல கான்ட்ராக்ட் திரும்பப் பெறப்படுகிறது. + +- பிட் வெற்றிபெறாத பயனாளர்களுக்கு, அவர்கள் நிதிகள் திருப்பித் தரப்படுகின்றன + +**குறிப்பு**: அனுமானங்களைச் சோதிப்பதற்கான மற்றொரு வழி, ஒரு ஒப்பந்தத்தில் [செயல்பாட்டு மாற்றிகளை](https://docs.soliditylang.org/en/v0.8.16/contracts.html#function-modifiers), குறிப்பாக `require`, `assert`, மற்றும் `if...else` அறிக்கைகளைத் தூண்டும் சோதனைகளை எழுதுவதாகும். + +##### ஒரு நல்ல கதை. குறியீடு பரப்புகளை அளவிடுங்கள் + +[குறியீடு கவரேஜ்](https://en.m.wikipedia.org/wiki/Code_coverage) என்பது ஒரு சோதனை அளவீடு ஆகும், இது சோதனைகளின் போது செயல்படுத்தப்படும் உங்கள் குறியீட்டில் உள்ள கிளைகள், வரிகள் மற்றும் அறிக்கைகளின் எண்ணிக்கையைக் கண்காணிக்கும். சோதிக்கப்படாத பாதிப்புகளின் அபாயத்தைக் குறைக்க சோதனைகள் நல்ல குறியீடு கவரேஜைக் கொண்டிருக்க வேண்டும். போதுமான கவரேஜ் இல்லாமல், சோதிக்கப்படாத குறியீடு பாதைகளில் பாதிப்புகள் இன்னும் இருக்கும்போது, எல்லா சோதனைகளும் தேர்ச்சி பெறுவதால் உங்கள் ஒப்பந்தம் பாதுகாப்பானது என்று நீங்கள் தவறாகக் கருதலாம். ஆனால் உயர்ந்த குறியீடு பரப்புகளைப் பதிவு செய்வது, ஸ்மார்ட் கான்ட்ராக்ட் உள்ள அனைத்து கூற்றுகள் மற்றும் செயல்பாடுகள் சரியாகச் சோதிக்கப்பட்டன என்பதற்கு உறுதியை அளிக்கிறது. + +##### 4. நன்கு அபிவிருத்தி செய்யப்பட்ட சோதனை கட்டமைப்புகளைப் பயன்படுத்துங்கள் + +உங்கள் ஸ்மார்ட் கான்ட்ராக்ட்டின் யூனிட் சோதனைகளை இயக்குவதற்கு பயன்படுத்தப்படும் கருவிகளின் தரமான முக்கியமானது. ஒரு நேர்த்தியான சோதனை கட்டமைப்பு என்பது, வழக்கமாகப் பராமரிக்கப்படும்; பயனுள்ள அம்சங்களை (எ.கா., பதிவேற்றம் மற்றும் அறிக்கை அளிக்கும் திறன்கள்) வழங்குகிறது; மற்றும் மற்ற டெவலப்பர்களால் பரந்த அளவிலான பயன்பாட்டுக்கு உள்ளாகி மதிப்பீடு செய்யப்பட்டுள்ளது. + +Solidity ஸ்மார்ட் கான்ட்ராக்ட் யூனிட் சோதனை கட்டமைப்புகள் பல்வேறு மொழிகளில் கிடைக்கின்றன (மிகவும் ஜாவாஸ்கிரிப்ட், பைதான், மற்றும் ரஸ்ட்). கீழ்க்கண்ட வழிகாட்டிகளில், வேறு சோதனை கட்டமைப்புகளுடன் யூனிட் சோதனைகளை இயக்குவது பற்றித் தகவலைப் பெறலாம்: + +- **[Brownie உடன் அலகு சோதனைகளை இயக்குதல்](https://eth-brownie.readthedocs.io/en/v1.0.0_a/tests.html)** +- **[Foundry உடன் அலகு சோதனைகளை இயக்குதல்](https://book.getfoundry.sh/forge/writing-tests)** +- **[Waffle உடன் அலகு சோதனைகளை இயக்குதல்](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#writing-tests)** +- **[Remix உடன் அலகு சோதனைகளை இயக்குதல்](https://remix-ide.readthedocs.io/en/latest/unittesting.html#write-tests)** +- **[Ape உடன் அலகு சோதனைகளை இயக்குதல்](https://docs.apeworx.io/ape/stable/userguides/testing.html)** +- **[Hardhat உடன் அலகு சோதனைகளை இயக்குதல்](https://hardhat.org/hardhat-runner/docs/guides/test-contracts)** +- **[Wake உடன் அலகு சோதனைகளை இயக்குதல்](https://ackeeblockchain.com/wake/docs/latest/testing-framework/overview/)** + +### ஒருங்கிணைப்பு சோதனை {#integration-testing-for-smart-contracts} + +யூனிட் சோதனைகள் தனிமையில் கான்ட்ராக்ட் செயல்பாடுகளைப் பிழைத்திருத்தம் செய்யும்போது, இணைப்புச் சோதனைகள் ஒரு ஸ்மார்ட் கான்ட்ராக்டின் கூறுகளை ஒன்றாக மதிப்பீடு செய்கின்றன. இணைப்புச் சோதனைகள் கிராஸ்-கான்ட்ராக்ட் அழைப்புகள் அல்லது ஒரே ஸ்மார்ட் கான்ட்ராக்ட் உள்ளேயுள்ள பல்வேறு செயல்பாடுகளுக்கு இடையிலான இணக்கத்திலிருந்து தோன்றும் பிரச்சினைகளைக் கண்டுபிடிக்க முடியும். எடுத்துக்காட்டாக, ஒருங்கிணைப்பு சோதனைகள் [மரபுவழி](https://docs.soliditylang.org/en/v0.8.12/contracts.html#inheritance) மற்றும் சார்பு உட்செலுத்துதல் போன்றவை சரியாக வேலை செய்கிறதா என்று சரிபார்க்க உதவும். + +உங்கள் ஒப்பந்தம் ஒரு மட்டு கட்டமைப்பை ஏற்றுக்கொண்டால் அல்லது செயல்பாட்டின் போது மற்ற ஆன்செயின் ஒப்பந்தங்களுடன் இடைமுகம் செய்தால் ஒருங்கிணைப்பு சோதனை பயனுள்ளதாக இருக்கும். ஒருங்கிணைப்பு சோதனைகளை இயக்குவதற்கான ஒரு வழி, ஒரு குறிப்பிட்ட உயரத்தில் [பிளாக்செயினை ஃபோர்க்](/glossary/#fork) செய்து ([Forge](https://book.getfoundry.sh/forge/fork-testing) அல்லது [Hardhat](https://hardhat.org/hardhat-network/docs/guides/forking-other-networks) போன்ற ஒரு கருவியைப் பயன்படுத்தி) உங்கள் ஒப்பந்தத்திற்கும் பகிரப்பட்ட ஒப்பந்தங்களுக்கும் இடையிலான தொடர்புகளை உருவகப்படுத்துவதாகும். + +கிளைத்த ப்ளாக்செயின் மெய்நிகர் நெட்வொர்க்கைப் போலவே செயல்படும், மேலும் கணக்குகளுடன் இணைக்கப்பட்ட நிலைகளும் மற்றும் சமநிலைகளும் இருக்கும். ஆனால் இது வெறும் சாண்ட்பாக்ஸ் செய்யப்பட்ட உள்ளூர் வளர்ச்சியுறும் சூழலாகவே செயல்படும், அதாவது உருப்படியான ETH போன்றவற்றிற்காக நீங்கள் வேலையைச் செய்யத் தேவையில்லை, மேலும் உங்கள் மாற்றங்கள் உண்மையான Ethereum நெறிமுறையைப் பாதிக்காது. + +### பண்பு அடிப்படையிலான சோதனை {#property-based-testing-for-smart-contracts} + +பண்பு அடிப்படையிலான சோதனை என்பது ஒரு ஸ்மார்ட் கான்ட்ராக்ட் குறிப்பிட்ட ஒரு பண்பினை பூர்த்தி செய்கிறதா என்பதை சரிபார்ப்பது ஆகும். பண்புகள் ஒரு கான்ட்ராக்டின் செயல்பாட்டைப் பற்றிய விளக்கங்களை நியமிக்கின்றன, மற்றும் இவ்வாறு நியமிக்கப்பட்ட விளக்கங்கள் வெவ்வேறு காட்சிகளில் மாறாமல் இருக்குமா என்பதைப் பரிசோதிக்கின்றன. ஒரு ஸ்மார்ட் கான்ட்ராக்டின் ஒரு பண்பு எடுத்துக்காட்டாக, "கான்ட்ராக்டில் உள்ள எண்கணித செயல்பாடுகள் எப்போதும் மேற்பொலிக்கும் அல்லது அதிக குறைவாக மாறாது." + +**நிலையான பகுப்பாய்வு** மற்றும் **இயங்கு பகுப்பாய்வு** ஆகியவை பண்பு அடிப்படையிலான சோதனையைச் செயல்படுத்துவதற்கான இரண்டு பொதுவான நுட்பங்கள் ஆகும், மேலும் ஒரு நிரலுக்கான குறியீடு (இந்த விஷயத்தில் ஒரு ஸ்மார்ட் ஒப்பந்தம்) சில முன்வரையறுக்கப்பட்ட பண்புகளை திருப்திப்படுத்துகிறதா என்பதை இரண்டும் சரிபார்க்க முடியும். சில பண்பு அடிப்படையிலான சோதனை கருவிகள் முன்கூட்டியே வரையறுக்கப்பட்ட நியமங்களைக் கொண்டு கான்ட்ராக்ட் பண்புகளை எதிர்பார்க்கின்றன, மற்றும் அந்த நியமங்களுக்கேற்ப குறியீட்டைக் சோதிக்கின்றன. சில மற்றவை உங்களுக்கு ஒரு ஸ்மார்ட் கான்ட்ராக்டிற்கு தனிப்பயனான பண்புகளை உருவாக்கும் சாதனத்தை வழங்குகின்றன. + +#### நிலையான பகுப்பாய்வு {#static-analysis} + +நிலையான பகுப்பாய்வு என்பது ஸ்மார்ட் கான்ட்ராக்டின் மூலக் குறியீட்டை உள்ளீடாகப் பெற்று, கான்ட்ராக்ட் ஒரு பண்பினை பூர்த்தி செய்கிறதா இல்லையா என்பதை விளக்கமாக வெளியிடும். இயங்கு பகுப்பாய்வைப் போன்றது இல்லாமல், நிலையான பகுப்பாய்வு ஒரு கான்ட்ராக்ட்டை செயல்படுத்தி சரியானதா என்பதைப் பகுப்பாய்வு செய்யவில்லை. நிலையான பகுப்பாய்வு மாற்றாக, ஸ்மார்ட் கான்ட்ராக்ட் செயல்பாடின்போது எடுக்கும் அனைத்து முடிவு பாதைகளைக் குறியீட்டின் நிலையான கட்டமைப்பைக் கண்டறிந்து பகுப்பாய்வு செய்கின்றது. + +[லிண்டிங்](https://www.perforce.com/blog/qac/what-is-linting) மற்றும் [நிலையான சோதனை](https://www.techtarget.com/whatis/definition/static-analysis-static-code-analysis) ஆகியவை ஒப்பந்தங்களில் நிலையான பகுப்பாய்வை இயக்குவதற்கான பொதுவான முறைகள் ஆகும். இரண்டிற்கும் ஒரு ஒப்பந்தத்தின் செயல்பாட்டின் குறைந்த-நிலை பிரதிநிதித்துவங்களை பகுப்பாய்வு செய்ய வேண்டும், அதாவது [சுருக்க தொடரியல் மரங்கள்](https://en.m.wikipedia.org/wiki/Abstract_syntax_tree) மற்றும் தொகுப்பியால் வெளியிடப்பட்ட [கட்டுப்பாட்டு ஓட்ட வரைபடங்கள்](https://www.geeksforgeeks.org/software-engineering-control-flow-graph-cfg/amp/) போன்றவை. + +பல சந்தர்ப்பங்களில், நிலையான பகுப்பாய்வு பாதுகாப்பு பிரச்சினைகளை, எடுத்துக்காட்டாக, பாதுகாப்பற்ற கட்டமைப்புகளைப் பயன்படுத்துதல், சிறு குறியீட்டுக் கோளாறுகள் அல்லது குறியீட்டு முறைமைகளில் இழப்புகளைக் கண்டறிய உதவியாக இருக்கும். ஆனால், நிலையான பகுப்பாய்வாளர்கள் உள்ளார்ந்த முடிவுகளைக் கண்டறிய பொதுவாக உண்மையல்லாதவர்களாகக் கருதப்படுகின்றனர், மேலும் அதிக அளவில் தவறான ஒத்திவைப்புகளை உருவாக்கலாம். + +#### இயங்கு பகுப்பாய்வு {#dynamic-analysis} + +இயங்கு பகுப்பாய்வு, ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் செயல்பாடுகளுக்கு குறியீட்டு உள்ளீடுகளை (எ.கா., [குறியீட்டு செயல்பாட்டில்](https://en.m.wikipedia.org/wiki/Symbolic_execution)) அல்லது உறுதியான உள்ளீடுகளை (எ.கா., [ஃபஸ்ஸிங்கில்](https://owasp.org/www-community/Fuzzing)) உருவாக்குகிறது, எந்தவொரு செயல்பாட்டுத் தடயங்களும் குறிப்பிட்ட பண்புகளை மீறுகின்றனவா என்பதைப் பார்க்க. இங்குச் சோதனைை சேமிப்புகள் பல காட்சிகளை உள்ளடக்கியவையாக இருக்கின்றன, மேலும் ஒரு நிரல் சோதனை சேமிப்புகளை உருவாக்குவதை நிர்வகிக்கின்றது. + +[ஃபஸ்ஸிங்](https://www.halborn.com/blog/post/what-is-fuzz-testing-fuzzing) என்பது ஸ்மார்ட் ஒப்பந்தங்களில் தன்னிச்சையான பண்புகளைச் சரிபார்ப்பதற்கான ஒரு இயங்கு பகுப்பாய்வு நுட்பத்திற்கு ஒரு எடுத்துக்காட்டு. ஒரு குறியீட்டில் நிர்ணயிக்கப்பட்ட உள்ளீடு மதிப்பின் தாறுமாறான அல்லது தெளிவற்ற மாறுபாடுகளுடன் ஒரு பெருமளவு குறியீட்டின் செயல்பாடுகளை அழைக்கின்றது. ஸ்மார்ட் கான்ட்ராக்ட்டில் ஒரு பிழை நிலை (உதாரணமாக, ஒரு சரிபார்ப்பு தோல்வியடைகின்றது) உள்ளிட்டால், பிரச்சினை குறிக்கப்பட வேண்டும், மேலும் செயல்பாட்டின் வலிமையற்ற பாதைக்குள் வந்த உள்ளீடுகள் ஒரு அறிக்கையில் தொகுக்கப்படுகின்றன. + +தாறுமாறான செயல்பாடு ஒரு ஸ்மார்ட் கான்ட்ராக்ட்டின் உள்ளீட்டு செல்லுபடியாகும் முறையைச் சோதிக்க மிகவும் பயனுள்ளதாக இருக்கும், ஏனெனில் எதிர்பாராத உள்ளீடுகளைத் தவறாகக் கையாள்வது எதிர்பாராத செயல்பாட்டை ஏற்படுத்தி ஆபத்தான எதிர்விளைவுகளை உருவாக்கச் செய்யக்கூடும். இந்தப் பண்பு அடிப்படையிலான சோதனை வெவ்வேறு காரணங்களுக்காகச் சரியானதாக இருக்கும்: + +1. **பல காட்சிகளை உள்ளடக்கிய சோதனை நிகழ்வுகளை எழுதுவது கடினம்.** ஒரு பண்பு சோதனைக்கு நீங்கள் ஒரு நடத்தை மற்றும் அந்த நடத்தையைச் சோதிக்க தரவின் வரம்பை வரையறுக்க வேண்டும்—வரையறுக்கப்பட்ட பண்பின் அடிப்படையில் நிரல் தானாகவே சோதனை நிகழ்வுகளை உருவாக்குகிறது. + +2. **உங்கள் சோதனைத் தொகுப்பு நிரலில் உள்ள அனைத்து சாத்தியமான பாதைகளையும் போதுமான அளவில் உள்ளடக்காமல் இருக்கலாம்.** 100% கவரேஜ் இருந்தாலும், விளிம்பு நிகழ்வுகளைத் தவறவிட வாய்ப்புள்ளது. + +3. **அலகு சோதனைகள் ஒரு ஒப்பந்தம் மாதிரி தரவுகளுக்கு சரியாகச் செயல்படுவதை நிரூபிக்கின்றன, ஆனால் மாதிரிக்கு வெளியே உள்ள உள்ளீடுகளுக்கு ஒப்பந்தம் சரியாகச் செயல்படுகிறதா என்பது தெரியவில்லை.** பண்பு சோதனைகள், வலியுறுத்தல் தோல்விகளை ஏற்படுத்தும் செயல்பாட்டுத் தடயங்களைக் கண்டறிய, கொடுக்கப்பட்ட உள்ளீட்டு மதிப்பின் பல மாறுபாடுகளுடன் ஒரு இலக்கு ஒப்பந்தத்தைச் செயல்படுத்துகின்றன. இதனால், ஒரு பண்புச் சோதனை பயன்பாட்டின் பெரிய உள்ளீட்டு தகவல்களுக்கான சரியான செயல்பாடுகளை மேலும் வசதி உருவாக்கச் செய்கின்றது. + +### ஸ்மார்ட் ஒப்பந்தங்களுக்கான பண்பு அடிப்படையிலான சோதனையை இயக்குவதற்கான வழிகாட்டுதல்கள் {#running-property-based-tests} + +பண்பு அடிப்படையிலான சோதனையை இயக்குவது பொதுவாக ஒரு ஸ்மார்ட் ஒப்பந்தத்தில் நீங்கள் சரிபார்க்க விரும்பும் ஒரு பண்பை (எ.கா., [முழு எண் வழிதலின்](https://github.com/ConsenSys/mythril/wiki/Integer-Overflow) இல்லாமை) அல்லது பண்புகளின் தொகுப்பை வரையறுப்பதில் தொடங்குகிறது. நீங்கள் ஒரு நிரலுக்குச் சொந்தமான பரிமாணங்களுக்குள் தகவல்களை உருவாக்க நிறுவலாம். இது சொந்தமான சோதனைகளின் நிபந்தனைகளையும் உருவாக்க வேண்டும். + +சரியான அமைப்புகள் செய்யப்பட்டவுடன், பண்புச் சோதனை சாதனம் உங்கள் ஸ்மார்ட் கான்ட்ராக்டின் செயல்பாடுகளைத் தற்செயலாக உருவாக்கப்பட்ட உள்ளீடுகளுடன் செயலாக்கும். எந்தவொரு சரிபார்ப்பு மீறல்கள் இருந்தால், சோதனை சாதனம் அதற்குரிய உறுதிப்படுத்தப்பட்ட உள்ளீட்டு தகவல்களுடன் ஒரு அறிக்கையை உங்களுக்கு வழங்கும். விளக்கங்களைக் காண நீங்கள் பின்வரும் வழிகாட்டுதல்களை பின்பற்றலாம்: + +- **[Slither உடன் ஸ்மார்ட் ஒப்பந்தங்களின் நிலையான பகுப்பாய்வு](https://github.com/crytic/slither)** +- **[Wake உடன் ஸ்மார்ட் ஒப்பந்தங்களின் நிலையான பகுப்பாய்வு](https://ackeeblockchain.com/wake/docs/latest/static-analysis/using-detectors/)** +- **[Brownie உடன் பண்பு அடிப்படையிலான சோதனை](https://eth-brownie.readthedocs.io/en/stable/tests-hypothesis-property.html)** +- **[Foundry உடன் ஒப்பந்தங்களை ஃபஸ்ஸிங் செய்தல்](https://book.getfoundry.sh/forge/fuzz-testing)** +- **[Echidna உடன் ஒப்பந்தங்களை ஃபஸ்ஸிங் செய்தல்](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna#echidna-tutorial)** +- **[Wake உடன் ஒப்பந்தங்களை ஃபஸ்ஸிங் செய்தல்](https://ackeeblockchain.com/wake/docs/latest/testing-framework/fuzzing/)** +- **[Manticore உடன் ஸ்மார்ட் ஒப்பந்தங்களின் குறியீட்டு செயல்பாடு](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore#manticore-tutorial)** +- **[Mythril உடன் ஸ்மார்ட் ஒப்பந்தங்களின் குறியீட்டு செயல்பாடு](https://mythril-classic.readthedocs.io/en/master/tutorial.html)** + +## ஸ்மார்ட் ஒப்பந்தங்களுக்கான கைமுறை சோதனை {#manual-testing-for-smart-contracts} + +ஸ்மார்ட் கான்ட்ராக்ட்களின் கைமுறை சோதனை பொதுவாக ஆட்டோமேஷன் சோதனைகளை நடத்திய பிறகு மேல்நிலை படுகிறது. இந்த வகை சோதனை ஒரு முழுமையாக ஒன்று சேர்க்கப்பட்ட தயாரிப்பு பொருளாக ஸ்மார்ட் கான்ட்ராக்டின் செயல்பாடுகளை மதிப்பீடு செய்கிறது, அது தொழில்நுட்ப விவரங்களின் நிர்ணயத்திற்கிணங்க செயல்படுகிறதா என்பதை தெரிய செய்கிறது. + +### உள்ளூர் பிளாக்செயினில் ஒப்பந்தங்களை சோதித்தல் {#testing-on-local-blockchain} + +ஆட்டோமேஷன் சோதனை ஒரு உள்ளூர் வளர்ப்பு சூழலில் நடத்தப்பட்டபோது, அது பயனுள்ள பிழைத்திருத்த தகவல்களை வழங்கக்கூடிய சூழ்நிலையாக இருக்கலாம். ஆனால், உங்கள் ஸ்மார்ட் கான்ட்ராக்ட் ஒரு உற்பத்தி சூழலில் எப்படி நடத்துகின்றது என்பதை நீங்கள் தெரிந்து கொள்ள வேண்டும். எனினும், முக்கிய எத்தெருமான் செயினில் பிரச்சினைகளை படைத்த போது காஸ் கட்டணங்கள் நடக்கின்றன — செய்யப்பட்ட பின்பு உங்கள் ஸ்மார்ட் கான்ட்ராக்ட் இன்னும் பிழைகள் உள்ளது என்றால், நீங்கள் அல்லது உங்கள் பயனர்கள் உண்மையான பணத்தை இழக்க முடியும். + +உங்கள் ஒப்பந்தத்தை உள்ளூர் பிளாக்செயினில் ([வளர்ச்சி நெட்வொர்க்](/developers/docs/development-networks/) என்றும் அழைக்கப்படுகிறது) சோதிப்பது Mainnet இல் சோதிப்பதற்குப் பரிந்துரைக்கப்படும் ஒரு மாற்று ஆகும். உள்ளூர் பிளாக்செயின் உங்கள் கணினியில் உள்ள Ethereum பிளாக்செயினின் ஒரு நகல் அதிகாரத்தைக் போன்ற நடைமுறையைப் பின்பற்றும். அதனால், நீங்கள் கான்ட்ராக்டுடன் செயல்படுத்த ஒப்பந்தங்களைப் பட்டியலில் உள்ள சர்ச்சை செய்ய முடியும். + +ஒரு உள்ளூர் பிளாக்செயினில் ஒப்பந்தங்களை நடத்துவது கைமுறை ஒப்பந்த சேர்க்கை சோதனையாகப் பயனுள்ளதாக இருக்கலாம். [ஸ்மார்ட் ஒப்பந்தங்கள் அதிகளவில் தொகுக்கக்கூடியவை](/developers/docs/smart-contracts/composability/), ஏற்கனவே உள்ள நெறிமுறைகளுடன் ஒருங்கிணைக்க உங்களை அனுமதிக்கிறது—ஆனால் அத்தகைய சிக்கலான ஆன்செயின் தொடர்புகள் சரியான முடிவுகளைத் தருகின்றன என்பதை நீங்கள் இன்னும் உறுதிப்படுத்த வேண்டும். + +[வளர்ச்சி நெட்வொர்க்குகள் பற்றி மேலும்.](/developers/docs/development-networks/) + +### டெஸ்ட்நெட்களில் ஒப்பந்தங்களை சோதித்தல் {#testing-contracts-on-testnets} + +ஒரு சோதனை நெட்வொர்க் அல்லது டெஸ்ட்நெட் ஆனது Ethereum Mainnet போலவே செயல்படுகிறது, இது உண்மையான-உலக மதிப்பு இல்லாத ஈதரை (ETH) பயன்படுத்துகிறது என்பதைத் தவிர. உங்கள் ஒப்பந்தத்தை ஒரு [டெஸ்ட்நெட்டில்](/developers/docs/networks/#ethereum-testnets) பகிர்தல் என்பது, நிதியை அபாயத்தில் வைக்காமல் யார் வேண்டுமானாலும் அதனுடன் (எ.கா., டாப்பின் முகப்பு வழியாக) தொடர்பு கொள்ளலாம் என்பதாகும். + +இந்தக் கைமுறை சோதனை உங்கள் விண்ணப்பத்தின் முடிவில் பயனர் வினைச்செயல்களை மதிப்பீடு செய்யப் பயனுள்ளதாக இருக்கிறது. இங்கு, பேட்டா சோதகர்களுக்கு அவர்கள் கான்ட்ராக்டின் வணிக மூலோபாயங்கள் மற்றும் மொத்தம் செயல்பாடுகள்பற்றிய சிக்கல்களை அறிக்கையளிக்க முடியும். + +உள்ளூர் பிளாக்செயினில் சோதனையிட்ட பிறகு சோதனை நெட்வொர்க் எட்டிய இருப்பது அதிக வெகுளியில் திறனடைய இருக்கிறது என்றால் இருந்தாலும் Ethereum Virtual Machine போல இருக்கிறது. ஆகையால், பல Ethereum-உள்நாட்டு திட்டங்கள் சோதனை நெட்வொர்க்களில் dapps விண்டோ என்றும் செயல்படுகிறது. + +[எத்தேரியம் டெஸ்ட்நெட்கள் பற்றி மேலும்.](/developers/docs/development-networks/#public-beacon-testchains) + +## சோதனை மற்றும் முறையான சரிபார்ப்பு {#testing-vs-formal-verification} + +சோதனை ஒரு கான்ட்ராக்டு சில தரவுகளுக்கான காணொளிகளைத் திரும்பப் பெறுவதை உறுதிப்படுத்த உதவுகிறது, ஆனால் சோதனையில் பயன்படுத்தாத தரவுகளுக்கு அதே முடிவுகளை நிச்சயமாக விரிவாகச் செய்ய முடியாது. எனவே, ஒரு ஸ்மார்ட் ஒப்பந்தத்தைச் சோதிப்பது "செயல்பாட்டுச் சரியானது" என்பதற்கு உத்தரவாதம் அளிக்காது (அதாவது, ஒரு நிரல் _அனைத்து_ உள்ளீட்டு மதிப்புகளுக்கும் தேவைக்கேற்ப செயல்படுவதைக் காட்ட முடியாது). + +துல்லியமான சரிபார்ப்பு என்பது மென்பொருளின் சரியானதன்மையை மதிப்பீடு செய்யும் முறையாக, ஒருவரின் மாத்யமிகர்த்துமா மாதிரி உத்தியோகபூர்வ விளக்கத்தைப் பொருந்துமா என்பதைக் கணிக்கின்றது. ஒரு துல்லியமான மாத்யமிகர்த்துமா என்பது ஒரு திட்டத்தின் கணித மாதிரி ஆகும், மேலும் ஒரு உத்தியோகபூர்வ விளக்கம் (i.e., திட்டத்தின் செயல்பாட்டைப் பற்றிய மாந்திகமான புகார்கள்) திட்டத்தின் சொந்தங்கள் (i.e., திட்டத்தின் செயல்பாட்டைப் பற்றிய மாந்திகமான புகார்கள்) ஆகும். + +சொந்தங்கள் கணித துறையில் எழுதப்படுவதால், துல்லியமான (கணித) மாத்யமிகர்த்துமா முறை ஒரு குறிப்பிட்ட விளக்கத்தைப் பூர்த்தி செய்யுமா என்பதை சோதனை செய்யக்கூடியதாகிறது. எனவே, துல்லியமான சரிபார்ப்பு கருவிகள் ஒரு அமைப்பின் சரியானதன்மையை ‘கணிதமான சான்று’ அளிக்கும் என்று கூறப்படுகிறது. + +சோதனையைப் போலல்லாமல், முறையான சரிபார்ப்பு ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் செயலாக்கம் மாதிரித் தரவுகளுடன் செயல்படுத்தப்பட வேண்டிய அவசியமின்றி _அனைத்து_ செயல்பாடுகளுக்கும் ஒரு முறையான விவரக்குறிப்பை திருப்திப்படுத்துகிறதா என்பதைச் சரிபார்க்கப் பயன்படுத்தலாம் (அதாவது, அதில் பிழைகள் இல்லை). இது பல வினாடிகளின் சோதனைகளை ஓரளவு குறைக்க மட்டுமல்லாமல், மறைந்த பிழைகளைப் பிடிக்கவும் மிகவும் திறமையானது. அதாவது, துல்லியமான சரிபார்ப்பு முறைகள் செயல்படுத்துவதற்கும் பயனுள்ளதாக இருக்கும். + +[ஸ்மார்ட் ஒப்பந்தங்களுக்கான முறையான சரிபார்ப்பு பற்றி மேலும்.](/developers/docs/smart-contracts/formal-verification) + +## சோதனை, தணிக்கைகள் மற்றும் பிழை வெகுமதிகள் {#testing-vs-audits-bug-bounties} + +அண்மையில், நுணுக்கமான சோதனைகள் ஒரு கான்ட்ராக்டில் பிழைகள் இல்லாமல் இருப்பதை உறுதி செய்ய முடியாது; துல்லியமான சரிபார்ப்பு முறைகள் சோதனையின் வலுவான உறுதிகளை வழங்கலாம் ஆனால் தற்போது அவற்றைப் பயன்படுத்துவது கடினமாகவும் அதிக செலவாகவும் உள்ளது. + +இருப்பினும், ஒரு சுதந்தரமாக்கப்பட்ட குறியீட்டு பரிசீலனையை பெறுவதன் மூலம் கான்ட்ராக்ட் சிக்கல்களைப் பிடிக்கும் சாத்தியத்தை மேலும் அதிகரிக்கலாம். [ஸ்மார்ட் ஒப்பந்த தணிக்கைகள்](https://www.immunebytes.com/blog/what-is-a-smart-contract-audit/) மற்றும் [பிழை வெகுமதிகள்](https://medium.com/immunefi/a-defi-security-standard-the-scaling-bug-bounty-9b83dfdc1ba7) ஆகியவை மற்றவர்களை உங்கள் ஒப்பந்தங்களை ஆய்வு செய்ய வைப்பதற்கான இரண்டு வழிகள். + +ஆய்வுகள் சிக்கல்களை மற்றும் குறைந்த தரமான மேம்பாட்டுப் முறைகளைக் கண்டறிய அனுபவமிக்க ஆய்வாளர்களால் செய்கிறார்கள். ஒரு ஆய்வு பொதுவாகச் சோதனையை (மற்றும், சாத்தியமாகத் துல்லியமான சரிபார்ப்பை) மற்றும் முழு குறியீட்டு அடிப்படையின் கையேடு பரிசீலனையை அடங்கும். + +மாறாக, ஒரு பிழை வெகுமதித் திட்டம் பொதுவாக ஒரு ஸ்மார்ட் ஒப்பந்தத்தில் ஒரு பாதிப்பைக் கண்டறிந்து அதை டெவலப்பர்களுக்கு வெளிப்படுத்தும் ஒரு தனிநபருக்கு (பொதுவாக [வெள்ளை தொப்பி ஹேக்கர்கள்](https://en.wikipedia.org/wiki/White_hat_\(computer_security\)) என்று விவரிக்கப்படுகிறது) நிதி வெகுமதியை வழங்குவதை உள்ளடக்கியது. பிழை பரிசுகள் ஆய்வுகளுக்குச் சமானமாகும், ஏனெனில் இது மற்றவர்களைப் கேட்டுக்கொண்டு ஸ்மார்ட் கான்ட்ராக்டில் பிழைகளைக் கண்டுபிடிக்க உதவுகிறது. + +முக்கிய வேறுபாடு என்னவெனில், பிழை பரிசுத் திட்டங்கள் பரந்த வளர்த்தாளர்/ஹேக்கர் சமூகத்திற்கு திறந்ததாக இருக்கும் மற்றும் தனித்துவமான திறன்கள் மற்றும் அனுபவமுள்ள ஏதேனும் நியாயமான ஹேக்கர்கள் மற்றும் சுதந்திரமான பாதுகாப்பு வல்லுநர்களைக் ஈர்க்கும். இது, குறைந்த அல்லது வகைப்படுத்தப்பட்ட நிபுணத்துவம் கொண்ட குழுக்களைப் பெரும்பாலும் சார்ந்த ஸ்மார்ட் கான்ட்ராக்ட் ஆய்வுகளுக்கு மேலாக ஒரு நன்மை ஆக இருக்க முடியும். + +## சோதனைக் கருவிகள் மற்றும் நூலகங்கள் {#testing-tools-and-libraries} + +### அலகு சோதனைக் கருவிகள் {#unit-testing-tools} + +- **[solidity-coverage](https://github.com/sc-forks/solidity-coverage)** - _Solidity-இல் எழுதப்பட்ட ஸ்மார்ட் ஒப்பந்தங்களுக்கான குறியீடு கவரேஜ் கருவி._ + +- **[Waffle](https://ethereum-waffle.readthedocs.io/en/latest/)** - _மேம்பட்ட ஸ்மார்ட் ஒப்பந்த மேம்பாடு மற்றும் சோதனைக்கான கட்டமைப்பு (ethers.js அடிப்படையில்)._ + +- **[Remix சோதனைகள்](https://github.com/ethereum/remix-project/tree/master/libs/remix-tests)** - _Solidity ஸ்மார்ட் ஒப்பந்தங்களைச் சோதிப்பதற்கான கருவி. ஒரு ஒப்பந்தத்திற்கான சோதனை நிகழ்வுகளை எழுதவும் இயக்கவும் பயன்படுத்தப்படும் Remix IDE "Solidity Unit Testing" செருகுநிரலின் கீழ் வேலை செய்கிறது._ + +- **[OpenZeppelin சோதனை உதவியாளர்கள்](https://github.com/OpenZeppelin/openzeppelin-test-helpers)** - _எத்தேரியம் ஸ்மார்ட் ஒப்பந்த சோதனைக்கான வலியுறுத்தல் நூலகம். உங்கள் ஒப்பந்தங்கள் எதிர்பார்த்தபடி செயல்படுவதை உறுதிப்படுத்திக் கொள்ளுங்கள்!_ + +- **[Brownie அலகு சோதனை கட்டமைப்பு](https://eth-brownie.readthedocs.io/en/v1.0.0_a/tests.html)** - _Brownie, Pytest-ஐப் பயன்படுத்துகிறது, இது ஒரு அம்சம் நிறைந்த சோதனை கட்டமைப்பாகும், இது குறைந்த குறியீட்டுடன் சிறிய சோதனைகளை எழுத உங்களை அனுமதிக்கிறது, பெரிய திட்டங்களுக்கு நன்றாக அளவிடப்படுகிறது மற்றும் அதிக அளவில் நீட்டிக்கக்கூடியது._ + +- **[Foundry சோதனைகள்](https://github.com/foundry-rs/foundry/tree/master/crates/forge)** - _Foundry, Forge-ஐ வழங்குகிறது, இது எளிய அலகு சோதனைகள், எரிவாயு உகப்பாக்கச் சரிபார்ப்புகள் மற்றும் ஒப்பந்த ஃபஸ்ஸிங் ஆகியவற்றைச் செயல்படுத்தும் திறன் கொண்ட வேகமான மற்றும் நெகிழ்வான எத்தேரியம் சோதனை கட்டமைப்பாகும்._ + +- **[Hardhat சோதனைகள்](https://hardhat.org/hardhat-runner/docs/guides/test-contracts)** - _ethers.js, Mocha மற்றும் Chai ஆகியவற்றின் அடிப்படையில் ஸ்மார்ட் ஒப்பந்தங்களைச் சோதிப்பதற்கான கட்டமைப்பு._ + +- **[ApeWorx](https://docs.apeworx.io/ape/stable/userguides/testing.html)** - _எத்தேரியம் மெய்நிகர் இயந்திரத்தை இலக்காகக் கொண்ட ஸ்மார்ட் ஒப்பந்தங்களுக்கான பைதான் அடிப்படையிலான மேம்பாடு மற்றும் சோதனை கட்டமைப்பு._ + +- **[Wake](https://ackeeblockchain.com/wake/docs/latest/testing-framework/overview/)** - _சிறந்த பயனர் அனுபவம் மற்றும் செயல்திறனுக்காக pytest மற்றும் Anvil-ஐப் பயன்படுத்தி, வலுவான பிழைத்திருத்த திறன்கள் மற்றும் குறுக்கு-செயின் சோதனை ஆதரவுடன் அலகு சோதனை மற்றும் ஃபஸ்ஸிங்கிற்கான பைதான் அடிப்படையிலான கட்டமைப்பு._ + +### பண்பு அடிப்படையிலான சோதனைக் கருவிகள் {#property-based-testing-tools} + +#### நிலையான பகுப்பாய்வுக் கருவிகள் {#static-analysis-tools} + +- **[Slither](https://github.com/crytic/slither)** - _பாதிப்புகளைக் கண்டறிதல், குறியீட்டுப் புரிதலை மேம்படுத்துதல் மற்றும் ஸ்மார்ட் ஒப்பந்தங்களுக்கான தனிப்பயன் பகுப்பாய்வுகளை எழுதுவதற்கான பைதான் அடிப்படையிலான Solidity நிலையான பகுப்பாய்வு கட்டமைப்பு._ + +- **[Ethlint](https://ethlint.readthedocs.io/en/latest/)** - _Solidity ஸ்மார்ட் ஒப்பந்த நிரலாக்க மொழிக்கு நடை மற்றும் பாதுகாப்பு சிறந்த நடைமுறைகளைச் செயல்படுத்துவதற்கான லிண்டர்._ + +- **[Cyfrin Aderyn](https://cyfrin.io/tools/aderyn)** - _Web3 ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பு மற்றும் மேம்பாட்டிற்காக பிரத்யேகமாக வடிவமைக்கப்பட்ட ரஸ்ட் அடிப்படையிலான நிலையான பகுப்பாய்வி._ + +- **[Wake](https://ackeeblockchain.com/wake/docs/latest/static-analysis/using-detectors/)** - _பாதிப்பு மற்றும் குறியீட்டுத் தரக் கண்டறிவான்கள், குறியீட்டிலிருந்து பயனுள்ள தகவல்களைப் பிரித்தெடுப்பதற்கான அச்சுப்பொறிகள் மற்றும் தனிப்பயன் துணைத் தொகுதிகளை எழுதுவதற்கான ஆதரவுடன் கூடிய பைதான் அடிப்படையிலான நிலையான பகுப்பாய்வுக் கட்டமைப்பு._ + +- **[Slippy](https://github.com/fvictorio/slippy)** - _Solidity-க்கான எளிய மற்றும் சக்திவாய்ந்த லிண்டர்._ + +#### இயங்கு பகுப்பாய்வுக் கருவிகள் {#dynamic-analysis-tools} + +- **[Echidna](https://github.com/crytic/echidna/)** - _பண்பு அடிப்படையிலான சோதனை மூலம் ஸ்மார்ட் ஒப்பந்தங்களில் பாதிப்புகளைக் கண்டறிவதற்கான வேகமான ஒப்பந்த ஃபஸ்சர்._ + +- **[Diligence Fuzzing](https://consensys.net/diligence/fuzzing/)** - _ஸ்மார்ட் ஒப்பந்த குறியீட்டில் பண்பு மீறல்களைக் கண்டறியப் பயன்படும் தானியங்கு ஃபஸ்ஸிங் கருவி._ + +- **[Manticore](https://manticore.readthedocs.io/en/latest/index.html)** - _EVM பைட்கோடைப் பகுப்பாய்வு செய்வதற்கான டைனமிக் சிம்பாலிக் எக்ஸிகியூஷன் கட்டமைப்பு._ + +- **[Mythril](https://github.com/ConsenSys/mythril-classic)** - _கறை பகுப்பாய்வு, கான்கோலிக் பகுப்பாய்வு மற்றும் கட்டுப்பாட்டு ஓட்டச் சரிபார்ப்பு ஆகியவற்றைப் பயன்படுத்தி ஒப்பந்த பாதிப்புகளைக் கண்டறிவதற்கான EVM பைட்கோட் மதிப்பீட்டுக் கருவி._ + +- **[Diligence Scribble](https://consensys.net/diligence/scribble/)** - _Scribble என்பது ஒரு விவரக்குறிப்பு மொழி மற்றும் இயக்க நேர சரிபார்ப்புக் கருவியாகும், இது ஸ்மார்ட் ஒப்பந்தங்களைப் பண்புகளுடன் சிறுகுறிப்பு செய்ய உங்களை அனுமதிக்கிறது, இது Diligence Fuzzing அல்லது MythX போன்ற கருவிகளைக் கொண்டு ஒப்பந்தங்களைத் தானாகவே சோதிக்க உதவுகிறது._ + +## தொடர்புடைய பயிற்சிகள் {#related-tutorials} + +- [வெவ்வேறு சோதனைத் தயாரிப்புகளின் கண்ணோட்டம் மற்றும் ஒப்பீடு](/developers/tutorials/guide-to-smart-contract-security-tools/) \_ +- [ஸ்மார்ட் ஒப்பந்தங்களைச் சோதிக்க Echidna-வை எவ்வாறு பயன்படுத்துவது](/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/) +- [ஸ்மார்ட் ஒப்பந்தப் பிழைகளைக் கண்டறிய Manticore ஐ எவ்வாறு பயன்படுத்துவது](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/) +- [ஸ்மார்ட் ஒப்பந்தப் பிழைகளைக் கண்டறிய Slither ஐ எவ்வாறு பயன்படுத்துவது](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/) +- [சோதனைக்காக Solidity ஒப்பந்தங்களை எவ்வாறு மாக் செய்வது](/developers/tutorials/how-to-mock-solidity-contracts-for-testing/) +- [Foundry-ஐப் பயன்படுத்தி Solidity-இல் யூனிட் சோதனைகளை எவ்வாறு இயக்குவது](https://www.rareskills.io/post/foundry-testing-solidity) + +## மேலும் வாசிக்க {#further-reading} + +- [எத்தேரியம் ஸ்மார்ட் ஒப்பந்தங்களைச் சோதிப்பதற்கான ஒரு ஆழமான வழிகாட்டி](https://iamdefinitelyahuman.medium.com/an-in-depth-guide-to-testing-ethereum-smart-contracts-2e41b2770297) +- [எத்தேரியம் ஸ்மார்ட் ஒப்பந்தங்களை எவ்வாறு சோதிப்பது](https://betterprogramming.pub/how-to-test-ethereum-smart-contracts-35abc8fa199d) +- [டெவலப்பர்களுக்கான MolochDAO-இன் அலகு சோதனை வழிகாட்டி](https://github.com/MolochVentures/moloch/tree/4e786db8a4aa3158287e0935dcbc7b1e43416e38/test#moloch-testing-guide) +- [ஒரு ராக்ஸ்டார் போல ஸ்மார்ட் ஒப்பந்தங்களை எவ்வாறு சோதிப்பது](https://forum.openzeppelin.com/t/test-smart-contracts-like-a-rockstar/1001) diff --git a/public/content/translations/ta/developers/docs/smart-contracts/upgrading/index.md b/public/content/translations/ta/developers/docs/smart-contracts/upgrading/index.md new file mode 100644 index 00000000000..6a4ff6c74bd --- /dev/null +++ b/public/content/translations/ta/developers/docs/smart-contracts/upgrading/index.md @@ -0,0 +1,165 @@ +--- +title: "ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்துதல்" +description: "எத்தேரியம் ஸ்மார்ட் ஒப்பந்தங்களுக்கான மேம்படுத்தல் வடிவங்களின் ஒரு கண்ணோட்டம்" +lang: ta +--- + +எத்தேரியத்தில் உள்ள ஸ்மார்ட் ஒப்பந்தங்கள் எத்தேரியம் மெய்நிகர் இயந்திரத்தில் (EVM) இயங்கும் சுய-செயல்படுத்தும் நிரல்களாகும். இந்த நிரல்கள் வடிவமைப்பால் மாற்ற முடியாதவை, இது ஒப்பந்தம் பயன்படுத்தப்பட்டவுடன் வணிக தர்க்கத்தில் எந்தப் புதுப்பிப்புகளையும் தடுக்கிறது. + +நம்பகத்தன்மை, பரவலாக்கம் மற்றும் ஸ்மார்ட் ஒப்பந்தங்களின் பாதுகாப்பிற்கு மாற்றமுடியாத தன்மை அவசியமாக இருந்தாலும், சில சந்தர்ப்பங்களில் இது ஒரு குறைபாடாக இருக்கலாம். உதாரணமாக, மாற்ற முடியாத குறியீடு, பாதிக்கப்படக்கூடிய ஒப்பந்தங்களை டெவலப்பர்கள் சரிசெய்வதை சாத்தியமற்றதாக்கும். + +இருப்பினும், ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்துவதில் அதிகரித்த ஆராய்ச்சி பல மேம்படுத்தல் வடிவங்களை அறிமுகப்படுத்த வழிவகுத்தது. இந்த மேம்படுத்தல் முறைகள், டெவலப்பர்கள் வணிக தர்க்கத்தை வெவ்வேறு ஒப்பந்தங்களில் வைப்பதன் மூலம் ஸ்மார்ட் ஒப்பந்தங்களை (மாற்றமுடியாத தன்மையைப் பாதுகாக்கும் போது) மேம்படுத்த உதவுகின்றன. + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +[ஸ்மார்ட் ஒப்பந்தங்கள்](/developers/docs/smart-contracts/), [ஸ்மார்ட் ஒப்பந்த உடற்கூறியல்](/developers/docs/smart-contracts/anatomy/) மற்றும் [எத்தேரியம் மெய்நிகர் இயந்திரம் (EVM)](/developers/docs/evm/) பற்றி உங்களுக்கு நல்ல புரிதல் இருக்க வேண்டும். இந்த வழிகாட்டி, வாசகர்களுக்கு ஸ்மார்ட் ஒப்பந்தங்களை நிரலாக்குவதில் பிடிப்பு உள்ளது என்று கருதுகிறது. + +## ஸ்மார்ட் ஒப்பந்த மேம்படுத்தல் என்றால் என்ன? {#what-is-a-smart-contract-upgrade} + +ஒரு ஸ்மார்ட் ஒப்பந்த மேம்படுத்தல் என்பது ஒப்பந்தத்தின் நிலையைப் பாதுகாக்கும் போது ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் வணிக தர்க்கத்தை மாற்றுவதை உள்ளடக்குகிறது. மேம்படுத்தக்கூடிய தன்மை மற்றும் மாற்றக்கூடிய தன்மை இரண்டும் ஒன்றல்ல என்பதைத் தெளிவுபடுத்துவது முக்கியம், குறிப்பாக ஸ்மார்ட் ஒப்பந்தங்களின் சூழலில். + +எத்தேரியம் நெட்வொர்க்கில் ஒரு முகவரிக்கு பயன்படுத்தப்பட்ட ஒரு நிரலை உங்களால் இன்னும் மாற்ற முடியாது. ஆனால் பயனர்கள் ஒரு ஸ்மார்ட் ஒப்பந்தத்துடன் தொடர்பு கொள்ளும்போது செயல்படுத்தப்படும் குறியீட்டை நீங்கள் மாற்றலாம். + +பின்வரும் முறைகள் மூலம் இதைச் செய்யலாம்: + +1. ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் பல பதிப்புகளை உருவாக்குதல் மற்றும் பழைய ஒப்பந்தத்திலிருந்து ஒப்பந்தத்தின் புதிய நிகழ்விற்கு நிலையை (அதாவது, தரவு) மாற்றுதல். + +2. வணிக தர்க்கம் மற்றும் நிலையைச் சேமிக்க தனித்தனி ஒப்பந்தங்களை உருவாக்குதல். + +3. மாற்ற முடியாத ப்ராக்ஸி ஒப்பந்தத்திலிருந்து மாற்றியமைக்கக்கூடிய தர்க்க ஒப்பந்தத்திற்கு செயல்பாட்டு அழைப்புகளை ஒப்படைக்க ப்ராக்ஸி வடிவங்களைப் பயன்படுத்துதல். + +4. குறிப்பிட்ட செயல்பாடுகளைச் செயல்படுத்த, நெகிழ்வான துணை ஒப்பந்தங்களுடன் இடைமுகம் செய்து அவற்றைச் சார்ந்திருக்கும் ஒரு மாற்ற முடியாத முக்கிய ஒப்பந்தத்தை உருவாக்குதல். + +5. ஒரு ப்ராக்ஸி ஒப்பந்தத்திலிருந்து தர்க்க ஒப்பந்தங்களுக்குச் செயல்பாட்டு அழைப்புகளை ஒப்படைக்க டைமண்ட் வடிவத்தைப் பயன்படுத்துதல். + +### மேம்படுத்தல் வழிமுறை #1: ஒப்பந்தப் பெயர்ச்சி {#contract-migration} + +ஒப்பந்தப் பெயர்ச்சி என்பது பதிப்பாக்கத்தை அடிப்படையாகக் கொண்டது - ஒரே மென்பொருளின் தனித்துவமான நிலைகளை உருவாக்கி நிர்வகிக்கும் யோசனை. ஒப்பந்த பெயர்ச்சி என்பது ஏற்கனவே உள்ள ஸ்மார்ட் ஒப்பந்தத்தின் புதிய நிகழ்வைப் பயன்படுத்துதல் மற்றும் சேமிப்பகம் மற்றும் இருப்புகளைப் புதிய ஒப்பந்தத்திற்கு மாற்றுவதை உள்ளடக்குகிறது. + +புதிதாகப் பயன்படுத்தப்பட்ட ஒப்பந்தத்தில் ஒரு வெற்று சேமிப்பகம் இருக்கும், இது பழைய ஒப்பந்தத்திலிருந்து தரவை மீட்டெடுக்கவும், புதிய செயலாக்கத்தில் அதை எழுதவும் உங்களை அனுமதிக்கிறது. அதன்பிறகு, புதிய முகவரியைப் பிரதிபலிக்கும் வகையில் பழைய ஒப்பந்தத்துடன் தொடர்பு கொண்ட அனைத்து ஒப்பந்தங்களையும் நீங்கள் புதுப்பிக்க வேண்டும். + +ஒப்பந்தப் பெயர்ச்சியின் கடைசிப் படி, புதிய ஒப்பந்தத்தைப் பயன்படுத்த பயனர்களை மாற்றுவதாகும். புதிய ஒப்பந்தப் பதிப்பு பயனர் இருப்புகள் மற்றும் முகவரிகளைத் தக்க வைத்துக் கொள்ளும், இது மாற்ற முடியாத தன்மையைப் பாதுகாக்கிறது. இது டோக்கன் அடிப்படையிலான ஒப்பந்தமாக இருந்தால், பழைய ஒப்பந்தத்தை நிராகரித்து புதிய ஒப்பந்தத்தைப் பயன்படுத்த, பரிமாற்றங்களைத் தொடர்பு கொள்ளவும் வேண்டும். + +ஒப்பந்தப் பெயர்ச்சி என்பது பயனர் தொடர்புகளை முறித்துக் கொள்ளாமல் ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்துவதற்கான ஒப்பீட்டளவில் நேரடியான மற்றும் பாதுகாப்பான நடவடிக்கையாகும். இருப்பினும், பயனர் சேமிப்பகம் மற்றும் இருப்புகளைப் புதிய ஒப்பந்தத்திற்கு கைமுறையாக மாற்றுவது நேரத்தைச் செலவழிக்கும் மற்றும் அதிக எரிவாயு செலவுகளை ஏற்படுத்தலாம். + +[ஒப்பந்தப் பெயர்ச்சி பற்றி மேலும் அறிக.](https://blog.trailofbits.com/2018/10/29/how-contract-migration-works/) + +### மேம்படுத்தல் வழிமுறை #2: தரவுப் பிரிப்பு {#data-separation} + +ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்துவதற்கான மற்றொரு முறை, வணிக தர்க்கம் மற்றும் தரவு சேமிப்பகத்தை தனித்தனி ஒப்பந்தங்களாகப் பிரிப்பதாகும். இதன் பொருள் பயனர்கள் தர்க்க ஒப்பந்தத்துடன் தொடர்பு கொள்கிறார்கள், அதே நேரத்தில் தரவு சேமிப்பக ஒப்பந்தத்தில் சேமிக்கப்படுகிறது. + +பயனர்கள் செயலியுடன் தொடர்பு கொள்ளும்போது செயல்படுத்தப்படும் குறியீட்டை தர்க்க ஒப்பந்தம் கொண்டுள்ளது. இது சேமிப்பக ஒப்பந்தத்தின் முகவரியையும் வைத்திருக்கிறது மற்றும் தரவைப் பெறவும் அமைக்கவும் அதனுடன் தொடர்பு கொள்கிறது. + +இதற்கிடையில், சேமிப்பக ஒப்பந்தம் பயனர் இருப்புகள் மற்றும் முகவரிகள் போன்ற ஸ்மார்ட் ஒப்பந்தத்துடன் தொடர்புடைய நிலையை வைத்திருக்கிறது. சேமிப்பக ஒப்பந்தம் தர்க்க ஒப்பந்தத்திற்குச் சொந்தமானது மற்றும் வரிசைப்படுத்தலில் பின்னதன் முகவரியுடன் கட்டமைக்கப்பட்டுள்ளது என்பதைக் கவனத்தில் கொள்க. இது அங்கீகரிக்கப்படாத ஒப்பந்தங்கள் சேமிப்பக ஒப்பந்தத்தை அழைப்பதையோ அல்லது அதன் தரவைப் புதுப்பிப்பதையோ தடுக்கிறது. + +இயல்பாக, சேமிப்பக ஒப்பந்தம் மாற்ற முடியாதது - ஆனால் அது சுட்டிக்காட்டும் தர்க்க ஒப்பந்தத்தை ஒரு புதிய செயலாக்கத்துடன் மாற்றலாம். இது EVM-இல் இயங்கும் குறியீட்டை மாற்றும், அதே நேரத்தில் சேமிப்பகம் மற்றும் இருப்புகளை அப்படியே வைத்திருக்கும். + +இந்த மேம்படுத்தல் முறையைப் பயன்படுத்த, சேமிப்பக ஒப்பந்தத்தில் உள்ள தர்க்க ஒப்பந்தத்தின் முகவரியைப் புதுப்பிக்க வேண்டும். முன்னர் விளக்கப்பட்ட காரணங்களுக்காக, புதிய தர்க்க ஒப்பந்தத்தை சேமிப்பக ஒப்பந்தத்தின் முகவரியுடன் நீங்கள் கட்டமைக்க வேண்டும். + +ஒப்பந்தப் பெயர்ச்சியுடன் ஒப்பிடும்போது தரவுப் பிரிப்பு வடிவத்தைச் செயல்படுத்துவது விவாதத்திற்குரிய வகையில் எளிதானது. இருப்பினும், நீங்கள் பல ஒப்பந்தங்களை நிர்வகிக்க வேண்டும் மற்றும் தீங்கிழைக்கும் மேம்படுத்தல்களில் இருந்து ஸ்மார்ட் ஒப்பந்தங்களைப் பாதுகாக்க சிக்கலான அங்கீகாரத் திட்டங்களைச் செயல்படுத்த வேண்டும். + +### மேம்படுத்தல் வழிமுறை #3: ப்ராக்ஸி வடிவங்கள் {#proxy-patterns} + +ப்ராக்ஸி வடிவமும் வணிக தர்க்கத்தையும் தரவையும் தனித்தனி ஒப்பந்தங்களில் வைத்திருக்க தரவுப் பிரிப்பைப் பயன்படுத்துகிறது. இருப்பினும், ஒரு ப்ராக்ஸி வடிவத்தில், சேமிப்பக ஒப்பந்தம் (ப்ராக்ஸி என்று அழைக்கப்படுகிறது) குறியீடு செயல்படுத்தும் போது தர்க்க ஒப்பந்தத்தை அழைக்கிறது. இது தரவு பிரிப்பு முறையின் தலைகீழ் ஆகும், அங்கு தர்க்க ஒப்பந்தம் சேமிப்பக ஒப்பந்தத்தை அழைக்கிறது. + +ஒரு ப்ராக்ஸி வடிவத்தில் இதுதான் நடக்கிறது: + +1. பயனர்கள் ப்ராக்ஸி ஒப்பந்தத்துடன் தொடர்பு கொள்கிறார்கள், இது தரவைச் சேமிக்கிறது, ஆனால் வணிக தர்க்கத்தைக் கொண்டிருக்கவில்லை. + +2. `delegatecall` செயல்பாட்டைப் பயன்படுத்தி தர்க்க ஒப்பந்தத்தின் முகவரியை ப்ராக்ஸி ஒப்பந்தம் சேமித்து, அனைத்து செயல்பாட்டு அழைப்புகளையும் தர்க்க ஒப்பந்தத்திற்கு (வணிக தர்க்கத்தைக் கொண்டிருக்கும்) ஒப்படைக்கிறது. + +3. அழைப்பு தர்க்க ஒப்பந்தத்திற்கு அனுப்பப்பட்ட பிறகு, தர்க்க ஒப்பந்தத்திலிருந்து திரும்பிய தரவு மீட்டெடுக்கப்பட்டு பயனருக்குத் திருப்பி அனுப்பப்படுகிறது. + +ப்ராக்ஸி வடிவங்களைப் பயன்படுத்த **delegatecall** செயல்பாட்டின் புரிதல் தேவை. அடிப்படையில், `delegatecall` என்பது ஒரு ஒப்பந்தம் மற்றொரு ஒப்பந்தத்தை அழைக்க அனுமதிக்கும் ஒரு ஆப்கோட் ஆகும், அதே நேரத்தில் உண்மையான குறியீடு செயல்படுத்தல் அழைக்கும் ஒப்பந்தத்தின் சூழலில் நிகழ்கிறது. ப்ராக்ஸி வடிவங்களில் `delegatecall` ஐப் பயன்படுத்துவதன் ஒரு தாக்கம் என்னவென்றால், ப்ராக்ஸி ஒப்பந்தம் அதன் சேமிப்பகத்தில் படித்து எழுதுகிறது மற்றும் தர்க்க ஒப்பந்தத்தில் சேமிக்கப்பட்ட தர்க்கத்தை ஒரு உள் செயல்பாட்டை அழைப்பதைப் போல செயல்படுத்துகிறது. + +[Solidity ஆவணத்திலிருந்து](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#delegatecall-callcode-and-libraries): + +> _**delegatecall** எனப்படும் ஒரு செய்தி அழைப்பின் ஒரு சிறப்பு மாறுபாடு உள்ளது, இது இலக்கு முகவரியில் உள்ள குறியீடு அழைக்கும் ஒப்பந்தத்தின் சூழலில் (அதாவது, முகவரியில்) செயல்படுத்தப்படுகிறது மற்றும் `msg.sender` மற்றும் `msg.value` அவற்றின் மதிப்புகளை மாற்றாது என்பதைத் தவிர, இது ஒரு செய்தி அழைப்பைப் போன்றது._ _இதன் பொருள் ஒரு ஒப்பந்தம் இயக்க நேரத்தில் வேறு முகவரியிலிருந்து குறியீட்டை மாறும் வகையில் ஏற்ற முடியும். சேமிப்பகம், தற்போதைய முகவரி மற்றும் இருப்பு ஆகியவை இன்னும் அழைக்கும் ஒப்பந்தத்தையே குறிப்பிடுகின்றன, குறியீடு மட்டுமே அழைக்கப்பட்ட முகவரியிலிருந்து எடுக்கப்படுகிறது._ + +ப்ராக்ஸி ஒப்பந்தத்தில் ஒரு `fallback` செயல்பாடு உள்ளதால், ஒரு பயனர் ஒரு செயல்பாட்டை அழைக்கும்போதெல்லாம் `delegatecall` ஐ அழைக்க வேண்டும் என்பதை அது அறியும். Solidity நிரலாக்கத்தில், ஒரு செயல்பாட்டு அழைப்பு ஒரு ஒப்பந்தத்தில் குறிப்பிடப்பட்ட செயல்பாடுகளுடன் பொருந்தாதபோது [fallback செயல்பாடு](https://docs.soliditylang.org/en/latest/contracts.html#fallback-function) செயல்படுத்தப்படுகிறது. + +ப்ராக்ஸி வடிவத்தை வேலை செய்ய வைக்க, ப்ராக்ஸி ஒப்பந்தம் ஆதரிக்காத செயல்பாட்டு அழைப்புகளை எவ்வாறு கையாள வேண்டும் என்பதைக் குறிப்பிடும் ஒரு தனிப்பயன் fallback செயல்பாட்டை எழுத வேண்டும். இந்த வழக்கில், ப்ராக்ஸியின் fallback செயல்பாடு ஒரு delegatecall-ஐத் தொடங்கவும், பயனரின் கோரிக்கையை தற்போதைய தர்க்க ஒப்பந்தச் செயலாக்கத்திற்குத் திருப்பிவிடவும் நிரல்படுத்தப்பட்டுள்ளது. + +ப்ராக்ஸி ஒப்பந்தம் இயல்பாக மாற்ற முடியாதது, ஆனால் புதுப்பிக்கப்பட்ட வணிக தர்க்கத்துடன் புதிய தர்க்க ஒப்பந்தங்களை உருவாக்கலாம். மேம்படுத்தலைச் செய்வது என்பது ப்ராக்ஸி ஒப்பந்தத்தில் குறிப்பிடப்பட்டுள்ள தர்க்க ஒப்பந்தத்தின் முகவரியை மாற்றுவதாகும். + +ப்ராக்ஸி ஒப்பந்தத்தை ஒரு புதிய தர்க்க ஒப்பந்தத்திற்குச் சுட்டிக்காட்டுவதன் மூலம், பயனர்கள் ப்ராக்ஸி ஒப்பந்தச் செயல்பாட்டை அழைக்கும்போது செயல்படுத்தப்படும் குறியீடு மாறுகிறது. புதிய ஒப்பந்தத்துடன் தொடர்பு கொள்ளும்படி பயனர்களைக் கேட்காமல் ஒரு ஒப்பந்தத்தின் தர்க்கத்தை மேம்படுத்த இது நம்மை அனுமதிக்கிறது. + +ஒப்பந்தப் பெயர்ச்சியுடன் தொடர்புடைய சிரமங்களை நீக்குவதால், ப்ராக்ஸி வடிவங்கள் ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்துவதற்கான ஒரு பிரபலமான முறையாகும். இருப்பினும், ப்ராக்ஸி வடிவங்களைப் பயன்படுத்துவது மிகவும் சிக்கலானது மற்றும் தவறாகப் பயன்படுத்தப்பட்டால், [செயல்பாட்டுத் தேர்வி மோதல்கள்](https://medium.com/nomic-foundation-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357) போன்ற முக்கியமான குறைபாடுகளை அறிமுகப்படுத்தலாம். + +[ப்ராக்ஸி வடிவங்கள் பற்றி மேலும் அறிக](https://blog.openzeppelin.com/proxy-patterns/). + +### மேம்படுத்தல் வழிமுறை #4: உத்தி வடிவம் {#strategy-pattern} + +இந்த நுட்பம் [உத்தி வடிவத்தால்](https://en.wikipedia.org/wiki/Strategy_pattern) பாதிக்கப்பட்டுள்ளது, இது குறிப்பிட்ட அம்சங்களைச் செயல்படுத்த பிற நிரல்களுடன் இடைமுகம் செய்யும் மென்பொருள் நிரல்களை உருவாக்குவதை ஊக்குவிக்கிறது. எத்தேரியம் மேம்பாட்டிற்கு உத்தி வடிவத்தைப் பயன்படுத்துவது என்பது மற்ற ஒப்பந்தங்களிலிருந்து செயல்பாடுகளை அழைக்கும் ஒரு ஸ்மார்ட் ஒப்பந்தத்தை உருவாக்குவதாகும். + +இந்த வழக்கில் முக்கிய ஒப்பந்தம் முக்கிய வணிக தர்க்கத்தைக் கொண்டுள்ளது, ஆனால் சில செயல்பாடுகளைச் செயல்படுத்த மற்ற ஸ்மார்ட் ஒப்பந்தங்களுடன் ("துணை ஒப்பந்தங்கள்") இடைமுகம் செய்கிறது. இந்த முக்கிய ஒப்பந்தம் ஒவ்வொரு துணை ஒப்பந்தத்திற்கான முகவரியையும் சேமித்து, துணை ஒப்பந்தத்தின் வெவ்வேறு செயலாக்கங்களுக்கு இடையில் மாறலாம். + +நீங்கள் ஒரு புதிய துணை ஒப்பந்தத்தை உருவாக்கி, முக்கிய ஒப்பந்தத்தை புதிய முகவரியுடன் கட்டமைக்கலாம். இது ஒரு ஸ்மார்ட் ஒப்பந்தத்திற்கான _உத்திகளை_ (அதாவது, புதிய தர்க்கத்தைச் செயல்படுத்துதல்) மாற்ற உங்களை அனுமதிக்கிறது. + +முன்னர் விவாதிக்கப்பட்ட ப்ராக்ஸி வடிவத்தைப் போலவே இருந்தாலும், உத்தி வடிவம் வேறுபட்டது, ஏனெனில் பயனர்கள் தொடர்பு கொள்ளும் முக்கிய ஒப்பந்தம், வணிக தர்க்கத்தைக் கொண்டுள்ளது. இந்த வடிவத்தைப் பயன்படுத்துவது, முக்கிய உள்கட்டமைப்பைப் பாதிக்காமல் ஒரு ஸ்மார்ட் ஒப்பந்தத்தில் வரையறுக்கப்பட்ட மாற்றங்களை அறிமுகப்படுத்த உங்களுக்கு வாய்ப்பளிக்கிறது. + +முக்கிய குறைபாடு என்னவென்றால், இந்த வடிவம் பெரும்பாலும் சிறிய மேம்படுத்தல்களை வெளியிடுவதற்கு மட்டுமே பயனுள்ளதாக இருக்கும். மேலும், முக்கிய ஒப்பந்தம் சமரசம் செய்யப்பட்டால் (எ.கா., ஒரு ஹேக் மூலம்), இந்த மேம்படுத்தல் முறையை நீங்கள் பயன்படுத்த முடியாது. + +### மேம்படுத்தல் வழிமுறை #5: டைமண்ட் வடிவம் {#diamond-pattern} + +டைமண்ட் வடிவத்தை ப்ராக்ஸி வடிவத்தின் மேம்பாடாகக் கருதலாம். டைமண்ட் ப்ராக்ஸி ஒப்பந்தம் ஒன்றுக்கு மேற்பட்ட தர்க்க ஒப்பந்தங்களுக்கு செயல்பாட்டு அழைப்புகளை ஒப்படைக்க முடியும் என்பதால், டைமண்ட் வடிவங்கள் ப்ராக்ஸி வடிவங்களிலிருந்து வேறுபடுகின்றன. + +டைமண்ட் வடிவத்தில் உள்ள தர்க்க ஒப்பந்தங்கள் _ஃபேசெட்கள்_ என்று அழைக்கப்படுகின்றன. டைமண்ட் வடிவத்தை வேலை செய்ய வைக்க, ப்ராக்ஸி ஒப்பந்தத்தில் [செயல்பாட்டுத் தேர்வாளர்களை](https://docs.soliditylang.org/en/latest/abi-spec.html#function-selector) வெவ்வேறு ஃபேசெட் முகவரிகளுக்கு வரைபடமாக்கும் ஒரு வரைபடத்தை நீங்கள் உருவாக்க வேண்டும். + +ஒரு பயனர் ஒரு செயல்பாட்டு அழைப்பைச் செய்யும்போது, ப்ராக்ஸி ஒப்பந்தம் அந்தச் செயல்பாட்டைச் செயல்படுத்துவதற்குப் பொறுப்பான ஃபேசெட்டைக் கண்டறிய வரைபடத்தைச் சரிபார்க்கிறது. பின்னர் அது `delegatecall` ஐ (fallback செயல்பாட்டைப் பயன்படுத்தி) வரவழைத்து, அழைப்பை பொருத்தமான தர்க்க ஒப்பந்தத்திற்குத் திருப்பிவிடுகிறது. + +பாரம்பரிய ப்ராக்ஸி மேம்படுத்தல் வடிவங்களைக் காட்டிலும் டைமண்ட் மேம்படுத்தல் வடிவத்தில் சில நன்மைகள் உள்ளன: + +1. அனைத்துக் குறியீட்டையும் மாற்றாமல் ஒப்பந்தத்தின் ஒரு சிறிய பகுதியை மேம்படுத்த இது உங்களை அனுமதிக்கிறது. மேம்படுத்தல்களுக்கு ப்ராக்ஸி வடிவத்தைப் பயன்படுத்த, சிறிய மேம்படுத்தல்களுக்குக் கூட, முற்றிலும் புதிய தர்க்க ஒப்பந்தத்தை உருவாக்க வேண்டும். + +2. அனைத்து ஸ்மார்ட் ஒப்பந்தங்களும் (ப்ராக்ஸி வடிவங்களில் பயன்படுத்தப்படும் தர்க்க ஒப்பந்தங்கள் உட்பட) 24KB அளவு வரம்பைக் கொண்டுள்ளன, இது ஒரு வரம்பாக இருக்கலாம் - குறிப்பாக அதிக செயல்பாடுகள் தேவைப்படும் சிக்கலான ஒப்பந்தங்களுக்கு. டைமண்ட் வடிவம் பல தர்க்க ஒப்பந்தங்களில் செயல்பாடுகளைப் பிரிப்பதன் மூலம் இந்தச் சிக்கலைத் தீர்ப்பதை எளிதாக்குகிறது. + +3. ப்ராக்ஸி வடிவங்கள் அணுகல் கட்டுப்பாடுகளுக்கு அனைத்தையும் உள்ளடக்கிய அணுகுமுறையை ஏற்றுக்கொள்கின்றன. செயல்பாடுகளை மேம்படுத்துவதற்கான அணுகல் உள்ள ஒரு நிறுவனம் _முழு_ ஒப்பந்தத்தையும் மாற்ற முடியும். ஆனால் டைமண்ட் வடிவம் ஒரு மட்டு அனுமதிகள் அணுகுமுறையை செயல்படுத்துகிறது, அங்கு நீங்கள் ஒரு ஸ்மார்ட் ஒப்பந்தத்திற்குள் சில செயல்பாடுகளை மேம்படுத்துவதற்கு நிறுவனங்களைக் கட்டுப்படுத்தலாம். + +[டைமண்ட் வடிவம் பற்றி மேலும் அறிக](https://eip2535diamonds.substack.com/p/introduction-to-the-diamond-standard?s=w). + +## ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்துவதன் நன்மை தீமைகள் {#pros-and-cons-of-upgrading-smart-contracts} + +| நிறைகள் | குறைகள் | +| ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| ஒரு ஸ்மார்ட் ஒப்பந்த மேம்படுத்தல், வரிசைப்படுத்தலுக்குப் பிந்தைய கட்டத்தில் கண்டறியப்பட்ட பாதிப்புகளை சரிசெய்வதை எளிதாக்கும். | ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்துவது குறியீடு மாற்ற முடியாதது என்ற கருத்தை மறுக்கிறது, இது பரவலாக்கம் மற்றும் பாதுகாப்பிற்கான தாக்கங்களைக் கொண்டுள்ளது. | +| டெவலப்பர்கள் பரவலாக்கப்பட்ட பயன்பாடுகளில் புதிய அம்சங்களைச் சேர்க்க தர்க்க மேம்படுத்தல்களைப் பயன்படுத்தலாம். | பயனர்கள் டெவலப்பர்கள் ஸ்மார்ட் ஒப்பந்தங்களை தன்னிச்சையாக மாற்ற மாட்டார்கள் என்று நம்ப வேண்டும். | +| பிழைகளை விரைவாக சரிசெய்ய முடியும் என்பதால் ஸ்மார்ட் ஒப்பந்த மேம்படுத்தல்கள் இறுதிப் பயனர்களுக்கான பாதுகாப்பை மேம்படுத்தலாம். | ஸ்மார்ட் ஒப்பந்தங்களில் மேம்படுத்தல் செயல்பாட்டை நிரலாக்குவது மற்றொரு அடுக்கு சிக்கலைச் சேர்க்கிறது மற்றும் முக்கியமான குறைபாடுகளின் சாத்தியத்தை அதிகரிக்கிறது. | +| ஒப்பந்த மேம்படுத்தல்கள் டெவலப்பர்களுக்கு வெவ்வேறு அம்சங்களுடன் பரிசோதனை செய்வதற்கும் காலப்போக்கில் டாப்களை மேம்படுத்துவதற்கும் அதிக இடமளிக்கின்றன. | ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்துவதற்கான வாய்ப்பு, மேம்பாட்டுக் கட்டத்தில் உரிய விடாமுயற்சியைச் செய்யாமல், திட்டங்களை விரைவாகத் தொடங்க டெவலப்பர்களை ஊக்குவிக்கலாம். | +| | பாதுகாப்பற்ற அணுகல் கட்டுப்பாடு அல்லது ஸ்மார்ட் ஒப்பந்தங்களில் மையப்படுத்தல் ஆகியவை தீங்கிழைக்கும் நடிகர்கள் அங்கீகரிக்கப்படாத மேம்படுத்தல்களைச் செய்வதை எளிதாக்கும். | + +## ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்துவதற்கான பரிசீலனைகள் {#considerations-for-upgrading-smart-contracts} + +1. அங்கீகரிக்கப்படாத ஸ்மார்ட் ஒப்பந்த மேம்படுத்தல்களைத் தடுக்க, பாதுகாப்பான அணுகல் கட்டுப்பாடு/அங்கீகார வழிமுறைகளைப் பயன்படுத்தவும், குறிப்பாக ப்ராக்ஸி வடிவங்கள், உத்தி வடிவங்கள் அல்லது தரவுப் பிரிப்பைப் பயன்படுத்தினால். ஒரு உதாரணம் மேம்படுத்தல் செயல்பாட்டிற்கான அணுகலைக் கட்டுப்படுத்துவதாகும், அதாவது ஒப்பந்தத்தின் உரிமையாளர் மட்டுமே அதை அழைக்க முடியும். + +2. ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்துவது ஒரு சிக்கலான செயலாகும், மேலும் பாதிப்புகள் அறிமுகப்படுத்தப்படுவதைத் தடுக்க அதிக அளவு விடாமுயற்சி தேவைப்படுகிறது. + +3. மேம்படுத்தல்களைச் செயல்படுத்தும் செயல்முறையைப் பரவலாக்குவதன் மூலம் நம்பிக்கை அனுமானங்களைக் குறைக்கவும். சாத்தியமான உத்திகளில் மேம்படுத்தல்களைக் கட்டுப்படுத்த [பல்-கையொப்ப பணப்பை ஒப்பந்தத்தைப்](/developers/docs/smart-contracts/#multisig) பயன்படுத்துவது அல்லது மேம்படுத்தலுக்கு ஒப்புதல் அளிக்க வாக்களிக்க [ஒரு DAO இன் உறுப்பினர்களை](/dao/) கோருவது ஆகியவை அடங்கும். + +4. ஒப்பந்தங்களை மேம்படுத்துவதில் உள்ள செலவுகள் குறித்து எச்சரிக்கையாக இருங்கள். உதாரணமாக, ஒப்பந்தப் பெயர்ச்சியின் போது ஒரு பழைய ஒப்பந்தத்திலிருந்து ஒரு புதிய ஒப்பந்தத்திற்கு நிலையை (எ.கா., பயனர் இருப்புகள்) நகலெடுப்பதற்கு ஒன்றுக்கு மேற்பட்ட பரிவர்த்தனைகள் தேவைப்படலாம், அதாவது அதிக எரிவாயு கட்டணம். + +5. பயனர்களைப் பாதுகாக்க **நேரப்பூட்டுகளை** செயல்படுத்துவதைக் கவனியுங்கள். ஒரு நேரப்பூட்டு என்பது ஒரு அமைப்பில் ஏற்படும் மாற்றங்களுக்கு விதிக்கப்படும் தாமதத்தைக் குறிக்கிறது. மேம்படுத்தல்களைக் கட்டுப்படுத்த நேரப்பூட்டுகளை பல்-கையொப்ப ஆளுமை அமைப்புடன் இணைக்கலாம்: முன்மொழியப்பட்ட செயல் தேவையான ஒப்புதல் வரம்பை அடைந்தால், முன்னரே வரையறுக்கப்பட்ட தாமத காலம் முடியும் வரை அது செயல்படுத்தப்படாது. + +முன்மொழியப்பட்ட மாற்றத்துடன் (எ.கா., தர்க்க மேம்படுத்தல் அல்லது புதிய கட்டணத் திட்டங்கள்) உடன்படவில்லை என்றால், அமைப்பிலிருந்து வெளியேற பயனர்களுக்கு நேரப்பூட்டுகள் சிறிது நேரம் கொடுக்கின்றன. நேரப்பூட்டுகள் இல்லாமல், முன்னறிவிப்பின்றி ஒரு ஸ்மார்ட் ஒப்பந்தத்தில் தன்னிச்சையான மாற்றங்களைச் செயல்படுத்த மாட்டார்கள் என்று பயனர்கள் டெவலப்பர்களை நம்ப வேண்டும். இங்குள்ள குறைபாடு என்னவென்றால், நேரப்பூட்டுகள் பாதிப்புகளை விரைவாக சரிசெய்யும் திறனைக் கட்டுப்படுத்துகின்றன. + +## ஆதாரங்கள் {#resources} + +**OpenZeppelin மேம்படுத்தல்கள் செருகுநிரல்கள் - _மேம்படுத்தக்கூடிய ஸ்மார்ட் ஒப்பந்தங்களைப் பயன்படுத்துவதற்கும் பாதுகாப்பதற்கும் ஆன கருவிகளின் தொகுப்பு._** + +- [GitHub](https://github.com/OpenZeppelin/openzeppelin-upgrades) +- [ஆவணம்](https://docs.openzeppelin.com/upgrades) + +## பயிற்சிகள் {#tutorials} + +- [உங்கள் ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்துதல் | YouTube பயிற்சி](https://www.youtube.com/watch?v=bdXJmWajZRY) by Patrick Collins +- [எத்தேரியம் ஸ்மார்ட் ஒப்பந்தப் பெயர்ச்சி பயிற்சி](https://medium.com/coinmonks/ethereum-smart-contract-migration-13f6f12539bd) by Austin Griffith +- [ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்த UUPS ப்ராக்ஸி வடிவத்தைப் பயன்படுத்துதல்](https://blog.logrocket.com/author/praneshas/) by Pranesh A.S +- [Web3 பயிற்சி: OpenZeppelin-ஐப் பயன்படுத்தி மேம்படுத்தக்கூடிய ஸ்மார்ட் ஒப்பந்தம் (ப்ராக்ஸி) எழுதுங்கள்](https://dev.to/yakult/tutorial-write-upgradeable-smart-contract-proxy-contract-with-openzeppelin-1916) by fangjun.eth + +## மேலும் வாசிக்க {#further-reading} + +- [ஸ்மார்ட் ஒப்பந்த மேம்படுத்தல்களின் நிலை](https://blog.openzeppelin.com/the-state-of-smart-contract-upgrades/) by Santiago Palladino +- [ஒரு Solidity ஸ்மார்ட் ஒப்பந்தத்தை மேம்படுத்த பல வழிகள்](https://cryptomarketpool.com/multiple-ways-to-upgrade-a-solidity-smart-contract/) - Crypto Market Pool வலைப்பதிவு +- [அறிக: ஸ்மார்ட் ஒப்பந்தங்களை மேம்படுத்துதல்](https://docs.openzeppelin.com/learn/upgrading-smart-contracts) - OpenZeppelin ஆவணங்கள் +- [Solidity ஒப்பந்தங்களின் மேம்படுத்தலுக்கான ப்ராக்ஸி வடிவங்கள்: வெளிப்படையான மற்றும் UUPS ப்ராக்ஸிகள்](https://mirror.xyz/0xB38709B8198d147cc9Ff9C133838a044d78B064B/M7oTptQkBGXxox-tk9VJjL66E1V8BUF0GF79MMK4YG0) by Naveen Sahu +- [டைமண்ட் மேம்படுத்தல்கள் எவ்வாறு செயல்படுகின்றன](https://dev.to/mudgen/how-diamond-upgrades-work-417j) by Nick Mudge diff --git a/public/content/translations/ta/developers/docs/smart-contracts/verifying/index.md b/public/content/translations/ta/developers/docs/smart-contracts/verifying/index.md new file mode 100644 index 00000000000..9860998c60c --- /dev/null +++ b/public/content/translations/ta/developers/docs/smart-contracts/verifying/index.md @@ -0,0 +1,113 @@ +--- +title: "ஸ்மார்ட் ஒப்பந்தங்களைச் சரிபார்த்தல்" +description: "எத்தேரியம் ஸ்மார்ட் ஒப்பந்தங்களுக்கான மூலக் குறியீடு சரிபார்ப்பின் மேலோட்டம்" +lang: ta +--- + +[ஸ்மார்ட் ஒப்பந்தங்கள்](/developers/docs/smart-contracts/) “நம்பிக்கை தேவைப்படாத” வகையில் வடிவமைக்கப்பட்டுள்ளன, அதாவது ஒரு ஒப்பந்தத்துடன் ஊடாடுவதற்கு முன்பு பயனர்கள் மூன்றாம் தரப்பினரை (எ.கா., உருவாக்குநர்கள் (டெவலப்பர்கள்) மற்றும் நிறுவனங்கள்) நம்ப வேண்டியதில்லை. நம்பிக்கை தேவைப்படாத தன்மைக்கு ஒரு தேவையாக, பயனர்கள் மற்றும் பிற உருவாக்குநர்கள் ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் மூலக் குறியீட்டைச் சரிபார்க்கக் கூடியதாக இருக்க வேண்டும். மூலக் குறியீடு சரிபார்ப்பானது, வெளியிடப்பட்ட ஒப்பந்தக் குறியீடு எத்தேரியம் பிளாக்செயினில் உள்ள ஒப்பந்த முகவரியில் இயங்கும் அதே குறியீடுதான் என்பதைப் பயனர்கள் மற்றும் உருவாக்குநர்களுக்கு உறுதி செய்கிறது. + +"மூலக் குறியீடு சரிபார்ப்பு" மற்றும் "[முறைசார் சரிபார்ப்பு](/developers/docs/smart-contracts/formal-verification/)" ஆகியவற்றுக்கு இடையேயான வேறுபாட்டை உருவாக்குவது முக்கியம். மூலக் குறியீடு சரிபார்ப்பு, கீழே விரிவாக விளக்கப்படும், இது ஒரு உயர்-நிலை மொழியில் (எ.கா., Solidity) ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் கொடுக்கப்பட்ட மூலக் குறியீடு ஒப்பந்த முகவரியில் செயல்படுத்தப்பட வேண்டிய அதே பைட்கோடாக தொகுக்கப்படுகிறதா என்பதைச் சரிபார்ப்பதைக் குறிக்கிறது. இருப்பினும், முறைசார் சரிபார்ப்பு ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் சரியான தன்மையைச் சரிபார்ப்பதை விவரிக்கிறது, அதாவது ஒப்பந்தம் எதிர்பார்த்தபடி செயல்படுகிறது. சூழல் சார்ந்ததாக இருந்தாலும், ஒப்பந்தச் சரிபார்ப்பு பொதுவாக மூலக் குறியீடு சரிபார்ப்பைக் குறிக்கிறது. + +## மூலக் குறியீடு சரிபார்ப்பு என்றால் என்ன? {#what-is-source-code-verification} + +[எத்தேரியம் மெய்நிகர் இயந்திரத்தில் (EVM)](/developers/docs/evm/) ஒரு ஸ்மார்ட் ஒப்பந்தத்தைச் செயல்படுத்துவதற்கு முன்பு, உருவாக்குநர்கள் ஒப்பந்தத்தின் மூலக் குறியீட்டை — [Solidity-இல் எழுதப்பட்ட](/developers/docs/smart-contracts/languages/) அறிவுறுத்தல்கள் அல்லது மற்றொரு உயர்-நிலை நிரலாக்க மொழி — பைட்கோடாக [தொகுக்கிறார்கள்](/developers/docs/smart-contracts/compiling/). EVM உயர்-நிலை வழிமுறைகளைப் புரிந்துகொள்ள முடியாததால், EVM-இல் ஒப்பந்த தர்க்கத்தைச் செயல்படுத்த மூலக் குறியீட்டை பைட்கோடாக (அதாவது, கீழ்-நிலை, இயந்திர வழிமுறைகள்) தொகுப்பது அவசியமாகும். + +மூலக் குறியீடு சரிபார்ப்பு என்பது ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் மூலக் குறியீட்டையும், ஒப்பந்தத்தை உருவாக்கும்போது பயன்படுத்தப்பட்ட தொகுக்கப்பட்ட பைட்கோட்டையும் ஒப்பிட்டு ஏதேனும் வேறுபாடுகளைக் கண்டறிவதாகும். விளம்பரப்படுத்தப்பட்ட ஒப்பந்தக் குறியீடு பிளாக்செயினில் இயங்குவதிலிருந்து வேறுபட்டிருக்கலாம் என்பதால், ஸ்மார்ட் ஒப்பந்தங்களைச் சரிபார்ப்பது முக்கியம். + +ஸ்மார்ட் ஒப்பந்தச் சரிபார்ப்பு, இயந்திரக் குறியீட்டைப் படிக்காமலேயே, அது எழுதப்பட்ட உயர்-நிலை மொழி மூலம் ஒரு ஒப்பந்தம் என்ன செய்கிறது என்பதை ஆராய உதவுகிறது. செயல்பாடுகள், மதிப்புகள் மற்றும் பொதுவாக மாறிப் பெயர்கள் மற்றும் கருத்துகள் தொகுக்கப்பட்டு செயல்படுத்தப்பட்ட அசல் மூலக் குறியீட்டுடன் அப்படியே இருக்கும். இது குறியீட்டைப் படிப்பதை மிகவும் எளிதாக்குகிறது. மூல சரிபார்ப்பு குறியீடு ஆவணப்படுத்தலுக்கான ஏற்பாட்டையும் செய்கிறது, எனவே ஒரு ஸ்மார்ட் ஒப்பந்தம் என்ன செய்ய வடிவமைக்கப்பட்டுள்ளது என்பதை இறுதிப் பயனர்கள் அறிவார்கள். + +### முழு சரிபார்ப்பு என்றால் என்ன? {#full-verification} + +கருத்துகள் அல்லது மாறி பெயர்கள் போன்ற தொகுக்கப்பட்ட பைட்கோடை பாதிக்காத மூலக் குறியீட்டின் சில பகுதிகள் உள்ளன. அதாவது, வெவ்வேறு மாறி பெயர்கள் மற்றும் வெவ்வேறு கருத்துகளுடன் கூடிய இரண்டு மூலக் குறியீடுகள் இரண்டும் ஒரே ஒப்பந்தத்தைச் சரிபார்க்க முடியும். அதனுடன், ஒரு தீங்கிழைக்கும் நடிகர் மூலக் குறியீட்டின் உள்ளே ஏமாற்றும் கருத்துகளைச் சேர்க்கலாம் அல்லது தவறான மாறி பெயர்களைக் கொடுக்கலாம் மற்றும் அசல் மூலக் குறியீட்டிலிருந்து வேறுபட்ட ஒரு மூலக் குறியீட்டைக் கொண்டு ஒப்பந்தத்தைச் சரிபார்க்கலாம். + +மூலக் குறியீட்டின் துல்லியத்திற்கு ஒரு _மறைகுறியீட்டு உத்தரவாதமாகவும்_, மற்றும் தொகுப்புத் தகவலின் ஒரு _கைரேகையாகவும்_ செயல்பட பைட்கோட்டுடன் கூடுதல் தரவைச் சேர்ப்பதன் மூலம் இதைத் தவிர்க்க முடியும். தேவையான தகவல்கள் [Solidity-யின் ஒப்பந்த மெட்டாடேட்டாவில்](https://docs.soliditylang.org/en/v0.8.15/metadata.html) காணப்படுகின்றன, மேலும் இந்த கோப்பின் ஹாஷ் ஒரு ஒப்பந்தத்தின் பைட்கோட்டுடன் இணைக்கப்பட்டுள்ளது. இதை [மெட்டாடேட்டா பிளேகிரவுண்டில்](https://playground.sourcify.dev) நீங்கள் செயலில் காணலாம் + +மெட்டாடேட்டா கோப்பில் மூலக் கோப்புகள் மற்றும் அவற்றின் ஹாஷ்கள் உட்பட ஒப்பந்தத்தின் தொகுப்பு பற்றிய தகவல்கள் உள்ளன. அதாவது, தொகுப்பு அமைப்புகளில் ஏதேனும் அல்லது மூலக் கோப்புகளில் ஒன்றில் ஒரு பைட் மாறினாலும், மெட்டாடேட்டா கோப்பு மாறும். இதன் விளைவாக, பைட்கோட்டுடன் இணைக்கப்பட்ட மெட்டாடேட்டா கோப்பின் ஹாஷும் மாறுகிறது. அதாவது, ஒரு ஒப்பந்தத்தின் பைட்கோட் + இணைக்கப்பட்ட மெட்டாடேட்டா ஹாஷ் கொடுக்கப்பட்ட மூலக் குறியீடு மற்றும் தொகுப்பு அமைப்புகளுடன் பொருந்தினால், இது அசல் தொகுப்பில் பயன்படுத்தப்பட்ட அதே மூலக் குறியீடுதான் என்று நாம் உறுதியாக நம்பலாம், ஒரு பைட் கூட வேறுபடாது. + +மெட்டாடேட்டா ஹாஷைப் பயன்படுத்தும் இந்த வகை சரிபார்ப்பு **"[முழு சரிபார்ப்பு](https://docs.sourcify.dev/docs/full-vs-partial-match/)"** (அல்லது "சரியான சரிபார்ப்பு") என்று குறிப்பிடப்படுகிறது. மெட்டாடேட்டா ஹாஷ்கள் பொருந்தவில்லை அல்லது சரிபார்ப்பில் கருதப்படவில்லை என்றால் அது ஒரு "பகுதிப் பொருத்தம்" ஆக இருக்கும், இது தற்போது ஒப்பந்தங்களைச் சரிபார்க்க மிகவும் பொதுவான வழியாகும். முழு சரிபார்ப்பு இல்லாமல் சரிபார்க்கப்பட்ட மூலக் குறியீட்டில் பிரதிபலிக்காத [தீங்கிழைக்கும் குறியீட்டைச் செருகுவது](https://samczsun.com/hiding-in-plain-sight/) சாத்தியமாகும். பெரும்பாலான உருவாக்குநர்கள் முழு சரிபார்ப்பு பற்றி அறிந்திருக்கவில்லை மற்றும் அவர்களின் தொகுப்பின் மெட்டாடேட்டா கோப்பை வைத்திருக்கவில்லை, எனவே இதுவரை ஒப்பந்தங்களைச் சரிபார்க்க பகுதி சரிபார்ப்பு நடைமுறை முறையாக உள்ளது. + +## மூலக் குறியீடு சரிபார்ப்பு ஏன் முக்கியமானது? {#importance-of-source-code-verification} + +### நம்பிக்கை தேவைப்படாத தன்மை {#trustlessness} + +ஸ்மார்ட் ஒப்பந்தங்கள் மற்றும் [பரவலாக்கப்பட்ட பயன்பாடுகளுக்கு (dapps)](/developers/docs/dapps/) நம்பிக்கை தேவைப்படாத தன்மை மிகப்பெரிய முன்மாதிரி என்று வாதிடலாம். ஸ்மார்ட் ஒப்பந்தங்கள் “மாற்ற முடியாதவை” மற்றும் மாற்றியமைக்க முடியாது; ஒரு ஒப்பந்தம் செயல்பாட்டுக் காலத்தில் குறியீட்டில் வரையறுக்கப்பட்ட வணிகத் தர்க்கத்தை மட்டுமே செயல்படுத்தும். அதாவது, எத்தேரியத்தில் செயல்படுத்திய பிறகு உருவாக்குநர்கள் மற்றும் நிறுவனங்கள் ஒரு ஒப்பந்தத்தின் குறியீட்டை மாற்றியமைக்க முடியாது. + +ஒரு ஸ்மார்ட் ஒப்பந்தம் நம்பிக்கை தேவைப்படாததாக இருக்க, ஒப்பந்தக் குறியீடு சுயாதீன சரிபார்ப்புக்குக் கிடைக்க வேண்டும். ஒவ்வொரு ஸ்மார்ட் ஒப்பந்தத்திற்கும் தொகுக்கப்பட்ட பைட்கோட் பிளாக்செயினில் பொதுவில் கிடைத்தாலும், கீழ்-நிலை மொழியை உருவாக்குநர்கள் மற்றும் பயனர்கள் இருவருக்கும் புரிந்துகொள்வது கடினம். + +திட்டங்கள் தங்கள் ஒப்பந்தங்களின் மூலக் குறியீட்டை வெளியிடுவதன் மூலம் நம்பிக்கை அனுமானங்களைக் குறைக்கின்றன. ஆனால் இது மற்றொரு சிக்கலுக்கு வழிவகுக்கிறது: வெளியிடப்பட்ட மூலக் குறியீடு ஒப்பந்த பைட்கோட்டுடன் பொருந்துகிறதா என்பதைச் சரிபார்ப்பது கடினம். இந்தச் சூழ்நிலையில், நம்பிக்கை தேவைப்படாத தன்மையின் மதிப்பு இழக்கப்படுகிறது, ஏனெனில் பயனர்கள் பிளாக்செயினில் ஒரு ஒப்பந்தத்தைச் செயல்படுத்துவதற்கு முன்பு அதன் வணிக தர்க்கத்தை (அதாவது, பைட்கோடை மாற்றுவதன் மூலம்) மாற்ற வேண்டாம் என்று உருவாக்குநர்களை நம்ப வேண்டும். + +மூலக் குறியீடு சரிபார்ப்புக் கருவிகள் ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் மூலக் குறியீட்டுக் கோப்புகள் அசெம்பிளி குறியீட்டுடன் பொருந்துவதற்கான உத்தரவாதங்களை வழங்குகின்றன. இதன் விளைவாக ஒரு நம்பிக்கை தேவைப்படாத சுற்றுச்சூழல் அமைப்பு உருவாகிறது, அங்கு பயனர்கள் மூன்றாம் தரப்பினரைக் கண்மூடித்தனமாக நம்பாமல், ஒரு ஒப்பந்தத்தில் நிதியை வைப்பு செய்வதற்கு முன்பு குறியீட்டைச் சரிபார்க்கிறார்கள். + +### பயனர் பாதுகாப்பு {#user-safety} + +ஸ்மார்ட் ஒப்பந்தங்களைப் பொறுத்தவரை, பொதுவாக நிறையப் பணம் பணயம் வைக்கப்பட்டுள்ளது. இதற்கு அதிக பாதுகாப்பு உத்தரவாதங்கள் மற்றும் ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் தர்க்கத்தைப் பயன்படுத்துவதற்கு முன்பு சரிபார்ப்பு தேவைப்படுகிறது. சிக்கல் என்னவென்றால், நேர்மையற்ற உருவாக்குநர்கள் ஒரு ஸ்மார்ட் ஒப்பந்தத்தில் தீங்கிழைக்கும் குறியீட்டைச் செருகுவதன் மூலம் பயனர்களை ஏமாற்றலாம். சரிபார்ப்பு இல்லாமல், தீங்கிழைக்கும் ஸ்மார்ட் ஒப்பந்தங்கள் [பின் கதவுகள்](https://www.trustnodes.com/2018/11/10/concerns-rise-over-backdoored-smart-contracts), சர்ச்சைக்குரிய அணுகல் கட்டுப்பாட்டு வழிமுறைகள், சுரண்டக்கூடிய பாதிப்புகள் மற்றும் பயனர் பாதுகாப்பிற்கு ஆபத்தை விளைவிக்கும் பிற விஷயங்களைக் கொண்டிருக்கலாம், அவை கண்டறியப்படாமல் போகும். + +ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் மூலக் குறியீட்டுக் கோப்புகளை வெளியிடுவது, தணிக்கையாளர்கள் போன்ற ஆர்வமுள்ளவர்களுக்கு, சாத்தியமான தாக்குதல் வெக்டர்களுக்காக ஒப்பந்தத்தை மதிப்பிடுவதை எளிதாக்குகிறது. பல தரப்பினர் ஒரு ஸ்மார்ட் ஒப்பந்தத்தை சுயாதீனமாகச் சரிபார்ப்பதன் மூலம், பயனர்கள் அதன் பாதுகாப்பிற்கு வலுவான உத்தரவாதங்களைக் கொண்டுள்ளனர். + +## எத்தேரியம் ஸ்மார்ட் ஒப்பந்தங்களுக்கான மூலக் குறியீட்டை எவ்வாறு சரிபார்ப்பது {#source-code-verification-for-ethereum-smart-contracts} + +[எத்தேரியத்தில் ஒரு ஸ்மார்ட் ஒப்பந்தத்தைச் செயல்படுத்துவதற்கு](/developers/docs/smart-contracts/deploying/) ஒரு தரவு பேலோடுடன் (தொகுக்கப்பட்ட பைட்கோட்) ஒரு பரிவர்த்தனையை ஒரு சிறப்பு முகவரிக்கு அனுப்ப வேண்டும். தரவு பேலோடு மூலக் குறியீட்டைத் தொகுப்பதன் மூலம் உருவாக்கப்படுகிறது, மேலும் ஒப்பந்த நிகழ்வின் [கன்ஸ்ட்ரக்டர் ஆர்க்யூமென்ட்கள்](https://docs.soliditylang.org/en/v0.8.14/contracts.html#constructor) பரிவர்த்தனையில் தரவு பேலோடுடன் இணைக்கப்பட்டுள்ளன. தொகுப்பு தீர்மானகரமானது, அதாவது ஒரே மூலக் கோப்புகள் மற்றும் தொகுப்பு அமைப்புகள் (எ.கா., கம்பைலர் பதிப்பு, ஆப்டிமைசர்) பயன்படுத்தப்பட்டால் அது எப்போதும் ஒரே வெளியீட்டை (அதாவது, ஒப்பந்த பைட்கோட்) உருவாக்குகிறது. + +![ஸ்மார்ட் ஒப்பந்த மூலக் குறியீடு சரிபார்ப்பைக் காட்டும் வரைபடம்](./source-code-verification.png) + +ஒரு ஸ்மார்ட் ஒப்பந்தத்தைச் சரிபார்ப்பது அடிப்படையில் பின்வரும் படிகளை உள்ளடக்கியது: + +1. மூலக் கோப்புகள் மற்றும் தொகுப்பு அமைப்புகளை ஒரு கம்பைலரில் உள்ளிடவும். + +2. கம்பைலர் ஒப்பந்தத்தின் பைட்கோடை வெளியிடுகிறது + +3. கொடுக்கப்பட்ட முகவரியில் செயல்படுத்தப்பட்ட ஒப்பந்தத்தின் பைட்கோடைப் பெறவும் + +4. செயல்படுத்தப்பட்ட பைட்கோடை மீண்டும் தொகுக்கப்பட்ட பைட்கோட்டுடன் ஒப்பிடவும். குறியீடுகள் பொருந்தினால், ஒப்பந்தம் கொடுக்கப்பட்ட மூலக் குறியீடு மற்றும் தொகுப்பு அமைப்புகளுடன் சரிபார்க்கப்படும். + +5. கூடுதலாக, பைட்கோட்டின் முடிவில் உள்ள மெட்டாடேட்டா ஹாஷ்கள் பொருந்தினால், அது ஒரு முழுப் பொருத்தமாக இருக்கும். + +இது சரிபார்ப்பின் ஒரு எளிமையான விளக்கம் என்பதையும், [மாற்ற முடியாத மாறிகள்](https://docs.sourcify.dev/docs/immutables/) இருப்பது போன்ற பல விதிவிலக்குகள் இதனுடன் வேலை செய்யாது என்பதையும் கவனத்தில் கொள்ளவும். + +## மூலக் குறியீடு சரிபார்ப்புக் கருவிகள் {#source-code-verification-tools} + +ஒப்பந்தங்களைச் சரிபார்க்கும் பாரம்பரிய செயல்முறை சிக்கலானதாக இருக்கலாம். இதனால்தான் எத்தேரியத்தில் செயல்படுத்தப்பட்ட ஸ்மார்ட் ஒப்பந்தங்களுக்கான மூலக் குறியீட்டைச் சரிபார்க்கும் கருவிகள் எங்களிடம் உள்ளன. இந்தக் கருவிகள் மூலக் குறியீடு சரிபார்ப்பின் பெரிய பகுதிகளைத் தானியக்கமாக்குகின்றன மேலும் பயனர்களின் நலன்களுக்காகச் சரிபார்க்கப்பட்ட ஒப்பந்தங்களையும் நிர்வகிக்கின்றன. + +### Etherscan {#etherscan} + +[எத்தேரியம் பிளாக்செயின் எக்ஸ்புளோரராக](/developers/docs/data-and-analytics/block-explorers/) பெரும்பாலும் அறியப்பட்டாலும், Etherscan ஸ்மார்ட் ஒப்பந்த உருவாக்குநர்கள் மற்றும் பயனர்களுக்காக ஒரு [மூலக் குறியீடு சரிபார்ப்பு சேவையையும்](https://etherscan.io/verifyContract) வழங்குகிறது. + +Etherscan அசல் தரவு பேலோடிலிருந்து (மூலக் குறியீடு, நூலக முகவரி, கம்பைலர் அமைப்புகள், ஒப்பந்த முகவரி, முதலியன) ஒப்பந்த பைட்கோடை மீண்டும் தொகுக்க உங்களை அனுமதிக்கிறது. மீண்டும் தொகுக்கப்பட்ட பைட்கோட் ஆன்செயின் ஒப்பந்தத்தின் பைட்கோட்டுடன் (மற்றும் கன்ஸ்ட்ரக்டர் அளவுருக்கள்) தொடர்புடையதாக இருந்தால், [ஒப்பந்தம் சரிபார்க்கப்படுகிறது](https://info.etherscan.com/types-of-contract-verification/). + +சரிபார்க்கப்பட்டதும், உங்கள் ஒப்பந்தத்தின் மூலக் குறியீடு "சரிபார்க்கப்பட்டது" என்ற லேபிளைப் பெறுகிறது மற்றும் மற்றவர்கள் தணிக்கை செய்ய Etherscan-இல் வெளியிடப்படுகிறது. இது [சரிபார்க்கப்பட்ட ஒப்பந்தங்கள்](https://etherscan.io/contractsVerified/) பிரிவிலும் சேர்க்கப்படுகிறது—சரிபார்க்கப்பட்ட மூலக் குறியீடுகளுடன் கூடிய ஸ்மார்ட் ஒப்பந்தங்களின் களஞ்சியம். + +ஒப்பந்தங்களைச் சரிபார்ப்பதற்கு Etherscan மிகவும் பயன்படுத்தப்படும் கருவியாகும். இருப்பினும், Etherscan-இன் ஒப்பந்தச் சரிபார்ப்பில் ஒரு குறைபாடு உள்ளது: அது ஆன்செயின் பைட்கோட் மற்றும் மீண்டும் தொகுக்கப்பட்ட பைட்கோட்டின் **மெட்டாடேட்டா ஹாஷை** ஒப்பிடத் தவறுகிறது. எனவே Etherscan-இல் உள்ள பொருத்தங்கள் பகுதிப் பொருத்தங்களாகும். + +[Etherscan-இல் ஒப்பந்தங்களைச் சரிபார்ப்பது பற்றி மேலும்](https://medium.com/etherscan-blog/verifying-contracts-on-etherscan-f995ab772327). + +### Blockscout {#blockscout} + +[Blockscout](https://blockscout.com/) ஒரு திறந்த மூல பிளாக்செயின் எக்ஸ்புளோரர் ஆகும், இது ஸ்மார்ட் ஒப்பந்த உருவாக்குநர்கள் மற்றும் பயனர்களுக்காக ஒரு [ஒப்பந்த சரிபார்ப்பு சேவையையும்](https://eth.blockscout.com/contract-verification) வழங்குகிறது. ஒரு திறந்த மூல மாற்றாக, Blockscout சரிபார்ப்பு எவ்வாறு செய்யப்படுகிறது என்பதில் வெளிப்படைத்தன்மையை வழங்குகிறது மற்றும் சரிபார்ப்பு செயல்முறையை மேம்படுத்த சமூக பங்களிப்புகளை செயல்படுத்துகிறது. + +மற்ற சரிபார்ப்பு சேவைகளைப் போலவே, Blockscout பைட்கோடை மீண்டும் தொகுத்து, அதைச் செயல்படுத்தப்பட்ட ஒப்பந்தத்துடன் ஒப்பிடுவதன் மூலம் உங்கள் ஒப்பந்தத்தின் மூலக் குறியீட்டைச் சரிபார்க்க உங்களை அனுமதிக்கிறது. சரிபார்க்கப்பட்டதும், உங்கள் ஒப்பந்தம் சரிபார்ப்பு நிலையைப் பெறுகிறது மற்றும் மூலக் குறியீடு தணிக்கை மற்றும் தொடர்புக்கு பொதுவில் கிடைக்கிறது. சரிபார்க்கப்பட்ட ஒப்பந்தங்கள் எளிதாக உலாவுவதற்கும் கண்டுபிடிப்பதற்கும் Blockscout-இன் [சரிபார்க்கப்பட்ட ஒப்பந்தங்கள் களஞ்சியத்தில்](https://eth.blockscout.com/verified-contracts) பட்டியலிடப்பட்டுள்ளன. + +### Sourcify {#sourcify} + +[Sourcify](https://sourcify.dev/#/verifier) என்பது ஒப்பந்தங்களைச் சரிபார்க்கும் மற்றொரு கருவியாகும், இது திறந்த மூல மற்றும் பரவலாக்கப்பட்டதாகும். இது ஒரு தொகுதி ஆய்வு கருவி அல்ல மற்றும் [வெவ்வேறு EVM அடிப்படையிலான நெட்வொர்க்குகளில்](https://docs.sourcify.dev/docs/chains) உள்ள ஒப்பந்தங்களை மட்டுமே சரிபார்க்கிறது. இது மற்ற கருவிகள் அதன் மேல் உருவாக்க ஒரு பொது உள்கட்டமைப்பாக செயல்படுகிறது, மேலும் மெட்டாடேட்டா கோப்பில் காணப்படும் [ABI](/developers/docs/smart-contracts/compiling/#web-applications) மற்றும் [NatSpec](https://docs.soliditylang.org/en/v0.8.15/natspec-format.html) கருத்துகளைப் பயன்படுத்தி மனிதர்களுக்கு மிகவும் உகந்த ஒப்பந்த ஊடாட்டங்களைச் செயல்படுத்தும் நோக்கம் கொண்டது. + +Etherscan போலல்லாமல், Sourcify மெட்டாடேட்டா ஹாஷுடன் முழுப் பொருத்தங்களை ஆதரிக்கிறது. சரிபார்க்கப்பட்ட ஒப்பந்தங்கள் அதன் [பொது களஞ்சியத்தில்](https://docs.sourcify.dev/docs/repository/) HTTP மற்றும் [IPFS](https://docs.ipfs.io/concepts/what-is-ipfs/#what-is-ipfs) இல் வழங்கப்படுகின்றன, இது ஒரு பரவலாக்கப்பட்ட, [உள்ளடக்க-முகவரியிடப்பட்ட](https://docs.storacha.network/concepts/content-addressing/) சேமிப்பகமாகும். இணைக்கப்பட்ட மெட்டாடேட்டா ஹாஷ் ஒரு IPFS ஹாஷ் என்பதால், இது IPFS வழியாக ஒரு ஒப்பந்தத்தின் மெட்டாடேட்டா கோப்பைப் பெற அனுமதிக்கிறது. + +கூடுதலாக, இந்த கோப்புகளின் IPFS ஹாஷ்கள் மெட்டாடேட்டாவிலும் காணப்படுவதால், ஒருவர் IPFS வழியாக மூலக் குறியீட்டுக் கோப்புகளையும் மீட்டெடுக்கலாம். ஒரு ஒப்பந்தத்தை அதன் API அல்லது [UI](https://sourcify.dev/#/verifier) வழியாக மெட்டாடேட்டா கோப்பு மற்றும் மூலக் கோப்புகளை வழங்குவதன் மூலமோ அல்லது செருகுநிரல்களைப் பயன்படுத்துவதன் மூலமோ சரிபார்க்கலாம். Sourcify கண்காணிப்புக் கருவியும் புதிய தொகுதிகளில் ஒப்பந்த உருவாக்கங்களைக் கேட்கிறது மற்றும் அவற்றின் மெட்டாடேட்டா மற்றும் மூலக் கோப்புகள் IPFS இல் வெளியிடப்பட்டால் ஒப்பந்தங்களைச் சரிபார்க்க முயற்சிக்கிறது. + +[Sourcify-இல் ஒப்பந்தங்களைச் சரிபார்ப்பது பற்றி மேலும்](https://soliditylang.org/blog/2020/06/25/sourcify-faq/). + +### Tenderly {#tenderly} + +[Tenderly பிளாட்ஃபார்ம்](https://tenderly.co/) Web3 உருவாக்குநர்களுக்கு ஸ்மார்ட் ஒப்பந்தங்களை உருவாக்க, சோதிக்க, கண்காணிக்க மற்றும் இயக்க உதவுகிறது. பிழைத்திருத்தக் கருவிகளை கவனிப்புத்திறன் மற்றும் உள்கட்டமைப்பு கட்டுமானத் தொகுதிகளுடன் இணைத்து, Tenderly உருவாக்குநர்கள் ஸ்மார்ட் ஒப்பந்த மேம்பாட்டை விரைவுபடுத்த உதவுகிறது. Tenderly அம்சங்களை முழுமையாக இயக்க, உருவாக்குநர்கள் பல முறைகளைப் பயன்படுத்தி [மூலக் குறியீடு சரிபார்ப்பைச் செய்ய](https://docs.tenderly.co/monitoring/contract-verification) வேண்டும். + +ஒரு ஒப்பந்தத்தை தனிப்பட்ட முறையிலோ அல்லது பொதுவிலோ சரிபார்க்க முடியும். தனிப்பட்ட முறையில் சரிபார்க்கப்பட்டால், ஸ்மார்ட் ஒப்பந்தம் உங்களுக்கு (மற்றும் உங்கள் திட்டத்தில் உள்ள மற்ற உறுப்பினர்களுக்கு) மட்டுமே தெரியும். ஒரு ஒப்பந்தத்தை பொதுவில் சரிபார்ப்பது Tenderly பிளாட்ஃபார்மைப் பயன்படுத்தும் அனைவருக்கும் அதைக் காண வைக்கிறது. + +உங்கள் ஒப்பந்தங்களை [டாஷ்போர்டு](https://docs.tenderly.co/contract-verification), [Tenderly Hardhat செருகுநிரல்](https://docs.tenderly.co/contract-verification/hardhat), அல்லது [CLI](https://docs.tenderly.co/monitoring/smart-contract-verification/verifying-contracts-using-cli) ஆகியவற்றைப் பயன்படுத்தி சரிபார்க்கலாம். + +டாஷ்போர்டு மூலம் ஒப்பந்தங்களைச் சரிபார்க்கும்போது, Solidity கம்பைலரால் உருவாக்கப்பட்ட மூலக் கோப்பு அல்லது மெட்டாடேட்டா கோப்பு, முகவரி/நெட்வொர்க் மற்றும் கம்பைலர் அமைப்புகளை நீங்கள் இறக்குமதி செய்ய வேண்டும். + +Tenderly Hardhat செருகுநிரலைப் பயன்படுத்துவது குறைந்த முயற்சியுடன் சரிபார்ப்பு செயல்முறையின் மீது அதிக கட்டுப்பாட்டை அனுமதிக்கிறது, தானியங்கி (குறியீடு-இல்லாத) மற்றும் கைமுறை (குறியீடு-அடிப்படையிலான) சரிபார்ப்புக்கு இடையே தேர்வு செய்ய உங்களை அனுமதிக்கிறது. + +## மேலும் வாசிக்க {#further-reading} + +- [ஒப்பந்த மூலக் குறியீட்டைச் சரிபார்த்தல்](https://programtheblockchain.com/posts/2018/01/16/verifying-contract-source-code/) diff --git a/public/content/translations/ta/developers/docs/standards/index.md b/public/content/translations/ta/developers/docs/standards/index.md new file mode 100644 index 00000000000..e4344583071 --- /dev/null +++ b/public/content/translations/ta/developers/docs/standards/index.md @@ -0,0 +1,59 @@ +--- +title: "எத்தேரியம் மேம்பாட்டுத் தரநிலைகள்" +description: "EIPகள், ERC-20 மற்றும் ERC-721 போன்ற டோக்கன் தரநிலைகள் மற்றும் மேம்பாட்டு மரபுகள் உள்ளிட்ட எத்தேரியம் தரநிலைகளைப் பற்றி அறியவும்." +lang: ta +incomplete: true +--- + +## தரநிலைகளின் கண்ணோட்டம் {#standards-overview} + +எத்தேரியம் சமூகம் பல தரநிலைகளை ஏற்றுக்கொண்டது, இது திட்டங்களை ([எத்தேரியம் கிளையன்ட்கள்](/developers/docs/nodes-and-clients/) மற்றும் பணப்பைகள் போன்றவை) செயல்படுத்துதல்களில் ஒன்றிணைந்து செயல்பட உதவுகிறது, மேலும் ஸ்மார்ட் ஒப்பந்தங்கள் மற்றும் டாப்கள் இயற்றக்கூடியதாக இருப்பதை உறுதி செய்கிறது. + +பொதுவாக, தரநிலைகள் [எத்தேரியம் முன்னேற்ற முன்மொழிவுகளாக](/eips/) (EIPs) அறிமுகப்படுத்தப்படுகின்றன, அவை சமூக உறுப்பினர்களால் ஒரு [நிலையான செயல்முறை](https://eips.ethereum.org/EIPS/eip-1) மூலம் விவாதிக்கப்படுகின்றன. + +- [EIPகளுக்கான அறிமுகம்](/eips/) +- [EIPகளின் பட்டியல்](https://eips.ethereum.org/) +- [EIP GitHub ரெப்போ](https://github.com/ethereum/EIPs) +- [EIP விவாதக் குழு](https://ethereum-magicians.org/c/eips) +- [எத்தேரியம் நிர்வாகத்திற்கான அறிமுகம்](/governance/) +- [எத்தேரியம் நிர்வாக கண்ணோட்டம்](https://web.archive.org/web/20201107234050/https://blog.bmannconsulting.com/ethereum-governance/) _மார்ச் 31, 2019 - போரிஸ் மான்_ +- [எத்தேரியம் நெறிமுறை மேம்பாட்டு ஆளுமை மற்றும் நெட்வொர்க் மேம்படுத்தல் ஒருங்கிணைப்பு](https://hudsonjameson.com/posts/2020-03-23-ethereum-protocol-development-governance-and-network-upgrade-coordination/) _மார்ச் 23, 2020 - ஹட்சன் ஜேம்சன்_ +- [அனைத்து எத்தேரியம் கோர் டெவ் சந்திப்புகளின் பிளேலிஸ்ட்](https://www.youtube.com/@EthereumProtocol) _(YouTube பிளேலிஸ்ட்)_ + +## தரநிலைகளின் வகைகள் {#types-of-standards} + +3 வகையான EIPகள் உள்ளன: + +- தரநிலைகள் தடம்: பெரும்பாலான அல்லது அனைத்து எத்தேரியம் செயலாக்கங்களையும் பாதிக்கும் எந்தவொரு மாற்றத்தையும் விவரிக்கிறது +- [மெட்டா டிராக்](https://eips.ethereum.org/meta): எத்தேரியத்தைச் சுற்றியுள்ள ஒரு செயல்முறையை விவரிக்கிறது அல்லது ஒரு செயல்முறைக்கு மாற்றத்தை முன்மொழிகிறது +- [தகவல் தடம்](https://eips.ethereum.org/informational): ஒரு எத்தேரியம் வடிவமைப்புச் சிக்கலை விவரிக்கிறது அல்லது எத்தேரியம் சமூகத்திற்குப் பொதுவான வழிகாட்டுதல்கள் அல்லது தகவல்களை வழங்குகிறது + +மேலும், நிலையான தடம் 4 வகைகளாகப் பிரிக்கப்பட்டுள்ளது: + +- [கோர்](https://eips.ethereum.org/core): கருத்தொற்றுமை ஃபோர்க் தேவைப்படும் மேம்பாடுகள் +- [நெட்வொர்க்கிங்](https://eips.ethereum.org/networking): devp2p மற்றும் லைட் எத்தேரியம் துணை நெறிமுறையைச் சுற்றியுள்ள மேம்பாடுகள், அத்துடன் விஸ்பர் மற்றும் ஸ்வர்மின் நெட்வொர்க் நெறிமுறை விவரக்குறிப்புகளுக்கு முன்மொழியப்பட்ட மேம்பாடுகள். +- [இடைமுகம்](https://eips.ethereum.org/interface): கிளையன்ட் API/RPC விவரக்குறிப்புகள் மற்றும் தரநிலைகள் மற்றும் முறைப் பெயர்கள் மற்றும் ஒப்பந்த ABIகள் போன்ற சில மொழி-நிலை தரநிலைகளைச் சுற்றியுள்ள மேம்பாடுகள். +- [ERC](https://eips.ethereum.org/erc): பயன்பாட்டு-நிலை தரநிலைகள் மற்றும் மரபுகள் + +இந்த வெவ்வேறு வகைகள் மற்றும் வகைகளைப் பற்றிய விரிவான தகவல்களை [EIP-1](https://eips.ethereum.org/EIPS/eip-1#eip-types) இல் காணலாம் + +### டோக்கன் தரநிலைகள் {#token-standards} + +- [ERC-20](/developers/docs/standards/tokens/erc-20/) - வாக்களிப்பு டோக்கன்கள், ஸ்டேக்கிங் டோக்கன்கள் அல்லது மெய்நிகர் நாணயங்கள் போன்ற ஒத்த மதிப்புடைய (இடமாற்றம் செய்யக்கூடிய) டோக்கன்களுக்கான ஒரு நிலையான இடைமுகம். + - [ERC-223](/developers/docs/standards/tokens/erc-223/) - ஈதருக்கு ஒப்பானதாக டோக்கன்களை செயல்பட வைக்கும் மற்றும் பெறுநர்களின் பக்கத்தில் டோக்கன் இடமாற்றங்களைக் கையாளுவதை ஆதரிக்கும் ஒரு ஒத்த மதிப்புடைய டோக்கன்கள் தரநிலை. + - [ERC-1363](/developers/docs/standards/tokens/erc-1363/) - ஒரே பரிவர்த்தனையில் பெறுநர் ஒப்பந்தங்களில் கால்பேக்கை செயல்படுத்துவதை ஆதரிக்கும் ERC-20 டோக்கன்களுக்கான நீட்டிப்பு இடைமுகம். +- [ERC-721](/developers/docs/standards/tokens/erc-721/) - ஒரு கலைப்படைப்பு அல்லது பாடலுக்கான பத்திரம் போன்ற ஒத்த மதிப்பற்ற டோக்கன்களுக்கான ஒரு நிலையான இடைமுகம். + - [ERC-2309](https://eips.ethereum.org/EIPS/eip-2309) - தொடர்ச்சியான டோக்கன் அடையாளங்காட்டிகளைப் பயன்படுத்தி ஒன்று அல்லது பல ஒத்த மதிப்பற்ற டோக்கன்களை உருவாக்கும்போது/பரிமாற்றும்போது வெளியிடப்படும் ஒரு தரப்படுத்தப்பட்ட நிகழ்வு. + - [ERC-4400](https://eips.ethereum.org/EIPS/eip-4400) - EIP-721 நுகர்வோர் பங்கிற்கான இடைமுக நீட்டிப்பு. + - [ERC-4907](https://eips.ethereum.org/EIPS/eip-4907) - ERC-721 டோக்கன்களுக்கு கட்டுப்படுத்தப்பட்ட அனுமதிகளுடன் நேர-வரையறுக்கப்பட்ட பங்கைச் சேர்க்கிறது. +- [ERC-777](/developers/docs/standards/tokens/erc-777/) - **(பரிந்துரைக்கப்படவில்லை)** ERC-20 ஐ விட மேம்பட்ட ஒரு டோக்கன் தரநிலை. +- [ERC-1155](/developers/docs/standards/tokens/erc-1155/) - ஒத்த மதிப்புடைய மற்றும் ஒத்த மதிப்பற்ற சொத்துக்கள் இரண்டையும் கொண்டிருக்கக்கூடிய ஒரு டோக்கன் தரநிலை. +- [ERC-4626](/developers/docs/standards/tokens/erc-4626/) - மகசூல் தரும் வால்ட்களின் தொழில்நுட்ப அளவுருக்களை மேம்படுத்தவும் ஒருங்கிணைக்கவும் வடிவமைக்கப்பட்ட டோக்கனைஸ் செய்யப்பட்ட வால்ட் தரநிலை. + +[டோக்கன் தரநிலைகள்](/developers/docs/standards/tokens/) பற்றி மேலும் அறிக. + +## மேலும் வாசிக்க {#further-reading} + +- [எத்தேரியம் முன்னேற்ற முன்மொழிவுகள் (EIPகள்)](/eips/) + +_உங்களுக்கு உதவிய ஒரு சமூக வளம் பற்றி தெரியுமா?_ இந்தப் பக்கத்தைத் திருத்தி அதைச் சேர்க்கவும்!_ diff --git a/public/content/translations/ta/developers/docs/standards/tokens/erc-1155/index.md b/public/content/translations/ta/developers/docs/standards/tokens/erc-1155/index.md new file mode 100644 index 00000000000..f011839dd07 --- /dev/null +++ b/public/content/translations/ta/developers/docs/standards/tokens/erc-1155/index.md @@ -0,0 +1,146 @@ +--- +title: "ERC-1155 பல-குறி தரநிலை" +description: "ERC-1155 பற்றி அறிக, இது ஒரே ஒப்பந்தத்தில் ஒன்றுக்கொன்று மாற்றக்கூடிய மற்றும் ஒன்றுக்கொன்று மாற்ற முடியாத குறிமுறைகளை இணைக்கும் ஒரு பல-குறி தரநிலையாகும்." +lang: ta +--- + +## அறிமுகம் {#introduction} + +பல குறி வகைகளை நிர்வகிக்கும் ஒப்பந்தங்களுக்கான ஒரு தரப்படுத்தப்பட்ட இடைமுகம். ஒற்றை பயன்படுத்தப்பட்ட ஒப்பந்தம், பரிமாற்றக்கூடிய குறிகள், பரிமாற முடியாத குறிகள் அல்லது பிற உள்ளமைவுகளின் (எ.கா., அரை-பரிமாற்றக்கூடிய குறிகள்) எந்தவொரு கலவையையும் கொண்டிருக்கலாம். + +**பல-குறி தரநிலை என்பதன் பொருள் என்ன?** + +இந்த எண்ணம் எளிமையானது மற்றும் எந்த எண்ணிக்கையிலான ஒன்றுக்கொன்று மாற்றக்கூடிய மற்றும் ஒன்றுக்கொன்று மாற்ற முடியாத குறி வகைகளைக் குறிப்பிட மற்றும் கட்டுப்படுத்தக்கூடிய ஒரு ஸ்மார்ட் ஒப்பந்த இடைமுகத்தை உருவாக்குவதை நோக்கமாகக் கொண்டுள்ளது. இந்த வழியில், ERC-1155 குறியானது [ERC-20](/developers/docs/standards/tokens/erc-20/) மற்றும் [ERC-721](/developers/docs/standards/tokens/erc-721/) குறி போன்ற அதே செயல்பாடுகளைச் செய்ய முடியும், மேலும் ஒரே நேரத்தில் இரண்டையும் கூட செய்ய முடியும். இது ERC-20 மற்றும் ERC-721 தரநிலைகளின் செயல்பாட்டை மேம்படுத்துகிறது, இது மிகவும் திறமையானதாக ஆக்குகிறது மற்றும் வெளிப்படையான செயலாக்கப் பிழைகளை சரிசெய்கிறது. + +ERC-1155 குறியானது [EIP-1155](https://eips.ethereum.org/EIPS/eip-1155) இல் முழுமையாக விவரிக்கப்பட்டுள்ளது. + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +இந்தப் பக்கத்தை நன்கு புரிந்துகொள்ள, நீங்கள் முதலில் [குறி தரநிலைகள்](/developers/docs/standards/tokens/), [ERC-20](/developers/docs/standards/tokens/erc-20/), மற்றும் [ERC-721](/developers/docs/standards/tokens/erc-721/) பற்றிப் படிக்குமாறு பரிந்துரைக்கிறோம். + +## ERC-1155 செயல்பாடுகள் மற்றும் அம்சங்கள்: {#body} + +- [தொகுதி பரிமாற்றம்](#batch_transfers): ஒரே அழைப்பில் பல சொத்துக்களை மாற்றவும். +- [தொகுதி இருப்பு](#batch_balance): ஒரே அழைப்பில் பல சொத்துகளின் இருப்புகளைப் பெறுங்கள். +- [தொகுதி ஒப்புதல்](#batch_approval): ஒரு முகவரிக்கு அனைத்து குறிகளையும் அங்கீகரிக்கவும். +- [கொக்கிகள்](#receive_hook): குறிகளை பெறும் கொக்கி. +- [NFT ஆதரவு](#nft_support): வழங்கல் 1 ஆக மட்டுமே இருந்தால், அதை NFT ஆகக் கருதவும். +- [பாதுகாப்பான பரிமாற்ற விதிகள்](#safe_transfer_rule): பாதுகாப்பான பரிமாற்றத்திற்கான விதிகள் தொகுப்பு. + +### தொகுதிப் பரிமாற்றங்கள் {#batch-transfers} + +தொகுதி பரிமாற்றம் வழக்கமான ERC-20 பரிமாற்றங்களைப் போலவே செயல்படுகிறது. வழக்கமான ERC-20 `transferFrom` செயல்பாட்டைப் பார்ப்போம்: + +```solidity +// ERC-20 +function transferFrom(address from, address to, uint256 value) external returns (bool); + +// ERC-1155 +function safeBatchTransferFrom( + address _from, + address _to, + uint256[] calldata _ids, + uint256[] calldata _values, + bytes calldata _data +) external; +``` + +ERC-1155 இல் உள்ள ஒரே வித்தியாசம் என்னவென்றால், நாம் மதிப்புகளை ஒரு வரிசையாக அனுப்புகிறோம், மேலும் நாம் ஐடிகளின் ஒரு வரிசையையும் அனுப்புகிறோம். எடுத்துக்காட்டாக, `ids=[3, 6, 13]` மற்றும் `values=[100, 200, 5]` எனக் கொடுக்கப்பட்டால், இதன் விளைவாக வரும் பரிமாற்றங்கள் + +1. `_from` இடமிருந்து `_to` இற்கு 3 என்ற ஐடியுடன் 100 குறிகளை மாற்றவும். +2. `_from` இடமிருந்து `_to` இற்கு 6 என்ற ஐடியுடன் 200 குறிகளை மாற்றவும். +3. `_from` இடமிருந்து `_to` இற்கு 13 என்ற ஐடியுடன் 5 குறிகளை மாற்றவும். + +ERC-1155 இல் எங்களிடம் `transferFrom` மட்டுமே உள்ளது, `transfer` இல்லை. இதை ஒரு வழக்கமான `transfer` போலப் பயன்படுத்த, செயல்பாட்டை அழைக்கும் முகவரிக்கு அனுப்பும் முகவரியை அமைக்கவும். + +### தொகுதி இருப்பு {#batch-balance} + +அந்தந்த ERC-20 `balanceOf` அழைப்பும் இதேபோல் தொகுதி ஆதரவுடன் அதன் கூட்டாளர் செயல்பாட்டைக் கொண்டுள்ளது. நினைவூட்டலாக, இது ERC-20 பதிப்பு: + +```solidity +// ERC-20 +function balanceOf(address owner) external view returns (uint256); + +// ERC-1155 +function balanceOfBatch( + address[] calldata _owners, + uint256[] calldata _ids +) external view returns (uint256[] memory); +``` + +இருப்பு அழைப்பிற்கு இன்னும் எளிமையாக, ஒரே அழைப்பில் பல இருப்புகளை நாம் மீட்டெடுக்கலாம். உரிமையாளர்களின் வரிசையைத் தொடர்ந்து, குறி ஐடிகளின் வரிசையை நாங்கள் அனுப்புகிறோம். + +எடுத்துக்காட்டாக, `_ids=[3, 6, 13]` மற்றும் `_owners=[0xbeef..., 0x1337..., 0x1111...]` என கொடுக்கப்பட்டால், திரும்ப வரும் மதிப்பு + +```solidity +[ + balanceOf(0xbeef...), + balanceOf(0x1337...), + balanceOf(0x1111...) +] +``` + +### தொகுதி ஒப்புதல் {#batch-approval} + +```solidity +// ERC-1155 +function setApprovalForAll( + address _operator, + bool _approved +) external; + +function isApprovedForAll( + address _owner, + address _operator +) external view returns (bool); +``` + +ஒப்புதல்கள் ERC-20 ஐ விட சற்று வித்தியாசமானவை. குறிப்பிட்ட தொகைகளுக்கு ஒப்புதல் அளிப்பதற்குப் பதிலாக, `setApprovalForAll` வழியாக ஒரு ஆபரேட்டரை அங்கீகரிக்கப்பட்டவர் அல்லது அங்கீகரிக்கப்படாதவர் என அமைக்கிறீர்கள். + +`isApprovedForAll` வழியாக தற்போதைய நிலையைப் படிக்கலாம். நீங்கள் பார்க்கிறபடி, இது எல்லாம் அல்லது ஒன்றுமில்லை என்ற செயல்பாடு. எத்தனை குறிகளுக்கு ஒப்புதல் அளிக்க வேண்டும் அல்லது எந்த குறி வகுப்பிற்கு ஒப்புதல் அளிக்க வேண்டும் என்பதை உங்களால் வரையறுக்க முடியாது. + +இது வேண்டுமென்றே எளிமையை மனதில் கொண்டு வடிவமைக்கப்பட்டுள்ளது. ஒரு முகவரிக்கு மட்டுமே நீங்கள் எல்லாவற்றிற்கும் ஒப்புதல் அளிக்க முடியும். + +### பெறுதல் கொக்கி {#receive-hook} + +```solidity +function onERC1155BatchReceived( + address _operator, + address _from, + uint256[] calldata _ids, + uint256[] calldata _values, + bytes calldata _data +) external returns(bytes4); +``` + +[EIP-165](https://eips.ethereum.org/EIPS/eip-165) ஆதரவைக் கொண்டு, ERC-1155 ஸ்மார்ட் ஒப்பந்தங்களுக்கு மட்டுமே பெறுதல் கொக்கிகளை ஆதரிக்கிறது. கொக்கிச் செயல்பாடு ஒரு மாயாஜால முன்னரே வரையறுக்கப்பட்ட bytes4 மதிப்பைத் திருப்பித் தர வேண்டும், இது இவ்வாறு கொடுக்கப்பட்டுள்ளது: + +```solidity +bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)")) +``` + +பெறும் ஒப்பந்தம் இந்த மதிப்பைத் திருப்பித் தரும்போது, ஒப்பந்தம் பரிமாற்றத்தை ஏற்றுக்கொண்டு ERC-1155 குறிகளை எவ்வாறு கையாள்வது என்று அறிந்திருப்பதாகக் கருதப்படுகிறது. அருமை, இனி ஒரு ஒப்பந்தத்தில் குறிகள் சிக்கிக் கொள்ளாது! + +### NFT ஆதரவு {#nft-support} + +வழங்கல் ஒன்றாக இருக்கும்போது, குறி அடிப்படையில் ஒரு பரிமாறாக் குறி (NFT) ஆகும். ERC-721 க்கு தரநிலையாக இருப்பது போலவே, நீங்கள் ஒரு மெட்டாடேட்டா URL ஐ வரையறுக்கலாம். URL ஐ வாடிக்கையாளர்களால் படிக்கவும் மாற்றவும் முடியும், [இங்கே](https://eips.ethereum.org/EIPS/eip-1155#metadata) பார்க்கவும். + +### பாதுகாப்பான பரிமாற்ற விதி {#safe-transfer-rule} + +முந்தைய விளக்கங்களில் சில பாதுகாப்பான பரிமாற்ற விதிகளை நாங்கள் ஏற்கனவே தொட்டுள்ளோம். ஆனால் விதிகளில் மிக முக்கியமானவற்றைப் பார்ப்போம்: + +1. அழைப்பாளர் `_from` முகவரிக்கான குறிகளைச் செலவழிக்க அங்கீகரிக்கப்பட வேண்டும் அல்லது அழைப்பாளர் `_from` க்கு சமமாக இருக்க வேண்டும். +2. பின்வரும் சமயங்களில் பரிமாற்ற அழைப்பு ரத்து செய்யப்பட வேண்டும்: + 1. `_to` முகவரி 0 ஆக இருந்தால். + 2. `_ids` இன் நீளம் `_values` இன் நீளத்திற்கு சமமாக இல்லை என்றால். + 3. `_ids` இல் உள்ள குறி(களு)க்கான வைத்திருப்பாளர்(களின்) இருப்பு(களில்) ஏதேனும் ஒன்று பெறுநருக்கு அனுப்பப்பட்ட `_values` இல் உள்ள அந்தந்தத் தொகை(களை) விட குறைவாக இருந்தால். + 4. வேறு ஏதேனும் பிழை ஏற்பட்டால். + +_குறிப்பு_: கொக்கி உட்பட அனைத்து தொகுதி செயல்பாடுகளும் தொகுதி இல்லாத பதிப்புகளாகவும் உள்ளன. ஒற்றைச் சொத்தை மாற்றுவது என்பது மிகவும் பொதுவாகப் பயன்படுத்தப்படும் வழியாக இருக்கும் என்பதைக் கருத்தில் கொண்டு, இது எரிவாயு செயல்திறனுக்காக செய்யப்படுகிறது. விளக்கங்களில் எளிமைக்காக, பாதுகாப்பான பரிமாற்ற விதிகள் உட்பட, அவற்றை நாங்கள் விட்டுவிட்டோம். பெயர்கள் ஒரே மாதிரியானவை, 'தொகுதி' என்பதை அகற்றவும். + +## மேலும் வாசிக்க {#further-reading} + +- [EIP-1155: பல குறி தரநிலை](https://eips.ethereum.org/EIPS/eip-1155) +- [ERC-1155: Openzeppelin ஆவணங்கள்](https://docs.openzeppelin.com/contracts/5.x/erc1155) +- [ERC-1155: GitHub ரெப்போ](https://github.com/enjin/erc-1155) +- [Alchemy NFT API](https://www.alchemy.com/docs/reference/nft-api-quickstart) diff --git a/public/content/translations/ta/developers/docs/standards/tokens/erc-1363/index.md b/public/content/translations/ta/developers/docs/standards/tokens/erc-1363/index.md new file mode 100644 index 00000000000..38f916a0b37 --- /dev/null +++ b/public/content/translations/ta/developers/docs/standards/tokens/erc-1363/index.md @@ -0,0 +1,213 @@ +--- +title: "ERC-1363 செலுத்தக்கூடிய டோக்கன் தரநிலை" +description: "ERC-1363 என்பது ERC-20 டோக்கன்களுக்கான ஒரு நீட்டிப்பு இடைமுகமாகும், இது இடமாற்றங்களுக்குப் பிறகு பெறுநர் ஒப்பந்தத்திலோ அல்லது ஒப்புதல்களுக்குப் பிறகு செலவு செய்பவரின் ஒப்பந்தத்திலோ தனிப்பயன் தர்க்கத்தைச் செயல்படுத்துவதை ஆதரிக்கிறது, இவை அனைத்தும் ஒரே பரிவர்த்தனையில் நடக்கும்." +lang: ta +--- + +## அறிமுகம் {#introduction} + +### ERC-1363 என்றால் என்ன? {#what-is-erc1363} + +ERC-1363 என்பது ERC-20 டோக்கன்களுக்கான ஒரு நீட்டிப்பு இடைமுகமாகும், இது இடமாற்றங்களுக்குப் பிறகு பெறுநர் ஒப்பந்தத்திலோ அல்லது ஒப்புதல்களுக்குப் பிறகு செலவு செய்பவரின் ஒப்பந்தத்திலோ தனிப்பயன் தர்க்கத்தைச் செயல்படுத்துவதை ஆதரிக்கிறது, இவை அனைத்தும் ஒரே பரிவர்த்தனையில் நடக்கும். + +### ERC-20 இலிருந்து வேறுபாடுகள் {#erc20-differences} + +`transfer`, `transferFrom` மற்றும் `approve` போன்ற நிலையான ERC-20 செயல்பாடுகள், தனி பரிவர்த்தனை இல்லாமல் பெறுநர் அல்லது செலவு செய்பவர் ஒப்பந்தத்தில் குறியீட்டை இயக்க அனுமதிக்காது. +இது UI மேம்பாட்டில் சிக்கலை அறிமுகப்படுத்துகிறது மற்றும் தத்தெடுப்பதில் தடையை ஏற்படுத்துகிறது. ஏனெனில் பயனர்கள் முதல் பரிவர்த்தனை செயல்படுத்தப்படும் வரை காத்திருந்து பின்னர் இரண்டாவதைச் சமர்ப்பிக்க வேண்டும். +அவர்கள் GAS-ஐ இரண்டு முறை செலுத்த வேண்டும். + +ERC-1363 மாற்றத்தக்க டோக்கன்களை மிகவும் எளிதாகச் செயல்களைச் செய்யக்கூடியதாகவும், எந்த ஆஃப்-செயின் கேட்பவரையும் பயன்படுத்தாமல் வேலை செய்வதாகவும் ஆக்குகிறது. +இது ஒரே பரிவர்த்தனையில், ஒரு இடமாற்றம் அல்லது ஒப்புதலுக்குப் பிறகு, பெறுநர் அல்லது செலவு செய்பவர் ஒப்பந்தத்தில் ஒரு கால்பேக்கைச் செய்ய அனுமதிக்கிறது. + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +இந்தப் பக்கத்தை நன்கு புரிந்து கொள்ள, நீங்கள் முதலில் இதைப் பற்றிப் படிக்கப் பரிந்துரைக்கிறோம்: + +- [டோக்கன் தரநிலைகள்](/developers/docs/standards/tokens/) +- [ERC-20](/developers/docs/standards/tokens/erc-20/) + +## உள்ளடக்கம் {#body} + +ERC-1363, `transfer`, `transferFrom` அல்லது `approve` க்குப் பிறகு ஸ்மார்ட் ஒப்பந்தங்களுடன் தொடர்பு கொள்ள ERC-20 டோக்கன்களுக்கான ஒரு நிலையான API-ஐ அறிமுகப்படுத்துகிறது. + +இந்தத் தரநிலை டோக்கன்களை மாற்றுவதற்கான அடிப்படைச் செயல்பாடுகளை வழங்குகிறது, அத்துடன் டோக்கன்கள் மற்றொரு ஆன்-செயின் மூன்றாம் தரப்பினரால் செலவழிக்கப்படுவதற்காக அங்கீகரிக்கப்பட அனுமதிக்கிறது, பின்னர் பெறுநர் அல்லது செலவு செய்பவர் ஒப்பந்தத்தில் ஒரு கால்பேக்கைச் செய்கிறது. + +ERC-20 கால்பேக்குகளை ஏற்கக்கூடிய ஸ்மார்ட் ஒப்பந்தங்களின் பல முன்மொழியப்பட்ட பயன்பாடுகள் உள்ளன. + +எடுத்துக்காட்டுகள்: + +- **கூட்ட விற்பனை**: அனுப்பப்பட்ட டோக்கன்கள் உடனடி வெகுமதி ஒதுக்கீட்டைத் தூண்டுகின்றன. +- **சேவைகள்**: செலுத்துதல் ஒரே படியில் சேவை அணுகலைச் செயல்படுத்துகிறது. +- **விலைப்பட்டியல்**: டோக்கன்கள் விலைப்பட்டியல்களைத் தானாகவே தீர்க்கின்றன. +- **சந்தாக்கள்**: வருடாந்திர விகிதத்தை அங்கீகரிப்பது முதல் மாத கட்டணத்திற்குள் சந்தாவைச் செயல்படுத்துகிறது. + +இந்தக் காரணங்களுக்காக இது முதலில் **"Payable Token"** என்று பெயரிடப்பட்டது. + +கால்பேக் நடத்தை அதன் பயன்பாட்டை மேலும் விரிவுபடுத்துகிறது, இது போன்ற தடையற்ற தொடர்புகளை செயல்படுத்துகிறது: + +- **ஸ்டேக்கிங்**: மாற்றப்பட்ட டோக்கன்கள் ஒரு ஸ்டேக்கிங் ஒப்பந்தத்தில் தானியங்கிப் பூட்டுதலைத் தூண்டுகின்றன. +- **வாக்களிப்பு**: பெறப்பட்ட டோக்கன்கள் ஒரு ஆளுகை அமைப்பில் வாக்குகளைப் பதிவு செய்கின்றன. +- **ஸ்வாப்பிங்**: டோக்கன் ஒப்புதல்கள் ஒரே படியில் ஸ்வாப் தர்க்கத்தைச் செயல்படுத்துகின்றன. + +ஒரு இடமாற்றம் அல்லது பெறப்பட்ட ஒப்புதலுக்குப் பிறகு ஒரு கால்பேக் செயல்படுத்தப்பட வேண்டிய அனைத்து நிகழ்வுகளிலும் குறிப்பிட்ட பயன்பாடுகளுக்கு ERC-1363 டோக்கன்களைப் பயன்படுத்தலாம். +டோக்கன்களைக் கையாளும் பெறுநரின் திறனைச் சரிபார்ப்பதன் மூலம் ஸ்மார்ட் ஒப்பந்தங்களில் டோக்கன் இழப்பு அல்லது டோக்கன் பூட்டுதலைத் தவிர்ப்பதற்கும் ERC-1363 பயனுள்ளதாக இருக்கும். + +மற்ற ERC-20 நீட்டிப்பு முன்மொழிவுகளைப் போலல்லாமல், ERC-1363 ஆனது ERC-20 `transfer` மற்றும் `transferFrom` முறைகளை மேலெழுதாது மற்றும் ERC-20 உடன் பின்னோக்கிய இணக்கத்தன்மையைப் பேணுவதன் மூலம் செயல்படுத்தப்பட வேண்டிய இடைமுக ID-க்களை வரையறுக்கிறது. + +[EIP-1363](https://eips.ethereum.org/EIPS/eip-1363) இலிருந்து: + +### முறைகள் {#methods} + +ERC-1363 தரநிலையைச் செயல்படுத்தும் ஸ்மார்ட் ஒப்பந்தங்கள், `ERC1363` இடைமுகத்தில் உள்ள அனைத்துச் செயல்பாடுகளையும், `ERC20` மற்றும் `ERC165` இடைமுகங்களையும் **கட்டாயம்** செயல்படுத்த வேண்டும். + +```solidity +pragma solidity ^0.8.0; + +/** + * @title ERC1363 + * @dev `transfer` அல்லது `transferFrom` க்குப் பிறகு ஒரு பெறுநர் ஒப்பந்தத்தில் குறியீட்டைச் செயல்படுத்துவதை ஆதரிக்கும் ERC-20 டோக்கன்களுக்கான ஒரு நீட்டிப்பு இடைமுகம் + * அல்லது `approve` க்குப் பிறகு ஒரு செலவு செய்பவர் ஒப்பந்தத்தில் குறியீடு, ஒரே பரிவர்த்தனையில். + */ +interface ERC1363 is ERC20, ERC165 { + /* + * குறிப்பு: இந்த இடைமுகத்திற்கான ERC-165 அடையாளங்காட்டி 0xb0202a11 ஆகும். + * 0xb0202a11 === + * bytes4(keccak256('transferAndCall(address,uint256)')) ^ + * bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^ + * bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^ + * bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^ + * bytes4(keccak256('approveAndCall(address,uint256)')) ^ + * bytes4(keccak256('approveAndCall(address,uint256,bytes)')) + */ + + /** + * @dev அழைப்பாளரின் கணக்கிலிருந்து `to` க்கு `value` அளவு டோக்கன்களை நகர்த்தி + * பின்னர் `to` இல் `ERC1363Receiver::onTransferReceived` ஐ அழைக்கிறது. + * @param to டோக்கன்கள் மாற்றப்படும் முகவரி. + * @param value மாற்றப்பட வேண்டிய டோக்கன்களின் அளவு. + * @return எறியாத வரை செயல்பாடு வெற்றி பெற்றதைக் குறிக்கும் ஒரு பூலியன் மதிப்பு. + */ + function transferAndCall(address to, uint256 value) external returns (bool); + + /** + * @dev அழைப்பாளரின் கணக்கிலிருந்து `to` க்கு `value` அளவு டோக்கன்களை நகர்த்தி + * பின்னர் `to` இல் `ERC1363Receiver::onTransferReceived` ஐ அழைக்கிறது. + * @param to டோக்கன்கள் மாற்றப்படும் முகவரி. + * @param value மாற்றப்பட வேண்டிய டோக்கன்களின் அளவு. + * @param data குறிப்பிட்ட வடிவமைப்பு இல்லாத கூடுதல் தரவு, `to` க்கான அழைப்பில் அனுப்பப்பட்டது. + * @return எறியாத வரை செயல்பாடு வெற்றி பெற்றதைக் குறிக்கும் ஒரு பூலியன் மதிப்பு. + */ + function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool); + + /** + * @dev ஒதுக்கீட்டு பொறிமுறையைப் பயன்படுத்தி `from` இலிருந்து `to` க்கு `value` அளவு டோக்கன்களை நகர்த்தி + * பின்னர் `to` இல் `ERC1363Receiver::onTransferReceived` ஐ அழைக்கிறது. + * @param from டோக்கன்களை அனுப்ப வேண்டிய முகவரி. + * @param to டோக்கன்கள் மாற்றப்படும் முகவரி. + * @param value மாற்றப்பட வேண்டிய டோக்கன்களின் அளவு. + * @return எறியாத வரை செயல்பாடு வெற்றி பெற்றதைக் குறிக்கும் ஒரு பூலியன் மதிப்பு. + */ + function transferFromAndCall(address from, address to, uint256 value) external returns (bool); + + /** + * @dev ஒதுக்கீட்டு பொறிமுறையைப் பயன்படுத்தி `from` இலிருந்து `to` க்கு `value` அளவு டோக்கன்களை நகர்த்தி + * பின்னர் `to` இல் `ERC1363Receiver::onTransferReceived` ஐ அழைக்கிறது. + * @param from டோக்கன்களை அனுப்ப வேண்டிய முகவரி. + * @param to டோக்கன்கள் மாற்றப்படும் முகவரி. + * @param value மாற்றப்பட வேண்டிய டோக்கன்களின் அளவு. + * @param data குறிப்பிட்ட வடிவமைப்பு இல்லாத கூடுதல் தரவு, `to` க்கான அழைப்பில் அனுப்பப்பட்டது. + * @return எறியாத வரை செயல்பாடு வெற்றி பெற்றதைக் குறிக்கும் ஒரு பூலியன் மதிப்பு. + */ + function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool); + + /** + * @dev அழைப்பாளரின் டோக்கன்களின் மீது `spender` இன் ஒதுக்கீடாக `value` அளவு டோக்கன்களை அமைத்து + * பின்னர் `spender` இல் `ERC1363Spender::onApprovalReceived` ஐ அழைக்கிறது. + * @param spender நிதியைச் செலவிடும் முகவரி. + * @param value செலவழிக்கப்பட வேண்டிய டோக்கன்களின் அளவு. + * @return எறியாத வரை செயல்பாடு வெற்றி பெற்றதைக் குறிக்கும் ஒரு பூலியன் மதிப்பு. + */ + function approveAndCall(address spender, uint256 value) external returns (bool); + + /** + * @dev அழைப்பாளரின் டோக்கன்களின் மீது `spender` இன் ஒதுக்கீடாக `value` அளவு டோக்கன்களை அமைத்து + * பின்னர் `spender` இல் `ERC1363Spender::onApprovalReceived` ஐ அழைக்கிறது. + * @param spender நிதியைச் செலவிடும் முகவரி. + * @param value செலவழிக்கப்பட வேண்டிய டோக்கன்களின் அளவு. + * @param data குறிப்பிட்ட வடிவமைப்பு இல்லாத கூடுதல் தரவு, `spender` க்கான அழைப்பில் அனுப்பப்பட்டது. + * @return எறியாத வரை செயல்பாடு வெற்றி பெற்றதைக் குறிக்கும் ஒரு பூலியன் மதிப்பு. + */ + function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool); +} + +interface ERC20 { + event Transfer(address indexed from, address indexed to, uint256 value); + event Approval(address indexed owner, address indexed spender, uint256 value); + function transfer(address to, uint256 value) external returns (bool); + function transferFrom(address from, address to, uint256 value) external returns (bool); + function approve(address spender, uint256 value) external returns (bool); + function totalSupply() external view returns (uint256); + function balanceOf(address account) external view returns (uint256); + function allowance(address owner, address spender) external view returns (uint256); +} + +interface ERC165 { + function supportsInterface(bytes4 interfaceId) external view returns (bool); +} +``` + +`transferAndCall` அல்லது `transferFromAndCall` வழியாக ERC-1363 டோக்கன்களை ஏற்க விரும்பும் ஒரு ஸ்மார்ட் ஒப்பந்தம் **கட்டாயம்** `ERC1363Receiver` இடைமுகத்தைச் செயல்படுத்த வேண்டும்: + +```solidity +/** + * @title ERC1363Receiver + * @dev ERC-1363 டோக்கன் ஒப்பந்தங்களிலிருந்து `transferAndCall` அல்லது `transferFromAndCall` ஐ ஆதரிக்க விரும்பும் எந்தவொரு ஒப்பந்தத்திற்கான இடைமுகம். + */ +interface ERC1363Receiver { + /** + * @dev இந்த ஒப்பந்தத்திற்கு ERC-1363 டோக்கன்கள் `ERC1363::transferAndCall` அல்லது `ERC1363::transferFromAndCall` வழியாக மாற்றப்படும் போதெல்லாம் + * `from` இலிருந்து `operator` மூலம், இந்த செயல்பாடு அழைக்கப்படுகிறது. + * + * குறிப்பு: இடமாற்றத்தை ஏற்க, இது திரும்ப வேண்டும் + * `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))` + * (அதாவது 0x88a7ca5c, அல்லது அதன் சொந்த செயல்பாட்டு தேர்வி). + * + * @param operator `transferAndCall` அல்லது `transferFromAndCall` செயல்பாட்டை அழைத்த முகவரி. + * @param from டோக்கன்கள் மாற்றப்பட்ட முகவரி. + * @param value மாற்றப்பட்ட டோக்கன்களின் அளவு. + * @param data குறிப்பிட்ட வடிவமைப்பு இல்லாத கூடுதல் தரவு. + * @return இடமாற்றம் அனுமதிக்கப்பட்டால் `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))` எறியாத வரை. + */ + function onTransferReceived(address operator, address from, uint256 value, bytes calldata data) external returns (bytes4); +} +``` + +`approveAndCall` வழியாக ERC-1363 டோக்கன்களை ஏற்க விரும்பும் ஒரு ஸ்மார்ட் ஒப்பந்தம் **கட்டாயம்** `ERC1363Spender` இடைமுகத்தைச் செயல்படுத்த வேண்டும்: + +```solidity +/** + * @title ERC1363Spender + * @dev ERC-1363 டோக்கன் ஒப்பந்தங்களிலிருந்து `approveAndCall` ஐ ஆதரிக்க விரும்பும் எந்தவொரு ஒப்பந்தத்திற்கான இடைமுகம். + */ +interface ERC1363Spender { + /** + * @dev ஒரு ERC-1363 டோக்கன் `owner` இந்த ஒப்பந்தத்தை `ERC1363::approveAndCall` வழியாக அங்கீகரிக்கும் போதெல்லாம் + * தங்கள் டோக்கன்களைச் செலவழிக்க, இந்த செயல்பாடு அழைக்கப்படுகிறது. + * + * குறிப்பு: ஒப்புதலை ஏற்க, இது திரும்ப வேண்டும் + * `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))` + * (அதாவது 0x7b04a2d0, அல்லது அதன் சொந்த செயல்பாட்டு தேர்வி). + * + * @param owner `approveAndCall` செயல்பாட்டை அழைத்த மற்றும் முன்னர் டோக்கன்களை வைத்திருந்த முகவரி. + * @param value செலவழிக்கப்பட வேண்டிய டோக்கன்களின் அளவு. + * @param data குறிப்பிட்ட வடிவமைப்பு இல்லாத கூடுதல் தரவு. + * @return ஒப்புதல் அனுமதிக்கப்பட்டால் `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))` எறியாத வரை. + */ + function onApprovalReceived(address owner, uint256 value, bytes calldata data) external returns (bytes4); +} +``` + +## மேலும் வாசிக்க {#further-reading} + +- [ERC-1363: செலுத்தக்கூடிய டோக்கன் தரநிலை](https://eips.ethereum.org/EIPS/eip-1363) +- [ERC-1363: GitHub ரெப்போ](https://github.com/vittominacori/erc1363-payable-token) diff --git a/public/content/translations/ta/developers/docs/standards/tokens/erc-20/index.md b/public/content/translations/ta/developers/docs/standards/tokens/erc-20/index.md new file mode 100644 index 00000000000..7f6f3803ed7 --- /dev/null +++ b/public/content/translations/ta/developers/docs/standards/tokens/erc-20/index.md @@ -0,0 +1,192 @@ +--- +title: "ERC-20 டோக்கன் தரநிலை" +description: "ERC-20 பற்றி அறிக, இது எத்தேரியத்தில் மாற்றத்தக்க டோக்கன்களுக்கான தரநிலையாகும், இது ஊடாடக்கூடிய டோக்கன் பயன்பாடுகளை செயல்படுத்துகிறது." +lang: ta +--- + +## அறிமுகம் {#introduction} + +**டோக்கன் என்றால் என்ன?** + +டோக்கன்கள் எத்தேரியத்தில் கிட்டத்தட்ட எதையும் குறிப்பிடலாம்: + +- ஒரு ஆன்லைன் தளத்தில் உள்ள நற்பெயர் புள்ளிகள் +- ஒரு விளையாட்டில் ஒரு கதாபாத்திரத்தின் திறன்கள் +- ஒரு நிறுவனத்தில் உள்ள ஒரு பங்கு போன்ற நிதிச் சொத்துக்கள் +- USD போன்ற ஒரு ஃபியட் நாணயம் +- ஒரு அவுன்ஸ் தங்கம் +- மேலும் பல... + +எத்தேரியத்தின் இத்தகைய சக்திவாய்ந்த அம்சம் ஒரு வலுவான தரநிலையால் கையாளப்பட வேண்டும், இல்லையா? சரியாக +இங்குதான் ERC-20 அதன் பங்கை வகிக்கிறது! இந்தத் தரநிலை, மற்ற தயாரிப்புகள் மற்றும் சேவைகளுடன் ஊடாடக்கூடிய டோக்கன் பயன்பாடுகளை உருவாக்க உருவாக்குநர்களை (டெவலப்பர்களை) அனுமதிக்கிறது. [ஈதருக்கு](/glossary/#ether) கூடுதல் செயல்பாட்டை வழங்க ERC-20 தரநிலையும் பயன்படுத்தப்படுகிறது. + +**ERC-20 என்றால் என்ன?** + +ERC-20 மாற்றத்தக்க டோக்கன்களுக்கான ஒரு தரநிலையை அறிமுகப்படுத்துகிறது, வேறுவிதமாகக் கூறினால், அவை ஒவ்வொரு டோக்கனையும் மற்றொரு டோக்கனைப் போலவே (வகை மற்றும் மதிப்பில்) சரியாக +ஒரே மாதிரியாக மாற்றும் ஒரு பண்பைக் கொண்டுள்ளன. உதாரணமாக, ஒரு ERC-20 டோக்கன் ETH போலவே செயல்படுகிறது, அதாவது 1 டோக்கன் +மற்ற எல்லா டோக்கன்களுக்கும் சமமாக இருக்கிறது மற்றும் எப்போதும் சமமாகவே இருக்கும். + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +- [கணக்குகள்](/developers/docs/accounts) +- [ஸ்மார்ட் ஒப்பந்தங்கள்](/developers/docs/smart-contracts/) +- [டோக்கன் தரநிலைகள்](/developers/docs/standards/tokens/) + +## உள்ளடக்கம் {#body} + +நவம்பர் 2015 இல் ஃபேபியன் வோகல்ஸ்டெல்லரால் முன்மொழியப்பட்ட ERC-20 (Ethereum Request for Comments 20), என்பது ஸ்மார்ட் ஒப்பந்தங்களுக்குள் டோக்கன்களுக்கான ஒரு பயன்பாட்டு நிரலாக்க இடைமுகத்தை (API) +செயல்படுத்தும் ஒரு டோக்கன் தரநிலையாகும். + +ERC-20 வழங்கும் உதாரண செயல்பாடுகள்: + +- ஒரு கணக்கிலிருந்து மற்றொரு கணக்கிற்கு டோக்கன்களைப் பரிமாற்றுதல் +- ஒரு கணக்கின் தற்போதைய டோக்கன் இருப்பைப் பெறுதல் +- நெட்வொர்க்கில் கிடைக்கும் டோக்கனின் மொத்த விநியோகத்தைப் பெறுதல் +- ஒரு கணக்கிலிருந்து ஒரு குறிப்பிட்ட அளவு டோக்கனை ஒரு மூன்றாம் தரப்புக் கணக்கு செலவழிக்க முடியுமா என்பதை அங்கீகரித்தல் + +ஒரு ஸ்மார்ட் ஒப்பந்தம் பின்வரும் முறைகளையும் நிகழ்வுகளையும் செயல்படுத்தினால், அதை ERC-20 டோக்கன் ஒப்பந்தம் என அழைக்கலாம், மேலும், வரிசைப்படுத்தப்பட்டவுடன், அது +எத்தேரியத்தில் உருவாக்கப்பட்ட டோக்கன்களைக் கண்காணிக்கும் பொறுப்பை ஏற்கும். + +[EIP-20](https://eips.ethereum.org/EIPS/eip-20) இலிருந்து: + +### முறைகள் {#methods} + +```solidity +function name() public view returns (string) +function symbol() public view returns (string) +function decimals() public view returns (uint8) +function totalSupply() public view returns (uint256) +function balanceOf(address _owner) public view returns (uint256 balance) +function transfer(address _to, uint256 _value) public returns (bool success) +function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) +function approve(address _spender, uint256 _value) public returns (bool success) +function allowance(address _owner, address _spender) public view returns (uint256 remaining) +``` + +### நிகழ்வுகள் {#events} + +```solidity +event Transfer(address indexed _from, address indexed _to, uint256 _value) +event Approval(address indexed _owner, address indexed _spender, uint256 _value) +``` + +### உதாரணங்கள் {#web3py-example} + +எத்தேரியத்தில் உள்ள எந்த ERC-20 டோக்கன் ஒப்பந்தத்தையும் ஆய்வு செய்வதை நமக்கு எளிதாக்குவதில் ஒரு தரநிலை எவ்வளவு முக்கியமானது என்பதைப் பார்ப்போம். +எந்தவொரு ERC-20 டோக்கனுக்கும் ஒரு இடைமுகத்தை உருவாக்க, நமக்கு ஒப்பந்த பயன்பாட்டு பைனரி இடைமுகம் (ABI) மட்டுமே தேவை. நீங்கள் கீழே காண்பது போல், +இதை ஒரு சிக்கலற்ற எடுத்துக்காட்டாக மாற்றுவதற்கு நாங்கள் ஒரு எளிமைப்படுத்தப்பட்ட ABI-ஐப் பயன்படுத்துவோம். + +#### Web3.py உதாரணம் {#web3py-example} + +முதலில், நீங்கள் [Web3.py](https://web3py.readthedocs.io/en/stable/quickstart.html#installation) பைத்தான் லைப்ரரியை நிறுவியுள்ளீர்கள் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள்: + +``` +pip install web3 +``` + +```python +from web3 import Web3 + + +w3 = Web3(Web3.HTTPProvider("https://cloudflare-eth.com")) + +dai_token_addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F" # DAI +weth_token_addr = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" # சுற்றப்பட்ட ஈதர் (WETH) + +acc_address = "0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11" # Uniswap V2: DAI 2 + +# இது ஒரு ERC-20 டோக்கன் ஒப்பந்தத்தின் எளிமைப்படுத்தப்பட்ட ஒப்பந்த பயன்பாட்டு பைனரி இடைமுகம் (ABI) ஆகும். +# இது balanceOf(address), decimals(), symbol() மற்றும் totalSupply() ஆகிய முறைகளை மட்டுமே வெளிப்படுத்தும். +simplified_abi = [ + { + 'inputs': [{'internalType': 'address', 'name': 'account', 'type': 'address'}], + 'name': 'balanceOf', + 'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}], + 'stateMutability': 'view', 'type': 'function', 'constant': True + }, + { + 'inputs': [], + 'name': 'decimals', + 'outputs': [{'internalType': 'uint8', 'name': '', 'type': 'uint8'}], + 'stateMutability': 'view', 'type': 'function', 'constant': True + }, + { + 'inputs': [], + 'name': 'symbol', + 'outputs': [{'internalType': 'string', 'name': '', 'type': 'string'}], + 'stateMutability': 'view', 'type': 'function', 'constant': True + }, + { + 'inputs': [], + 'name': 'totalSupply', + 'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}], + 'stateMutability': 'view', 'type': 'function', 'constant': True + } +] + +dai_contract = w3.eth.contract(address=w3.to_checksum_address(dai_token_addr), abi=simplified_abi) +symbol = dai_contract.functions.symbol().call() +decimals = dai_contract.functions.decimals().call() +totalSupply = dai_contract.functions.totalSupply().call() / 10**decimals +addr_balance = dai_contract.functions.balanceOf(acc_address).call() / 10**decimals + +# DAI +print("===== %s =====" % symbol) +print("Total Supply:", totalSupply) +print("Addr Balance:", addr_balance) + +weth_contract = w3.eth.contract(address=w3.to_checksum_address(weth_token_addr), abi=simplified_abi) +symbol = weth_contract.functions.symbol().call() +decimals = weth_contract.functions.decimals().call() +totalSupply = weth_contract.functions.totalSupply().call() / 10**decimals +addr_balance = weth_contract.functions.balanceOf(acc_address).call() / 10**decimals + +# WETH +print("===== %s =====" % symbol) +print("Total Supply:", totalSupply) +print("Addr Balance:", addr_balance) +``` + +## அறியப்பட்ட சிக்கல்கள் {#erc20-issues} + +### ERC-20 டோக்கன் பெறும் சிக்கல் {#reception-issue} + +**06/20/2024 நிலவரப்படி, இந்தச் சிக்கலால் குறைந்தபட்சம் $83,656,418 மதிப்புள்ள ERC-20 டோக்கன்கள் இழக்கப்பட்டன. **கீழே பட்டியலிடப்பட்டுள்ளபடி, தரநிலையின் மேல் கூடுதல் கட்டுப்பாடுகளின் தொகுப்பைச் செயல்படுத்தாவிட்டால், ஒரு தூய ERC-20 செயலாக்கம் இந்தச் சிக்கலுக்கு ஆளாகக்கூடும் என்பதை நினைவில் கொள்க.** + +ERC-20 டோக்கன்களைக் கையாள வடிவமைக்கப்படாத ஒரு ஸ்மார்ட் ஒப்பந்தத்திற்கு அவை அனுப்பப்படும்போது, அந்த டோக்கன்கள் நிரந்தரமாக இழக்கப்படலாம். உள்வரும் டோக்கன்களை அங்கீகரிக்க அல்லது பதிலளிப்பதற்கான செயல்பாடு பெறும் ஒப்பந்தத்தில் இல்லாததாலும், உள்வரும் டோக்கன்களைப் பற்றி பெறும் ஒப்பந்தத்திற்கு அறிவிக்க ERC-20 தரநிலையில் எந்த வழிமுறையும் இல்லாததாலும் இது நிகழ்கிறது. இந்தச் சிக்கல் பின்வரும் முக்கிய வழிகளில் உருவாகிறது: + +1. டோக்கன் பரிமாற்ற வழிமுறை + +- ERC-20 டோக்கன்கள் transfer அல்லது transferFrom செயல்பாடுகளைப் பயன்படுத்தி மாற்றப்படுகின்றன + - ஒரு பயனர் இந்த செயல்பாடுகளைப் பயன்படுத்தி ஒரு ஒப்பந்த முகவரிக்கு டோக்கன்களை அனுப்பும்போது, பெறும் ஒப்பந்தம் அவற்றை கையாள வடிவமைக்கப்பட்டுள்ளதா என்பதைப் பொருட்படுத்தாமல் டோக்கன்கள் மாற்றப்படுகின்றன + +2. அறிவிப்பு இல்லாமை + - டோக்கன்கள் தனக்கு அனுப்பப்பட்டதற்கான அறிவிப்பையோ அல்லது கால்பேக்கையோ பெறும் ஒப்பந்தம் பெறுவதில்லை. + - டோக்கன்களைக் கையாளும் ஒரு பொறிமுறை (எ.கா., ஒரு ஃபால்பேக் செயல்பாடு அல்லது டோக்கன் பெறுதலை நிர்வகிக்க ஒரு பிரத்யேக செயல்பாடு) பெறும் ஒப்பந்தத்தில் இல்லை என்றால், டோக்கன்கள் திறம்பட ஒப்பந்தத்தின் முகவரியில் சிக்கிக்கொள்கின்றன. +3. உள்ளமைக்கப்பட்ட கையாளுதல் இல்லை + - ERC-20 தரநிலையானது பெறும் ஒப்பந்தங்கள் செயல்படுத்துவதற்கு ஒரு கட்டாயமான செயல்பாட்டை உள்ளடக்கவில்லை, இது பல ஒப்பந்தங்கள் உள்வரும் டோக்கன்களை முறையாக நிர்வகிக்க முடியாத சூழ்நிலைக்கு வழிவகுக்கிறது. + +**சாத்தியமான தீர்வுகள்** + +ERC-20 உடன் இந்தச் சிக்கலை முழுமையாகத் தடுக்க முடியாவிட்டாலும், இறுதிப் பயனருக்கான டோக்கன் இழப்புக்கான சாத்தியக்கூறுகளைக் கணிசமாகக் குறைக்க அனுமதிக்கும் முறைகள் உள்ளன: + +- மிகவும் பொதுவான பிரச்சனை என்னவென்றால், ஒரு பயனர் டோக்கன்களை டோக்கன் ஒப்பந்த முகவரிக்கே அனுப்பும்போது (எ.கா., USDT டோக்கன் ஒப்பந்தத்தின் முகவரிக்கு USDT டெபாசிட் செய்யப்படுவது). அத்தகைய பரிமாற்ற முயற்சிகளைத் திரும்பப்பெற `transfer(..)` செயல்பாட்டைக் கட்டுப்படுத்தப் பரிந்துரைக்கப்படுகிறது. `transfer(..)` செயல்பாட்டின் செயலாக்கத்திற்குள் `require(_to != address(this));` சரிபார்ப்பைச் சேர்ப்பதைக் கவனியுங்கள். +- பொதுவாக `transfer(..)` செயல்பாடானது ஒப்பந்தங்களுக்கு டோக்கன்களை டெபாசிட் செய்வதற்காக வடிவமைக்கப்படவில்லை. `approve(..) `& transferFrom(..)`முறை அதற்குப் பதிலாக ERC-20 டோக்கன்களை ஒப்பந்தங்களில் டெபாசிட் செய்யப் பயன்படுகிறது. பரிமாற்றச் செயல்பாட்டை கட்டுப்படுத்துவதன் மூலம், அதனுடன் எந்த ஒப்பந்தங்களுக்கும் டோக்கன்களை டெபாசிட் செய்வதைத் தடுக்க முடியும், இருப்பினும் இது`trasnfer(..)` செயல்பாட்டின் மூலம் ஒப்பந்தங்களில் டோக்கன்களை டெபாசிட் செய்யலாம் என்று கருதும் ஒப்பந்தங்களுடன் (எ.கா., யூனிஸ்வாப் நீர்மைப் பூல்கள்) பொருந்தக்கூடிய தன்மையை உடைக்கக்கூடும். +- உங்கள் ஒப்பந்தம் எப்போதாவது எதையும் பெற வேண்டும் என்று கருதப்படாவிட்டாலும் கூட, ERC-20 டோக்கன்கள் உங்கள் ஒப்பந்தத்தில் முடிவடையக்கூடும் என எப்போதும் கருதுங்கள். பெறுநரின் தரப்பிலிருந்து தற்செயலான வைப்புகளைத் தடுக்கவோ அல்லது நிராகரிக்கவோ வழியில்லை. தற்செயலாக டெபாசிட் செய்யப்பட்ட ERC-20 டோக்கன்களை மீட்டெடுக்க அனுமதிக்கும் ஒரு செயல்பாட்டைச் செயல்படுத்தப் பரிந்துரைக்கப்படுகிறது. +- மாற்று டோக்கன் தரநிலைகளைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள். + +இந்த சிக்கலில் இருந்து [ERC-223](/developers/docs/standards/tokens/erc-223) அல்லது [ERC-1363](/developers/docs/standards/tokens/erc-1363) போன்ற சில மாற்று தரநிலைகள் வந்துள்ளன. + +## மேலும் வாசிக்க {#further-reading} + +- [EIP-20: ERC-20 டோக்கன் தரநிலை](https://eips.ethereum.org/EIPS/eip-20) +- [OpenZeppelin - டோக்கன்கள்](https://docs.openzeppelin.com/contracts/3.x/tokens#ERC20) +- [OpenZeppelin - ERC-20 செயலாக்கம்](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol) +- [Alchemy - Solidity ERC20 டோக்கன்களுக்கான வழிகாட்டி](https://www.alchemy.com/overviews/erc20-solidity) + +## மற்ற மாற்றத்தக்க டோக்கன் தரநிலைகள் {#fungible-token-standards} + +- [ERC-223](/developers/docs/standards/tokens/erc-223) +- [ERC-1363](/developers/docs/standards/tokens/erc-1363) +- [ERC-777](/developers/docs/standards/tokens/erc-777) +- [ERC-4626 - டோக்கனைஸ்டு வால்ட்கள்](/developers/docs/standards/tokens/erc-4626) diff --git a/public/content/translations/ta/developers/docs/standards/tokens/erc-223/index.md b/public/content/translations/ta/developers/docs/standards/tokens/erc-223/index.md new file mode 100644 index 00000000000..ba10a1e56e9 --- /dev/null +++ b/public/content/translations/ta/developers/docs/standards/tokens/erc-223/index.md @@ -0,0 +1,198 @@ +--- +title: "ERC-223 தரநிலைக் குறி" +description: "ERC-223 fungible தரநிலைக் குறியின் மேலோட்டம், அது எவ்வாறு செயல்படுகிறது மற்றும் ERC-20 உடனான ஒப்பீடு." +lang: ta +--- + +## அறிமுகம் {#introduction} + +### ERC-223 என்றால் என்ன? {#what-is-erc223} + +ERC-223 என்பது ERC-20 தரநிலையைப் போன்ற fungible டோக்கன்களுக்கான ஒரு தரநிலையாகும். முக்கிய வேறுபாடு என்னவென்றால், ERC-223 டோக்கன் பயன்பாட்டு நிரலாக்க இடைமுகத்தை மட்டும் வரையறுக்காமல், அனுப்புநரிடமிருந்து பெறுநருக்கு டோக்கன்களை மாற்றுவதற்கான தர்க்கத்தையும் வரையறுக்கிறது. பெறுநரின் பக்கத்தில் டோக்கன் இடமாற்றங்களைக் கையாள அனுமதிக்கும் ஒரு தொடர்பு மாதிரியை இது அறிமுகப்படுத்துகிறது. + +### ERC-20 இலிருந்து வேறுபாடுகள் {#erc20-differences} + +ERC-223, ERC-20-இன் சில வரம்புகளை நிவர்த்தி செய்கிறது மற்றும் டோக்கன் ஒப்பந்தத்திற்கும் டோக்கன்களைப் பெறக்கூடிய ஒரு ஒப்பந்தத்திற்கும் இடையில் ஒரு புதிய தொடர்பு முறையை அறிமுகப்படுத்துகிறது. ERC-223 உடன் சாத்தியமான சில விஷயங்கள் ERC-20 உடன் சாத்தியமில்லை: + +- பெறுநரின் பக்கத்தில் டோக்கன் பரிமாற்றத்தைக் கையாளுதல்: ஒரு ERC-223 டோக்கன் டெபாசிட் செய்யப்படுகிறது என்பதை பெறுநர்களால் கண்டறிய முடியும். +- முறையற்ற முறையில் அனுப்பப்பட்ட டோக்கன்களை நிராகரித்தல்: ஒரு பயனர், டோக்கன்களைப் பெறக் கூடாத ஒப்பந்தத்திற்கு ERC-223 டோக்கன்களை அனுப்பினால், அந்த ஒப்பந்தம் பரிவர்த்தனையை நிராகரித்து, டோக்கன் இழப்பைத் தடுக்கும். +- பரிமாற்றங்களில் உள்ள மீதரவு: ERC-223 டோக்கன்கள் மீதரவை உள்ளடக்கலாம், இது டோக்கன் பரிவர்த்தனைகளுடன் தன்னிச்சையான தகவல்களை இணைக்க அனுமதிக்கிறது. + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +- [கணக்குகள்](/developers/docs/accounts) +- [ஸ்மார்ட் ஒப்பந்தங்கள்](/developers/docs/smart-contracts/) +- [டோக்கன் தரநிலைகள்](/developers/docs/standards/tokens/) +- [ERC-20](/developers/docs/standards/tokens/erc-20/) + +## உள்ளடக்கம் {#body} + +ERC-223 என்பது ஸ்மார்ட் ஒப்பந்தங்களுக்குள் உள்ள டோக்கன்களுக்காக ஒரு பயன்பாட்டு நிரலாக்க இடைமுகத்தை (API) செயல்படுத்தும் ஒரு டோக்கன் தரநிலையாகும். ERC-223 டோக்கன்களைப் பெற வேண்டிய ஒப்பந்தங்களுக்காக இது ஒரு பயன்பாட்டு நிரலாக்க இடைமுகத்தையும் (API) அறிவிக்கிறது. ERC-223 பெறுநர் பயன்பாட்டு நிரலாக்க இடைமுகத்தை (API) ஆதரிக்காத ஒப்பந்தங்களால் ERC-223 டோக்கன்களைப் பெற முடியாது, இது பயனர் பிழையைத் தடுக்கிறது. + +ஒரு ஸ்மார்ட் ஒப்பந்தம் பின்வரும் முறைகள் மற்றும் நிகழ்வுகளைச் செயல்படுத்தினால், அது ஒரு ERC-223 இணக்கமான டோக்கன் ஒப்பந்தம் என்று அழைக்கப்படலாம். செயல்பாட்டிற்கு வந்தவுடன், அது +Ethereum-இல் உருவாக்கப்பட்ட டோக்கன்களைக் கண்காணிக்கும் பொறுப்பை ஏற்கும். + +இந்தச் செயல்பாடுகளை மட்டும் கொண்டிருக்க வேண்டிய கட்டாயம் இந்த ஒப்பந்தத்திற்கு இல்லை மற்றும் ஒரு உருவாக்குநர் வெவ்வேறு டோக்கன் தரநிலைகளிலிருந்து வேறு எந்த அம்சத்தையும் இந்த ஒப்பந்தத்தில் சேர்க்கலாம். உதாரணமாக, `approve` மற்றும் `transferFrom` செயல்பாடுகள் ERC-223 தரநிலையின் ஒரு பகுதியாக இல்லை, ஆனால் தேவைப்பட்டால் இந்த செயல்பாடுகளைச் செயல்படுத்தலாம். + +[EIP-223](https://eips.ethereum.org/EIPS/eip-223) இலிருந்து: + +### முறைகள் {#methods} + +ERC-223 டோக்கன் பின்வரும் முறைகளைச் செயல்படுத்த வேண்டும்: + +```solidity +function name() public view returns (string) +function symbol() public view returns (string) +function decimals() public view returns (uint8) +function totalSupply() public view returns (uint256) +function balanceOf(address _owner) public view returns (uint256 balance) +function transfer(address _to, uint256 _value) public returns (bool success) +function transfer(address _to, uint256 _value, bytes calldata _data) public returns (bool success) +``` + +ERC-223 டோக்கன்களைப் பெற வேண்டிய ஒரு ஒப்பந்தம் பின்வரும் முறையைச் செயல்படுத்த வேண்டும்: + +```solidity +function tokenReceived(address _from, uint _value, bytes calldata _data) +``` + +`tokenReceived(..)` செயல்பாட்டைச் செயல்படுத்தாத ஒப்பந்தத்திற்கு ERC-223 டோக்கன்கள் அனுப்பப்பட்டால், பரிமாற்றம் தோல்வியடைய வேண்டும் மற்றும் டோக்கன்கள் அனுப்புநரின் இருப்பிலிருந்து நகர்த்தப்படக்கூடாது. + +### நிகழ்வுகள் {#events} + +```solidity +event Transfer(address indexed _from, address indexed _to, uint256 _value, bytes calldata _data) +``` + +### எடுத்துக்காட்டுகள் {#examples} + +ERC-223 டோக்கனின் பயன்பாட்டு நிரலாக்க இடைமுகம் (API) ERC-20-ஐப் போன்றது, எனவே UI மேம்பாட்டுக் கண்ணோட்டத்தில் எந்த வேறுபாடும் இல்லை. இங்குள்ள ஒரே விதிவிலக்கு என்னவென்றால், ERC-223 டோக்கன்களில் `approve` + `transferFrom` செயல்பாடுகள் இல்லாமல் இருக்கலாம், ஏனெனில் இவை இந்த தரநிலைக்கு விருப்பத்தேர்வானவை. + +#### Solidity எடுத்துக்காட்டுகள் {#solidity-example} + +ஒரு அடிப்படை ERC-223 டோக்கன் ஒப்பந்தம் எவ்வாறு செயல்படுகிறது என்பதை பின்வரும் எடுத்துக்காட்டு விளக்குகிறது: + +```solidity +pragma solidity ^0.8.19; +abstract contract IERC223Recipient { + function tokenReceived(address _from, uint _value, bytes memory _data) public virtual; +} +contract VeryBasicERC223Token { + event Transfer(address indexed from, address indexed to, uint value, bytes data); + string private _name; + string private _symbol; + uint8 private _decimals; + uint256 private _totalSupply; + mapping(address => uint256) private balances; + function name() public view returns (string memory) { return _name; } + function symbol() public view returns (string memory) {return _symbol; } + function decimals() public view returns (uint8) { return _decimals; } + function totalSupply() public view returns (uint256) { return _totalSupply; } + function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } + function isContract(address account) internal view returns (bool) { + uint256 size; + assembly { size := extcodesize(account) } + return size > 0; + } + function transfer(address _to, uint _value, bytes calldata _data) public returns (bool success){ + balances[msg.sender] = balances[msg.sender] - _value; + balances[_to] = balances[_to] + _value; + if(isContract(_to)) { + IERC223Recipient(_to).tokenReceived(msg.sender, _value, _data); + } + emit Transfer(msg.sender, _to, _value, _data); + return true; + } + function transfer(address _to, uint _value) public returns (bool success){ + bytes memory _empty = hex"00000000"; + balances[msg.sender] = balances[msg.sender] - _value; + balances[_to] = balances[_to] + _value; + if(isContract(_to)) { + IERC223Recipient(_to).tokenReceived(msg.sender, _value, _empty); + } + emit Transfer(msg.sender, _to, _value, _empty); + return true; + } +} +``` + +இப்போது, tokenA ஒரு ERC-223 டோக்கன் என்று கருதி, `tokenA`-இன் டெபாசிட்களை ஏற்க மற்றொரு ஒப்பந்தம் நமக்குத் தேவை. அந்த ஒப்பந்தம் tokenA-ஐ மட்டுமே ஏற்க வேண்டும் மற்றும் வேறு எந்த டோக்கன்களையும் நிராகரிக்க வேண்டும். ஒப்பந்தம் tokenA-ஐப் பெறும்போது, அது ஒரு `Deposit()` நிகழ்வை வெளியிட வேண்டும் மற்றும் உள் `deposits` மாறியின் மதிப்பை அதிகரிக்க வேண்டும். + +இதோ அந்தக் குறியீடு: + +```solidity +contract RecipientContract is IERC223Recipient { + event Deposit(address whoSentTheTokens); + uint256 deposits = 0; + address tokenA; // நாம் ஏற்க விரும்பும் ஒரே டோக்கன். + function tokenReceived(address _from, uint _value, bytes memory _data) public override + { + // இந்தச் செயல்பாட்டிற்குள் என்பதைப் புரிந்துகொள்வது அவசியம் + // msg.sender என்பது பெறப்படும் டோக்கனின் முகவரி, + // msg.value எப்போதுமே 0 ஆக இருக்கும், ஏனெனில் டோக்கன் ஒப்பந்தம் பெரும்பாலான சந்தர்ப்பங்களில் ஈதரை சொந்தமாக வைத்திருக்கவோ அல்லது அனுப்பவோ இல்லை, + // _from என்பது டோக்கன் பரிமாற்றத்தை அனுப்புபவர், + // _value என்பது டெபாசிட் செய்யப்பட்ட டோக்கன்களின் அளவு. + require(msg.sender == tokenA); + deposits += _value; + emit Deposit(_from); + } +} +``` + +## Frequently asked questions {#faq} + +### நாம் சில tokenB-ஐ ஒப்பந்தத்திற்கு அனுப்பினால் என்ன நடக்கும்? {#sending-tokens} + +பரிவர்த்தனை தோல்வியடையும், மற்றும் டோக்கன்களின் பரிமாற்றம் நடக்காது. டோக்கன்கள் அனுப்புநரின் முகவரிக்குத் திருப்பி அனுப்பப்படும். + +### இந்த ஒப்பந்தத்தில் நாம் எப்படி டெபாசிட் செய்வது? {#contract-deposits} + +`RecipientContract`-இன் முகவரியைக் குறிப்பிடும் ERC-223 டோக்கனின் `transfer(address,uint256)` அல்லது `transfer(address,uint256,bytes)` செயல்பாட்டை அழைக்கவும். + +### நாம் ஒரு ERC-20 டோக்கனை இந்த ஒப்பந்தத்திற்கு மாற்றினால் என்ன நடக்கும்? {#erc-20-transfers} + +`RecipientContract`-க்கு ஒரு ERC-20 டோக்கன் அனுப்பப்பட்டால், டோக்கன்கள் மாற்றப்படும், ஆனால் அந்தப் பரிமாற்றம் அங்கீகரிக்கப்படாது (`Deposit()` நிகழ்வு எதுவும் வெளியிடப்படாது, மேலும் டெபாசிட் மதிப்பு மாறாது). தேவையற்ற ERC-20 டெபாசிட்களை வடிகட்டவோ அல்லது தடுக்கவோ முடியாது. + +### டோக்கன் டெபாசிட் முடிந்த பிறகு சில செயல்பாடுகளை இயக்க விரும்பினால் என்ன செய்வது? {#function-execution} + +அவ்வாறு செய்ய பல வழிகள் உள்ளன. இந்த எடுத்துக்காட்டில், ERC-223 பரிமாற்றங்களை ஈதர் பரிமாற்றங்களைப் போலவே ஆக்கும் முறையைப் பின்பற்றுவோம்: + +```solidity +contract RecipientContract is IERC223Recipient { + event Foo(); + event Bar(uint256 someNumber); + address tokenA; // நாம் ஏற்க விரும்பும் ஒரே டோக்கன். + function tokenReceived(address _from, uint _value, bytes memory _data) public override + { + require(msg.sender == tokenA); + address(this).call(_data); // உள்வரும் பரிவர்த்தனையைக் கையாண்டு, அடுத்தடுத்த செயல்பாட்டு அழைப்பைச் செய்யவும். + } + function foo() public + { + emit Foo(); + } + function bar(uint256 _someNumber) public + { + emit Bar(_someNumber); + } +} +``` + +`RecipientContract` ஒரு ERC-223 டோக்கனைப் பெறும்போது, ஈதர் பரிவர்த்தனைகள் செயல்பாட்டு அழைப்புகளை பரிவர்த்தனை `data`-ஆகக் குறியாக்கம் செய்வதைப் போலவே, அந்த ஒப்பந்தமும் டோக்கன் பரிவர்த்தனையின் `_data` அளவுருவாகக் குறியாக்கம் செய்யப்பட்ட ஒரு செயல்பாட்டை இயக்கும். மேலும் தகவலுக்கு [தரவுப் புலம்](/developers/docs/transactions/#the-data-field)-த்தைப் படிக்கவும். + +மேலே உள்ள எடுத்துக்காட்டில், ஒரு 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 ஆகும். + +## வரம்புகள் {#limitations} + +ERC-223, ERC-20 தரநிலையில் காணப்படும் பல சிக்கல்களை நிவர்த்தி செய்தாலும், அதற்கும் சில வரம்புகள் உள்ளன: + +- ஏற்றுக்கொள்ளுதல் மற்றும் இணக்கத்தன்மை: ERC-223 இன்னும் பரவலாக ஏற்றுக்கொள்ளப்படவில்லை, இது தற்போதுள்ள கருவிகள் மற்றும் தளங்களுடனான அதன் இணக்கத்தன்மையைக் கட்டுப்படுத்தக்கூடும். +- பழையவற்றுடன் இணக்கத்தன்மை: ERC-223, ERC-20 உடன் பழையவற்றிற்கு இணக்கத்தன்மை கொண்டதல்ல, அதாவது தற்போதுள்ள ERC-20 ஒப்பந்தங்கள் மற்றும் கருவிகள் மாற்றங்கள் இல்லாமல் ERC-223 டோக்கன்களுடன் வேலை செய்யாது. +- கேஸ் செலவுகள்: ERC-223 பரிமாற்றங்களில் உள்ள கூடுதல் சோதனைகள் மற்றும் செயல்பாடுகள், ERC-20 பரிவர்த்தனைகளுடன் ஒப்பிடும்போது அதிக கேஸ் செலவுகளை ஏற்படுத்தக்கூடும். + +## மேலும் வாசிக்க {#further-reading} + +- [EIP-223: ERC-223 தரநிலைக் குறி](https://eips.ethereum.org/EIPS/eip-223) +- [ஆரம்ப ERC-223 முன்மொழிவு](https://github.com/ethereum/eips/issues/223) diff --git a/public/content/translations/ta/developers/docs/standards/tokens/erc-4626/index.md b/public/content/translations/ta/developers/docs/standards/tokens/erc-4626/index.md new file mode 100644 index 00000000000..8160b78b731 --- /dev/null +++ b/public/content/translations/ta/developers/docs/standards/tokens/erc-4626/index.md @@ -0,0 +1,227 @@ +--- +title: "ERC-4626 டோக்கனைஸ் செய்யப்பட்ட வால்ட் தரநிலை" +description: "மகசூல் ஈட்டும் வால்ட்டுகளுக்கான ஒரு தரநிலை." +lang: ta +--- + +## அறிமுகம் {#introduction} + +ERC-4626 என்பது மகசூல் ஈட்டும் வால்ட்டுகளின் தொழில்நுட்ப அளவுருக்களை மேம்படுத்தவும் ஒருங்கிணைக்கவும் உதவும் ஒரு தரநிலையாகும். ஒற்றை அடிப்படையான ERC-20 டோக்கனின் பங்குகளைப் பிரதிநிதித்துவப்படுத்தும் டோக்கனைஸ் செய்யப்பட்ட மகசூல் ஈட்டும் வால்ட்டுகளுக்கு இது ஒரு நிலையான API-ஐ வழங்குகிறது. டோக்கன்களை டெபாசிட் செய்வதற்கும், திரும்பப் பெறுவதற்கும் மற்றும் இருப்புகளைப் படிப்பதற்கும் அடிப்படை செயல்பாட்டை வழங்கும் ERC-20 ஐப் பயன்படுத்தும் டோக்கனைஸ் செய்யப்பட்ட வால்ட்டுகளுக்கான விருப்ப நீட்டிப்பையும் ERC-4626 கோடிட்டுக் காட்டுகிறது. + +**மகசூல் ஈட்டும் வால்ட்டுகளில் ERC-4626 இன் பங்கு** + +கடன் வழங்கும் சந்தைகள், திரட்டிகள் மற்றும் இயல்பாகவே வட்டி ஈட்டும் டோக்கன்கள் ஆகியவை வெவ்வேறு உத்திகளைச் செயல்படுத்துவதன் மூலம் பயனர்கள் தங்கள் கிரிப்டோ டோக்கன்களில் சிறந்த மகசூலைக் கண்டறிய உதவுகின்றன. இந்த உத்திகள் சிறிய மாறுபாடுகளுடன் செய்யப்படுகின்றன, இது பிழை ஏற்பட வாய்ப்புள்ளது அல்லது மேம்பாட்டு வளங்களை வீணடிக்கக்கூடும். + +மகசூல் ஈட்டும் வால்ட்டுகளில் உள்ள ERC-4626, மிகவும் சீரான மற்றும் வலுவான செயலாக்க முறைகளை உருவாக்குவதன் மூலம் ஒருங்கிணைப்பு முயற்சியைக் குறைக்கும் மற்றும் டெவலப்பர்களிடமிருந்து சிறிதளவு சிறப்பு முயற்சியுடன் பல்வேறு பயன்பாடுகளில் மகசூலுக்கான அணுகலைத் திறக்கும். + +ERC-4626 டோக்கன் [EIP-4626](https://eips.ethereum.org/EIPS/eip-4626) இல் முழுமையாக விவரிக்கப்பட்டுள்ளது. + +**ஒத்திசைவற்ற வால்ட் நீட்டிப்பு (ERC-7540)** + +ERC-4626 ஒரு வரம்பு வரை அணுவியல் வைப்புத்தொகை மற்றும் மீட்புகளுக்கு உகந்ததாக்கப்பட்டுள்ளது. வரம்பை எட்டினால், புதிய வைப்புத்தொகை அல்லது மீட்புகளைச் சமர்ப்பிக்க முடியாது. இந்த வரம்பு, வால்ட்டுடன் இடைமுகம் செய்வதற்கான ஒரு முன்நிபந்தனையாக ஒத்திசைவற்ற செயல்கள் அல்லது தாமதங்களைக் கொண்ட எந்த ஸ்மார்ட் ஒப்பந்த முறைக்கும் (எ.கா., நிஜ-உலக சொத்து நெறிமுறைகள், குறைந்த இணைக்கடன் நெறிமுறைகள், குறுக்கு-சங்கிலி கடன் நெறிமுறைகள், திரவ ஸ்டேக்கிங் டோக்கன்கள், அல்லது காப்பீட்டுப் பாதுகாப்பு தொகுதிகள்) நன்றாக வேலை செய்யாது. + +ERC-7540, ஒத்திசைவற்ற பயன்பாட்டு நிகழ்வுகளுக்கு ERC-4626 வால்ட்டுகளின் பயன்பாட்டை விரிவுபடுத்துகிறது. தற்போதுள்ள வால்ட் இடைமுகம் (`deposit`/`withdraw`/`mint`/`redeem`) ஒத்திசைவற்ற கோரிக்கைகளைக் கோருவதற்கு முழுமையாகப் பயன்படுத்தப்படுகிறது. + +ERC-7540 நீட்டிப்பு [ERC-7540](https://eips.ethereum.org/EIPS/eip-7540) இல் முழுமையாக விவரிக்கப்பட்டுள்ளது. + +**பல-சொத்து வால்ட் நீட்டிப்பு (ERC-7575)** + +ERC-4626 ஆல் ஆதரிக்கப்படாத விடுபட்ட ஒரு பயன்பாட்டு நிகழ்வு, திரவத்தன்மை வழங்குநர் (LP) டோக்கன்கள் போன்ற பல சொத்துக்கள் அல்லது நுழைவுப் புள்ளிகளைக் கொண்ட வால்ட்டுகள் ஆகும். ERC-4626 தானே ஒரு ERC-20 ஆக இருக்க வேண்டும் என்ற தேவை காரணமாக, இவை பொதுவாகப் பயன்படுத்த கடினமானவை அல்லது இணக்கமற்றவை. + +ERC-7575 ஆனது ERC-4626 செயலாக்கத்திலிருந்து ERC-20 டோக்கன் செயலாக்கத்தை வெளிப்புறமாக்குவதன் மூலம் பல சொத்துக்கள் கொண்ட வால்ட்டுகளுக்கு ஆதரவைச் சேர்க்கிறது. + +ERC-7575 நீட்டிப்பு [ERC-7575](https://eips.ethereum.org/EIPS/eip-7575) இல் முழுமையாக விவரிக்கப்பட்டுள்ளது. + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +இந்தப் பக்கத்தை நன்கு புரிந்துகொள்ள, நீங்கள் முதலில் [டோக்கன் தரநிலைகள்](/developers/docs/standards/tokens/) மற்றும் [ERC-20](/developers/docs/standards/tokens/erc-20/) பற்றிப் படிக்கப் பரிந்துரைக்கிறோம். + +## ERC-4626 செயல்பாடுகள் மற்றும் அம்சங்கள்: {#body} + +### முறைகள் {#methods} + +#### சொத்து {#asset} + +```solidity +function asset() public view returns (address assetTokenAddress) +``` + +இந்தச் செயல்பாடு, கணக்கு வைத்தல், டெபாசிட் செய்தல், திரும்பப் பெறுதல் ஆகியவற்றிற்கு வால்ட்டுக்கு பயன்படுத்தப்படும் அடிப்படை டோக்கனின் முகவரியைத் திருப்பித் தருகிறது. + +#### மொத்த சொத்துக்கள் {#totalassets} + +```solidity +function totalAssets() public view returns (uint256) +``` + +இந்தச் செயல்பாடு வால்ட் வைத்திருக்கும் அடிப்படை சொத்துக்களின் மொத்தத் தொகையைத் திருப்பித் தருகிறது. + +#### பங்குகளாக மாற்று {#convertoshares} + +```solidity +function convertToShares(uint256 assets) public view returns (uint256 shares) +``` + +இந்தச் செயல்பாடு, வழங்கப்பட்ட `assets` அளவுக்காக வால்ட்டால் பரிமாற்றம் செய்யப்படும் `shares` அளவைத் திருப்பித் தருகிறது. + +#### சொத்துக்களாக மாற்று {#convertoassets} + +```solidity +function convertToAssets(uint256 shares) public view returns (uint256 assets) +``` + +இந்தச் செயல்பாடு, வழங்கப்பட்ட `shares` அளவுக்காக வால்ட்டால் பரிமாற்றம் செய்யப்படும் `assets` அளவைத் திருப்பித் தருகிறது. + +#### அதிகபட்ச வைப்புத்தொகை {#maxdeposit} + +```solidity +function maxDeposit(address receiver) public view returns (uint256 maxAssets) +``` + +இந்தச் செயல்பாடு, `receiver`-க்கு உருவாக்கப்பட்ட பங்குகளுடன், ஒற்றை [`deposit`](#deposit) அழைப்பில் டெபாசிட் செய்யக்கூடிய அடிப்படைச் சொத்துகளின் அதிகபட்ச அளவைத் திருப்பித் தருகிறது. + +#### வைப்புத்தொகை மாதிரிக்காட்சி {#previewdeposit} + +```solidity +function previewDeposit(uint256 assets) public view returns (uint256 shares) +``` + +இந்தச் செயல்பாடு பயனர்கள் தற்போதைய பிளாக்கில் தங்கள் வைப்புத்தொகையின் விளைவுகளை உருவகப்படுத்த அனுமதிக்கிறது. + +#### வைப்புத்தொகை {#deposit} + +```solidity +function deposit(uint256 assets, address receiver) public returns (uint256 shares) +``` + +இந்தச் செயல்பாடு அடிப்படை டோக்கன்களின் `assets`-ஐ வால்ட்டுக்குள் டெபாசிட் செய்து, `shares` இன் உரிமையை `receiver`-க்கு வழங்குகிறது. + +#### அதிகபட்ச உருவாக்கம் {#maxmint} + +```solidity +function maxMint(address receiver) public view returns (uint256 maxShares) +``` + +இந்தச் செயல்பாடு, `receiver`-க்கு உருவாக்கப்பட்ட பங்குகளுடன், ஒற்றை [`mint`](#mint) அழைப்பில் உருவாக்கக்கூடிய அதிகபட்ச பங்குகளின் அளவைத் திருப்பித் தருகிறது. + +#### உருவாக்க மாதிரிக்காட்சி {#previewmint} + +```solidity +function previewMint(uint256 shares) public view returns (uint256 assets) +``` + +இந்தச் செயல்பாடு பயனர்கள் தற்போதைய பிளாக்கில் தங்கள் உருவாக்கத்தின் விளைவுகளை உருவகப்படுத்த அனுமதிக்கிறது. + +#### உருவாக்கு {#mint} + +```solidity +function mint(uint256 shares, address receiver) public returns (uint256 assets) +``` + +இந்தச் செயல்பாடு அடிப்படை டோக்கன்களின் `assets`-ஐ டெபாசிட் செய்வதன் மூலம் சரியாக `shares` வால்ட் பங்குகளை `receiver`-க்கு உருவாக்குகிறது. + +#### அதிகபட்ச திரும்பப் பெறுதல் {#maxwithdraw} + +```solidity +function maxWithdraw(address owner) public view returns (uint256 maxAssets) +``` + +இந்தச் செயல்பாடு ஒற்றை [`withdraw`](#withdraw) அழைப்புடன் `owner` இருப்பில் இருந்து திரும்பப் பெறக்கூடிய அடிப்படைச் சொத்துகளின் அதிகபட்ச அளவைத் திருப்பித் தருகிறது. + +#### திரும்பப் பெறுதல் மாதிரிக்காட்சி {#previewwithdraw} + +```solidity +function previewWithdraw(uint256 assets) public view returns (uint256 shares) +``` + +இந்தச் செயல்பாடு பயனர்கள் தற்போதைய பிளாக்கில் தங்கள் திரும்பப் பெறுதலின் விளைவுகளை உருவகப்படுத்த அனுமதிக்கிறது. + +#### திரும்பப் பெறு {#withdraw} + +```solidity +function withdraw(uint256 assets, address receiver, address owner) public returns (uint256 shares) +``` + +இந்தச் செயல்பாடு `owner`-இடமிருந்து `shares`-ஐ எரித்து, வால்ட்டில் இருந்து `receiver`-க்குச் சரியாக `assets` டோக்கனை அனுப்புகிறது. + +#### அதிகபட்ச மீட்பு {#maxredeem} + +```solidity +function maxRedeem(address owner) public view returns (uint256 maxShares) +``` + +இந்தச் செயல்பாடு, ஒரு [`redeem`](#redeem) அழைப்பின் மூலம் `owner` இருப்பிலிருந்து மீட்கப்படக்கூடிய அதிகபட்ச பங்குகளின் அளவைத் திருப்பித் தருகிறது. + +#### மீட்பு மாதிரிக்காட்சி {#previewredeem} + +```solidity +function previewRedeem(uint256 shares) public view returns (uint256 assets) +``` + +இந்தச் செயல்பாடு பயனர்கள் தற்போதைய பிளாக்கில் தங்கள் மீட்பின் விளைவுகளை உருவகப்படுத்த அனுமதிக்கிறது. + +#### மீட்டெடு {#redeem} + +```solidity +function redeem(uint256 shares, address receiver, address owner) public returns (uint256 assets) +``` + +இந்தச் செயல்பாடு `owner` இடமிருந்து ஒரு குறிப்பிட்ட எண்ணிக்கையிலான `shares`-ஐ மீட்டு, வால்ட்டில் இருந்து `receiver`-க்கு அடிப்படை டோக்கனின் `assets`-ஐ அனுப்புகிறது. + +#### மொத்த வழங்கல் {#totalsupply} + +```solidity +function totalSupply() public view returns (uint256) +``` + +புழக்கத்தில் உள்ள மீட்கப்படாத வால்ட் பங்குகளின் மொத்த எண்ணிக்கையைத் திருப்பித் தருகிறது. + +#### இருப்பு {#balanceof} + +```solidity +function balanceOf(address owner) public view returns (uint256) +``` + +`owner` தற்போது வைத்திருக்கும் வால்ட் பங்குகளின் மொத்த அளவைத் திருப்பித் தருகிறது. + +### இடைமுகத்தின் வரைபடம் {#mapOfTheInterface} + +![ERC-4626 இடைமுகத்தின் வரைபடம்](./map-of-erc-4626.png) + +### நிகழ்வுகள் {#events} + +#### வைப்புத்தொகை நிகழ்வு + +[`mint`](#mint) மற்றும் [`deposit`](#deposit) முறைகள் வழியாக டோக்கன்கள் வால்ட்டில் டெபாசிட் செய்யப்படும்போது **கட்டாயம்** வெளியிடப்பட வேண்டும். + +```solidity +event Deposit( + address indexed sender, + address indexed owner, + uint256 assets, + uint256 shares +) +``` + +இதில் `sender` என்பவர் `assets`-ஐ `shares`-ஆகப் பரிமாறிக்கொண்ட மற்றும் அந்த `shares`-ஐ `owner`-க்கு மாற்றிய பயனர் ஆவார். + +#### திரும்பப் பெறுதல் நிகழ்வு + +[`redeem`](#redeem) அல்லது [`withdraw`](#withdraw) முறைகளில் ஒரு வைப்பாளரால் பங்குகள் வால்ட்டிலிருந்து திரும்பப் பெறப்படும்போது **கட்டாயம்** வெளியிடப்பட வேண்டும். + +```solidity +event Withdraw( + address indexed sender, + address indexed receiver, + address indexed owner, + uint256 assets, + uint256 shares +) +``` + +இதில் `sender` என்பவர் திரும்பப் பெறுதலைத் தூண்டி, `owner`-க்குச் சொந்தமான `shares`-ஐ `assets`-ஆகப் பரிமாறிக்கொண்ட பயனர் ஆவார். `receiver` என்பவர் திரும்பப் பெறப்பட்ட `assets`-ஐப் பெற்ற பயனர் ஆவார். + +## மேலும் வாசிக்க {#further-reading} + +- [EIP-4626: டோக்கனைஸ் செய்யப்பட்ட வால்ட் தரநிலை](https://eips.ethereum.org/EIPS/eip-4626) +- [ERC-4626: GitHub ரெப்போ](https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC4626.sol) diff --git a/public/content/translations/ta/developers/docs/standards/tokens/erc-721/index.md b/public/content/translations/ta/developers/docs/standards/tokens/erc-721/index.md new file mode 100644 index 00000000000..0c655e7b7d0 --- /dev/null +++ b/public/content/translations/ta/developers/docs/standards/tokens/erc-721/index.md @@ -0,0 +1,248 @@ +--- +title: "ERC-721 பரிமாற்ற முடியாத டோக்கன் தரநிலை" +description: "Ethereum இல் உள்ள தனித்துவமான டிஜிட்டல் சொத்துக்களைப் பிரதிநிதித்துவப்படுத்தும் பரிமாற்ற முடியாத டோக்கன்களுக்கான (NFTs) தரநிலையான ERC-721 பற்றி அறிக." +lang: ta +--- + +## அறிமுகம் {#introduction} + +**பரிமாற்ற முடியாத டோக்கன் என்றால் என்ன?** + +ஒரு பரிமாற்ற முடியாத டோக்கன் (NFT) என்பது ஏதேனும் ஒன்றையோ அல்லது ஒருவரையோ ஒரு தனித்துவமான வழியில் அடையாளம் காணப் பயன்படுகிறது. சேகரிக்கக்கூடிய பொருட்கள், அணுகல் சாவிகள், லாட்டரி சீட்டுகள், இசை நிகழ்ச்சிகள் மற்றும் விளையாட்டுப் போட்டிகளுக்கான எண்ணிடப்பட்ட இருக்கைகள் போன்றவற்றை வழங்கும் தளங்களில் இந்த வகை டோக்கன் பயன்படுத்த மிகவும் ஏற்றது. இந்த சிறப்பு வகை டோக்கன் அற்புதமான சாத்தியக்கூறுகளைக் கொண்டுள்ளது, எனவே இது ஒரு சரியான தரநிலைக்குத் தகுதியானது, ERC-721 அதைத் தீர்க்க வந்தது! + +**ERC-721 என்றால் என்ன?** + +ERC-721 ஆனது NFT-க்கான ஒரு தரநிலையை அறிமுகப்படுத்துகிறது, வேறுவிதமாகக் கூறினால், இந்த வகை டோக்கன் தனித்துவமானது மற்றும் அதன் வயது, அரிதான தன்மை அல்லது அதன் தோற்றம் போன்ற வேறு காரணங்களால், அதே ஸ்மார்ட் ஒப்பந்தத்தில் உள்ள மற்றொரு டோக்கனை விட வேறுபட்ட மதிப்பைக் கொண்டிருக்கலாம். +பொறுங்கள், தோற்றமா? + +ஆம்! அனைத்து NFT-களிலும் `tokenId` எனப்படும் `uint256` மாறி உள்ளது, எனவே எந்தவொரு ERC-721 ஒப்பந்தத்திற்கும், `contract address, uint256 tokenId` ஜோடி உலகளவில் தனித்துவமானதாக இருக்க வேண்டும். அப்படியிருந்தும், ஒரு dapp ஆனது `tokenId`-ஐ உள்ளீடாகப் பயன்படுத்தி, ஸோம்பிகள், ஆயுதங்கள், திறன்கள் அல்லது அற்புதமான பூனைக்குட்டிகள் போன்ற அருமையான ஒன்றின் படத்தை வெளியிடும் ஒரு "மாற்றி"யைக் கொண்டிருக்கலாம்! + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +- [கணக்குகள்](/developers/docs/accounts/) +- [ஸ்மார்ட் ஒப்பந்தங்கள்](/developers/docs/smart-contracts/) +- [டோக்கன் தரநிலைகள்](/developers/docs/standards/tokens/) + +## உள்ளடக்கம் {#body} + +ஜனவரி 2018 இல் வில்லியம் என்ட்ரிக்கன், டீட்டர் ஷிர்லி, ஜேக்கப் எவன்ஸ், நஸ்டாசியா சாக்ஸ் ஆகியோரால் முன்மொழியப்பட்ட ERC-721 (Ethereum கோரிக்கைக்கான கருத்துகள் 721), என்பது ஸ்மார்ட் ஒப்பந்தங்களுக்குள் டோக்கன்களுக்கான ஒரு API-ஐ செயல்படுத்தும் பரிமாற்ற முடியாத டோக்கன் தரநிலை ஆகும். + +இது ஒரு கணக்கிலிருந்து மற்றொரு கணக்கிற்கு டோக்கன்களை மாற்றுவது, ஒரு கணக்கின் தற்போதைய டோக்கன் இருப்பைப் பெறுவது, ஒரு குறிப்பிட்ட டோக்கனின் உரிமையாளரைப் பெறுவது மற்றும் நெட்வொர்க்கில் கிடைக்கும் டோக்கனின் மொத்த விநியோகத்தைப் பெறுவது போன்ற செயல்பாடுகளை வழங்குகிறது. +இவற்றைத் தவிர, ஒரு கணக்கிலிருந்து ஒரு குறிப்பிட்ட அளவு டோக்கனை மூன்றாம் தரப்புக் கணக்கு நகர்த்த முடியும் என்பதை அங்கீகரிப்பது போன்ற பிற செயல்பாடுகளையும் இது கொண்டுள்ளது. + +ஒரு ஸ்மார்ட் ஒப்பந்தம் பின்வரும் முறைகள் மற்றும் நிகழ்வுகளைச் செயல்படுத்தினால், அது ERC-721 பரிமாற்ற முடியாத டோக்கன் ஒப்பந்தம் என்று அழைக்கப்படலாம், மேலும், அது பயன்படுத்தப்பட்டவுடன் Ethereum இல் உருவாக்கப்பட்ட டோக்கன்களைக் கண்காணிக்கும் பொறுப்பை ஏற்கும். + +[EIP-721](https://eips.ethereum.org/EIPS/eip-721) இலிருந்து: + +### முறைகள் {#methods} + +```solidity + function balanceOf(address _owner) external view returns (uint256); + function ownerOf(uint256 _tokenId) external view returns (address); + function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable; + function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable; + function transferFrom(address _from, address _to, uint256 _tokenId) external payable; + function approve(address _approved, uint256 _tokenId) external payable; + function setApprovalForAll(address _operator, bool _approved) external; + function getApproved(uint256 _tokenId) external view returns (address); + function isApprovedForAll(address _owner, address _operator) external view returns (bool); +``` + +### நிகழ்வுகள் {#events} + +```solidity + event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); + event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); + event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved); +``` + +### உதாரணங்கள் {#web3py-example} + +Ethereum இல் உள்ள எந்தவொரு ERC-721 டோக்கன் ஒப்பந்தத்தையும் ஆய்வு செய்வதை நமக்கு எளிதாக்குவதில் ஒரு தரநிலை எவ்வளவு முக்கியமானது என்பதைப் பார்ப்போம். +எந்தவொரு ERC-721 டோக்கனுக்கும் ஒரு இடைமுகத்தை உருவாக்க நமக்கு ஒப்பந்தப் பயன்பாட்டு பைனரி இடைமுகம் (ABI) தேவை. நீங்கள் கீழே காண்பது போல், +இதை ஒரு சிக்கலற்ற எடுத்துக்காட்டாக மாற்றுவதற்கு நாங்கள் ஒரு எளிமைப்படுத்தப்பட்ட ABI-ஐப் பயன்படுத்துவோம். + +#### Web3.py உதாரணம் {#web3py-example} + +முதலில், நீங்கள் [Web3.py](https://web3py.readthedocs.io/en/stable/quickstart.html#installation) பைத்தான் லைப்ரரியை நிறுவியுள்ளீர்கள் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள்: + +``` +pip install web3 +``` + +```python +from web3 import Web3 +from web3._utils.events import get_event_data + + +w3 = Web3(Web3.HTTPProvider("https://cloudflare-eth.com")) + +ck_token_addr = "0x06012c8cf97BEaD5deAe237070F9587f8E7A266d" # CryptoKitties ஒப்பந்தம் + +acc_address = "0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C" # CryptoKitties விற்பனை ஏலம் + +# இது ஒரு ERC-721 NFT ஒப்பந்தத்தின் எளிமைப்படுத்தப்பட்ட ஒப்பந்தப் பயன்பாட்டு பைனரி இடைமுகம் (ABI) ஆகும். +# இது balanceOf(address), name(), ownerOf(tokenId), symbol(), totalSupply() ஆகிய முறைகளை மட்டுமே வெளிப்படுத்தும் +simplified_abi = [ + { + 'inputs': [{'internalType': 'address', 'name': 'owner', 'type': 'address'}], + 'name': 'balanceOf', + 'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}], + 'payable': False, 'stateMutability': 'view', 'type': 'function', 'constant': True + }, + { + 'inputs': [], + 'name': 'name', + 'outputs': [{'internalType': 'string', 'name': '', 'type': 'string'}], + 'stateMutability': 'view', 'type': 'function', 'constant': True + }, + { + 'inputs': [{'internalType': 'uint256', 'name': 'tokenId', 'type': 'uint256'}], + 'name': 'ownerOf', + 'outputs': [{'internalType': 'address', 'name': '', 'type': 'address'}], + 'payable': False, 'stateMutability': 'view', 'type': 'function', 'constant': True + }, + { + 'inputs': [], + 'name': 'symbol', + 'outputs': [{'internalType': 'string', 'name': '', 'type': 'string'}], + 'stateMutability': 'view', 'type': 'function', 'constant': True + }, + { + 'inputs': [], + 'name': 'totalSupply', + 'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}], + 'stateMutability': 'view', 'type': 'function', 'constant': True + }, +] + +ck_extra_abi = [ + { + 'inputs': [], + 'name': 'pregnantKitties', + 'outputs': [{'name': '', 'type': 'uint256'}], + 'payable': False, 'stateMutability': 'view', 'type': 'function', 'constant': True + }, + { + 'inputs': [{'name': '_kittyId', 'type': 'uint256'}], + 'name': 'isPregnant', + 'outputs': [{'name': '', 'type': 'bool'}], + 'payable': False, 'stateMutability': 'view', 'type': 'function', 'constant': True + } +] + +ck_contract = w3.eth.contract(address=w3.to_checksum_address(ck_token_addr), abi=simplified_abi+ck_extra_abi) +name = ck_contract.functions.name().call() +symbol = ck_contract.functions.symbol().call() +kitties_auctions = ck_contract.functions.balanceOf(acc_address).call() +print(f"{name} [{symbol}] NFTs in Auctions: {kitties_auctions}") + +pregnant_kitties = ck_contract.functions.pregnantKitties().call() +print(f"{name} [{symbol}] NFTs Pregnants: {pregnant_kitties}") + +# மாற்றப்பட்ட பூனைக்குட்டிகள் பற்றிய தகவல்களைப் பெற Transfer Event ABI-ஐப் பயன்படுத்துதல். +tx_event_abi = { + 'anonymous': False, + 'inputs': [ + {'indexed': False, 'name': 'from', 'type': 'address'}, + {'indexed': False, 'name': 'to', 'type': 'address'}, + {'indexed': False, 'name': 'tokenId', 'type': 'uint256'}], + 'name': 'Transfer', + 'type': 'event' +} + +# பதிவுகளை வடிகட்ட நமக்கு நிகழ்வின் கையொப்பம் தேவை +event_signature = w3.keccak(text="Transfer(address,address,uint256)").hex() + +logs = w3.eth.get_logs({ + "fromBlock": w3.eth.block_number - 120, + "address": w3.to_checksum_address(ck_token_addr), + "topics": [event_signature] +}) + +# குறிப்புகள்: +# - எந்த Transfer நிகழ்வும் திரும்ப வரவில்லை என்றால், பிளாக்குகளின் எண்ணிக்கையை 120-க்கு மேல் அதிகரிக்கவும். +# - நீங்கள் எந்த Transfer நிகழ்வையும் கண்டுபிடிக்கவில்லை என்றால், இதிலிருந்தும் ஒரு tokenId-ஐப் பெற முயற்சி செய்யலாம்: +# https://etherscan.io/address/0x06012c8cf97BEaD5deAe237070F9587f8E7A266d#events +# நிகழ்வின் பதிவுகளை விரிவாக்க கிளிக் செய்து அதன் "tokenId" வாதத்தை நகலெடுக்கவும் +recent_tx = [get_event_data(w3.codec, tx_event_abi, log)["args"] for log in logs] + +if recent_tx: + kitty_id = recent_tx[0]['tokenId'] # மேலே உள்ள இணைப்பிலிருந்து "tokenId"-ஐ இங்கே ஒட்டவும் + is_pregnant = ck_contract.functions.isPregnant(kitty_id).call() + print(f"{name} [{symbol}] NFTs {kitty_id} is pregnant: {is_pregnant}") +``` + +CryptoKitties ஒப்பந்தம், தரமான நிகழ்வுகளைத் தவிர வேறு சில சுவாரஸ்யமான நிகழ்வுகளையும் கொண்டுள்ளது. + +அவற்றில் இரண்டைப் பார்ப்போம், `Pregnant` மற்றும் `Birth`. + +```python +# புதிய பூனைக்குட்டிகள் பற்றிய தகவல்களைப் பெற Pregnant மற்றும் Birth Events ABI-ஐப் பயன்படுத்துதல். +ck_extra_events_abi = [ + { + 'anonymous': False, + 'inputs': [ + {'indexed': False, 'name': 'owner', 'type': 'address'}, + {'indexed': False, 'name': 'matronId', 'type': 'uint256'}, + {'indexed': False, 'name': 'sireId', 'type': 'uint256'}, + {'indexed': False, 'name': 'cooldownEndBlock', 'type': 'uint256'}], + 'name': 'Pregnant', + 'type': 'event' + }, + { + 'anonymous': False, + 'inputs': [ + {'indexed': False, 'name': 'owner', 'type': 'address'}, + {'indexed': False, 'name': 'kittyId', 'type': 'uint256'}, + {'indexed': False, 'name': 'matronId', 'type': 'uint256'}, + {'indexed': False, 'name': 'sireId', 'type': 'uint256'}, + {'indexed': False, 'name': 'genes', 'type': 'uint256'}], + 'name': 'Birth', + 'type': 'event' + }] + +# பதிவுகளை வடிகட்ட நமக்கு நிகழ்வின் கையொப்பம் தேவை +ck_event_signatures = [ + w3.keccak(text="Pregnant(address,uint256,uint256,uint256)").hex(), + w3.keccak(text="Birth(address,uint256,uint256,uint256,uint256)").hex(), +] + +# இதோ ஒரு Pregnant நிகழ்வு: +# - https://etherscan.io/tx/0xc97eb514a41004acc447ac9d0d6a27ea6da305ac8b877dff37e49db42e1f8cef#eventlog +pregnant_logs = w3.eth.get_logs({ + "fromBlock": w3.eth.block_number - 120, + "address": w3.to_checksum_address(ck_token_addr), + "topics": [ck_event_signatures[0]] +}) + +recent_pregnants = [get_event_data(w3.codec, ck_extra_events_abi[0], log)["args"] for log in pregnant_logs] + +# இதோ ஒரு Birth நிகழ்வு: +# - https://etherscan.io/tx/0x3978028e08a25bb4c44f7877eb3573b9644309c044bf087e335397f16356340a +birth_logs = w3.eth.get_logs({ + "fromBlock": w3.eth.block_number - 120, + "address": w3.to_checksum_address(ck_token_addr), + "topics": [ck_event_signatures[1]] +}) + +recent_births = [get_event_data(w3.codec, ck_extra_events_abi[1], log)["args"] for log in birth_logs] +``` + +## பிரபலமான NFT-கள் {#popular-nfts} + +- [Etherscan NFT Tracker](https://etherscan.io/nft-top-contracts) பரிமாற்றங்களின் அளவின் அடிப்படையில் Ethereum இல் உள்ள சிறந்த NFT-களைப் பட்டியலிடுகிறது. +- [CryptoKitties](https://www.cryptokitties.co/) என்பது CryptoKitties என்று நாம் அழைக்கும் இனப்பெருக்கம் செய்யக்கூடிய, சேகரிக்கக்கூடிய, மற்றும் மிகவும் அபிமான உயிரினங்களை மையமாகக் கொண்ட ஒரு விளையாட்டு ஆகும். +- [Sorare](https://sorare.com/) என்பது ஒரு உலகளாவிய கற்பனைக் கால்பந்து விளையாட்டாகும், அங்கு நீங்கள் வரையறுக்கப்பட்ட பதிப்பு சேகரிப்புகளைச் சேகரிக்கலாம், உங்கள் அணிகளை நிர்வகிக்கலாம் மற்றும் பரிசுகளைப் பெற போட்டியிடலாம். +- [The Ethereum Name Service (ENS)](https://ens.domains/) எளிய, மனிதர்கள் படிக்கக்கூடிய பெயர்களைப் பயன்படுத்தி, பிளாக்செயினுக்கு உள்ளேயும் வெளியேயும் உள்ள வளங்களை முகவரியிட ஒரு பாதுகாப்பான மற்றும் பரவலாக்கப்பட்ட வழியை வழங்குகிறது. +- [POAP](https://poap.xyz) நிகழ்வுகளில் கலந்துகொள்பவர்கள் அல்லது குறிப்பிட்ட செயல்களை முடிப்பவர்களுக்கு இலவச NFT-களை வழங்குகிறது. POAP-களை உருவாக்குவதும் விநியோகிப்பதும் இலவசம். +- [Unstoppable Domains](https://unstoppabledomains.com/) என்பது சான் பிரான்சிஸ்கோவை தளமாகக் கொண்ட ஒரு நிறுவனமாகும், இது பிளாக்செயின்களில் களங்களை உருவாக்குகிறது. பிளாக்செயின் களங்கள் கிரிப்டோகரன்சி முகவரிகளை மனிதர்கள் படிக்கக்கூடிய பெயர்களுடன் மாற்றுகின்றன மற்றும் தணிக்கை-எதிர்ப்பு வலைத்தளங்களை இயக்கப் பயன்படுத்தப்படலாம். +- [Gods Unchained Cards](https://godsunchained.com/) என்பது Ethereum பிளாக்செயினில் உள்ள ஒரு TCG ஆகும், இது விளையாட்டிலுள்ள சொத்துக்களுக்கு உண்மையான உரிமையைக் கொண்டுவர NFT-களைப் பயன்படுத்துகிறது. +- [Bored Ape Yacht Club](https://boredapeyachtclub.com) என்பது 10,000 தனித்துவமான NFT-களின் தொகுப்பாகும், இது நிரூபிக்கக்கூடிய-அரிதான கலைப் படைப்பாக இருப்பதுடன், கிளப்பிற்கான உறுப்பினர் டோக்கனாகவும் செயல்படுகிறது, இது சமூக முயற்சிகளின் விளைவாக காலப்போக்கில் அதிகரிக்கும் உறுப்பினர் சலுகைகளையும் நன்மைகளையும் வழங்குகிறது. + +## மேலும் வாசிக்க {#further-reading} + +- [EIP-721: ERC-721 பரிமாற்ற முடியாத டோக்கன் தரநிலை](https://eips.ethereum.org/EIPS/eip-721) +- [OpenZeppelin - ERC-721 ஆவணங்கள்](https://docs.openzeppelin.com/contracts/3.x/erc721) +- [OpenZeppelin - ERC-721 செயலாக்கம்](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol) +- [Alchemy NFT API](https://www.alchemy.com/docs/reference/nft-api-quickstart) diff --git a/public/content/translations/ta/developers/docs/standards/tokens/erc-777/index.md b/public/content/translations/ta/developers/docs/standards/tokens/erc-777/index.md new file mode 100644 index 00000000000..e9494d2b599 --- /dev/null +++ b/public/content/translations/ta/developers/docs/standards/tokens/erc-777/index.md @@ -0,0 +1,45 @@ +--- +title: "ERC-777 தரநிலைக் குறி" +description: "பாதுகாப்பிற்காக ERC-20 பரிந்துரைக்கப்பட்டாலும், ஹூக்குகளுடன் கூடிய மேம்படுத்தப்பட்ட மாற்றத்தக்க தரநிலைக் குறியான ERC-777 பற்றி அறிக." +lang: ta +--- + +## எச்சரிக்கை {#warning} + +**பல்வேறு வகையான தாக்குதல்களுக்கு ஆளாகும் தன்மை காரணமாக [ERC-777-ஐ சரியாகச் செயல்படுத்துவது கடினம்](https://github.com/OpenZeppelin/openzeppelin-contracts/issues/2620). அதற்குப் பதிலாக [ERC-20](/developers/docs/standards/tokens/erc-20/)-ஐப் பயன்படுத்தப் பரிந்துரைக்கப்படுகிறது.** இப்பக்கம் ஒரு வரலாற்று ஆவணமாக உள்ளது. + +## அறிமுகம்? {#introduction} + +ERC-777 என்பது ஒரு மாற்றத்தக்க டோக்கன் தரநிலைக் குறியாகும், இது தற்போதுள்ள [ERC-20](/developers/docs/standards/tokens/erc-20/) தரநிலையை மேம்படுத்துகிறது. + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +இந்தப் பக்கத்தை நன்கு புரிந்து கொள்ள, நீங்கள் முதலில் [ERC-20](/developers/docs/standards/tokens/erc-20/) பற்றிப் படிக்கப் பரிந்துரைக்கிறோம். + +## ERC-20-ஐ விட ERC-777 என்ன மேம்பாடுகளை முன்மொழிகிறது? {#-erc-777-vs-erc-20} + +ERC-777 ஆனது ERC-20-ஐ விட பின்வரும் மேம்பாடுகளை வழங்குகிறது. + +### ஹூக்ஸ் {#hooks} + +ஹூக்ஸ் என்பது ஒரு ஸ்மார்ட் ஒப்பந்தத்தின் குறியீட்டில் விவரிக்கப்பட்டுள்ள ஒரு செயல்பாடாகும். ஒப்பந்தத்தின் மூலம் டோக்கன்கள் அனுப்பப்படும்போதோ அல்லது பெறப்படும்போதோ ஹூக்ஸ் அழைக்கப்படுகின்றன. இது ஒரு ஸ்மார்ட் ஒப்பந்தம் உள்வரும் அல்லது வெளிச்செல்லும் டோக்கன்களுக்கு எதிர்வினையாற்ற அனுமதிக்கிறது. + +[ERC-1820](https://eips.ethereum.org/EIPS/eip-1820) தரநிலையைப் பயன்படுத்தி ஹூக்ஸ் பதிவு செய்யப்பட்டு கண்டுபிடிக்கப்படுகின்றன. + +#### ஹூக்ஸ் ஏன் சிறந்தவை? {#why-are-hooks-great} + +1. இதைச் செய்வதற்கு (`approve`/`transferFrom`) இரட்டை அழைப்பு தேவைப்படும் [ERC-20](https://eips.ethereum.org/EIPS/eip-20) போலல்லாமல், ஒரே பரிவர்த்தனையில் டோக்கன்களை ஒரு ஒப்பந்தத்திற்கு அனுப்பவும், அந்த ஒப்பந்தத்திற்கு அறிவிக்கவும் ஹூக்குகள் அனுமதிக்கின்றன. +2. ஹூக்குகளைப் பதிவு செய்யாத ஒப்பந்தங்கள் ERC-777 உடன் ஒத்துப்போவதில்லை. பெறும் ஒப்பந்தம் ஒரு ஹூக்கைப் பதிவு செய்யாதபோது, அனுப்பும் ஒப்பந்தம் பரிவர்த்தனையை ரத்து செய்யும். இது ERC-777 அல்லாத ஸ்மார்ட் ஒப்பந்தங்களுக்கு தற்செயலான இடமாற்றங்களைத் தடுக்கிறது. +3. ஹூக்குகள் பரிவர்த்தனைகளை நிராகரிக்க முடியும். + +### தசமங்கள் {#decimals} + +இந்தத் தரநிலை ERC-20 இல் `decimals` பற்றி ஏற்பட்ட குழப்பத்தையும் தீர்க்கிறது. இந்தத் தெளிவு டெவலப்பர் அனுபவத்தை மேம்படுத்துகிறது. + +### ERC-20 உடன் பின்தங்கிய இணக்கத்தன்மை {#backwards-compatibility-with-erc-20} + +ERC-777 ஒப்பந்தங்களுடன் அவை ERC-20 ஒப்பந்தங்கள் போலவே தொடர்பு கொள்ளலாம். + +## மேலும் வாசிக்க {#further-reading} + +[EIP-777: தரநிலைக் குறி](https://eips.ethereum.org/EIPS/eip-777) diff --git a/public/content/translations/ta/developers/docs/standards/tokens/index.md b/public/content/translations/ta/developers/docs/standards/tokens/index.md new file mode 100644 index 00000000000..a5fc8c03524 --- /dev/null +++ b/public/content/translations/ta/developers/docs/standards/tokens/index.md @@ -0,0 +1,41 @@ +--- +title: "டோக்கன் தரநிலைகள்" +description: "பூஞ்சையுள்ள மற்றும் பூஞ்சையற்ற டோக்கன்களுக்கான ERC-20, ERC-721, மற்றும் ERC-1155 உள்ளிட்ட எத்தேரியம் டோக்கன் தரநிலைகளை ஆராயுங்கள்." +lang: ta +incomplete: true +--- + +## அறிமுகம் {#introduction} + +பல எத்தேரியம் மேம்பாட்டுத் தரநிலைகள் டோக்கன் இடைமுகங்களில் கவனம் செலுத்துகின்றன. இந்தத் தரநிலைகள் ஸ்மார்ட் ஒப்பந்தங்கள் இணைக்கத்தக்கவையாக இருப்பதை உறுதிசெய்ய உதவுகின்றன, எனவே ஒரு புதிய திட்டம் ஒரு டோக்கனை வெளியிடும் போது, அது ஏற்கனவே உள்ள பரவலாக்கப்பட்ட பரிமாற்றங்கள் மற்றும் பயன்பாடுகளுடன் இணக்கமாக இருக்கும். + +டோக்கன் தரநிலைகள், எத்தேரியம் சூழல் அமைப்பு முழுவதும் டோக்கன்கள் எவ்வாறு நடந்துகொள்கின்றன மற்றும் தொடர்பு கொள்கின்றன என்பதை வரையறுக்கின்றன. மீண்டும் சக்கரத்தை உருவாக்காமல் உருவாக்குநர்கள் உருவாக்குவதை அவை எளிதாக்குகின்றன, டோக்கன்கள் பணப்பைகள், பரிமாற்றங்கள் மற்றும் DeFi தளங்களுடன் தடையின்றி செயல்படுவதை உறுதி செய்கின்றன. கேமிங், ஆளுகை அல்லது பிற பயன்பாட்டு நிகழ்வுகளில் இருந்தாலும், இந்தத் தரநிலைகள் நிலைத்தன்மையை வழங்குகின்றன மற்றும் எத்தேரியத்தை மேலும் ஒன்றோடொன்று இணைக்கின்றன. + +## முன்னேற்றக் கட்டுரை {#prerequisites} + +- [எத்தேரியம் மேம்பாட்டுத் தரநிலைகள்](/developers/docs/standards/) +- [ஸ்மார்ட் ஒப்பந்தங்கள்](/developers/docs/smart-contracts/) + +## டோக்கன் தரநிலைகள் {#token-standards} + +எத்தேரியத்தில் மிகவும் பிரபலமான சில டோக்கன் தரநிலைகள் இங்கே: + +- [ERC-20](/developers/docs/standards/tokens/erc-20/) - வாக்களிப்பு டோக்கன்கள், ஸ்டேக்கிங் டோக்கன்கள் அல்லது மெய்நிகர் நாணயங்கள் போன்ற ஒத்த மதிப்புடைய (இடமாற்றம் செய்யக்கூடிய) டோக்கன்களுக்கான ஒரு நிலையான இடைமுகம். + +### NFT தரநிலைகள் {#nft-standards} + +- [ERC-721](/developers/docs/standards/tokens/erc-721/) - ஒரு கலைப்படைப்பு அல்லது பாடலுக்கான பத்திரம் போன்ற ஒத்த மதிப்பற்ற டோக்கன்களுக்கான ஒரு நிலையான இடைமுகம். +- [ERC-1155](/developers/docs/standards/tokens/erc-1155/) - ERC-1155 மிகவும் திறமையான வர்த்தகங்களையும் பரிவர்த்தனைகளை தொகுப்பதையும் அனுமதிக்கிறது – இதனால் செலவுகளைச் சேமிக்கிறது. இந்த டோக்கன் தரநிலையானது பயன்பாட்டு டோக்கன்களையும் ($BNB அல்லது $BAT போன்றவை) மற்றும் CryptoPunks போன்ற பூஞ்சையற்ற டோக்கன்களையும் உருவாக்க அனுமதிக்கிறது. + +[ERC](https://eips.ethereum.org/erc) முன்மொழிவுகளின் முழுப் பட்டியல். + +## மேலும் வாசிக்க {#further-reading} + +_உங்களுக்கு உதவிய ஒரு சமூக வளம் பற்றி தெரியுமா?_ இந்தப் பக்கத்தைத் திருத்தி அதைச் சேர்க்கவும்!_ + +## தொடர்புடைய பயிற்சிகள் {#related-tutorials} + +- [டோக்கன் ஒருங்கிணைப்பு சரிபார்ப்புப் பட்டியல்](/developers/tutorials/token-integration-checklist/) _– டோக்கன்களுடன் தொடர்பு கொள்ளும்போது கருத்தில் கொள்ள வேண்டிய விஷயங்களின் சரிபார்ப்புப் பட்டியல்._ +- [ERC20 டோக்கன் ஸ்மார்ட் ஒப்பந்தத்தைப் புரிந்து கொள்ளுங்கள்](/developers/tutorials/understand-the-erc-20-token-smart-contract/) _– ஒரு எத்தேரியம் சோதனை நெட்வொர்க்கில் உங்கள் முதல் ஸ்மார்ட் ஒப்பந்தத்தைப் பயன்படுத்துவதற்கான ஒரு அறிமுகம்._ +- [ஒரு Solidity ஸ்மார்ட் ஒப்பந்தத்திலிருந்து ERC20 டோக்கன்களின் இடமாற்றங்கள் மற்றும் ஒப்புதல்](/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/) _– Solidity மொழியைப் பயன்படுத்தி ஒரு டோக்கனுடன் தொடர்பு கொள்ள ஒரு ஸ்மார்ட் ஒப்பந்தத்தை எவ்வாறு பயன்படுத்துவது._ +- [ஒரு ERC721 சந்தையை செயல்படுத்துதல் [ஒரு எப்படி-செய்வது வழிகாட்டி]](/developers/tutorials/how-to-implement-an-erc721-market/) _– பரவலாக்கப்பட்ட விளம்பரப் பலகையில் டோக்கனாக்கப்பட்ட பொருட்களை விற்பனைக்கு வைப்பது எப்படி._ diff --git a/public/content/translations/ta/developers/docs/storage/index.md b/public/content/translations/ta/developers/docs/storage/index.md new file mode 100644 index 00000000000..b52346bf753 --- /dev/null +++ b/public/content/translations/ta/developers/docs/storage/index.md @@ -0,0 +1,216 @@ +--- +title: "பரவலாக்கப்பட்ட சேமிப்பகம்" +description: "பரவலாக்கப்பட்ட சேமிப்பகம் என்றால் என்ன, அதை ஒரு டாப்பில் ஒருங்கிணைக்கக் கிடைக்கும் கருவிகள் பற்றிய கண்ணோட்டம்." +lang: ta +--- + +ஒற்றை நிறுவனம் அல்லது அமைப்பால் இயக்கப்படும் ஒரு மையப்படுத்தப்பட்ட சர்வரைப் போலல்லாமல், பரவலாக்கப்பட்ட சேமிப்பக அமைப்புகள் பயனர்-செயல்பாட்டாளர்களின் ஒரு பியர்-டு-பியர் நெட்வொர்க்கைக் கொண்டிருக்கின்றன, அவர்கள் ஒட்டுமொத்த தரவின் ஒரு பகுதியை வைத்திருக்கிறார்கள், இது ஒரு மீள்தன்மையுள்ள கோப்பு சேமிப்பக பகிர்வு அமைப்பை உருவாக்குகிறது. இவை ஒரு பிளாக்செயின் அடிப்படையிலான பயன்பாடு அல்லது எந்த பியர்-டு-பியர் அடிப்படையிலான நெட்வொர்க்கிலும் இருக்கலாம். + +Ethereum-ஐயே ஒரு பரவலாக்கப்பட்ட சேமிப்பக அமைப்பாகப் பயன்படுத்தலாம், மேலும் இது அனைத்து ஸ்மார்ட் ஒப்பந்தங்களிலும் குறியீடு சேமிப்பகத்திற்கு வரும்போது பயன்படுத்தப்படுகிறது. இருப்பினும், அதிக அளவிலான தரவுகளைப் பொறுத்தவரை, Ethereum அதற்காக வடிவமைக்கப்படவில்லை. செயின் சீராக வளர்ந்து வருகிறது, ஆனால் எழுதும் நேரத்தில், Ethereum செயின் சுமார் 500GB - 1TB ஆகும் ([கிளையண்டைப் பொறுத்து](https://etherscan.io/chartsync/chaindefault)), மேலும் நெட்வொர்க்கில் உள்ள ஒவ்வொரு முனையும் எல்லா தரவுகளையும் சேமிக்க முடியும். செயின் அதிக அளவு தரவுகளுக்கு (சொல்லப்போனால் 5TB) விரிவடைந்தால், எல்லா முனைகளும் தொடர்ந்து இயங்குவது சாத்தியமில்லை. [கேஸ்](/developers/docs/gas) கட்டணங்கள் காரணமாக இந்தத் தரவை மெயின்நெட்டில் வரிசைப்படுத்துவதற்கான செலவு தடைசெய்யும் அளவுக்கு அதிகமாக இருக்கும். + +இந்தக் கட்டுப்பாடுகள் காரணமாக, பரவலாக்கப்பட்ட முறையில் அதிக அளவு தரவுகளைச் சேமிக்க நமக்கு வேறுபட்ட செயின் அல்லது வழிமுறை தேவை. + +பரவலாக்கப்பட்ட சேமிப்பக (dStorage) விருப்பங்களைப் பார்க்கும்போது, ஒரு பயனர் சில விஷயங்களை மனதில் கொள்ள வேண்டும். + +- தொடர்ச்சி வழிமுறை / ஊக்கக் கட்டமைப்பு +- தரவு தக்கவைப்பு அமலாக்கம் +- பரவலாக்கம் +- கருத்தொற்றுமை + +## தொடர்ச்சி வழிமுறை / ஊக்கக் கட்டமைப்பு {#persistence-mechanism} + +### பிளாக்செயின் அடிப்படையிலானது {#blockchain-based} + +ஒரு தரவுத் துண்டு எப்போதும் நிலைத்திருக்க, நாம் ஒரு தொடர்ச்சி வழிமுறையைப் பயன்படுத்த வேண்டும். உதாரணமாக, Ethereum-இல், தொடர்ச்சி வழிமுறை என்பது ஒரு முனையை இயக்கும் போது முழு செயினும் கணக்கில் எடுத்துக்கொள்ளப்பட வேண்டும். புதிய தரவுத் துண்டுகள் செயினின் முடிவில் இணைக்கப்படுகின்றன, மேலும் அது தொடர்ந்து வளர்ந்து வருகிறது - ஒவ்வொரு முனையும் உட்பொதிக்கப்பட்ட எல்லா தரவுகளையும் பிரதிபலிக்க வேண்டும். + +இது **பிளாக்செயின் அடிப்படையிலான** தொடர்ச்சி என அறியப்படுகிறது. + +பிளாக்செயின் அடிப்படையிலான தொடர்ச்சியில் உள்ள சிக்கல் என்னவென்றால், செயின் மிகப் பெரியதாகி, சாத்தியமான எல்லா தரவுகளையும் பராமரிக்கவும் சேமிக்கவும் முடியாமல் போகலாம் (எ.கா., [பல ஆதாரங்கள்](https://healthit.com.au/how-big-is-the-internet-and-how-do-we-measure-it/) இணையத்திற்கு 40 ஜெட்டாபைட்டுகளுக்கு மேல் சேமிப்புத் திறன் தேவை என்று மதிப்பிடுகின்றன). + +பிளாக்செயின் ஒருவித ஊக்கக் கட்டமைப்பையும் கொண்டிருக்க வேண்டும். பிளாக்செயின் அடிப்படையிலான தொடர்ச்சிக்கு, சரிபார்ப்பவருக்கு ஒரு கட்டணம் செலுத்தப்படுகிறது. தரவு செயினில் சேர்க்கப்படும்போது, சரிபார்ப்பவர்களுக்கு தரவைச் சேர்ப்பதற்காகப் பணம் செலுத்தப்படுகிறது. + +பிளாக்செயின் அடிப்படையிலான தொடர்ச்சியுள்ள தளங்கள்: + +- எத்தேரியம் +- [Arweave](https://www.arweave.org/) + +### ஒப்பந்த அடிப்படையிலானது {#contract-based} + +**ஒப்பந்த அடிப்படையிலான** தொடர்ச்சி என்பது, தரவை ஒவ்வொரு முனையாலும் பிரதிபலிக்கப்பட்டு என்றென்றும் சேமிக்க முடியாது, அதற்கு பதிலாக ஒப்பந்த உடன்படிக்கைகளுடன் பராமரிக்கப்பட வேண்டும் என்ற உள்ளுணர்வைக் கொண்டுள்ளது. இவை ஒரு குறிப்பிட்ட காலத்திற்கு ஒரு தரவுத் துண்டைப் பிடித்துக் கொள்வதாக உறுதியளித்த பல முனைகளுடன் செய்யப்பட்ட ஒப்பந்தங்கள். தரவு நிலைத்திருப்பதை உறுதிசெய்ய, அவை காலாவதியாகும் போதெல்லாம் திருப்பிச் செலுத்தப்பட வேண்டும் அல்லது புதுப்பிக்கப்பட வேண்டும். + +பெரும்பாலான சந்தர்ப்பங்களில், எல்லா தரவையும் ஆன்செயினில் சேமிப்பதற்குப் பதிலாக, ஒரு செயினில் தரவு எங்குள்ளது என்பதற்கான ஹாஷ் சேமிக்கப்படுகிறது. இந்த வழியில், எல்லா தரவையும் வைத்திருக்க முழு செயினும் அளவிடப்பட வேண்டியதில்லை. + +ஒப்பந்த அடிப்படையிலான தொடர்ச்சியுள்ள தளங்கள்: + +- [Filecoin](https://docs.filecoin.io/basics/what-is-filecoin) +- [Skynet](https://sia.tech/) +- [Storj](https://storj.io/) +- [Züs](https://zus.network/) +- [Crust Network](https://crust.network) +- [Swarm](https://www.ethswarm.org/) +- [4EVERLAND](https://www.4everland.org/) + +### கூடுதல் பரிசீலனைகள் {#additional-consideration} + +IPFS என்பது கோப்புகள், வலைத்தளங்கள், பயன்பாடுகள் மற்றும் தரவைச் சேமிப்பதற்கும் அணுகுவதற்கும் ஒரு பரவலாக்கப்பட்ட அமைப்பாகும். இது ஒரு உள்ளமைக்கப்பட்ட ஊக்கத் திட்டத்தைக் கொண்டிருக்கவில்லை, ஆனால் அதற்குப் பதிலாக நீண்ட கால தொடர்ச்சிக்கு மேலே உள்ள எந்தவொரு ஒப்பந்த அடிப்படையிலான ஊக்கத் தீர்வுகளுடனும் பயன்படுத்தப்படலாம். IPFS இல் தரவைத் தக்கவைப்பதற்கான மற்றொரு வழி, ஒரு பின்னிங் சேவையுடன் வேலை செய்வதாகும், இது உங்கள் தரவை உங்களுக்காக "பின்" செய்யும். நீங்கள் உங்கள் சொந்த IPFS முனையை இயக்கலாம் மற்றும் உங்கள் மற்றும்/அல்லது மற்றவர்களின் தரவை இலவசமாக நிலைநிறுத்த நெட்வொர்க்கிற்கு பங்களிக்கலாம்! + +- [IPFS](https://docs.ipfs.io/concepts/what-is-ipfs/) +- [Pinata](https://www.pinata.cloud/) _(IPFS பின்னிங் சேவை)_ +- [web3.storage](https://web3.storage/) _(IPFS/Filecoin பின்னிங் சேவை)_ +- [Infura](https://infura.io/product/ipfs) _(IPFS பின்னிங் சேவை)_ +- [IPFS Scan](https://ipfs-scan.io) _(IPFS பின்னிங் எக்ஸ்ப்ளோரர்)_ +- [4EVERLAND](https://www.4everland.org/)_（IPFS பின்னிங் சேவை）_ +- [Filebase](https://filebase.com) _(IPFS பின்னிங் சேவை)_ +- [Spheron Network](https://spheron.network/) _(IPFS/Filecoin பின்னிங் சேவை)_ + +SWARM என்பது ஒரு பரவலாக்கப்பட்ட தரவு சேமிப்பகம் மற்றும் விநியோக தொழில்நுட்பமாகும், இது ஒரு சேமிப்பக ஊக்க அமைப்பு மற்றும் சேமிப்பக வாடகை விலை ஆரக்கிளைக் கொண்டுள்ளது. + +## தரவு தக்கவைப்பு {#data-retention} + +தரவைத் தக்கவைக்க, தரவு தக்கவைக்கப்படுவதை உறுதிசெய்யும் ஒருவித வழிமுறையை அமைப்புகள் கொண்டிருக்க வேண்டும். + +### சவால் வழிமுறை {#challenge-mechanism} + +தரவு தக்கவைக்கப்படுவதை உறுதி செய்வதற்கான மிகவும் பிரபலமான வழிகளில் ஒன்று, முனைகளுக்கு ஒருவித கிரிப்டோகிராஃபிக் சவாலை வழங்குவதாகும், இது தரவு இன்னும் அவர்களிடம் உள்ளதா என்பதை உறுதி செய்கிறது. ஒரு எளிய உதாரணம், Arweave-இன் ப்ரூஃப்-ஆஃப்-ஆக்சஸ். மிக சமீபத்திய பிளாக் மற்றும் கடந்த காலத்தில் ஒரு சீரற்ற பிளாக் ஆகிய இரண்டிலும் தரவு உள்ளதா என்பதைப் பார்க்க அவர்கள் முனைகளுக்கு ஒரு சவாலை விடுக்கிறார்கள். முனையால் பதிலைக் கொண்டு வர முடியாவிட்டால், அது தண்டிக்கப்படும். + +சவால் வழிமுறையுடன் கூடிய dStorage வகைகள்: + +- Züs +- Skynet +- Arweave +- Filecoin +- Crust Network +- 4EVERLAND + +### பரவலாக்கம் {#decentrality} + +தளங்களின் பரவலாக்கத்தின் அளவை அளவிட சிறந்த கருவிகள் இல்லை, ஆனால் பொதுவாக, நீங்கள் KYC இல்லாத கருவிகளைப் பயன்படுத்த விரும்புவீர்கள், அவை மையப்படுத்தப்படவில்லை என்பதற்கு சான்றளிக்கின்றன. + +KYC இல்லாத பரவலாக்கப்பட்ட கருவிகள்: + +- Skynet +- Arweave +- Filecoin +- IPFS +- எத்தேரியம் +- Crust Network +- 4EVERLAND + +### ஒப்புதல் {#consensus} + +இந்தக் கருவிகளில் பெரும்பாலானவை [கருத்தொற்றுமைப் பொறிமுறையின்](/developers/docs/consensus-mechanisms/) சொந்தப் பதிப்பைக் கொண்டுள்ளன, ஆனால் பொதுவாக அவை [**வேலைக்கான சான்று (PoW)**](/developers/docs/consensus-mechanisms/pow/) அல்லது [**பங்குக்கான சான்று (PoS)**](/developers/docs/consensus-mechanisms/pos/) ஆகியவற்றை அடிப்படையாகக் கொண்டவை. + +வேலைக்கான சான்று அடிப்படையிலானது: + +- Skynet +- Arweave + +பங்குக்கான சான்று அடிப்படையிலானது: + +- எத்தேரியம் +- Filecoin +- Züs +- Crust Network + +## தொடர்புடைய கருவிகள் {#related-tools} + +**IPFS - _InterPlanetary File System என்பது Ethereum-க்கான ஒரு பரவலாக்கப்பட்ட சேமிப்பகம் மற்றும் கோப்பு குறிப்பு அமைப்பு ஆகும்._** + +- [Ipfs.io](https://ipfs.io/) +- [ஆவணம்](https://docs.ipfs.io/) +- [GitHub](https://github.com/ipfs/ipfs) + +**Storj DCS - _டெவலப்பர்களுக்கான பாதுகாப்பான, தனிப்பட்ட மற்றும் S3-இணக்கமான பரவலாக்கப்பட்ட கிளவுட் பொருள் சேமிப்பகம்._** + +- [Storj.io](https://storj.io/) +- [ஆவணம்](https://docs.storj.io/) +- [GitHub](https://github.com/storj/storj) + +**Sia - _நம்பிக்கையற்ற கிளவுட் சேமிப்பக சந்தையை உருவாக்க கிரிப்டோகிராஃபியைப் பயன்படுத்துகிறது, இது வாங்குபவர்களையும் விற்பவர்களையும் நேரடியாகப் பரிவர்த்தனை செய்ய அனுமதிக்கிறது._** + +- [Skynet.net](https://sia.tech/) +- [ஆவணம்](https://docs.sia.tech/) +- [GitHub](https://github.com/SiaFoundation/) + +**Filecoin - _Filecoin ஆனது IPFSக்குப் பின்னால் உள்ள அதே குழுவிலிருந்து உருவாக்கப்பட்டது. இது IPFS கொள்கைகளின் மேல் ஒரு ஊக்க அடுக்கு._** + +- [Filecoin.io](https://filecoin.io/) +- [ஆவணம்](https://docs.filecoin.io/) +- [GitHub](https://github.com/filecoin-project/) + +**Arweave - _Arweave என்பது தரவைச் சேமிப்பதற்கான ஒரு dStorage தளம்._** + +- [Arweave.org](https://www.arweave.org/) +- [ஆவணம்](https://docs.arweave.org/info/) +- [Arweave](https://github.com/ArweaveTeam/arweave/) + +**Züs - _Züs என்பது ஷார்டிங் மற்றும் ப்ளாப்பர்களைக் கொண்ட ஒரு ப்ரூஃப்-ஆஃப்-ஸ்டேக் dStorage தளம்._** + +- [zus.network](https://zus.network/) +- [ஆவணம்](https://docs.zus.network/zus-docs/) +- [GitHub](https://github.com/0chain/) + +**Crust Network - _Crust என்பது IPFSக்கு மேலே உள்ள ஒரு dStorage தளமாகும்._** + +- [Crust.network](https://crust.network) +- [ஆவணம்](https://wiki.crust.network) +- [GitHub](https://github.com/crustio) + +**Swarm - _Ethereum web3 ஸ்டேக்கிற்கான ஒரு பரவலாக்கப்பட்ட சேமிப்பக தளம் மற்றும் உள்ளடக்க விநியோக சேவை._** + +- [EthSwarm.org](https://www.ethswarm.org/) +- [ஆவணம்](https://docs.ethswarm.org/) +- [GitHub](https://github.com/ethersphere/) + +**OrbitDB - _IPFS க்கு மேல் ஒரு பரவலாக்கப்பட்ட பியர் டு பியர் தரவுத்தளம்._** + +- [OrbitDB.org](https://orbitdb.org/) +- [ஆவணம்](https://github.com/orbitdb/field-manual/) +- [GitHub](https://github.com/orbitdb/orbit-db/) + +**Aleph.im - _பரவலாக்கப்பட்ட கிளவுட் திட்டம் (தரவுத்தளம், கோப்பு சேமிப்பகம், கம்ப்யூட்டிங் மற்றும் DID). ஆஃப்செயின் மற்றும் ஆன்செயின் பியர்-டு-பியர் தொழில்நுட்பத்தின் ஒரு தனித்துவமான கலவை. IPFS மற்றும் மல்டி-செயின் இணக்கத்தன்மை._** + +- [Aleph.im](https://aleph.cloud/) +- [ஆவணம்](https://docs.aleph.cloud/) +- [GitHub](https://github.com/aleph-im/) + +**Ceramic - _தரவு நிறைந்த மற்றும் ஈர்க்கக்கூடிய பயன்பாடுகளுக்குப் பயனர் கட்டுப்பாட்டில் உள்ள IPFS தரவுத்தள சேமிப்பகம்._** + +- [Ceramic.network](https://ceramic.network/) +- [ஆவணம்](https://developers.ceramic.network/) +- [GitHub](https://github.com/ceramicnetwork/js-ceramic/) + +**Filebase - _S3-இணக்கமான பரவலாக்கப்பட்ட சேமிப்பகம் மற்றும் புவி-தேவையற்ற IPFS பின்னிங் சேவை. Filebase மூலம் IPFS இல் பதிவேற்றப்படும் அனைத்து கோப்புகளும் உலகெங்கிலும் 3x பிரதியாக்கத்துடன் Filebase உள்கட்டமைப்பில் தானாகவே பின் செய்யப்படுகின்றன._** + +- [Filebase.com](https://filebase.com/) +- [ஆவணம்](https://docs.filebase.com/) +- [GitHub](https://github.com/filebase) + +**4EVERLAND - _சேமிப்பகம், கணினி மற்றும் நெட்வொர்க்கிங் முக்கிய திறன்களை ஒருங்கிணைக்கும் ஒரு Web 3.0 கிளவுட் கம்ப்யூட்டிங் தளம், S3 இணக்கமானது மற்றும் IPFS மற்றும் Arweave போன்ற பரவலாக்கப்பட்ட சேமிப்பக நெட்வொர்க்குகளில் ஒத்திசைவான தரவு சேமிப்பகத்தை வழங்குகிறது._** + +- [4everland.org](https://www.4everland.org/) +- [ஆவணம்](https://docs.4everland.org/) +- [GitHub](https://github.com/4everland) + +**Kaleido - _கிளிக்-பட்டன் IPFS முனைகளைக் கொண்ட ஒரு பிளாக்செயின்-ஒரு-சேவை தளம்_** + +- [Kaleido](https://kaleido.io/) +- [ஆவணம்](https://docs.kaleido.io/kaleido-services/ipfs/) +- [GitHub](https://github.com/kaleido-io) + +**Spheron Network - _Spheron என்பது ஒரு பிளாட்ஃபார்ம்-ஒரு-சேவை (PaaS) ஆகும், இது சிறந்த செயல்திறனுடன் பரவலாக்கப்பட்ட உள்கட்டமைப்பில் தங்கள் பயன்பாடுகளைத் தொடங்க விரும்பும் dAppகளுக்காக வடிவமைக்கப்பட்டுள்ளது. இது கம்ப்யூட், பரவலாக்கப்பட்ட சேமிப்பகம், CDN & வெப் ஹோஸ்டிங்கை உடனடியாக பயன்படுத்தும் வகையில் வழங்குகிறது._** + +- [spheron.network](https://spheron.network/) +- [ஆவணம்](https://docs.spheron.network/) +- [GitHub](https://github.com/spheronFdn) + +## மேலும் வாசிக்க {#further-reading} + +- [பரவலாக்கப்பட்ட சேமிப்பகம் என்றால் என்ன?](https://coinmarketcap.com/academy/article/what-is-decentralized-storage-a-deep-dive-by-filecoin) - _CoinMarketCap_ +- [பரவலாக்கப்பட்ட சேமிப்பகம் பற்றிய ஐந்து பொதுவான கட்டுக்கதைகளை உடைத்தல்](https://www.storj.io/blog/busting-five-common-myths-about-decentralized-storage) - _Storj_ + +_உங்களுக்கு உதவிய ஒரு சமூக வளம் பற்றி தெரியுமா?_ இந்தப் பக்கத்தைத் திருத்தி அதைச் சேர்க்கவும்!_ + +## தொடர்புடைய தலைப்புகள் {#related-topics} + +- [உருவாக்க கட்டமைப்புகள்](/developers/docs/frameworks/)