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

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

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

corwintinesc (opens in a new tab)
MOSHKA-GOTM (opens in a new tab)
mdqstm (opens in a new tab)
+22

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

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

முன்நிபந்தனைகள்

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

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

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

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

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

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

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

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

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

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

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

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

கைமுறைச் சோதனை

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

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

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

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

அலகுச் சோதனை (Unit testing)

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

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

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

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

அலகுச் சோதனைகளை எழுதுவதற்கு முன், ஒரு ஸ்மார்ட் ஒப்பந்தம் என்ன செயல்பாடுகளை வழங்குகிறது மற்றும் பயனர்கள் அந்தச் செயல்பாடுகளை எவ்வாறு அணுகுவார்கள் மற்றும் பயன்படுத்துவார்கள் என்பதை அறிவது உதவுகிறது. செல்லுபடியாகும் பயனர் உள்ளீடுகளுக்கு ஒரு ஒப்பந்தத்தில் உள்ள செயல்பாடுகள் சரியான வெளியீட்டை வழங்குகின்றனவா என்பதைத் தீர்மானிக்கும் மகிழ்ச்சியான பாதைச் சோதனைகளை (happy path tests) (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-ஐ விடக் குறைவாக இருக்கும்போது) பயனர்கள் ஏலம் கேட்க முடியாது என்று ஏல ஒப்பந்தம் குறிப்பிடுகிறது. எனவே, ஏலம் முடிந்ததும் (அதாவது, auctionEndTime > block.timestamp ஆக இருக்கும்போது) bid() செயல்பாட்டிற்கான அழைப்புகள் வெற்றியடைகிறதா அல்லது தோல்வியடைகிறதா என்பதைச் சரிபார்க்கும் அலகுச் சோதனையை ஒரு டெவலப்பர் இயக்கலாம்.

2. ஒப்பந்தச் செயலாக்கம் தொடர்பான அனைத்து அனுமானங்களையும் மதிப்பிடுங்கள்

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

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

  • ஏலம் முடிந்ததும் அல்லது தொடங்காதபோதும் பயனர்கள் ஏலம் கேட்க முடியாது.

  • ஏலம் ஏற்றுக்கொள்ளக்கூடிய வரம்பிற்குக் கீழே இருந்தால் ஏல ஒப்பந்தம் திரும்பப் பெறப்படும்.

  • ஏலத்தை வெல்லத் தவறிய பயனர்களுக்கு அவர்களின் நிதி வரவு வைக்கப்படும்

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

3. குறியீட்டுத் கவரேஜை (Code coverage) அளவிடவும்

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

4. நன்கு உருவாக்கப்பட்ட சோதனைக் கட்டமைப்புகளைப் பயன்படுத்தவும்

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

Solidity ஸ்மார்ட் ஒப்பந்தங்களுக்கான அலகுச் சோதனைக் கட்டமைப்புகள் வெவ்வேறு மொழிகளில் (பெரும்பாலும் JavaScript, Python மற்றும் Rust) வருகின்றன. வெவ்வேறு சோதனைக் கட்டமைப்புகளுடன் அலகுச் சோதனைகளை எவ்வாறு தொடங்குவது என்பது பற்றிய தகவலுக்குக் கீழே உள்ள சில வழிகாட்டிகளைப் பார்க்கவும்:

ஒருங்கிணைப்புச் சோதனை (Integration testing)

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

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

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

பண்பு அடிப்படையிலான சோதனை (Property-based testing)

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

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

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

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

லிண்டிங் (Linting) (opens in a new tab) மற்றும் நிலையான சோதனை (static testing) (opens in a new tab) ஆகியவை ஒப்பந்தங்களில் நிலையான பகுப்பாய்வை இயக்குவதற்கான பொதுவான முறைகள். இரண்டிற்கும் கம்பைலரால் வெளியிடப்படும் சுருக்க தொடரியல் மரங்கள் (abstract syntax trees) (opens in a new tab) மற்றும் கட்டுப்பாட்டு ஓட்ட வரைபடங்கள் (control flow graphs) (opens in a new tab) போன்ற ஒப்பந்தச் செயலாக்கத்தின் குறைந்த-நிலை பிரதிநிதித்துவங்களை பகுப்பாய்வு செய்ய வேண்டும்.

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

மாறும் பகுப்பாய்வு

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

உள்ளூர் பிளாக்செயினில் சோதித்த பிறகு டெஸ்ட்நெட்டில் பயன்படுத்துவது சிறந்தது, ஏனெனில் முந்தையது எத்தேரியம் மெய்நிகர் இயந்திரத்தின் (Ethereum Virtual Machine) நடத்தைக்கு நெருக்கமாக உள்ளது. எனவே, நிஜ உலக நிலைமைகளின் கீழ் ஸ்மார்ட் ஒப்பந்தங்களின் செயல்பாட்டை மதிப்பிடுவதற்குப் பல எத்தேரியம்-சொந்த திட்டங்கள் டெஸ்ட்நெட்களில் டாப்-களைப் பயன்படுத்துவது பொதுவானது.

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

சோதனை மற்றும் முறையான சரிபார்ப்பு (Testing vs. formal verification)

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

முறையான சரிபார்ப்பு (Formal verification) என்பது நிரலின் முறையான மாதிரி முறையான விவரக்குறிப்புடன் பொருந்துகிறதா என்பதைச் சரிபார்ப்பதன் மூலம் மென்பொருளின் சரியான தன்மையை மதிப்பிடுவதற்கான ஒரு அணுகுமுறையாகும். ஒரு முறையான மாதிரி என்பது ஒரு நிரலின் சுருக்கமான கணிதப் பிரதிநிதித்துவமாகும், அதே சமயம் ஒரு முறையான விவரக்குறிப்பு ஒரு நிரலின் பண்புகளை வரையறுக்கிறது (அதாவது, நிரலின் செயலாக்கம் பற்றிய தர்க்கரீதியான கூற்றுகள்).

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

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

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

சோதனை மற்றும் தணிக்கைகள் மற்றும் பிழை வெகுமதிகள் (Testing vs audits and bug bounties)

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

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

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

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

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

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

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

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

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

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

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

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

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

  • Hardhat Tests (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 ஸ்மார்ட் ஒப்பந்த நிரலாக்க மொழிக்கான நடை மற்றும் பாதுகாப்புச் சிறந்த நடைமுறைகளைச் செயல்படுத்துவதற்கான லிண்டர் (Linter).

  • 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) - கறை பகுப்பாய்வு (taint analysis), கான்கோலிக் பகுப்பாய்வு (concolic analysis) மற்றும் கட்டுப்பாட்டு ஓட்டச் சரிபார்ப்பு (control flow checking) ஆகியவற்றைப் பயன்படுத்தி ஒப்பந்தப் பாதிப்புகளைக் கண்டறிவதற்கான EVM பைட்கோடு மதிப்பீட்டுக் கருவி.

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

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

மேலும் படிக்க

பயிற்சிகள்: எத்தேரியத்தில் ஸ்மார்ட் ஒப்பந்தச் சோதனை

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?