Inteligentny kontrakt Hello World dla początkujących

Solidity

Hardhat

Alchemy

smart kontrakty

wdrażanie

Początkujący

elanh

31 marca 2021

11 minuta czytania

Jeśli dopiero zaczynasz przygodę z tworzeniem oprogramowania blockchain i nie wiesz, od czego zacząć, lub jeśli po prostu chcesz zrozumieć, jak wdrażać inteligentne kontrakty i wchodzić z nimi w interakcję, ten przewodnik jest dla Ciebie. Przeprowadzimy Cię przez proces tworzenia i wdrażania prostego inteligentnego kontraktu w sieci testowej Sepolia przy użyciu wirtualnego portfela MetaMask (opens in a new tab), Solidity (opens in a new tab), Hardhat (opens in a new tab) i Alchemy (opens in a new tab) (nie martw się, jeśli jeszcze nie rozumiesz, co to wszystko znaczy, wyjaśnimy to).

W części 2 (opens in a new tab) tego samouczka omówimy, jak wejść w interakcję z naszym inteligentnym kontraktem po jego wdrożeniu, a w części 3 (opens in a new tab) omówimy, jak opublikować go na Etherscan.

Jeśli w dowolnym momencie będziesz mieć pytania, śmiało odezwij się na Discordzie Alchemy (opens in a new tab)!

Krok 1: Połącz się z siecią Ethereum

Istnieje wiele sposobów na wysyłanie żądań do łańcucha Ethereum. Dla uproszczenia użyjemy darmowego konta na Alchemy, platformy deweloperskiej i interfejsu API blockchain, która pozwala nam komunikować się z łańcuchem Ethereum bez konieczności uruchamiania własnych węzłów. Platforma posiada również narzędzia deweloperskie do monitorowania i analityki, które wykorzystamy w tym samouczku, aby zrozumieć, co dzieje się „pod maską” podczas wdrażania naszego inteligentnego kontraktu. Jeśli nie masz jeszcze konta Alchemy, możesz zarejestrować się za darmo tutaj (opens in a new tab).

Krok 2: Stwórz swoją aplikację (i klucz API)

Po utworzeniu konta Alchemy możesz wygenerować klucz API, tworząc aplikację. Pozwoli nam to na wysyłanie żądań do sieci testowej Sepolia. Jeśli nie znasz sieci testowych, sprawdź tę stronę.

Przejdź na stronę "Utwórz nową aplikację" w pulpicie nawigacyjnym Alchemy, wybierając "Wybierz aplikację" na pasku nawigacyjnym i klikając "Utwórz nową aplikację"

Nazwij swoją aplikację "Hello World", podaj krótki opis i wybierz przypadek użycia, np. "Infrastruktura i narzędzia". Następnie wyszukaj "Ethereum" i wybierz sieć.

Kliknij "Dalej", aby kontynuować, następnie "Utwórz aplikację" i to wszystko! Twoja aplikacja powinna pojawić się w rozwijanym menu paska nawigacyjnego, z kluczem API dostępnym do skopiowania.

Krok 3: Utwórz konto Ethereum (adres)

Potrzebujemy konta Ethereum do wysyłania i odbierania transakcji. W tym samouczku użyjemy MetaMask, wirtualnego portfela w przeglądarce, który służy do zarządzania adresem konta Ethereum. Więcej o transakcjach.

Możesz pobrać MetaMask i utworzyć darmowe konto Ethereum tutaj (opens in a new tab). Podczas tworzenia konta lub jeśli już je posiadasz, pamiętaj, aby przełączyć się na sieć testową "Sepolia" za pomocą rozwijanego menu sieci (abyśmy nie mieli do czynienia z prawdziwymi pieniędzmi).

Jeśli nie widzisz na liście sieci Sepolia, przejdź do menu, następnie do opcji Zaawansowane i przewiń w dół, aby włączyć opcję "Pokaż sieci testowe". W menu wyboru sieci wybierz kartę "Niestandardowe", aby znaleźć listę sieci testowych, i wybierz "Sepolia".

Krok 4: Dodaj ether z kranu (faucet)

Aby wdrożyć nasz inteligentny kontrakt w sieci testowej, będziemy potrzebować trochę fałszywego ETH. Aby otrzymać Sepolia ETH, możesz przejść do szczegółów sieci Sepolia, aby zobaczyć listę różnych kranów (faucetów). Jeśli jeden nie działa, spróbuj innego, ponieważ czasami mogą się wyczerpać. Otrzymanie fałszywego ETH może zająć trochę czasu ze względu na ruch w sieci. Wkrótce powinieneś zobaczyć ETH na swoim koncie MetaMask!

Krok 5: Sprawdź saldo

Aby upewnić się, że nasze saldo tam jest, wykonajmy żądanie eth_getBalance za pomocą narzędzia kompozytora Alchemy (opens in a new tab). Zwróci to ilość ETH w naszym portfelu. Po wprowadzeniu adresu konta MetaMask i kliknięciu „Wyślij żądanie” powinieneś zobaczyć następującą odpowiedź:

1{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }

UWAGA: Ten wynik jest w wei, a nie w ETH. Wei jest używany jako najmniejsza jednostka etheru. Przeliczenie z wei na ETH wynosi: 1 eth = 10¹⁸ wei. Więc jeśli przekonwertujemy 0x2B5E3AF16B1880000 na liczbę dziesiętną, otrzymamy 5*10¹⁸, co równa się 5 ETH.

Uff! Nasze fałszywe pieniądze są na miejscu .

Krok 6: Zainicjuj nasz projekt

Najpierw musimy utworzyć folder dla naszego projektu. Przejdź do wiersza poleceń i wpisz:

1mkdir hello-world
2cd hello-world

Teraz, gdy jesteśmy w folderze naszego projektu, użyjemy npm init, aby zainicjować projekt. Jeśli nie masz jeszcze zainstalowanego npm, postępuj zgodnie z tymi instrukcjami (opens in a new tab) (będziemy również potrzebować Node.js, więc pobierz go również!).

1npm init

Nie ma większego znaczenia, jak odpowiesz na pytania instalacyjne, dla porównania przedstawiamy, jak my to zrobiliśmy:

1nazwa pakietu: (hello-world)
2wersja: (1.0.0)
3opis: inteligentny kontrakt hello world
4punkt wejścia: (index.js)
5polecenie testowe:
6repozytorium git:
7słowa kluczowe:
8autor:
9licencja: (ISC)
10Zapisywanie do /Users/.../.../.../hello-world/package.json:
11
12{
13  "name": "hello-world",
14  "version": "1.0.0",
15  "description": "inteligentny kontrakt hello world",
16  "main": "index.js",
17  "scripts": {
18     "test": "echo \"Błąd: nie określono testu\" && exit 1"
19  },
20  "author": "",
21  "license": "ISC"
22}

Zatwierdź plik package.json i gotowe!

Krok 7: Pobierz Hardhat (opens in a new tab)

Hardhat to środowisko programistyczne do kompilacji, wdrażania, testowania i debugowania oprogramowania Ethereum. Pomaga deweloperom w tworzeniu inteligentnych kontraktów i dapek lokalnie przed wdrożeniem ich na żywym łańcuchu.

W naszym projekcie hello-world uruchom:

1npm install --save-dev hardhat

Sprawdź tę stronę, aby uzyskać więcej szczegółów na temat instrukcji instalacji (opens in a new tab).

Krok 8: Stwórz projekt Hardhat

W folderze naszego projektu uruchom:

1npx hardhat

Powinieneś wtedy zobaczyć wiadomość powitalną i opcję wyboru tego, co chcesz zrobić. Wybierz „utwórz pusty hardhat.config.js”:

1888    888                      888 888               888
2888    888                      888 888               888
3888    888                      888 888               888
48888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
5888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
6888    888 .d888888 888    888  888 888  888 .d888888 888
7888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
8888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888
9
10👷 Witamy w Hardhat v2.0.11 👷‍?
11
12Co chcesz zrobić? …
13Stwórz przykładowy projekt
14❯ Stwórz pusty plik hardhat.config.js
15Wyjdź

Spowoduje to wygenerowanie dla nas pliku hardhat.config.js, w którym określimy całą konfigurację naszego projektu (w kroku 13).

Krok 9: Dodaj foldery projektu

Aby utrzymać porządek w naszym projekcie, utworzymy dwa nowe foldery. Przejdź do katalogu głównego projektu w wierszu poleceń i wpisz:

1mkdir contracts
2mkdir scripts

w contracts/ będziemy przechowywać plik z kodem naszego inteligentnego kontraktu hello world
w scripts/ będziemy przechowywać skrypty do wdrażania naszego kontraktu i interakcji z nim

Krok 10: Napisz nasz kontrakt

Możesz zadawać sobie pytanie: kiedy, do licha, zaczniemy pisać kod?? Cóż, jesteśmy tutaj, w kroku 10.

Otwórz projekt hello-world w swoim ulubionym edytorze (my lubimy VSCode (opens in a new tab)). Inteligentne kontrakty pisane są w języku o nazwie Solidity, którego użyjemy do napisania naszego inteligentnego kontraktu HelloWorld.sol.‌

Przejdź do folderu "contracts" i utwórz nowy plik o nazwie HelloWorld.sol
Poniżej znajduje się przykładowy inteligentny kontrakt Hello World z Ethereum Foundation, którego będziemy używać w tym samouczku. Skopiuj i wklej poniższą zawartość do pliku HelloWorld.sol i koniecznie przeczytaj komentarze, aby zrozumieć, co robi ten kontrakt:

1// Określa wersję Solidity, używając wersjonowania semantycznego.
2// Dowiedz się więcej: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
3pragma solidity ^0.7.0;
4
5// Definiuje kontrakt o nazwie `HelloWorld`.
6// Kontrakt to zbiór funkcji i danych (jego stanu). Po wdrożeniu kontrakt znajduje się pod określonym adresem na blockchainie Ethereum. Dowiedz się więcej: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
7contract HelloWorld {
8
9   // Deklaruje zmienną stanu `message` typu `string`.
10   // Zmienne stanu to zmienne, których wartości są trwale przechowywane w pamięci kontraktu. Słowo kluczowe `public` udostępnia zmienne z zewnątrz kontraktu i tworzy funkcję, którą inne kontrakty lub klienci mogą wywołać w celu uzyskania dostępu do wartości.
11   string public message;
12
13   // Podobnie jak w wielu obiektowych językach programowania opartych na klasach, konstruktor jest specjalną funkcją, która jest wykonywana tylko podczas tworzenia kontraktu.
14   // Konstruktory służą do inicjalizacji danych kontraktu. Dowiedz się więcej:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
15   constructor(string memory initMessage) {
16
17      // Akceptuje argument typu string `initMessage` i ustawia jego wartość w zmiennej `message` w pamięci kontraktu).
18      message = initMessage;
19   }
20
21   // Funkcja publiczna, która akceptuje argument typu string i aktualizuje zmienną `message` w pamięci.
22   function update(string memory newMessage) public {
23      message = newMessage;
24   }
25}

To jest bardzo prosty inteligentny kontrakt, który przechowuje wiadomość po utworzeniu i może być aktualizowany przez wywołanie funkcji update.

Krok 11: Połącz MetaMask i Alchemy ze swoim projektem

Stworzyliśmy portfel MetaMask, konto Alchemy i napisaliśmy nasz inteligentny kontrakt, teraz nadszedł czas, aby połączyć te trzy elementy.

Każda transakcja wysłana z Twojego wirtualnego portfela wymaga podpisu przy użyciu Twojego unikalnego klucza prywatnego. Aby udzielić naszemu programowi tego uprawnienia, możemy bezpiecznie przechowywać nasz klucz prywatny (i klucz API Alchemy) w pliku środowiskowym.

Aby dowiedzieć się więcej o wysyłaniu transakcji, sprawdź ten samouczek o wysyłaniu transakcji przy użyciu web3.

Najpierw zainstaluj pakiet dotenv w katalogu swojego projektu:

1npm install dotenv --save

Następnie utwórz plik .env w katalogu głównym naszego projektu i dodaj do niego swój klucz prywatny MetaMask oraz adres URL HTTP API Alchemy.

Postępuj zgodnie z tymi instrukcjami (opens in a new tab), aby wyeksportować swój klucz prywatny
Poniżej dowiesz się, jak uzyskać adres URL interfejsu API HTTP Alchemy

Skopiuj adres URL interfejsu API Alchemy

Twój plik .env powinien wyglądać następująco:

1API_URL = "https://eth-sepolia.g.alchemy.com/v2/twój-klucz-api"
2PRIVATE_KEY = "twój-klucz-prywatny-metamask"

Aby faktycznie połączyć je z naszym kodem, odwołamy się do tych zmiennych w naszym pliku hardhat.config.js w kroku 13.

Nie commituj pliku .env! Upewnij się, że nigdy nie udostępniasz ani nie ujawniasz nikomu swojego pliku .env, ponieważ w ten sposób narażasz swoje poufne dane. Jeśli używasz kontroli wersji, dodaj swój plik .env do pliku gitignore.

Krok 12: Zainstaluj Ethers.js

Ethers.js to biblioteka, która ułatwia interakcję i wysyłanie żądań do Ethereum, opakowując standardowe metody JSON-RPC w bardziej przyjazne dla użytkownika metody.

Hardhat bardzo ułatwia integrację wtyczek (opens in a new tab) w celu uzyskania dodatkowych narzędzi i rozszerzonej funkcjonalności. Skorzystamy z wtyczki Ethers (opens in a new tab) do wdrażania kontraktów (Ethers.js (opens in a new tab) ma kilka bardzo przejrzystych metod wdrażania kontraktów).

W katalogu projektu wpisz:

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

Będziemy również wymagać ethers w naszym pliku hardhat.config.js w następnym kroku.

Krok 13: Zaktualizuj hardhat.config.js

Do tej pory dodaliśmy kilka zależności i wtyczek, teraz musimy zaktualizować hardhat.config.js, aby nasz projekt wiedział o wszystkich.

Zaktualizuj swój hardhat.config.js, aby wyglądał następująco:

1require('dotenv').config();
2
3require("@nomiclabs/hardhat-ethers");
4const { API_URL, PRIVATE_KEY } = process.env;
5
6/**
7* @type import('hardhat/config').HardhatUserConfig
8*/
9module.exports = {
10   solidity: "0.7.3",
11   defaultNetwork: "sepolia",
12   networks: {
13      hardhat: {},
14      sepolia: {
15         url: API_URL,
16         accounts: [`0x${PRIVATE_KEY}`]
17      }
18   },
19}

Krok 14: Skompiluj nasz kontrakt

Aby upewnić się, że wszystko do tej pory działa, skompilujmy nasz kontrakt. Zadanie compile jest jednym z wbudowanych zadań hardhat.

Z wiersza poleceń uruchom:

1npx hardhat compile

Możesz otrzymać ostrzeżenie o SPDX license identifier not provided in source file (brak identyfikatora licencji SPDX w pliku źródłowym), ale nie musisz się tym martwić — miejmy nadzieję, że wszystko inne wygląda dobrze! Jeśli nie, zawsze możesz napisać wiadomość na discordzie Alchemy (opens in a new tab).

Krok 15: Napisz nasz skrypt wdrożeniowy

Teraz, gdy nasz kontrakt jest napisany, a nasz plik konfiguracyjny jest gotowy, nadszedł czas, aby napisać nasz skrypt wdrażający kontrakt.

Przejdź do folderu scripts/ i utwórz nowy plik o nazwie deploy.js, dodając do niego następującą zawartość:

1async function main() {
2   const HelloWorld = await ethers.getContractFactory("HelloWorld");
3
4   // Rozpocznij wdrażanie, zwracając obietnicę, która prowadzi do obiektu kontraktu
5   const hello_world = await HelloWorld.deploy("Hello World!");
6   console.log("Kontrakt wdrożony pod adresem:", hello_world.address);}
7
8main()
9  .then(() => process.exit(0))
10  .catch(error => {
11    console.error(error);
12    process.exit(1);
13  });

Hardhat wykonuje niesamowitą robotę, wyjaśniając, co robi każda z tych linii kodu w swoim samouczku dotyczącym kontraktów (opens in a new tab), a my przyjęliśmy ich wyjaśnienia tutaj.

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

ContractFactory w ethers.js to abstrakcja używana do wdrażania nowych inteligentnych kontraktów, więc HelloWorld jest tutaj fabryką dla instancji naszego kontraktu hello world. Podczas korzystania z wtyczki hardhat-ethers instancje ContractFactory i Contract są domyślnie połączone z pierwszym sygnatariuszem.

1const hello_world = await HelloWorld.deploy();

Wywołanie deploy() na ContractFactory rozpocznie wdrażanie i zwróci Promise, które prowadzi do Contract. Jest to obiekt, który ma metodę dla każdej z naszych funkcji inteligentnego kontraktu.

Krok 16: Wdróż nasz kontrakt

Jesteśmy wreszcie gotowi do wdrożenia naszego inteligentnego kontraktu! Przejdź do wiersza poleceń i uruchom:

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

Powinieneś wtedy zobaczyć coś takiego:

1Kontrakt wdrożony pod adresem: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570

Jeśli przejdziemy do Etherscan Sepolia (opens in a new tab) i wyszukamy adres naszego kontraktu, powinniśmy zobaczyć, że został on pomyślnie wdrożony. Transakcja będzie wyglądać mniej więcej tak:

Adres Od powinien pasować do adresu Twojego konta MetaMask, a adres Do będzie miał napis „Tworzenie Kontraktu”, ale jeśli klikniemy w transakcję, zobaczymy adres naszego kontraktu w polu Do:

Gratulacje! Właśnie wdrożyłeś inteligentny kontrakt w łańcuchu Ethereum 🎉

Aby zrozumieć, co dzieje się pod maską, przejdźmy do karty Explorer w naszym panelu Alchemy (opens in a new tab). Jeśli masz wiele aplikacji Alchemy, pamiętaj, aby filtrować według aplikacji i wybrać „Hello World”.

Tutaj zobaczysz kilka wywołań JSON-RPC, które Hardhat/Ethers wykonały za nas „pod maską”, gdy wywołaliśmy funkcję .deploy(). Dwa ważne, które należy tu wymienić, to eth_sendRawTransaction (opens in a new tab), czyli żądanie faktycznego zapisania naszego kontraktu w łańcuchu Sepolia, oraz eth_getTransactionByHash (opens in a new tab), czyli żądanie odczytania informacji o naszej transakcji na podstawie haszu (typowy wzorzec podczas transakcji). Aby dowiedzieć się więcej o wysyłaniu transakcji, zapoznaj się z tym samouczkiem na temat wysyłania transakcji za pomocą Web3

To wszystko w części 1 tego samouczka, w części 2 faktycznie wejdziemy w interakcję z naszym inteligentnym kontraktem (opens in a new tab) poprzez aktualizację naszej początkowej wiadomości, a w części 3 opublikujemy nasz inteligentny kontrakt na Etherscan (opens in a new tab), aby każdy wiedział, jak z nim wchodzić w interakcję.

Chcesz dowiedzieć się więcej o Alchemy? Sprawdź naszą stronę internetową (opens in a new tab). Nie chcesz przegapić żadnej aktualizacji? Zapisz się do naszego newslettera tutaj (opens in a new tab)! Pamiętaj, aby dołączyć również do naszego Discorda (opens in a new tab)..

Strona ostatnio zaktualizowana: 3 marca 2026

+17