# Echidna: एक तेज़ स्मार्ट कॉन्ट्रैक्ट फ़ज़र <a href="https://raw.githubusercontent.com/crytic/echidna/master/echidna.png"><img src="https://assets.kitploit.com/production/public/readmes/2659/763a0b6f546e53fe33e871cd7359ba47272d81be37527f1cceaa827256af0337.png" width="75"/></a>
Echidna एक अजीब प्राणी है जो बग्स खाती है और अत्यधिक इलेक्ट्रोसेंसिटिव है (Jacob Stanley से क्षमा के साथ)
अधिक गंभीरता से, Echidna एक Haskell प्रोग्राम है जिसे Ethereum स्मार्ट कॉन्ट्रैक्ट्स के फ़ज़िंग/प्रॉपर्टी-आधारित परीक्षण के लिए डिज़ाइन किया गया है। यह उपयोगकर्ता-परिभाषित प्रेडिकेट्स या [Solidity assertions](https://docs.soliditylang.org/en/develop/control-structures.html#error-handling-assert-require-revert-and-exceptions) को गलत साबित करने के लिए [contract ABI](https://docs.soliditylang.org/en/develop/abi-spec.html) पर आधारित परिष्कृत व्याकरण-आधारित फ़ज़िंग अभियानों का उपयोग करता है। हमने Echidna को मॉड्यूलरिटी को ध्यान में रखते हुए डिज़ाइन किया है, इसलिए इसे नए म्यूटेशन शामिल करने या विशिष्ट मामलों में विशिष्ट कॉन्ट्रैक्ट्स का परीक्षण करने के लिए आसानी से विस्तारित किया जा सकता है।
## विशेषताएँ
* आपके वास्तविक कोड के अनुरूप इनपुट उत्पन्न करता है
* गहरे बग्स खोजने के लिए वैकल्पिक कॉर्पस संग्रह, म्यूटेशन और कवरेज मार्गदर्शन
* फ़ज़िंग अभियान से पहले उपयोगी जानकारी निकालने के लिए [Slither](https://github.com/crytic/slither) द्वारा संचालित
* फ़ज़िंग अभियान के बाद कौन सी पंक्तियाँ कवर की गईं, यह पहचानने के लिए स्रोत कोड एकीकरण
* इंटरैक्टिव टर्मिनल UI, केवल-टेक्स्ट या JSON आउटपुट
* त्वरित ट्राइएज के लिए स्वचालित टेस्ट केस न्यूनीकरण
* विकास वर्कफ़्लो में सहज एकीकरण
.. और [एक सुंदर उच्च-रिज़ॉल्यूशन हस्तनिर्मित लोगो](https://raw.githubusercontent.com/crytic/echidna/master/echidna.png)।
<a href="https://i.imgur.com/saFWti4.png"><img src="https://assets.kitploit.com/production/public/readmes/2659/ec117cf17d5b4eeb75f52a3654df19ba615818f232d5e9238093cf010431fedc.png" width="650"/></a>
## उपयोग
### टेस्ट रनर निष्पादित करना
Echidna की मुख्य कार्यक्षमता `echidna` नामक एक निष्पादन योग्य फ़ाइल है, जो एक कॉन्ट्रैक्ट और इनवेरिएंट्स (ऐसे गुण जो हमेशा सत्य रहने चाहिए) की सूची को इनपुट के रूप में लेती है। प्रत्येक इनवेरिएंट के लिए, यह कॉन्ट्रैक्ट को कॉल करने के यादृच्छिक अनुक्रम उत्पन्न करती है और जाँचती है कि इनवेरिएंट कायम है या नहीं। यदि यह इनवेरिएंट को गलत साबित करने का कोई तरीका खोज सकती है, तो यह उस कॉल अनुक्रम को प्रिंट करती है जो ऐसा करता है। यदि यह नहीं कर सकती, तो आपको कुछ आश्वासन मिलता है कि कॉन्ट्रैक्ट सुरक्षित है।
### इनवेरिएंट्स लिखना
इनवेरिएंट्स को Solidity फ़ंक्शन्स के रूप में व्यक्त किया जाता है जिनके नाम `echidna_` से शुरू होते हैं, कोई आर्ग्युमेंट नहीं लेते, और एक बूलियन लौटाते हैं। उदाहरण के लिए, यदि आपके पास कोई `balance` वेरिएबल है जो कभी भी `20` से नीचे नहीं जाना चाहिए, तो आप अपने कॉन्ट्रैक्ट में इस तरह एक अतिरिक्त फ़ंक्शन लिख सकते हैं:```solidity
function echidna_check_balance() public returns (bool) {
return(balance >= 20);
}
```
इन invariants को जाँचने के लिए, चलाएँ:```sh
$ echidna myContract.sol
```
एक उदाहरण अनुबंध जिसमें परीक्षण हैं, [tests/solidity/basic/flags.sol](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/flags.sol) पर पाया जा सकता है। इसे चलाने के लिए, आपको निष्पादित करना चाहिए:```sh
$ echidna tests/solidity/basic/flags.sol
```
Echidna को एक कॉल अनुक्रम खोजना चाहिए जो `echidna_sometimesfalse` को गलत साबित करता है और `echidna_alwaystrue` के लिए गलत साबित करने वाला इनपुट खोजने में असमर्थ होना चाहिए।
### परीक्षण मोड
ऊपर दिया गया उदाहरण डिफ़ॉल्ट **property** मोड का उपयोग करता है, लेकिन Echidna कई परीक्षण मोड का समर्थन करता है, जिन्हें कॉन्फ़िग फ़ाइल में `testMode` या CLI पर `--test-mode` के माध्यम से कॉन्फ़िगर किया जाता है:
* **`property`** (डिफ़ॉल्ट): `echidna_`-उपसर्ग वाले फ़ंक्शन का परीक्षण करें जो `bool` लौटाते हैं।
* **`assertion`**: `assert()` और Foundry के `assertX` हेल्पर्स (`assertTrue`, `assertEq`, आदि) से assertion विफलताओं का पता लगाएं।
* **`foundry`**: Foundry-शैली के परीक्षण चलाएं, इसकी नामकरण परंपराओं का पालन करते हुए: `test`-उपसर्ग वाले यूनिट और फ़ज़ परीक्षण (`testFail`-उपसर्ग वाले revert होने की अपेक्षा की जाती है) और `invariant`- या `statefulFuzz`-उपसर्ग वाले stateful invariants। `check`- और `prove`-उपसर्ग वाले फ़ंक्शन प्रतीकात्मक प्रवेश बिंदु हैं, लेकिन चूंकि यह मोड एक फ़ज़िंग अभियान है, उन्हें किसी भी अन्य परीक्षण फ़ंक्शन की तरह फ़ज़ किया जाता है।
* **`verification`**: एकल लेनदेन का उपयोग करके अनुबंध के प्रत्येक फ़ंक्शन को प्रतीकात्मक रूप से सत्यापित करें। `check`- और `prove`-उपसर्ग वाले फ़ंक्शन हमेशा प्रवेश बिंदु के रूप में उपयोग किए जाते हैं।
* **`overflow`**: पूर्णांक over/underflows का पता लगाएं (Solidity >= 0.8.0)।
* **`optimization`**: `echidna_`-उपसर्ग वाले फ़ंक्शन का रिटर्न मान अधिकतम करें जो `int256` लौटाते हैं (property मोड के समान कॉन्फ़िगर करने योग्य उपसर्ग का उपयोग करता है)।
* **`exploration`**: गुणों की जांच किए बिना कवरेज एकत्र करें।
### कवरेज एकत्र करना और देखना
अभियान समाप्त करने के बाद, Echidna `corpusDir` कॉन्फ़िग विकल्प के साथ निर्दिष्ट एक विशेष निर्देशिका में कवरेज अधिकतम करने वाला **corpus** सहेज सकता है। इस निर्देशिका में दो प्रविष्टियाँ होंगी: (1) `coverage` नाम की एक निर्देशिका जिसमें JSON फ़ाइलें होंगी जिन्हें Echidna द्वारा फिर से चलाया जा सकता है और (2) `covered.txt` नाम की एक सादा-पाठ फ़ाइल, जो कवरेज एनोटेशन के साथ स्रोत कोड की एक प्रति है।
यदि आप `tests/solidity/basic/flags.sol` उदाहरण चलाते हैं, तो Echidna `coverage` निर्देशिका में कुछ फ़ाइलों में क्रमबद्ध लेनदेन और निम्नलिखित पंक्तियों के साथ एक `covered.$(date +%s).txt` फ़ाइल सहेजेगा:```text
*r | function set0(int val) public returns (bool){
* | if (val % 100 == 0)
* | flag0 = false;
}
*r | function set1(int val) public returns (bool){
* | if (val % 10 == 0 && !flag0)
* | flag1 = false;
}
```
हमारा टूल कॉर्पस में प्रत्येक निष्पादन ट्रेस को निम्नलिखित "लाइन मार्कर" के साथ चिह्नित करता है:
* `*` यदि कोई निष्पादन STOP के साथ समाप्त हुआ
* `r` यदि कोई निष्पादन REVERT के साथ समाप्त हुआ
* `o` यदि कोई निष्पादन out-of-gas त्रुटि के साथ समाप्त हुआ
* `e` यदि कोई निष्पादन किसी अन्य त्रुटि (शून्य विभाजन, assertion विफलता, आदि) के साथ समाप्त हुआ
### स्मार्ट कॉन्ट्रैक्ट बिल्ड सिस्टम के लिए समर्थन
Echidna विभिन्न स्मार्ट कॉन्ट्रैक्ट बिल्ड सिस्टम के साथ संकलित कॉन्ट्रैक्ट्स का परीक्षण कर सकता है, जिनमें [Foundry](https://book.getfoundry.sh/), [Hardhat](https://hardhat.org/), और [Truffle](https://archive.trufflesuite.com/) शामिल हैं, [crytic-compile](https://github.com/crytic/crytic-compile) का उपयोग करके। वर्तमान संकलन फ्रेमवर्क के साथ Echidna को आमंत्रित करने के लिए, `echidna .` का उपयोग करें।
इसके अतिरिक्त, Echidna जटिल कॉन्ट्रैक्ट्स के परीक्षण के दो मोड का समर्थन करता है। पहला, कोई व्यक्ति [मौजूदा नेटवर्क स्थिति का लाभ उठा](https://secure-contracts.com/program-analysis/echidna/advanced/state-network-forking.html) सकता है और उसे Echidna के लिए आधार स्थिति के रूप में उपयोग कर सकता है। दूसरा, Echidna CLI में संबंधित Solidity स्रोत पास करके किसी भी ज्ञात ABI वाले कॉन्ट्रैक्ट को कॉल कर सकता है। इसे सक्षम करने के लिए अपने कॉन्फ़िग में `allContracts: true` का उपयोग करें।
### Echidna पर क्रैश कोर्स
हमारे [Building Secure Smart Contracts](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna#echidna-tutorial) रिपॉजिटरी में Echidna पर एक क्रैश कोर्स है, जिसमें उदाहरण, पाठ और अभ्यास शामिल हैं।
### GitHub Actions वर्कफ़्लो में Echidna का उपयोग करना
एक Echidna एक्शन है जिसका उपयोग GitHub Actions वर्कफ़्लो के भाग के रूप में `echidna` चलाने के लिए किया जा सकता है। उपयोग निर्देशों और उदाहरणों के लिए कृपया [crytic/echidna-action](https://github.com/crytic/echidna-action) रिपॉजिटरी देखें।
### कॉन्फ़िगरेशन विकल्प
Echidna की CLI का उपयोग परीक्षण के लिए कॉन्ट्रैक्ट चुनने और एक कॉन्फ़िगरेशन फ़ाइल लोड करने के लिए किया जा सकता है।```sh
$ echidna contract.sol --contract TEST --config config.yaml
```
कॉन्फ़िगरेशन फ़ाइल उपयोगकर्ताओं को EVM और परीक्षण जनरेशन पैरामीटर चुनने की अनुमति देती है। डिफ़ॉल्ट विकल्पों के साथ एक पूर्ण और एनोटेटेड कॉन्फ़िग फ़ाइल का उदाहरण [tests/solidity/basic/default.yaml](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/default.yaml) पर पाया जा सकता है। उपलब्ध कॉन्फ़िगरेशन विकल्पों पर अधिक विस्तृत जानकारी के लिए [दस्तावेज़ीकरण](https://secure-contracts.com/program-analysis/echidna/configuration.html) देखें।
Echidna तीन अलग-अलग आउटपुट ड्राइवरों का समर्थन करता है। डिफ़ॉल्ट `text` ड्राइवर, एक `json` ड्राइवर, और एक `none` ड्राइवर है, जो सभी `stdout` आउटपुट को दबा देना चाहिए। JSON ड्राइवर समग्र अभियान की रिपोर्ट इस प्रकार करता है।```
Campaign = {
"success" : bool,
"error" : string?,
"tests" : [Test],
"seed" : number,
"coverage" : Coverage
}
Test = {
"contract" : string,
"name" : string,
"status" : string,
"error" : string?,
"testType" : string,
"transactions" : [Transaction]?
}
Transaction = {
"contract" : string,
"function" : string,
"arguments" : [string]?,
"gas" : number,
"gasprice" : number
}
```
`Coverage` एक dict है जो कुछ coverage-बढ़ाने वाले calls का वर्णन करता है। ये interfaces बाद की तारीख में थोड़े अधिक user-friendly बनाने के लिए परिवर्तन के अधीन हैं। `testType` इनमें से एक होगा: `property`, `assertion`, `optimization`, `exploration`, या `call`, और `status` हमेशा `fuzzing`, `shrinking`, `solved`, `passed`, या `error` में से एक लेता है।
### Debugging Performance Problems
Echidna की performance समस्याओं का निदान करने का एक तरीका है `echidna` को profiling के साथ चलाना। Echidna को basic profiling के साथ चलाने के लिए, अपने मूल `echidna` command में `+RTS -p -s` जोड़ें:```sh
$ nix develop # alternatively nix-shell
$ cabal --enable-profiling run echidna -- ... +RTS -p -s
$ less echidna.prof
```
यह एक रिपोर्ट फ़ाइल (`echidna.prof`) उत्पन्न करता है, जो दिखाती है कि कौन से फ़ंक्शन सबसे अधिक CPU और मेमोरी उपयोग लेते हैं।
यदि बुनियादी प्रोफाइलिंग से मदद नहीं मिलती है, तो आप अधिक [उन्नत प्रोफाइलिंग तकनीकों](https://haskell.foundation/hs-opt-handbook.github.io/src/Measurement_Observation/Haskell_Profiling/eventlog.html) का उपयोग कर सकते हैं।
प्रदर्शन समस्याओं के सामान्य कारण जो हमने देखे:
- हॉट पाथ में कॉल किए जाने वाले महंगे फ़ंक्शन
- आलसी डेटा कंस्ट्रक्टर जो थंक्स जमा करते हैं
- हॉट पाथ में उपयोग की जाने वाली अक्षम डेटा संरचनाएँ
इनकी जाँच करना शुरू करने के लिए एक अच्छी जगह है। यदि आपको संदेह है कि कोई गणना बहुत आलसी है और
मेमोरी लीक कर रही है, तो आप यह सुनिश्चित करने के लिए `Control.DeepSeq` से `force` का उपयोग कर सकते हैं कि इसका मूल्यांकन हो जाए।
## सीमाएँ और ज्ञात समस्याएँ
EVM अनुकरण और परीक्षण कठिन हैं। नवीनतम रिलीज़ में Echidna की कुछ सीमाएँ हैं। इनमें से कुछ
[hevm](https://github.com/argotorg/hevm) से विरासत में मिली हैं, जबकि कुछ डिज़ाइन/प्रदर्शन निर्णयों या हमारे कोड में साधारण बग्स के परिणाम हैं। हम उन्हें यहाँ उनके संबंधित इश्यू और स्थिति ("wont fix", "on hold", "in review", "fixed") के साथ सूचीबद्ध करते हैं। जो इश्यू "fixed" हैं, उन्हें अगली Echidna रिलीज़ में शामिल होने की अपेक्षा है।
| विवरण | इश्यू | स्थिति |
| :--- | :---: | :---: |
| Vyper समर्थन सीमित है | [#652](https://github.com/crytic/echidna/issues/652) | *wont fix* |
| परीक्षण के लिए सीमित लाइब्रेरी समर्थन | [#651](https://github.com/crytic/echidna/issues/651) | *wont fix* |
## इंस्टॉलेशन
### प्रीकंपाइल्ड बाइनरीज़
शुरू करने से पहले, सुनिश्चित करें कि Slither [इंस्टॉल](https://github.com/crytic/slither) है (`pip3 install slither-analyzer --user`)।
यदि आप Linux या MacOS में Echidna का त्वरित परीक्षण करना चाहते हैं, तो हम अपने [रिलीज़ पेज](https://github.com/crytic/echidna/releases) पर Ubuntu पर बनी स्टैटिकली लिंक्ड Linux बाइनरीज़ और अधिकतर स्टैटिक MacOS बाइनरीज़ प्रदान करते हैं। आप हमारी [CI पाइपलाइन](https://github.com/crytic/echidna/actions?query=workflow%3ACI+branch%3Amaster+event%3Apush) से भी इसी प्रकार की बाइनरीज़ प्राप्त कर सकते हैं, Linux या MacOS के लिए बाइनरीज़ खोजने के लिए बस कमिट पर क्लिक करें।
### Homebrew (macOS / Linux)
यदि आपके Mac या Linux मशीन पर Homebrew इंस्टॉल है, तो आप `brew install echidna` चलाकर Echidna और इसकी सभी निर्भरताएँ (Slither, crytic-compile) इंस्टॉल कर सकते हैं।
आप `brew install --HEAD echidna` चलाकर नवीनतम `master` ब्रांच कोड भी कंपाइल और इंस्टॉल कर सकते हैं।
आप [`echidna` Homebrew Formula](https://formulae.brew.sh/formula/echidna) पेज पर अधिक जानकारी प्राप्त कर सकते हैं। फ़ॉर्मूला स्वयं [homebrew-core रिपॉज़िटरी](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/e/echidna.rb) के भाग के रूप में अनुरक्षित है।
### Docker कंटेनर
यदि आप पहले से बने Docker कंटेनर का उपयोग करना पसंद करते हैं, तो हमारा [docker
पैकेज](https://github.com/orgs/crytic/packages?repo_name=echidna) देखें, जो
GitHub Actions के माध्यम से स्वतः बनाया जाता है। `echidna` कंटेनर
`ubuntu:noble` पर आधारित है और इसका उद्देश्य Echidna का उपयोग करने के लिए एक छोटी
लेकिन पर्याप्त लचीली इमेज होना है। यह `echidna` का पहले से बना संस्करण प्रदान करता है, साथ ही
`slither`, `crytic-compile`, `solc-select`, `nvm`, और `foundry` (जिसमें
`forge`, `cast`, `anvil`, और `chisel` शामिल हैं) 200 MB से कम में।
ध्यान दें कि कंटेनर इमेज वर्तमान में केवल x86 सिस्टम पर बनती हैं। उन्हें
ARM डिवाइस, जैसे Mac M1 सिस्टम, पर चलाने की अनुशंसा नहीं की जाती है क्योंकि CPU एमुलेशन के कारण
प्रदर्शन में हानि होती है।
Docker कंटेनर इमेज के लिए विभिन्न टैग उपलब्ध हैं:
| टैग | टैग में बिल्ड
|---------------|-------------
| `vx.y.z` | रिलीज़ `vx.y.z` के अनुरूप बिल्ड
| `latest` | नवीनतम Echidna टैग किया गया रिलीज़।
| `edge` | डिफ़ॉल्ट ब्रांच पर सबसे हालिया कमिट।
| `testing-foo` | `foo` ब्रांच पर आधारित परीक्षण बिल्ड।
नवीनतम Echidna संस्करण के साथ कंटेनर को इंटरैक्टिव रूप से चलाने के लिए, आप
निम्नलिखित कमांड जैसा कुछ उपयोग कर सकते हैं। यह वर्तमान डायरेक्टरी को कंटेनर के अंदर
`/src` के रूप में मैप करेगा, और आपको एक शेल देगा जहाँ आप
`echidna` का उपयोग कर सकते हैं:```sh
$ docker run --rm -it -v "$(pwd)":/src ghcr.io/crytic/echidna/echidna
```
अन्यथा, यदि आप Echidna का नवीनतम संस्करण स्थानीय रूप से बनाना चाहते हैं, तो हम Docker का उपयोग करने की सलाह देते हैं। इस रिपॉज़िटरी के क्लोन के भीतर से, Docker कंटेनर इमेज बनाने के लिए निम्नलिखित कमांड चलाएँ:```sh
$ docker build -t echidna -f docker/Dockerfile --target final-ubuntu .
```
फिर, आप `echidna` इमेज को लोकली चला सकते हैं। उदाहरण के लिए, solc
0.5.7 इंस्टॉल करने और `tests/solidity/basic/flags.sol` की जाँच करने के लिए, आप चला सकते हैं:```sh
$ docker run -it -v "$(pwd)":/src echidna bash -c "solc-select install 0.5.7 && solc-select use 0.5.7 && echidna /src/tests/solidity/basic/flags.sol"
```
Docker इमेज में व्यापक स्मार्ट कॉन्ट्रैक्ट डेवलपमेंट और परीक्षण के लिए Foundry टूल्स भी शामिल हैं। आप कंटेनर में सीधे `forge`, `cast`, `anvil`, और `chisel` का उपयोग कर सकते हैं:```sh
# Run an interactive shell with Foundry tools available
$ docker run -it -v "$(pwd)":/src echidna bash
# Inside the container, you can use Foundry commands:
$ forge --version
$ cast --version
$ anvil --version
$ chisel --version
# Example: Initialize a new Foundry project
$ forge init my-project
$ cd my-project
$ forge build
$ forge test
```
### Stack का उपयोग करके बिल्ड करना
यदि आप सोर्स से बिल्ड करना पसंद करते हैं, तो [Stack](https://docs.haskellstack.org/en/stable/) का उपयोग करें। `stack install` को `~/.local/bin` में `echidna` को बिल्ड और कंपाइल करना चाहिए। आपको libreadline और libsecp256k1 (recovery सक्षम के साथ बिल्ड किया गया) के विरुद्ध लिंक करना होगा, जिसे आपकी पसंद के पैकेज मैनेजर के साथ इंस्टॉल किया जाना चाहिए। आपको [libff](https://github.com/scipr-lab/libff) का नवीनतम रिलीज़ भी इंस्टॉल करना होगा। मार्गदर्शन के लिए हमारे [CI टेस्ट](https://github.com/crytic/echidna/blob/master/.github/scripts/install-libff.sh) देखें।
कुछ Linux डिस्ट्रीब्यूशन कुछ चीज़ों के लिए स्टैटिक लाइब्रेरी शिप नहीं करते जिनकी Haskell को आवश्यकता होती है, जैसे Arch Linux, जिसके कारण `stack build` लिंकिंग त्रुटियों के साथ विफल हो जाएगा क्योंकि हम `-static` फ्लैग का उपयोग करते हैं। उस स्थिति में, डायनामिक रूप से लिंक किया गया बाइनरी बनाने के लिए `--flag echidna:-static` का उपयोग करें।
यदि आपको लिंकिंग से संबंधित बिल्ड त्रुटियाँ आ रही हैं, तो `--extra-include-dirs` और `--extra-lib-dirs` के साथ प्रयोग करके देखें।
### Nix का उपयोग करके बिल्ड करना (Apple M1 सिस्टम पर नेटिव रूप से काम करता है)
[Nix उपयोगकर्ता](https://nixos.org/download/) निम्नलिखित के साथ नवीनतम Echidna इंस्टॉल कर सकते हैं:```sh
$ nix-env -i -f https://github.com/crytic/echidna/tarball/master
```
फ्लेक्स सक्षम होने पर, आप Echidna को सीधे इस रेपो से चला सकते हैं:```sh
$ nix run github:crytic/echidna # master
$ nix run github:crytic/echidna/v2.1.1 # specific ref (tag/branch/commit)
```
Nix-रहित macOS सिस्टम के लिए एक स्टैंडअलोन रिलीज़ बनाने के लिए, निम्नलिखित Echidna को अधिकतर स्टैटिक बाइनरी में बनाएगा। इसका उपयोग Linux सिस्टम पर पूरी तरह से स्टैटिक बाइनरी बनाने के लिए भी किया जा सकता है।```sh
$ nix build .#echidna-redistributable
```
Nix विकास के लिए आवश्यक सभी निर्भरताएँ स्वचालित रूप से इंस्टॉल कर देगा
जिसमें `crytic-compile` और `solc` शामिल हैं। Echidna का विकास शुरू करने का एक त्वरित तरीका:```sh
$ git clone https://github.com/crytic/echidna
$ cd echidna
$ nix develop # alternatively nix-shell
[nix-shell]$ cabal run echidna
[nix-shell]$ cabal run tests
[nix-shell]$ cabal new-repl
```
### टेस्ट सूट चलाना
`cabal run tests` Haskell सूट है, और Echidna जो कुछ भी प्रक्रिया में करता है, उसे कवर करता है।
```
---
[Read more](https://github.com/crytic/echidna)
