---
title: "தொடக்கநிலையாளர்களுக்கான ஹலோ வேர்ல்ட் திறன் ஒப்பந்தம்"
description: "எத்திரியத்தில் ஒரு எளிய திறன் ஒப்பந்தத்தை எழுதி நிலைநிறுத்துவது குறித்த அறிமுகப் பயிற்சி."
author: "எலான்"
tags: ["Solidity", "Hardhat", "Alchemy", "திறன் ஒப்பந்தங்கள்", "நிலைநிறுத்துதல்"]
skill: beginner
breadcrumb: "ஹலோ வேர்ல்ட் ஒப்பந்தம்"
lang: ta
published: 2021-03-31
---

தொகுதிச்சங்கிலி மேம்பாட்டிற்கு நீங்கள் புதியவராக இருந்து, எங்கிருந்து தொடங்குவது என்று தெரியவில்லை என்றால், அல்லது திறன் ஒப்பந்தங்களை எவ்வாறு நிலைநிறுத்துவது மற்றும் அவற்றுடன் தொடர்புகொள்வது என்பதைப் புரிந்துகொள்ள விரும்பினால், இந்த வழிகாட்டி உங்களுக்கானது. மெய்நிகர் பணப்பையான [மெட்டாமேஸ்க்](https://metamask.io/), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/) மற்றும் [Alchemy](https://www.alchemy.com/eth) ஆகியவற்றைப் பயன்படுத்தி Sepolia சோதனைப் பிணையத்தில் ஒரு எளிய திறன் ஒப்பந்தத்தை உருவாக்கி நிலைநிறுத்துவது குறித்து நாங்கள் விளக்குவோம் (இவை எதைக் குறிக்கின்றன என்று உங்களுக்கு இன்னும் புரியவில்லை என்றால் கவலைப்பட வேண்டாம், நாங்கள் அதை விளக்குவோம்).

இந்தப் பயிற்சியின் [பகுதி 2](/developers/tutorials/hello-world-smart-contract-fullstack/#part-2-interact-with-your-smart-contract) இல், நமது திறன் ஒப்பந்தம் இங்கு நிலைநிறுத்தப்பட்டவுடன் அதனுடன் எவ்வாறு தொடர்புகொள்ளலாம் என்பதைப் பார்ப்போம், மேலும் [பகுதி 3](/developers/tutorials/hello-world-smart-contract-fullstack/#part-3-publish-your-smart-contract-to-etherscan) இல் அதை Etherscan இல் எவ்வாறு வெளியிடுவது என்பதைப் பற்றி விவாதிப்போம்.

எந்த நேரத்திலும் உங்களுக்குக் கேள்விகள் இருந்தால், [Alchemy டிஸ்கார்ட்](https://discord.gg/gWuC7zB) இல் தயங்காமல் தொடர்புகொள்ளவும்!

## படி 1: எத்திரியம் பிணையத்துடன் இணைக்கவும் {#step-1}

எத்திரியம் சங்கிலிக்குக் கோரிக்கைகளை அனுப்பப் பல வழிகள் உள்ளன. எளிமைக்காக, Alchemy இல் உள்ள இலவசக் கணக்கைப் பயன்படுத்துவோம், இது ஒரு தொகுதிச்சங்கிலி டெவலப்பர் தளம் மற்றும் API ஆகும், இது நமது சொந்தக் கணுக்களை இயக்காமலேயே எத்திரியம் சங்கிலியுடன் தொடர்புகொள்ள அனுமதிக்கிறது. இந்தத் தளத்தில் கண்காணிப்பு மற்றும் பகுப்பாய்விற்கான டெவலப்பர் கருவிகளும் உள்ளன, நமது திறன் ஒப்பந்த நிலைநிறுத்தத்தில் உள்முகமாக என்ன நடக்கிறது என்பதைப் புரிந்துகொள்ள இந்தப் பயிற்சியில் அவற்றைப் பயன்படுத்திக்கொள்வோம். உங்களிடம் ஏற்கனவே Alchemy கணக்கு இல்லையென்றால், [இங்கே இலவசமாகப் பதிவு செய்யலாம்](https://dashboard.alchemy.com/signup).

## படி 2: உங்கள் செயலியை (மற்றும் API திறவுகோலை) உருவாக்கவும் {#step-2}

நீங்கள் Alchemy கணக்கை உருவாக்கியவுடன், ஒரு செயலியை உருவாக்குவதன் மூலம் API திறவுகோலை உருவாக்கலாம். இது Sepolia சோதனைப் பிணையத்திற்குக் கோரிக்கைகளை அனுப்ப அனுமதிக்கும். சோதனைப் பிணையங்கள் (testnets) பற்றி உங்களுக்குத் தெரியாவிட்டால், [இந்தப் பக்கத்தைப்](/developers/docs/networks/) பார்க்கவும்.

1.  உங்கள் Alchemy டாஷ்போர்டில் உள்ள வழிசெலுத்தல் பட்டியில் (nav bar) "Select an app" என்பதைத் தேர்ந்தெடுத்து, "Create new app" என்பதைக் கிளிக் செய்வதன் மூலம் "Create new app" பக்கத்திற்குச் செல்லவும்.

![Hello world create app](./hello-world-create-app.png)

2. உங்கள் செயலிக்கு “Hello World” என்று பெயரிட்டு, ஒரு சிறிய விளக்கத்தை அளித்து, பயன்பாட்டு வகையைத் தேர்ந்தெடுக்கவும், எ.கா., "Infra & Tooling." அடுத்து, "Ethereum" என்று தேடி, பிணையத்தைத் தேர்ந்தெடுக்கவும்.

![create app view hello world](./create-app-view-hello-world.png)

3. தொடர "Next" என்பதைக் கிளிக் செய்து, பின்னர் “Create app” என்பதைக் கிளிக் செய்யவும், அவ்வளவுதான்! நகலெடுக்கக் கிடைக்கக்கூடிய API திறவுகோலுடன், உங்கள் செயலி வழிசெலுத்தல் பட்டி கீழ்தோன்றும் மெனுவில் (dropdown menu) தோன்ற வேண்டும்.

## படி 3: ஒரு எத்திரியம் கணக்கை (முகவரியை) உருவாக்கவும் {#step-3}

பரிவர்த்தனைகளை அனுப்பவும் பெறவும் நமக்கு ஒரு எத்திரியம் கணக்கு தேவை. இந்தப் பயிற்சிக்காக, உங்கள் எத்திரியம் கணக்கு முகவரியை நிர்வகிக்கப் பயன்படும் உலாவியில் உள்ள மெய்நிகர் பணப்பையான மெட்டாமேஸ்க்-ஐப் பயன்படுத்துவோம். [பரிவர்த்தனைகள்](/developers/docs/transactions/) பற்றி மேலும் அறிய.

நீங்கள் மெட்டாமேஸ்க்-ஐப் பதிவிறக்கம் செய்து, [இங்கே](https://metamask.io/download) இலவசமாக ஒரு எத்திரியம் கணக்கை உருவாக்கலாம். நீங்கள் ஒரு கணக்கை உருவாக்கும்போது, அல்லது உங்களிடம் ஏற்கனவே கணக்கு இருந்தால், பிணையக் கீழ்தோன்றும் மெனுவைப் பயன்படுத்தி "Sepolia" சோதனைப் பிணையத்திற்கு மாறுவதை உறுதிசெய்து கொள்ளவும் (இதனால் நாம் உண்மையான பணத்தைக் கையாள மாட்டோம்).

பட்டியலில் Sepolia-வைக் காணவில்லை என்றால், மெனுவிற்குச் சென்று, பின்னர் Advanced-க்குச் சென்று, கீழே ஸ்க்ரோல் செய்து "Show test networks" என்பதை ஆன் செய்யவும். பிணையத் தேர்வு மெனுவில், சோதனைப் பிணையங்களின் பட்டியலைக் கண்டறிய "Custom" தாவலைத் தேர்ந்தெடுத்து "Sepolia" என்பதைத் தேர்ந்தெடுக்கவும்.

![metamask sepolia example](./metamask-sepolia-example.png)

## படி 4: ஒரு பாசெட்டிலிருந்து ஈதரைச் சேர்க்கவும் {#step-4}

நமது திறன் ஒப்பந்தத்தைச் சோதனைப் பிணையத்தில் நிலைநிறுத்த, நமக்குச் சில போலி ETH தேவைப்படும். Sepolia ETH-ஐப் பெற, பல்வேறு பாசெட்களின் பட்டியலைக் காண [Sepolia பிணைய விவரங்களுக்குச்](/developers/docs/networks/#sepolia) செல்லலாம். ஒன்று வேலை செய்யவில்லை என்றால், மற்றொன்றை முயற்சிக்கவும், ஏனெனில் அவை சில நேரங்களில் காலியாகிவிடலாம். பிணைய நெரிசல் காரணமாக உங்கள் போலி ETH-ஐப் பெறச் சிறிது நேரம் ஆகலாம். சிறிது நேரத்திலேயே உங்கள் மெட்டாமேஸ்க் கணக்கில் ETH-ஐக் காண முடியும்!

## படி 5: உங்கள் இருப்பைச் சரிபார்க்கவும் {#step-5}

நமது இருப்பு உள்ளதா என்பதை மீண்டும் சரிபார்க்க, [Alchemy-இன் கம்போஸர் கருவியைப்](https://sandbox.alchemy.com/?network=ETH_SEPOLIA&method=eth_getBalance&body.id=1&body.jsonrpc=2.0&body.method=eth_getBalance&body.params%5B0%5D=&body.params%5B1%5D=latest) பயன்படுத்தி ஒரு [eth_getBalance](/developers/docs/apis/json-rpc/#eth_getbalance) கோரிக்கையை அனுப்புவோம். இது நமது பணப்பையில் உள்ள ETH அளவை வழங்கும். உங்கள் மெட்டாமேஸ்க் கணக்கு முகவரியை உள்ளிட்டு “Send Request” என்பதைக் கிளிக் செய்த பிறகு, இது போன்ற ஒரு பதிலைக் காண வேண்டும்:

```json
{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }
```

> **குறிப்பு:** இந்த முடிவு Wei-இல் உள்ளது, ETH-இல் அல்ல. ஈதரின் மிகச்சிறிய மதிப்பாக Wei பயன்படுத்தப்படுகிறது. Wei-லிருந்து ETH-க்கு மாற்றுவது: 1 eth = 10<sup>18</sup> wei. எனவே 0x2B5E3AF16B1880000 என்பதை தசமமாக மாற்றினால் 5\*10¹⁸ கிடைக்கும், இது 5 ETH-க்குச் சமம்.
>
> அப்பாடா! நமது போலிப் பணம் முழுவதும் அங்கேயே உள்ளது <Emoji text=":money_mouth_face:" size={1} />.

## படி 6: நமது திட்டத்தைத் துவக்கவும் {#step-6}

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

```
mkdir hello-world
cd hello-world
```

இப்போது நாம் நமது திட்டக் கோப்புறைக்குள் இருப்பதால், திட்டத்தைத் துவக்க `npm init`-ஐப் பயன்படுத்துவோம். உங்களிடம் ஏற்கனவே npm நிறுவப்படவில்லை என்றால், [Node.js நிறுவல் வழிமுறைகளைப்](https://nodejs.org/en/download/) பின்பற்றவும் (இந்தப் பயிற்சிக்கு நமக்கு Node.js மற்றும் npm தேவைப்படும்).

```
npm init
```

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

```
package name: (hello-world)
version: (1.0.0)
description: hello world smart contract
entry point: (index.js)
test command:
git repository:
keywords:
author:
license: (ISC)
About to write to /Users/.../.../.../hello-world/package.json:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "hello world smart contract",
  "main": "index.js",
  "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}
```

package.json-க்கு ஒப்புதல் அளிக்கவும், நாம் தொடங்குவதற்குத் தயாராகிவிட்டோம்!
## படி 7: [Hardhat](https://hardhat.org/getting-started/#overview)-ஐப் பதிவிறக்கவும் {#step-7}

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

நமது `hello-world` திட்டத்திற்குள் இயக்கவும்:

```
npm install --save-dev hardhat
```

[நிறுவல் வழிமுறைகள்](https://hardhat.org/getting-started/#overview) குறித்த கூடுதல் விவரங்களுக்கு இந்தப் பக்கத்தைப் பார்க்கவும்.

## படி 8: Hardhat திட்டத்தை உருவாக்கவும் {#step-8}

நமது திட்டக் கோப்புறைக்குள் இயக்கவும்:

```
npx hardhat
```

நீங்கள் ஒரு வரவேற்புச் செய்தியையும், நீங்கள் என்ன செய்ய விரும்புகிறீர்கள் என்பதைத் தேர்ந்தெடுப்பதற்கான விருப்பத்தையும் காண வேண்டும். “create an empty hardhat.config.js” என்பதைத் தேர்ந்தெடுக்கவும்:

```
888    888                      888 888               888
888    888                      888 888               888
888    888                      888 888               888
8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
888    888 .d888888 888    888  888 888  888 .d888888 888
888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888

👷 Welcome to Hardhat v2.0.11 👷‍?

What do you want to do? …
Create a sample project
❯ Create an empty hardhat.config.js
Quit
```

இது நமக்காக ஒரு `hardhat.config.js` கோப்பை உருவாக்கும், அங்குதான் நமது திட்டத்திற்கான அனைத்து அமைப்புகளையும் குறிப்பிடுவோம் (படி 13 இல்).

## படி 9: திட்டக் கோப்புறைகளைச் சேர்க்கவும் {#step-9}

நமது திட்டத்தை ஒழுங்கமைக்க இரண்டு புதிய கோப்புறைகளை உருவாக்குவோம். உங்கள் கட்டளை வரியில் உங்கள் திட்டத்தின் மூலக் கோப்பகத்திற்குச் (root directory) சென்று தட்டச்சு செய்யவும்:

```
mkdir contracts
mkdir scripts
```

- `contracts/` என்பது நமது ஹலோ வேர்ல்ட் திறன் ஒப்பந்தக் குறியீட்டுக் கோப்பை வைத்திருக்கும் இடமாகும்
- `scripts/` என்பது நமது ஒப்பந்தத்தை நிலைநிறுத்தவும் அதனுடன் தொடர்புகொள்ளவுமான ஸ்கிரிப்ட்களை வைத்திருக்கும் இடமாகும்

## படி 10: நமது ஒப்பந்தத்தை எழுதவும் {#step-10}

நாம் எப்போதுதான் குறியீட்டை எழுதப் போகிறோம் என்று நீங்கள் உங்களைக் கேட்டுக்கொள்ளலாம்?? இதோ, படி 10-க்கு வந்துவிட்டோம்.

உங்களுக்குப் பிடித்த எடிட்டரில் hello-world திட்டத்தைத் திறக்கவும் (நாங்கள் [VSCode](https://code.visualstudio.com/)-ஐ விரும்புகிறோம்). திறன் ஒப்பந்தங்கள் Solidity எனப்படும் மொழியில் எழுதப்படுகின்றன, அதைத்தான் நமது HelloWorld.sol திறன் ஒப்பந்தத்தை எழுதப் பயன்படுத்துவோம்.‌

1.  “contracts” கோப்புறைக்குச் சென்று HelloWorld.sol என்ற புதிய கோப்பை உருவாக்கவும்
2.  இந்தப் பயிற்சிக்காக நாம் பயன்படுத்தப் போகும் எத்தீரியம் அறக்கட்டளையின் மாதிரி ஹலோ வேர்ல்ட் திறன் ஒப்பந்தம் கீழே கொடுக்கப்பட்டுள்ளது. கீழே உள்ள உள்ளடக்கங்களை நகலெடுத்து உங்கள் HelloWorld.sol கோப்பில் ஒட்டவும், மேலும் இந்த ஒப்பந்தம் என்ன செய்கிறது என்பதைப் புரிந்துகொள்ளக் கருத்துகளைப் (comments) படிக்க மறக்காதீர்கள்:

```solidity
// சொற்பொருள் பதிப்பாக்கத்தைப் பயன்படுத்தி, Solidity பதிப்பைக் குறிப்பிடுகிறது.
// மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
pragma solidity ^0.7.0;

// `HelloWorld` என்ற பெயரிலான ஒரு ஒப்பந்தத்தை வரையறுக்கிறது.
// ஒரு ஒப்பந்தம் என்பது செயல்பாடுகள் மற்றும் தரவுகளின் (அதன் நிலை) தொகுப்பாகும். நிலைநிறுத்தப்பட்டவுடன், ஒரு ஒப்பந்தம் எத்திரியம் தொகுதிச்சங்கிலியில் ஒரு குறிப்பிட்ட முகவரியில் இருக்கும். மேலும் அறிக: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
contract HelloWorld {

   // `string` வகையிலான `message` என்ற நிலை மாறியை அறிவிக்கிறது.
   // நிலை மாறிகள் என்பவை ஒப்பந்த சேமிப்பகத்தில் நிரந்தரமாக மதிப்புகளைச் சேமிக்கும் மாறிகளாகும். `public` என்ற சிறப்புச்சொல் ஒரு ஒப்பந்தத்திற்கு வெளியிலிருந்து மாறிகளை அணுகக்கூடியதாக மாற்றுகிறது, மேலும் மதிப்பை அணுகுவதற்கு மற்ற ஒப்பந்தங்கள் அல்லது கிளையண்டுகள் அழைக்கக்கூடிய ஒரு செயல்பாட்டை உருவாக்குகிறது.
   string public message;

   // பல வகுப்பு அடிப்படையிலான பொருள் சார்ந்த மொழிகளைப் போலவே, கன்ஸ்ட்ரக்டர் (constructor) என்பது ஒப்பந்தம் உருவாக்கப்படும் போது மட்டுமே செயல்படுத்தப்படும் ஒரு சிறப்புச் செயல்பாடாகும்.
   // ஒப்பந்தத்தின் தரவைத் துவக்க கன்ஸ்ட்ரக்டர்கள் பயன்படுத்தப்படுகின்றன. மேலும் அறிக:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
   constructor(string memory initMessage) {

      // `initMessage` என்ற ஸ்ட்ரிங் (string) அளபுருவை ஏற்றுக்கொண்டு, ஒப்பந்தத்தின் `message` சேமிப்பக மாறியில் மதிப்பை அமைக்கிறது).
      message = initMessage;
   }

   // ஒரு ஸ்ட்ரிங் (string) அளபுருவை ஏற்றுக்கொண்டு `message` சேமிப்பக மாறியைப் புதுப்பிக்கும் ஒரு பொதுவான (public) செயல்பாடு.
   function update(string memory newMessage) public {
      message = newMessage;
   }
}
```

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

## படி 11: உங்கள் திட்டத்துடன் மெட்டாமேஸ்க் மற்றும் Alchemy-ஐ இணைக்கவும் {#step-11}

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

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

> பரிவர்த்தனைகளை அனுப்புவது பற்றி மேலும் அறிய, Web3-ஐப் பயன்படுத்திப் பரிவர்த்தனைகளை அனுப்புவது குறித்த [இந்தப் பயிற்சியைப்](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) பார்க்கவும்.

முதலில், உங்கள் திட்டக் கோப்பகத்தில் dotenv தொகுப்பை நிறுவவும்:

```
npm install dotenv --save
```

பின்னர், நமது திட்டத்தின் மூலக் கோப்பகத்தில் ஒரு `.env` கோப்பை உருவாக்கி, அதில் உங்கள் மெட்டாமேஸ்க் தனிப்பட்ட திறவுகோல் மற்றும் HTTP Alchemy API URL-ஐச் சேர்க்கவும்.

- உங்கள் தனிப்பட்ட திறவுகோலை ஏற்றுமதி செய்ய [இந்த வழிமுறைகளைப்](https://support.metamask.io/configure/accounts/how-to-export-an-accounts-private-key/) பின்பற்றவும்
- HTTP Alchemy API URL-ஐப் பெறக் கீழே பார்க்கவும்

![get alchemy api key](./get-alchemy-api-key.png)

Alchemy API URL-ஐ நகலெடுக்கவும்

உங்கள் `.env` இதுபோன்று இருக்க வேண்டும்:

```
API_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
PRIVATE_KEY = "your-metamask-private-key"
```

இவற்றை நமது குறியீட்டுடன் இணைக்க, படி 13 இல் உள்ள நமது `hardhat.config.js` கோப்பில் இந்த மாறிகளைக் (variables) குறிப்பிடுவோம்.

<Alert variant="warning">
<AlertContent>
<AlertDescription>
<code>.env</code>-ஐ கமிட் செய்ய வேண்டாம்! உங்கள் <code>.env</code> கோப்பை யாருடனும் பகிரவோ அல்லது வெளிப்படுத்தவோ வேண்டாம் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள், அவ்வாறு செய்வதன் மூலம் உங்கள் ரகசியங்களை நீங்கள் சமரசம் செய்கிறீர்கள். நீங்கள் பதிப்புக் கட்டுப்பாட்டைப் (version control) பயன்படுத்தினால், உங்கள் <code>.env</code>-ஐ ஒரு <a href="https://git-scm.com/docs/gitignore">gitignore</a> கோப்பில் சேர்க்கவும்.
</AlertDescription>
</AlertContent>
</Alert>

## படி 12: Ethers.js-ஐ நிறுவவும் {#step-12-install-ethersjs}

Ethers.js என்பது [நிலையான ஜேசன்-ஆர்பிசி முறைகளை](/developers/docs/apis/json-rpc/) அதிகப் பயனர் நட்பு முறைகளுடன் மூடுவதன் மூலம் எத்திரியத்துடன் தொடர்புகொள்வதையும் கோரிக்கைகளை அனுப்புவதையும் எளிதாக்கும் ஒரு நிரலகம் ஆகும்.

கூடுதல் கருவிகள் மற்றும் நீட்டிக்கப்பட்ட செயல்பாட்டிற்கான [செருகுநிரல்களை (Plugins)](https://hardhat.org/plugins/) ஒருங்கிணைப்பதை Hardhat மிகவும் எளிதாக்குகிறது. ஒப்பந்த நிலைநிறுத்தத்திற்கு [Ethers செருகுநிரலைப்](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) பயன்படுத்திக் கொள்வோம் ([Ethers.js](https://github.com/ethers-io/ethers.js/) சில மிகச் சிறந்த ஒப்பந்த நிலைநிறுத்த முறைகளைக் கொண்டுள்ளது).

உங்கள் திட்டக் கோப்பகத்தில் தட்டச்சு செய்யவும்:

```
npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0"
```

அடுத்த படியில் நமது `hardhat.config.js` இல் ethers-உம் தேவைப்படும்.

## படி 13: hardhat.config.js-ஐப் புதுப்பிக்கவும் {#step-13-update-hardhatconfigjs}

இதுவரை பல சார்புகளையும் (dependencies) செருகுநிரல்களையும் சேர்த்துள்ளோம், இப்போது நமது திட்டத்திற்கு அவை அனைத்தையும் பற்றித் தெரியப்படுத்த `hardhat.config.js`-ஐப் புதுப்பிக்க வேண்டும்.

உங்கள் `hardhat.config.js`-ஐ இதுபோன்று புதுப்பிக்கவும்:

```
require('dotenv').config();

require("@nomiclabs/hardhat-ethers");
const { API_URL, PRIVATE_KEY } = process.env;

/**
* @type import('hardhat/config').HardhatUserConfig
*/
module.exports = {
   solidity: "0.7.3",
   defaultNetwork: "sepolia",
   networks: {
      hardhat: {},
      sepolia: {
         url: API_URL,
         accounts: [`0x${PRIVATE_KEY}`]
      }
   },
}
```

## படி 14: நமது ஒப்பந்தத்தைத் தொகுக்கவும் {#step-14-compile-our-contracts}

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

கட்டளை வரியிலிருந்து இயக்கவும்:

```
npx hardhat compile
```

`SPDX license identifier not provided in source file` பற்றி உங்களுக்கு ஒரு எச்சரிக்கை வரலாம், ஆனால் அதைப் பற்றிக் கவலைப்படத் தேவையில்லை — மற்ற அனைத்தும் நன்றாக இருக்கும் என்று நம்புகிறோம்! இல்லையென்றால், நீங்கள் எப்போதும் [Alchemy டிஸ்கார்ட்](https://discord.gg/u72VCg3) இல் செய்தி அனுப்பலாம்.

## படி 15: நமது நிலைநிறுத்த ஸ்கிரிப்டை எழுதவும் {#step-15-write-our-deploy-scripts}

இப்போது நமது ஒப்பந்தம் எழுதப்பட்டு, நமது உள்ளமைவுக் கோப்பு (configuration file) தயாராக உள்ளதால், நமது ஒப்பந்த நிலைநிறுத்த ஸ்கிரிப்டை எழுத வேண்டிய நேரம் இது.

`scripts/` கோப்புறைக்குச் சென்று `deploy.js` என்ற புதிய கோப்பை உருவாக்கி, அதில் பின்வரும் உள்ளடக்கங்களைச் சேர்க்கவும்:

```
async function main() {
   const HelloWorld = await ethers.getContractFactory("HelloWorld");

   // நிலைநிறுத்தத்தைத் தொடங்கவும், இது ஒரு ஒப்பந்தப் பொருளாகத் தீர்க்கப்படும் ஒரு வாக்குறுதியை (promise) வழங்கும்
   const hello_world = await HelloWorld.deploy("Hello World!");
   console.log("Contract deployed to address:", hello_world.address);}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });
```

இந்தக் குறியீட்டின் ஒவ்வொரு வரியும் என்ன செய்கிறது என்பதை Hardhat அவர்களின் [ஒப்பந்தப் பயிற்சியில்](https://hardhat.org/tutorial/testing-contracts.html#writing-tests) மிகச் சிறப்பாக விளக்குகிறது, அவர்களின் விளக்கங்களை நாங்கள் இங்கே ஏற்றுக்கொண்டுள்ளோம்.

```
const HelloWorld = await ethers.getContractFactory("HelloWorld");
```

ethers.js இல் உள்ள `ContractFactory` என்பது புதிய திறன் ஒப்பந்தங்களை நிலைநிறுத்தப் பயன்படுத்தப்படும் ஒரு சுருக்கமாகும் (abstraction), எனவே இங்குள்ள `HelloWorld` என்பது நமது ஹலோ வேர்ல்ட் ஒப்பந்தத்தின் நிகழ்வுகளுக்கான (instances) ஒரு தொழிற்சாலையாகும். `hardhat-ethers` செருகுநிரலைப் பயன்படுத்தும்போது `ContractFactory` மற்றும் `Contract` நிகழ்வுகள் இயல்பாகவே முதல் கையொப்பமிடுபவருடன் இணைக்கப்படும்.

```
const hello_world = await HelloWorld.deploy();
```

ஒரு `ContractFactory` இல் `deploy()`-ஐ அழைப்பது நிலைநிறுத்தத்தைத் தொடங்கும், மேலும் ஒரு `Contract` ஆகத் தீர்க்கப்படும் ஒரு `Promise`-ஐ வழங்கும். இது நமது திறன் ஒப்பந்தச் செயல்பாடுகள் ஒவ்வொன்றிற்கும் ஒரு முறையைக் கொண்ட பொருளாகும்.

## படி 16: நமது ஒப்பந்தத்தை நிலைநிறுத்தவும் {#step-16-deploy-our-contract}

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

```
npx hardhat run scripts/deploy.js --network sepolia
```

நீங்கள் இது போன்ற ஒன்றைக் காண வேண்டும்:

```
Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
```

நாம் [Sepolia Etherscan](https://sepolia.etherscan.io/)-க்குச் சென்று நமது ஒப்பந்த முகவரியைத் தேடினால், அது வெற்றிகரமாக நிலைநிறுத்தப்பட்டிருப்பதைக் காண முடியும். பரிவர்த்தனை இதுபோன்று இருக்கும்:

![etherscan contract](./etherscan-contract.png)

`From` முகவரி உங்கள் மெட்டாமேஸ்க் கணக்கு முகவரியுடன் பொருந்த வேண்டும், மேலும் To முகவரி “Contract Creation” என்று கூறும், ஆனால் நாம் பரிவர்த்தனையைக் கிளிக் செய்தால் `To` புலத்தில் நமது ஒப்பந்த முகவரியைக் காண்போம்:

![etherscan transaction](./etherscan-transaction.png)

வாழ்த்துகள்! நீங்கள் எத்திரியம் சங்கிலியில் ஒரு திறன் ஒப்பந்தத்தை நிலைநிறுத்திவிட்டீர்கள் 🎉

உள்முகமாக என்ன நடக்கிறது என்பதைப் புரிந்துகொள்ள, நமது [Alchemy டாஷ்போர்டில்](https://dashboard.alchemy.com/explorer) உள்ள Explorer தாவலுக்குச் செல்வோம். உங்களிடம் பல Alchemy செயலிகள் இருந்தால், செயலி வாரியாக வடிகட்டி “Hello World” என்பதைத் தேர்ந்தெடுப்பதை உறுதிசெய்யவும்.
![hello world explorer](./hello-world-explorer.png)

நாம் `.deploy()` செயல்பாட்டை அழைத்தபோது Hardhat/Ethers நமக்காக உள்முகமாகச் செய்த சில ஜேசன்-ஆர்பிசி அழைப்புகளை இங்கே காண்பீர்கள். இங்கே குறிப்பிட வேண்டிய இரண்டு முக்கியமானவை [`eth_sendRawTransaction`](https://www.alchemy.com/docs/chains/ethereum/ethereum-api-endpoints/eth-send-raw-transaction), இது நமது ஒப்பந்தத்தை Sepolia சங்கிலியில் எழுதுவதற்கான கோரிக்கையாகும், மற்றும் [`eth_getTransactionByHash`](https://www.alchemy.com/docs/chains/ethereum/ethereum-api-endpoints/eth-get-transaction-by-hash), இது ஹாஷ் கொடுக்கப்பட்ட நமது பரிவர்த்தனை பற்றிய தகவலைப் படிப்பதற்கான கோரிக்கையாகும் (பரிவர்த்தனைகளைச் செய்யும்போது இது ஒரு பொதுவான முறை). பரிவர்த்தனைகளை அனுப்புவது பற்றி மேலும் அறிய, [Web3-ஐப் பயன்படுத்திப் பரிவர்த்தனைகளை அனுப்புவது](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) குறித்த இந்தப் பயிற்சியைப் பார்க்கவும்.

இந்தப் பயிற்சியின் பகுதி 1-க்கு அவ்வளவுதான், பகுதி 2 இல் நமது ஆரம்பச் செய்தியைப் புதுப்பிப்பதன் மூலம் [நமது திறன் ஒப்பந்தத்துடன் தொடர்புகொள்வோம்](/developers/tutorials/hello-world-smart-contract-fullstack/#part-2-interact-with-your-smart-contract), மேலும் பகுதி 3 இல் [நமது திறன் ஒப்பந்தத்தை Etherscan இல் வெளியிடுவோம்](/developers/tutorials/hello-world-smart-contract-fullstack/#part-3-publish-your-smart-contract-to-etherscan), இதன் மூலம் அதனுடன் எவ்வாறு தொடர்புகொள்வது என்பதை அனைவரும் அறிந்துகொள்வார்கள்.

**Alchemy பற்றி மேலும் அறிய விரும்புகிறீர்களா? எங்கள் [இணையதளத்தைப்](https://www.alchemy.com/eth) பார்க்கவும். எந்தவொரு புதுப்பிப்பையும் தவறவிட விரும்பவில்லையா? எங்கள் செய்திமடலுக்கு [இங்கே](https://www.alchemy.com/newsletter) குழுசேரவும்! எங்கள் [டிஸ்கார்ட்](https://discord.gg/u72VCg3) இலும் இணைவதை உறுதிசெய்யவும்.**.