பிரதான உள்ளடக்கத்திற்குச் செல்
Change page

ஸ்மார்ட் ஒப்பந்தங்களை சோதித்தல்

பக்கத்தின் கடைசி புதுப்பிப்பு: 26 பிப்ரவரி, 2026

wackeroww (opens in a new tab)
mnelsonBTm (opens in a new tab)
corwintinesc (opens in a new tab)
+22

பொது பிளாக்செயின்கள் மாதிரியான எதீரியம் இராதிகையாய் இருப்பதால், ஸ்மார்ட் கான்ட்ராக்ட்குறியீட்டைப் பாதுகாப்புு பிறகு மாற்றுவது கடினமாகிவிடுகிறது. ஒப்பந்த மேம்படுத்தல் வடிவங்கள் "மெய்நிகர் மேம்படுத்தல்களை" செய்ய உள்ளன, ஆனால் இவற்றைச் செயல்படுத்துவது கடினம் மற்றும் சமூக ஒருமித்த கருத்து தேவைப்படுகிறது. மேலும், ஒரு பிழை கண்டுபிடிக்கப்பட்ட பின்னரே ஒரு மேம்படுத்தல் அதை சரிசெய்ய முடியும்—ஒரு தாக்குபவர் முதலில் பாதிப்பைக் கண்டறிந்தால், உங்கள் ஸ்மார்ட் ஒப்பந்தம் சுரண்டப்படும் அபாயத்தில் உள்ளது.

இந்த காரணங்களுக்காக, Mainnet-இல் பகிர்தல் செய்வதற்கு முன் ஸ்மார்ட் ஒப்பந்தங்களைச் சோதிப்பது பாதுகாப்பிற்கான குறைந்தபட்சத் தேவையாகும். கான்ட்ராக்ட் சோதனை மற்றும் குறியீட்டு சரியான செயல்பாட்டை மதிப்பீடு செய்யப் பல முறைகள் உள்ளன; நீங்கள் தேர்வு செய்யும் முறை உங்கள் தேவைகளைப் பொறுத்தது. எதுவாயினும், பல்வேறு கருவிகள் மற்றும் அணுகுமுறைகளை உள்ளடக்கிய சோதனை தொகுப்பு, குறியீட்டில் சிறிய மற்றும் பெரிய பாதுகாப்பு குறைபாடுகளைப் பிடிக்கச் சிறந்ததாக இருக்கும்.

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

இந்தப் பக்கம் எதீரியம் நெட்வொர்க்கில் தயாரிக்கையா முன்பு ஸ்மார்ட் கான்ட்ராக்ட்களை எப்படி சோதிக்க வேண்டும் என்பதை விளக்குகிறது. நீங்கள் ஸ்மார்ட் ஒப்பந்தங்களுடன் பரிச்சயமானவர் என்று இது கருதுகிறது.

ஸ்மார்ட் கான்ட்ராக்ட் சோதனை என்ன? ஸ்மார்ட் ஒப்பந்த சோதனை என்றால் என்ன?

ஸ்மார்ட் கான்ட்ராக்ட் சோதனை என்பது ஒரு ஸ்மார்ட் கான்ட்ராக்ட் குறியீட்டு எதிர்பார்த்தப்படி செயல்படுமா என்பதை சோதனை செய்யும் செயல்முறை ஆகும். சோதனை ஒரு குறிப்பிட்ட ஸ்மார்ட் கான்ட்ராக்ட் நம்பகத்தன்மை, பயன்பாடு மற்றும் பாதுகாப்பு தேவைகளைப் பூர்த்தி செய்கின்றதா என்பதை சரிபார்க்க உதவுகிறது.

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

ஸ்மார்ட் கான்ட்ராக்ட்களை சோதிப்பதேன் முக்கியம்? ஸ்மார்ட் ஒப்பந்தங்களை சோதிப்பதன் முக்கியத்துவம்

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

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

ஸ்மார்ட் ஒப்பந்தங்களைச் சோதிப்பதற்கான முறைகள்

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

தானியங்கு சோதனை

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

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

கைமுறை சோதனை

கைமுறை சோதனை என்பது மனித உதவியுடன் செய்யப்படும் சோதனை முறையாகும். இதில், ஸ்மார்ட் கான்ட்ராக்ட்டின் சரியான செயல்பாட்டைப் பகுப்பாய்வு செய்யும்போது, உங்கள் சோதனை தொகுப்பில் உள்ள ஒவ்வொரு சோதனை வழக்கையும் ஒன்றின் பின் ஒன்றாகச் செயற்படுத்துவது அடங்கும். இது ஒரே சமயத்தில் பல தனிமைப்படுத்தப்பட்ட சோதனைகளைச் செயற்படுத்தி, தோல்வியடைந்த மற்றும் வெற்றிகரமாக முடிந்த சோதனைகளின் அறிக்கையைப் பெறும் தானியங்கி சோதனைக்கு மாறாகும்.

கைமுறை சோதனை ஒரே மனிதரால் மேற்கொள்ளப்படலாம், இது பல்வேறு சோதனை சூழ்நிலைகளைக் உள்ளடக்கிய எழுதப்பட்ட சோதனை திட்டத்தைப் பின்பற்றுகிறது. மேலும், பல மனிதர்கள் அல்லது குழுக்கள் கைமுறை சோதனையின் ஒரு பகுதியாக, குறிப்பிட்ட காலத்திற்கு ஒரு ஸ்மார்ட் கான்ட்ராக்ட்டுடன் தொடர்பு கொள்ள முடியும். சோதனையாளர்கள் கான்ட்ராக்ட்டின் உண்மையான நடத்தை எதிர்பார்க்கப்படும் நடத்தை இடத்தில் ஒப்பிட்டு, எந்தவொரு வேறுபாட்டையும் பிழையாகக் குறிக்கின்றனர்.

திறமையான கைமுறை சோதனை நிறைய வளங்கள் (திறமை, நேரம், பணம், மற்றும் முயற்சி) தேவைப்படுகின்றன, மேலும், மனித பிழை காரணமாகச் சோதனைகளைச் செயல்படுத்தும்போது சில பிழைகளைத் தவறவிடுவது சாத்தியமாகும். ஆனால், கைமுறை சோதனை நன்மைகளை வழங்கவும் செய்யும்—உதாரணமாக, ஒரு மனித சோதனையாளர் (உதாரணமாக, ஒரு ஆடிட்டர்) ஒரு தானியங்கி சோதனை கருவி தவறவிட்ட கடைசி நிலை சமயங்களைக் கண்டறிய உணர்ச்சிப்பூர்வமாகச் செயல்படலாம்.

ஸ்மார்ட் ஒப்பந்தங்களுக்கான தானியங்கு சோதனை

அலகு சோதனை

தானியங்கி சோதனை என்பது ஒவ்வொரு கான்ட்ராக்டின் செயல்பாடுகளைத் தனியாக மதிப்பீடு செய்து, ஒவ்வொரு உபகரணமும் சரியாகச் செயல்படுகிறதா என்பதைப் பரிசோதிக்கும் முறை ஆகும். சிறந்த யூனிட் சோதனைகள் எளிமையானவையாக, விரைவாக ஓடக்கூடியவையாக இருக்க வேண்டும் மற்றும் சோதனைகள் தோல்வியடைந்தால் எது தவறாக நடந்தது என்பதை தெளிவாகக் குறிப்பிட வேண்டும்.

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

ஸ்மார்ட் ஒப்பந்தங்களை அலகு சோதனை செய்வதற்கான வழிகாட்டுதல்கள்

1. உங்கள் கான்ட்ராக்டின் வணிக தருக்கமும் வேலைநிறுவகமும் புரிந்து கொள்ளுங்கள்

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

1constructor(
2        uint biddingTime,
3        address payable beneficiaryAddress
4    ) {
5        beneficiary = beneficiaryAddress;
6        auctionEndTime = block.timestamp + biddingTime;
7    }
8
9function bid() external payable {
10
11      if (block.timestamp > auctionEndTime)
12            revert AuctionAlreadyEnded();
13
14      if (msg.value <= highestBid)
15            revert BidNotHighEnough(highestBid);
16
17 if (highestBid != 0) {
18    pendingReturns[highestBidder] += highestBid;
19        }
20        highestBidder = msg.sender;
21        highestBid = msg.value;
22        emit HighestBidIncreased(msg.sender, msg.value);
23    }
24
25 function withdraw() external returns (bool) {
26        uint amount = pendingReturns[msg.sender];
27        if (amount > 0) {
28           pendingReturns[msg.sender] = 0;
29
30        if (!payable(msg.sender).send(amount)) {
31                pendingReturns[msg.sender] = amount;
32                return false;
33            }
34        }
35        return true;
36    }
37
38function auctionEnd() external {
39       if (block.timestamp < auctionEndTime)
40            revert AuctionNotYetEnded();
41        if (ended)
42            revert AuctionEndAlreadyCalled();
43
44        ended = true;
45        emit AuctionEnded(highestBidder, highestBid);
46
47        beneficiary.transfer(highestBid);
48    }
49}
அனைத்தையும் காட்டு

இது ஒரு எளிய ஏல கான்ட்ராக்ட் ஆகும், இது ஏல நேரத்தின்போது வரப்போகும் முறுகைகளைப் பெறுவதற்காக வடிவமைக்கப்பட்டுள்ளது. highestBid அதிகரித்தால், முந்தைய அதிக ஏலதாரர் தனது பணத்தைப் பெறுகிறார்; ஏல காலம் முடிந்தவுடன், beneficiary ஒப்பந்தத்தை அழைத்து தனது பணத்தைப் பெறுகிறார்.

யூனிட் சோதனைகள் இவ்வகை கான்ட்ராக்டின் மீது பயனாளர்கள் அடிக்கடி அழைக்கும் பல்வேறு செயல்பாடுகளைப் பரிசோதிக்கும் வகையில் இருக்கும். ஏலம் நடந்துகொண்டிருக்கும் போது ஒரு பயனர் ஏலம் எடுக்க முடியுமா (அதாவது, bid() க்கான அழைப்புகள் வெற்றி பெறுகின்றன) என்பதைச் சரிபார்க்கும் ஒரு அலகு சோதனை அல்லது தற்போதைய highestBid-ஐ விட அதிக ஏலம் எடுக்க முடியுமா என்பதைச் சரிபார்க்கும் ஒரு அலகு சோதனை ஒரு உதாரணமாகும்.

ஒரு கான்ட்ராக்டின் செயல்பாட்டு வேலைநிறுவகத்தை புரிந்துகொள்ளுவது, செயல்பாடுகள் தேவைகளைப் பூர்த்தி செய்கிறாரா எனச் சோதிக்க உதவும் யூனிட் சோதனைகளை எழுதவும் உதவுகிறது. எடுத்துக்காட்டாக, ஏலம் முடிந்ததும் பயனர்கள் ஏலம் எடுக்க முடியாது என்று ஏல ஒப்பந்தம் குறிப்பிடுகிறது (அதாவது, auctionEndTime ஆனது block.timestamp-ஐ விட குறைவாக இருக்கும்போது). எனவே, ஒரு டெவலப்பர் ஏலம் முடிந்ததும் bid() செயல்பாட்டிற்கான அழைப்புகள் வெற்றி பெறுமா அல்லது தோல்வியடையுமா என்பதைச் சரிபார்க்கும் ஒரு அலகு சோதனையை இயக்கலாம் (அதாவது, auctionEndTime > block.timestamp ஆக இருக்கும்போது).

2. கான்ட்ராக்ட் செயல்பாட்டிற்கு தொடர்பான அனைத்து நிரூபணங்களையும் மதிப்பீடு செய்யவும்

ஒரு கான்ட்ராக்டின் செயல்பாடுபற்றிய எந்தவொரு நிரூபணங்களையும் ஆவணப்படுத்துவது முக்கியம் மற்றும் அந்த நிரூபணங்கள் சரியாக உள்ளதா எனச் சோதிக்க யூனிட் சோதனைகளை எழுதவும். எதிர்பாராத செயல்பாட்டிற்கு பாதுகாப்பு அளிப்பதற்கு மட்டுமல்லாமல், அறிக்கைகளைச் சோதிப்பது ஒரு ஸ்மார்ட் கான்ட்ராக்ட்டின் பாதுகாப்பு மாதிரியை உணர உதவும் செயல்பாடுகளைப் பரிசோதிக்க உங்களை வலியுறுத்தும். ஒரு பயனுள்ள குறிப்பு என்னவென்றால், "மகிழ்ச்சியான பயனர் சோதனைகளை" மீறி, ஒரு செயல்பாடு தவறான உள்ளீடுகளுக்குத் தோல்வியடைகிறதா எனச் சோதிக்கும் எதிர்மறை சோதனைகளை எழுதுவது.

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

  • பயனாளர்கள், ஏல முடிந்த பிறகு அல்லது முதல்படிச் செய்யப்படாமல் இருக்கும்போது பிட் செய்ய முடியாது.

  • பிட் ஏற்கத் தக்க தொகை கீழே இருந்தால் ஏல கான்ட்ராக்ட் திரும்பப் பெறப்படுகிறது.

  • பிட் வெற்றிபெறாத பயனாளர்களுக்கு, அவர்கள் நிதிகள் திருப்பித் தரப்படுகின்றன

குறிப்பு: அனுமானங்களைச் சோதிப்பதற்கான மற்றொரு வழி, ஒரு ஒப்பந்தத்தில் செயல்பாட்டு மாற்றிகளை (opens in a new tab), குறிப்பாக require, assert, மற்றும் if...else அறிக்கைகளைத் தூண்டும் சோதனைகளை எழுதுவதாகும்.

ஒரு நல்ல கதை. குறியீடு பரப்புகளை அளவிடுங்கள்

குறியீடு கவரேஜ் (opens in a new tab) என்பது ஒரு சோதனை அளவீடு ஆகும், இது சோதனைகளின் போது செயல்படுத்தப்படும் உங்கள் குறியீட்டில் உள்ள கிளைகள், வரிகள் மற்றும் அறிக்கைகளின் எண்ணிக்கையைக் கண்காணிக்கும். சோதிக்கப்படாத பாதிப்புகளின் அபாயத்தைக் குறைக்க சோதனைகள் நல்ல குறியீடு கவரேஜைக் கொண்டிருக்க வேண்டும். போதுமான கவரேஜ் இல்லாமல், சோதிக்கப்படாத குறியீடு பாதைகளில் பாதிப்புகள் இன்னும் இருக்கும்போது, எல்லா சோதனைகளும் தேர்ச்சி பெறுவதால் உங்கள் ஒப்பந்தம் பாதுகாப்பானது என்று நீங்கள் தவறாகக் கருதலாம். ஆனால் உயர்ந்த குறியீடு பரப்புகளைப் பதிவு செய்வது, ஸ்மார்ட் கான்ட்ராக்ட் உள்ள அனைத்து கூற்றுகள் மற்றும் செயல்பாடுகள் சரியாகச் சோதிக்கப்பட்டன என்பதற்கு உறுதியை அளிக்கிறது.

4. நன்கு அபிவிருத்தி செய்யப்பட்ட சோதனை கட்டமைப்புகளைப் பயன்படுத்துங்கள்

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

Solidity ஸ்மார்ட் கான்ட்ராக்ட் யூனிட் சோதனை கட்டமைப்புகள் பல்வேறு மொழிகளில் கிடைக்கின்றன (மிகவும் ஜாவாஸ்கிரிப்ட், பைதான், மற்றும் ரஸ்ட்). கீழ்க்கண்ட வழிகாட்டிகளில், வேறு சோதனை கட்டமைப்புகளுடன் யூனிட் சோதனைகளை இயக்குவது பற்றித் தகவலைப் பெறலாம்:

ஒருங்கிணைப்பு சோதனை

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

உங்கள் ஒப்பந்தம் ஒரு மட்டு கட்டமைப்பை ஏற்றுக்கொண்டால் அல்லது செயல்பாட்டின் போது மற்ற ஆன்செயின் ஒப்பந்தங்களுடன் இடைமுகம் செய்தால் ஒருங்கிணைப்பு சோதனை பயனுள்ளதாக இருக்கும். ஒருங்கிணைப்பு சோதனைகளை இயக்குவதற்கான ஒரு வழி, ஒரு குறிப்பிட்ட உயரத்தில் செய்து (Forge (opens in a new tab) அல்லது Hardhat (opens in a new tab) போன்ற ஒரு கருவியைப் பயன்படுத்தி) உங்கள் ஒப்பந்தத்திற்கும் பகிரப்பட்ட ஒப்பந்தங்களுக்கும் இடையிலான தொடர்புகளை உருவகப்படுத்துவதாகும்.

கிளைத்த ப்ளாக்செயின் மெய்நிகர் நெட்வொர்க்கைப் போலவே செயல்படும், மேலும் கணக்குகளுடன் இணைக்கப்பட்ட நிலைகளும் மற்றும் சமநிலைகளும் இருக்கும். ஆனால் இது வெறும் சாண்ட்பாக்ஸ் செய்யப்பட்ட உள்ளூர் வளர்ச்சியுறும் சூழலாகவே செயல்படும், அதாவது உருப்படியான ETH போன்றவற்றிற்காக நீங்கள் வேலையைச் செய்யத் தேவையில்லை, மேலும் உங்கள் மாற்றங்கள் உண்மையான Ethereum நெறிமுறையைப் பாதிக்காது.

பண்பு அடிப்படையிலான சோதனை

பண்பு அடிப்படையிலான சோதனை என்பது ஒரு ஸ்மார்ட் கான்ட்ராக்ட் குறிப்பிட்ட ஒரு பண்பினை பூர்த்தி செய்கிறதா என்பதை சரிபார்ப்பது ஆகும். பண்புகள் ஒரு கான்ட்ராக்டின் செயல்பாட்டைப் பற்றிய விளக்கங்களை நியமிக்கின்றன, மற்றும் இவ்வாறு நியமிக்கப்பட்ட விளக்கங்கள் வெவ்வேறு காட்சிகளில் மாறாமல் இருக்குமா என்பதைப் பரிசோதிக்கின்றன. ஒரு ஸ்மார்ட் கான்ட்ராக்டின் ஒரு பண்பு எடுத்துக்காட்டாக, "கான்ட்ராக்டில் உள்ள எண்கணித செயல்பாடுகள் எப்போதும் மேற்பொலிக்கும் அல்லது அதிக குறைவாக மாறாது."

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

நிலையான பகுப்பாய்வு

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

லிண்டிங் (opens in a new tab) மற்றும் நிலையான சோதனை (opens in a new tab) ஆகியவை ஒப்பந்தங்களில் நிலையான பகுப்பாய்வை இயக்குவதற்கான பொதுவான முறைகள் ஆகும். இரண்டிற்கும் ஒரு ஒப்பந்தத்தின் செயல்பாட்டின் குறைந்த-நிலை பிரதிநிதித்துவங்களை பகுப்பாய்வு செய்ய வேண்டும், அதாவது சுருக்க தொடரியல் மரங்கள் (opens in a new tab) மற்றும் தொகுப்பியால் வெளியிடப்பட்ட கட்டுப்பாட்டு ஓட்ட வரைபடங்கள் (opens in a new tab) போன்றவை.

பல சந்தர்ப்பங்களில், நிலையான பகுப்பாய்வு பாதுகாப்பு பிரச்சினைகளை, எடுத்துக்காட்டாக, பாதுகாப்பற்ற கட்டமைப்புகளைப் பயன்படுத்துதல், சிறு குறியீட்டுக் கோளாறுகள் அல்லது குறியீட்டு முறைமைகளில் இழப்புகளைக் கண்டறிய உதவியாக இருக்கும். ஆனால், நிலையான பகுப்பாய்வாளர்கள் உள்ளார்ந்த முடிவுகளைக் கண்டறிய பொதுவாக உண்மையல்லாதவர்களாகக் கருதப்படுகின்றனர், மேலும் அதிக அளவில் தவறான ஒத்திவைப்புகளை உருவாக்கலாம்.

இயங்கு பகுப்பாய்வு

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

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

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

  1. பல காட்சிகளை உள்ளடக்கிய சோதனை நிகழ்வுகளை எழுதுவது கடினம். ஒரு பண்பு சோதனைக்கு நீங்கள் ஒரு நடத்தை மற்றும் அந்த நடத்தையைச் சோதிக்க தரவின் வரம்பை வரையறுக்க வேண்டும்—வரையறுக்கப்பட்ட பண்பின் அடிப்படையில் நிரல் தானாகவே சோதனை நிகழ்வுகளை உருவாக்குகிறது.

  2. உங்கள் சோதனைத் தொகுப்பு நிரலில் உள்ள அனைத்து சாத்தியமான பாதைகளையும் போதுமான அளவில் உள்ளடக்காமல் இருக்கலாம். 100% கவரேஜ் இருந்தாலும், விளிம்பு நிகழ்வுகளைத் தவறவிட வாய்ப்புள்ளது.

  3. அலகு சோதனைகள் ஒரு ஒப்பந்தம் மாதிரி தரவுகளுக்கு சரியாகச் செயல்படுவதை நிரூபிக்கின்றன, ஆனால் மாதிரிக்கு வெளியே உள்ள உள்ளீடுகளுக்கு ஒப்பந்தம் சரியாகச் செயல்படுகிறதா என்பது தெரியவில்லை. பண்பு சோதனைகள், வலியுறுத்தல் தோல்விகளை ஏற்படுத்தும் செயல்பாட்டுத் தடயங்களைக் கண்டறிய, கொடுக்கப்பட்ட உள்ளீட்டு மதிப்பின் பல மாறுபாடுகளுடன் ஒரு இலக்கு ஒப்பந்தத்தைச் செயல்படுத்துகின்றன. இதனால், ஒரு பண்புச் சோதனை பயன்பாட்டின் பெரிய உள்ளீட்டு தகவல்களுக்கான சரியான செயல்பாடுகளை மேலும் வசதி உருவாக்கச் செய்கின்றது.

ஸ்மார்ட் ஒப்பந்தங்களுக்கான பண்பு அடிப்படையிலான சோதனையை இயக்குவதற்கான வழிகாட்டுதல்கள்

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

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

ஸ்மார்ட் ஒப்பந்தங்களுக்கான கைமுறை சோதனை

ஸ்மார்ட் கான்ட்ராக்ட்களின் கைமுறை சோதனை பொதுவாக ஆட்டோமேஷன் சோதனைகளை நடத்திய பிறகு மேல்நிலை படுகிறது. இந்த வகை சோதனை ஒரு முழுமையாக ஒன்று சேர்க்கப்பட்ட தயாரிப்பு பொருளாக ஸ்மார்ட் கான்ட்ராக்டின் செயல்பாடுகளை மதிப்பீடு செய்கிறது, அது தொழில்நுட்ப விவரங்களின் நிர்ணயத்திற்கிணங்க செயல்படுகிறதா என்பதை தெரிய செய்கிறது.

உள்ளூர் பிளாக்செயினில் ஒப்பந்தங்களை சோதித்தல்

ஆட்டோமேஷன் சோதனை ஒரு உள்ளூர் வளர்ப்பு சூழலில் நடத்தப்பட்டபோது, அது பயனுள்ள பிழைத்திருத்த தகவல்களை வழங்கக்கூடிய சூழ்நிலையாக இருக்கலாம். ஆனால், உங்கள் ஸ்மார்ட் கான்ட்ராக்ட் ஒரு உற்பத்தி சூழலில் எப்படி நடத்துகின்றது என்பதை நீங்கள் தெரிந்து கொள்ள வேண்டும். எனினும், முக்கிய எத்தெருமான் செயினில் பிரச்சினைகளை படைத்த போது காஸ் கட்டணங்கள் நடக்கின்றன — செய்யப்பட்ட பின்பு உங்கள் ஸ்மார்ட் கான்ட்ராக்ட் இன்னும் பிழைகள் உள்ளது என்றால், நீங்கள் அல்லது உங்கள் பயனர்கள் உண்மையான பணத்தை இழக்க முடியும்.

உங்கள் ஒப்பந்தத்தை உள்ளூர் பிளாக்செயினில் (வளர்ச்சி நெட்வொர்க் என்றும் அழைக்கப்படுகிறது) சோதிப்பது Mainnet இல் சோதிப்பதற்குப் பரிந்துரைக்கப்படும் ஒரு மாற்று ஆகும். உள்ளூர் பிளாக்செயின் உங்கள் கணினியில் உள்ள Ethereum பிளாக்செயினின் ஒரு நகல் அதிகாரத்தைக் போன்ற நடைமுறையைப் பின்பற்றும். அதனால், நீங்கள் கான்ட்ராக்டுடன் செயல்படுத்த ஒப்பந்தங்களைப் பட்டியலில் உள்ள சர்ச்சை செய்ய முடியும்.

ஒரு உள்ளூர் பிளாக்செயினில் ஒப்பந்தங்களை நடத்துவது கைமுறை ஒப்பந்த சேர்க்கை சோதனையாகப் பயனுள்ளதாக இருக்கலாம். ஸ்மார்ட் ஒப்பந்தங்கள் அதிகளவில் தொகுக்கக்கூடியவை, ஏற்கனவே உள்ள நெறிமுறைகளுடன் ஒருங்கிணைக்க உங்களை அனுமதிக்கிறது—ஆனால் அத்தகைய சிக்கலான ஆன்செயின் தொடர்புகள் சரியான முடிவுகளைத் தருகின்றன என்பதை நீங்கள் இன்னும் உறுதிப்படுத்த வேண்டும்.

வளர்ச்சி நெட்வொர்க்குகள் பற்றி மேலும்.

டெஸ்ட்நெட்களில் ஒப்பந்தங்களை சோதித்தல்

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

இந்தக் கைமுறை சோதனை உங்கள் விண்ணப்பத்தின் முடிவில் பயனர் வினைச்செயல்களை மதிப்பீடு செய்யப் பயனுள்ளதாக இருக்கிறது. இங்கு, பேட்டா சோதகர்களுக்கு அவர்கள் கான்ட்ராக்டின் வணிக மூலோபாயங்கள் மற்றும் மொத்தம் செயல்பாடுகள்பற்றிய சிக்கல்களை அறிக்கையளிக்க முடியும்.

உள்ளூர் பிளாக்செயினில் சோதனையிட்ட பிறகு சோதனை நெட்வொர்க் எட்டிய இருப்பது அதிக வெகுளியில் திறனடைய இருக்கிறது என்றால் இருந்தாலும் Ethereum Virtual Machine போல இருக்கிறது. ஆகையால், பல Ethereum-உள்நாட்டு திட்டங்கள் சோதனை நெட்வொர்க்களில் dapps விண்டோ என்றும் செயல்படுகிறது.

எத்தேரியம் டெஸ்ட்நெட்கள் பற்றி மேலும்.

சோதனை மற்றும் முறையான சரிபார்ப்பு

சோதனை ஒரு கான்ட்ராக்டு சில தரவுகளுக்கான காணொளிகளைத் திரும்பப் பெறுவதை உறுதிப்படுத்த உதவுகிறது, ஆனால் சோதனையில் பயன்படுத்தாத தரவுகளுக்கு அதே முடிவுகளை நிச்சயமாக விரிவாகச் செய்ய முடியாது. எனவே, ஒரு ஸ்மார்ட் ஒப்பந்தத்தைச் சோதிப்பது "செயல்பாட்டுச் சரியானது" என்பதற்கு உத்தரவாதம் அளிக்காது (அதாவது, ஒரு நிரல் அனைத்து உள்ளீட்டு மதிப்புகளுக்கும் தேவைக்கேற்ப செயல்படுவதைக் காட்ட முடியாது).

துல்லியமான சரிபார்ப்பு என்பது மென்பொருளின் சரியானதன்மையை மதிப்பீடு செய்யும் முறையாக, ஒருவரின் மாத்யமிகர்த்துமா மாதிரி உத்தியோகபூர்வ விளக்கத்தைப் பொருந்துமா என்பதைக் கணிக்கின்றது. ஒரு துல்லியமான மாத்யமிகர்த்துமா என்பது ஒரு திட்டத்தின் கணித மாதிரி ஆகும், மேலும் ஒரு உத்தியோகபூர்வ விளக்கம் (i.e., திட்டத்தின் செயல்பாட்டைப் பற்றிய மாந்திகமான புகார்கள்) திட்டத்தின் சொந்தங்கள் (i.e., திட்டத்தின் செயல்பாட்டைப் பற்றிய மாந்திகமான புகார்கள்) ஆகும்.

சொந்தங்கள் கணித துறையில் எழுதப்படுவதால், துல்லியமான (கணித) மாத்யமிகர்த்துமா முறை ஒரு குறிப்பிட்ட விளக்கத்தைப் பூர்த்தி செய்யுமா என்பதை சோதனை செய்யக்கூடியதாகிறது. எனவே, துல்லியமான சரிபார்ப்பு கருவிகள் ஒரு அமைப்பின் சரியானதன்மையை ‘கணிதமான சான்று’ அளிக்கும் என்று கூறப்படுகிறது.

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

ஸ்மார்ட் ஒப்பந்தங்களுக்கான முறையான சரிபார்ப்பு பற்றி மேலும்.

சோதனை, தணிக்கைகள் மற்றும் பிழை வெகுமதிகள்

அண்மையில், நுணுக்கமான சோதனைகள் ஒரு கான்ட்ராக்டில் பிழைகள் இல்லாமல் இருப்பதை உறுதி செய்ய முடியாது; துல்லியமான சரிபார்ப்பு முறைகள் சோதனையின் வலுவான உறுதிகளை வழங்கலாம் ஆனால் தற்போது அவற்றைப் பயன்படுத்துவது கடினமாகவும் அதிக செலவாகவும் உள்ளது.

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

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

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

முக்கிய வேறுபாடு என்னவெனில், பிழை பரிசுத் திட்டங்கள் பரந்த வளர்த்தாளர்/ஹேக்கர் சமூகத்திற்கு திறந்ததாக இருக்கும் மற்றும் தனித்துவமான திறன்கள் மற்றும் அனுபவமுள்ள ஏதேனும் நியாயமான ஹேக்கர்கள் மற்றும் சுதந்திரமான பாதுகாப்பு வல்லுநர்களைக் ஈர்க்கும். இது, குறைந்த அல்லது வகைப்படுத்தப்பட்ட நிபுணத்துவம் கொண்ட குழுக்களைப் பெரும்பாலும் சார்ந்த ஸ்மார்ட் கான்ட்ராக்ட் ஆய்வுகளுக்கு மேலாக ஒரு நன்மை ஆக இருக்க முடியும்.

சோதனைக் கருவிகள் மற்றும் நூலகங்கள்

அலகு சோதனைக் கருவிகள்

  • solidity-coverage (opens in a new tab) - Solidity-இல் எழுதப்பட்ட ஸ்மார்ட் ஒப்பந்தங்களுக்கான குறியீடு கவரேஜ் கருவி.

  • Waffle (opens in a new tab) - மேம்பட்ட ஸ்மார்ட் ஒப்பந்த மேம்பாடு மற்றும் சோதனைக்கான கட்டமைப்பு (ethers.js அடிப்படையில்).

  • Remix சோதனைகள் (opens in a new tab) - Solidity ஸ்மார்ட் ஒப்பந்தங்களைச் சோதிப்பதற்கான கருவி. ஒரு ஒப்பந்தத்திற்கான சோதனை நிகழ்வுகளை எழுதவும் இயக்கவும் பயன்படுத்தப்படும் Remix IDE "Solidity Unit Testing" செருகுநிரலின் கீழ் வேலை செய்கிறது.

  • OpenZeppelin சோதனை உதவியாளர்கள் (opens in a new tab) - எத்தேரியம் ஸ்மார்ட் ஒப்பந்த சோதனைக்கான வலியுறுத்தல் நூலகம். உங்கள் ஒப்பந்தங்கள் எதிர்பார்த்தபடி செயல்படுவதை உறுதிப்படுத்திக் கொள்ளுங்கள்!

  • Brownie அலகு சோதனை கட்டமைப்பு (opens in a new tab) - Brownie, Pytest-ஐப் பயன்படுத்துகிறது, இது ஒரு அம்சம் நிறைந்த சோதனை கட்டமைப்பாகும், இது குறைந்த குறியீட்டுடன் சிறிய சோதனைகளை எழுத உங்களை அனுமதிக்கிறது, பெரிய திட்டங்களுக்கு நன்றாக அளவிடப்படுகிறது மற்றும் அதிக அளவில் நீட்டிக்கக்கூடியது.

  • Foundry சோதனைகள் (opens in a new tab) - Foundry, Forge-ஐ வழங்குகிறது, இது எளிய அலகு சோதனைகள், எரிவாயு உகப்பாக்கச் சரிபார்ப்புகள் மற்றும் ஒப்பந்த ஃபஸ்ஸிங் ஆகியவற்றைச் செயல்படுத்தும் திறன் கொண்ட வேகமான மற்றும் நெகிழ்வான எத்தேரியம் சோதனை கட்டமைப்பாகும்.

  • Hardhat சோதனைகள் (opens in a new tab) - ethers.js, Mocha மற்றும் Chai ஆகியவற்றின் அடிப்படையில் ஸ்மார்ட் ஒப்பந்தங்களைச் சோதிப்பதற்கான கட்டமைப்பு.

  • ApeWorx (opens in a new tab) - எத்தேரியம் மெய்நிகர் இயந்திரத்தை இலக்காகக் கொண்ட ஸ்மார்ட் ஒப்பந்தங்களுக்கான பைதான் அடிப்படையிலான மேம்பாடு மற்றும் சோதனை கட்டமைப்பு.

  • Wake (opens in a new tab) - சிறந்த பயனர் அனுபவம் மற்றும் செயல்திறனுக்காக pytest மற்றும் Anvil-ஐப் பயன்படுத்தி, வலுவான பிழைத்திருத்த திறன்கள் மற்றும் குறுக்கு-செயின் சோதனை ஆதரவுடன் அலகு சோதனை மற்றும் ஃபஸ்ஸிங்கிற்கான பைதான் அடிப்படையிலான கட்டமைப்பு.

பண்பு அடிப்படையிலான சோதனைக் கருவிகள்

நிலையான பகுப்பாய்வுக் கருவிகள்

  • Slither (opens in a new tab) - பாதிப்புகளைக் கண்டறிதல், குறியீட்டுப் புரிதலை மேம்படுத்துதல் மற்றும் ஸ்மார்ட் ஒப்பந்தங்களுக்கான தனிப்பயன் பகுப்பாய்வுகளை எழுதுவதற்கான பைதான் அடிப்படையிலான Solidity நிலையான பகுப்பாய்வு கட்டமைப்பு.

  • Ethlint (opens in a new tab) - Solidity ஸ்மார்ட் ஒப்பந்த நிரலாக்க மொழிக்கு நடை மற்றும் பாதுகாப்பு சிறந்த நடைமுறைகளைச் செயல்படுத்துவதற்கான லிண்டர்.

  • Cyfrin Aderyn (opens in a new tab) - Web3 ஸ்மார்ட் ஒப்பந்தப் பாதுகாப்பு மற்றும் மேம்பாட்டிற்காக பிரத்யேகமாக வடிவமைக்கப்பட்ட ரஸ்ட் அடிப்படையிலான நிலையான பகுப்பாய்வி.

  • Wake (opens in a new tab) - பாதிப்பு மற்றும் குறியீட்டுத் தரக் கண்டறிவான்கள், குறியீட்டிலிருந்து பயனுள்ள தகவல்களைப் பிரித்தெடுப்பதற்கான அச்சுப்பொறிகள் மற்றும் தனிப்பயன் துணைத் தொகுதிகளை எழுதுவதற்கான ஆதரவுடன் கூடிய பைதான் அடிப்படையிலான நிலையான பகுப்பாய்வுக் கட்டமைப்பு.

  • Slippy (opens in a new tab) - Solidity-க்கான எளிய மற்றும் சக்திவாய்ந்த லிண்டர்.

இயங்கு பகுப்பாய்வுக் கருவிகள்

  • Echidna (opens in a new tab) - பண்பு அடிப்படையிலான சோதனை மூலம் ஸ்மார்ட் ஒப்பந்தங்களில் பாதிப்புகளைக் கண்டறிவதற்கான வேகமான ஒப்பந்த ஃபஸ்சர்.

  • Diligence Fuzzing (opens in a new tab) - ஸ்மார்ட் ஒப்பந்த குறியீட்டில் பண்பு மீறல்களைக் கண்டறியப் பயன்படும் தானியங்கு ஃபஸ்ஸிங் கருவி.

  • Manticore (opens in a new tab) - EVM பைட்கோடைப் பகுப்பாய்வு செய்வதற்கான டைனமிக் சிம்பாலிக் எக்ஸிகியூஷன் கட்டமைப்பு.

  • Mythril (opens in a new tab) - கறை பகுப்பாய்வு, கான்கோலிக் பகுப்பாய்வு மற்றும் கட்டுப்பாட்டு ஓட்டச் சரிபார்ப்பு ஆகியவற்றைப் பயன்படுத்தி ஒப்பந்த பாதிப்புகளைக் கண்டறிவதற்கான EVM பைட்கோட் மதிப்பீட்டுக் கருவி.

  • Diligence Scribble (opens in a new tab) - Scribble என்பது ஒரு விவரக்குறிப்பு மொழி மற்றும் இயக்க நேர சரிபார்ப்புக் கருவியாகும், இது ஸ்மார்ட் ஒப்பந்தங்களைப் பண்புகளுடன் சிறுகுறிப்பு செய்ய உங்களை அனுமதிக்கிறது, இது Diligence Fuzzing அல்லது MythX போன்ற கருவிகளைக் கொண்டு ஒப்பந்தங்களைத் தானாகவே சோதிக்க உதவுகிறது.

தொடர்புடைய பயிற்சிகள்

மேலும் வாசிக்க

இந்தக் கட்டுரை உதவியாக இருந்ததா?