Przelew
+``` + +To jest format HTML (a dokładniej [JSX](https://react.dev/learn/writing-markup-with-jsx)) komponentu. + +#### `server/noir/src/main.nr` {#server-noir-src-main-nr} + +[Ten plik](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/src/main.nr) to faktyczny kod o zerowej wiedzy. + +``` +use std::hash::pedersen_hash; +``` + +[Hasz Pedersena](https://rya-sge.github.io/access-denied/2024/05/07/pedersen-hash-function/) jest dostarczany ze [standardową biblioteką Noir](https://noir-lang.org/docs/noir/standard_library/cryptographic_primitives/hashes#pedersen_hash). Dowody o zerowej wiedzy często używają tej funkcji haszującej. Jest znacznie łatwiejszy do obliczenia wewnątrz [obwodów arytmetycznych](https://rareskills.io/post/arithmetic-circuit) w porównaniu ze standardowymi funkcjami haszującymi. + +``` +use keccak256::keccak256; +use dep::ecrecover; +``` + +Te dwie funkcje to biblioteki zewnętrzne, zdefiniowane w [`Nargo.toml`](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Nargo.toml). Są dokładnie tym, na co wskazują ich nazwy: funkcją, która oblicza [hasz keccak256](https://emn178.github.io/online-tools/keccak_256.html) oraz funkcją, która weryfikuje podpisy Ethereum i odzyskuje adres Ethereum osoby podpisującej. + +``` +global ACCOUNT_NUMBER : u32 = 5; +``` + +Noir jest inspirowany językiem [Rust](https://www.rust-lang.org/). Zmienne domyślnie są stałymi. W ten sposób definiujemy globalne stałe konfiguracyjne. W szczególności `ACCOUNT_NUMBER` to liczba kont, które przechowujemy. + +Typy danych o nazwie `uGreeter
+Greeter
+ { + !readResults.isError && !readResults.isLoading && ++``` + +Utwórz komponent `ShowGreeting` (wyjaśniony poniżej), ale tylko wtedy, gdy powitanie zostało pomyślnie odczytane z blockchainu. + +```tsx + +``` + +Jest to pole tekstowe, w którym użytkownik może ustawić nowe powitanie. Za każdym razem, gdy użytkownik naciśnie klawisz, wywołujemy `greetingChange`, które wywołuje `setNewGreeting`. Ponieważ `setNewGreeting` pochodzi z hooka `useState`, powoduje to ponowne renderowanie komponentu `Greeter`. Oznacza to, że: + +- Musimy określić `value`, aby zachować wartość nowego powitania, ponieważ w przeciwnym razie powróciłoby ono do wartości domyślnej, czyli pustego ciągu znaków. +- `usePrepareContractWrite` jest wywoływane za każdym razem, gdy `newGreeting` się zmienia, co oznacza, że zawsze będzie miało najnowsze `newGreeting` w przygotowanej transakcji. + +```tsx + +``` + +Jeśli nie ma `workingTx.write`, oznacza to, że wciąż czekamy na informacje niezbędne do wysłania aktualizacji powitania, więc przycisk jest wyłączony. Jeśli istnieje wartość `workingTx.write`, to jest to funkcja do wywołania w celu wysłania transakcji. + +```tsx +
+
+```
+
+Nie chcemy zaśmiecać interfejsu użytkownika wszystkimi informacjami, więc aby umożliwić ich przeglądanie lub zamykanie, używamy znacznika [`details`](https://www.w3schools.com/tags/tag_details.asp).
+
+```tsx
+
+
+}
+```
+
+Zakończ różne znaczniki HTML.
+
+##### Ostateczny `export` {#the-final-export}
+
+```tsx
+export { Greeter }
+```
+
+Komponent `Greeter` jest tym, który musimy wyeksportować dla aplikacji.
+
+#### `src/wagmi.ts` {#wagmi-ts}
+
+Na koniec, różne definicje związane z WAGMI znajdują się w `src/wagmi.ts`. Nie będę tutaj wszystkiego wyjaśniać, ponieważ większość z tego to szablon, którego prawdopodobnie nie będziesz musiał zmieniać.
+
+Kod tutaj nie jest dokładnie taki sam jak [na GitHubie](https://github.com/qbzzt/20230801-modern-ui/blob/main/src/wagmi.ts), ponieważ w dalszej części artykułu dodajemy kolejny łańcuch ([Redstone Holesky](https://redstone.xyz/docs/network-info)).
+
+```ts
+import { getDefaultWallets } from '@rainbow-me/rainbowkit'
+import { configureChains, createConfig } from 'wagmi'
+import { holesky, sepolia } from 'wagmi/chains'
+```
+
+Importuj łańcuchy bloków, które obsługuje aplikacja. Listę obsługiwanych łańcuchów można zobaczyć [w viem github](https://github.com/wagmi-dev/viem/tree/main/src/chains/definitions).
+
+```ts
+import { publicProvider } from 'wagmi/providers/public'
+
+const walletConnectProjectId = 'c96e690bb92b6311e8e9b2a6a22df575'
+```
+
+Aby móc korzystać z [WalletConnect](https://walletconnect.com/), potrzebujesz identyfikatora projektu dla swojej aplikacji. Możesz go uzyskać na stronie [cloud.walletconnect.com](https://cloud.walletconnect.com/sign-in).
+
+```ts
+const { chains, publicClient, webSocketPublicClient } = configureChains(
+ [ holesky, sepolia ],
+ [
+ publicProvider(),
+ ],
+)
+
+const { connectors } = getDefaultWallets({
+ appName: 'My wagmi + RainbowKit App',
+ chains,
+ projectId: walletConnectProjectId,
+})
+
+export const config = createConfig({
+ autoConnect: true,
+ connectors,
+ publicClient,
+ webSocketPublicClient,
+})
+
+export { chains }
+```
+
+### Dodawanie kolejnego blockchaina {#add-blockchain}
+
+Obecnie istnieje wiele [rozwiązań skalujących L2](/layer-2/) i możesz chcieć obsługiwać niektóre, których viem jeszcze nie obsługuje. Aby to zrobić, zmodyfikuj `src/wagmi.ts`. Te instrukcje wyjaśniają, jak dodać [Redstone Holesky](https://redstone.xyz/docs/network-info).
+
+1. Zaimportuj typ `defineChain` z viem.
+
+ ```ts
+ import { defineChain } from 'viem'
+ ```
+
+2. Dodaj definicję sieci.
+
+ ```ts
+ const redstoneHolesky = defineChain({
+ id: 17_001,
+ name: 'Redstone Holesky',
+ network: 'redstone-holesky',
+ nativeCurrency: {
+ decimals: 18,
+ name: 'Ether',
+ symbol: 'ETH',
+ },
+ rpcUrls: {
+ default: {
+ http: ['https://rpc.holesky.redstone.xyz'],
+ webSocket: ['wss://rpc.holesky.redstone.xyz/ws'],
+ },
+ public: {
+ http: ['https://rpc.holesky.redstone.xyz'],
+ webSocket: ['wss://rpc.holesky.redstone.xyz/ws'],
+ },
+ },
+ blockExplorers: {
+ default: { name: 'Explorer', url: 'https://explorer.holesky.redstone.xyz' },
+ },
+ })
+ ```
+
+3. Dodaj nowy łańcuch do wywołania `configureChains`.
+
+ ```ts
+ const { chains, publicClient, webSocketPublicClient } = configureChains(
+ [ holesky, sepolia, redstoneHolesky ],
+ [ publicProvider(), ],
+ )
+ ```
+
+4. Upewnij się, że aplikacja zna adres Twoich kontraktów w nowej sieci. W tym przypadku modyfikujemy `src/components/Greeter.tsx`:
+
+ ```ts
+ const contractAddrs : AddressPerBlockchainType = {
+ // Holesky
+ 17000: '0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8',
+
+ // Redstone Holesky
+ 17001: '0x4919517f82a1B89a32392E1BF72ec827ba9986D3',
+
+ // Sepolia
+ 11155111: '0x7143d5c190F048C8d19fe325b748b081903E3BF0'
+ }
+ ```
+
+## Wnioski {#conclusion}
+
+Oczywiście, tak naprawdę nie zależy Ci na udostępnieniu interfejsu użytkownika dla `Greeter`. Chcesz stworzyć interfejs użytkownika dla własnych kontraktów. Aby utworzyć własną aplikację, wykonaj następujące kroki:
+
+1. Określ, aby utworzyć aplikację wagmi.
+
+ ```sh copy
+ pnpm create wagmi
+ ```
+
+2. Nazwij aplikację.
+
+3. Wybierz framework **React**.
+
+4. Wybierz wariant **Vite**.
+
+5. Możesz [dodać zestaw Rainbow](https://www.rainbowkit.com/docs/installation#manual-setup).
+
+Teraz idź i spraw, aby Twoje kontrakty były użyteczne dla całego świata.
+
+[Zobacz więcej mojej pracy tutaj](https://cryptodocguy.pro/).
+
diff --git a/public/content/translations/pl/developers/tutorials/deploying-your-first-smart-contract/index.md b/public/content/translations/pl/developers/tutorials/deploying-your-first-smart-contract/index.md
index b87270a560b..f0494c1235c 100644
--- a/public/content/translations/pl/developers/tutorials/deploying-your-first-smart-contract/index.md
+++ b/public/content/translations/pl/developers/tutorials/deploying-your-first-smart-contract/index.md
@@ -1,13 +1,8 @@
---
-title: Wdrożenie pierwszego inteligentnego kontraktu
-description: Wprowadzenie do wdrożenia pierwszego inteligentnego kontraktu w sieci testowej Ethereum
+title: "Wdrożenie pierwszego inteligentnego kontraktu"
+description: "Wprowadzenie do wdrożenia pierwszego inteligentnego kontraktu w sieci testowej Ethereum"
author: "jdourlens"
-tags:
- - "inteligentne kontrakty"
- - "remix"
- - "solidity"
- - "pierwsze kroki"
- - "wdrożenie"
+tags: [ "smart kontrakty", "remix", "solidity", "wdrażanie" ]
skill: beginner
lang: pl
published: 2020-04-03
@@ -16,32 +11,33 @@ sourceUrl: https://ethereumdev.io/deploying-your-first-smart-contract/
address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
---
-Chyba jesteś tak samo podekscytowany jak my [wdrażaniem](/developers/docs/smart-contracts/deploying/) i interakcją z pierwszym [inteligentnym kontraktem](/developers/docs/smart-contracts/) na blockchainie Ethereum.
+Zgaduję, że jesteś tak samo podekscytowany jak my, aby [wdrożyć](/developers/docs/smart-contracts/deploying/) i wejść w interakcję ze swoim pierwszym [inteligentnym kontraktem](/developers/docs/smart-contracts/) na blockchainie Ethereum.
-Nie martw się, ponieważ jest to nasz pierwszy inteligentny kontrakt, wdrożymy go w [lokalnej sieci testowej](/developers/docs/networks/), więc wdrożenie nic nie kosztuje i możesz bawić się nim tyle, ile chcesz.
+Nie przejmuj się, ponieważ jest to nasz pierwszy inteligentny kontrakt, wdrożymy go w lokalnej [sieci testowej](/developers/docs/networks/), więc jego wdrożenie nic nie kosztuje i możesz się nim bawić, ile tylko chcesz.
-## Pisanie kontraktu {#writing-our-contract}
+## Pisanie naszego kontraktu {#writing-our-contract}
Pierwszym krokiem jest [odwiedzenie Remix](https://remix.ethereum.org/) i utworzenie nowego pliku. W lewej górnej części interfejsu Remix dodaj nowy plik i wprowadź żądaną nazwę pliku.
-
+
W nowym pliku wkleimy następujący kod.
```solidity
-pragma solidity 0.5.17;
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.5.17;
contract Counter {
- // Public variable of type unsigned int to keep the number of counts
+ // Publiczna zmienna typu unsigned int do przechowywania liczby zliczeń
uint256 public count = 0;
- // Function that increments our counter
+ // Funkcja, która zwiększa nasz licznik
function increment() public {
count += 1;
}
- // Not necessary getter to get the count value
+ // Niepotrzebny getter do pobrania wartości licznika
function getCount() public view returns (uint256) {
return count;
}
@@ -49,20 +45,20 @@ contract Counter {
}
```
-Jeśli masz doświadczenie w programowaniu, możesz łatwo odgadnąć, co robi ten program. Oto wyjaśnienie kolejnych wierszy:
+Jeśli masz doświadczenie w programowaniu, możesz łatwo odgadnąć, co robi ten program. Oto wyjaśnienie linijka po linijce:
-- Wiersz 3: Określamy kontrakt nazwą `Counter`.
-- Wiersz 6: Nasz kontrakt przechowuje jedną niepodpisaną liczbę całkowitą o nazwie `count` zaczynając od 0.
-- Wiersz 9: Pierwsza funkcja zmieni stan kontraktu i zwiększy `increment()` zmienną `count`>.
-- Wiersz 14: Druga funkcja to tylko getter, który może odczytywać wartość zmiennej `count` poza inteligentnym kontraktem. Zauważ, że ponieważ zdefiniowaliśmy zmienną `count` jako publiczną, to nie jest konieczne, ale jest to przykład.
+- Wiersz 4: Definiujemy kontrakt o nazwie `Counter`.
+- Wiersz 7: Nasz kontrakt przechowuje jedną liczbę całkowitą bez znaku o nazwie `count`, zaczynając od 0.
+- Wiersz 10: Pierwsza funkcja modyfikuje stan kontraktu i zwiększa naszą zmienną `count`.
+- Wiersz 15: Druga funkcja to tylko getter, który umożliwia odczytanie wartości zmiennej `count` poza inteligentnym kontraktem. Zauważ, że ponieważ zdefiniowaliśmy naszą zmienną `count` jako publiczną, nie jest to konieczne, ale zostało pokazane jako przykład.
-To wszystko dotyczy naszego pierwszego prostego inteligentnego kontraktu. Jak możesz wiedzieć, wygląda to na klasę z języków programowania obiektowego takich jak Java lub C++. Nadszedł czas, aby pobawić się naszym kontraktem.
+To wszystko, jeśli chodzi o nasz pierwszy prosty inteligentny kontrakt. Jak być może wiesz, wygląda to jak klasa z języków programowania zorientowanego obiektowo (OOP), takich jak Java lub C++. Nadszedł czas, aby pobawić się naszym kontraktem.
-## Wdrażanie kontraktu {#deploying-our-contract}
+## Wdrażanie naszego kontraktu {#deploying-our-contract}
-Ponieważ napisaliśmy pierwszy inteligentny kontrakt, teraz wdrożymy go w blockchainie, aby móc się nim bawić.
+Ponieważ napisaliśmy nasz pierwszy inteligentny kontrakt, teraz wdrożymy go w blockchainie, aby móc się nim bawić.
-[Wdrażanie inteligentnego kontraktu w blockchainie](/developers/docs/smart-contracts/deploying/) to w rzeczywistości tylko wysłanie transakcji zawierającej kod skompilowanego inteligentnego kontraktu bez określania odbiorców.
+[Wdrażanie inteligentnego kontraktu na blockchainie](/developers/docs/smart-contracts/deploying/) to w rzeczywistości tylko wysłanie transakcji zawierającej kod skompilowanego inteligentnego kontraktu bez określania żadnych odbiorców.
Najpierw [skompilujemy kontrakt](/developers/docs/smart-contracts/compiling/), klikając ikonę kompilacji po lewej stronie:
@@ -70,30 +66,30 @@ Najpierw [skompilujemy kontrakt](/developers/docs/smart-contracts/compiling/), k
Następnie kliknij przycisk kompilacji:
-
+
-Możesz wybrać opcję „Automatyczna kompilacja”, aby umowa była zawsze kompilowana po zapisaniu zawartości w edytorze tekstowym.
+Możesz wybrać opcję "Automatyczna kompilacja", aby kontrakt był zawsze kompilowany po zapisaniu zawartości w edytorze tekstowym.
-Następnie przejdź do ekranu wdrażania i uruchamiania transakcji:
+Następnie przejdź do ekranu "wdrażanie i uruchamianie transakcji":
-Po przejściu do ekranu „wdróż i uruchom” transakcje sprawdź dokładnie, czy pojawia się nazwa Twojego kontraktu i kliknij Wdróż. Jak widać na górze strony, obecne środowisko to „Maszyna wirtualna JavaScript”, co oznacza, że wdrożymy inteligentny kontrakt i będziemy nad nim pracować w lokalnym testowym blockchainie, aby móc testować szybciej i bez żadnych opłat.
+Gdy znajdziesz się na ekranie "wdrażanie i uruchamianie transakcji", upewnij się, że wyświetla się nazwa Twojego kontraktu, a następnie kliknij "Wdróż". Jak widać na górze strony, obecne środowisko to "JavaScript VM", co oznacza, że będziemy wdrażać i wchodzić w interakcję z naszym inteligentnym kontraktem na lokalnym testowym blockchainie, aby móc go testować szybciej i bez żadnych opłat.
-
+
-Po kliknięciu przycisku „Wdróż” na dole pojawi się Twój kontrakt. Kliknij strzałkę po lewej stronie, aby ją rozwinąć i wyświetlić zawartość kontraktu. To jest utworzona zmienna `counter`, funkcja `increment()` i getter `getCounter()`.
+Po kliknięciu przycisku "Wdróż", na dole pojawi się Twój kontrakt. Kliknij strzałkę po lewej stronie, aby go rozwinąć i wyświetlić zawartość naszego kontraktu. To jest nasza zmienna `counter`, nasza funkcja `increment()` i getter `getCounter()`.
-Jeśli klikniesz przycisk `count` lub `getCount`, zostanie pobrana i wyświetlona zmienna `count`. Ponieważ funkcja `increment` nie została jeszcze wywołana, wyświetli 0.
+Jeśli klikniesz przycisk `count` lub `getCount`, zostanie odczytana zawartość zmiennej `count` z kontraktu i wyświetlona. Ponieważ nie wywołaliśmy jeszcze funkcji `increment`, wyświetli się 0.
-Wywołajmy funkcję `increment`, klikając przycisk. Zobaczysz dzienniki transakcji, wyświetlone na dole okna. Zobaczysz, że dzienniki są inne, gdy naciśniesz przycisk pobierania danych zamiast przycisku `increment`. To dlatego, że odczyt danych w blockchainie nie wymaga żadnych transakcji (pisanie) ani opłat. Ponieważ tylko modyfikacja stanu łańcucha bloków wymaga dokonania transakcji:
+Wywołajmy teraz funkcję `increment`, klikając przycisk. Zobaczysz logi wykonanych transakcji, które pojawią się na dole okna. Zobaczysz, że logi są inne, gdy naciskasz przycisk pobierania danych zamiast przycisku `increment`. Dzieje się tak, ponieważ odczytywanie danych z blockchaina nie wymaga żadnych transakcji (zapisu) ani opłat. Ponieważ tylko modyfikowanie stanu blockchaina wymaga wykonania transakcji:
-
+
-Po naciśnięciu przycisku inkrement, który wygeneruje transakcję, aby wywołać naszą funkcję `increment()`, jeśli ponownie klikniemy przycisk count lub getCount, odczytamy nowo zaktualizowany stan naszego inteligentnego kontraktu ze zmienną count większą niż 0.
+Po naciśnięciu przycisku `increment`, który wygeneruje transakcję wywołującą naszą funkcję `increment()`, jeśli ponownie klikniemy przyciski `count` lub `getCount`, odczytamy nowo zaktualizowany stan naszego inteligentnego kontraktu ze zmienną `count` większą od 0.
-W następnym samouczku omówimy [jak dodawać zdarzenia do inteligentnych kontraktów](/developers/tutorials/logging-events-smart-contracts/). Rejestrowanie zdarzeń jest wygodnym sposobem debugowania inteligentnego kontraktu i zrozumienia, co się dzieje podczas wywoływania funkcji.
+W następnym samouczku omówimy, [jak możesz dodawać zdarzenia do swoich inteligentnych kontraktów](/developers/tutorials/logging-events-smart-contracts/). Rejestrowanie zdarzeń jest wygodnym sposobem debugowania inteligentnego kontraktu i zrozumienia, co się dzieje podczas wywoływania funkcji.
diff --git a/public/content/translations/pl/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md b/public/content/translations/pl/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
new file mode 100644
index 00000000000..15dc728b16c
--- /dev/null
+++ b/public/content/translations/pl/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
@@ -0,0 +1,372 @@
+---
+title: "Jak rozwijać i testować dApp na lokalnej, wieloklientowej sieci testowej"
+description: "Ten poradnik najpierw przeprowadzi Cię przez proces tworzenia i konfigurowania wieloklientowej lokalnej sieci testowej Ethereum, a następnie pokaże, jak użyć tej sieci testowej do wdrożenia i przetestowania dApp."
+author: "Tedi Mitiku"
+tags:
+ [
+ "klienci",
+ "węzły",
+ "smart kontrakty",
+ "kompozycyjność",
+ "warstwa konsensusu",
+ "warstwa wykonawcza",
+ "testowanie"
+ ]
+skill: intermediate
+lang: pl
+published: 2023-04-11
+---
+
+## Wprowadzenie {#introduction}
+
+Ten poradnik przeprowadzi Cię przez proces tworzenia konfigurowalnej lokalnej sieci testowej Ethereum, wdrażania na niej smart kontraktu i używania sieci testowej do przeprowadzania testów Twojej dApp. Ten poradnik jest przeznaczony dla deweloperów dApp, którzy chcą rozwijać i testować swoje dapki lokalnie w różnych konfiguracjach sieci przed wdrożeniem na działającą sieć testową lub sieć główną.
+
+W tym poradniku:
+
+- Utworzyć lokalną sieć testową Ethereum za pomocą pakietu [`eth-network-package`](https://github.com/kurtosis-tech/eth-network-package) przy użyciu [Kurtosis](https://www.kurtosis.com/),
+- Połączyć swoje środowisko programistyczne dApp Hardhat z lokalną siecią testową w celu kompilacji, wdrożenia i przetestowania dApp oraz
+- Skonfigurować lokalną sieć testową, w tym parametry takie jak liczba węzłów i określone pary klientów EL/CL, aby umożliwić procesy programistyczne i testowe w różnych konfiguracjach sieci.
+
+### Czym jest Kurtosis? {#what-is-kurtosis}
+
+[Kurtosis](https://www.kurtosis.com/) to komponowalny system budowania przeznaczony do konfigurowania wielokontenerowych środowisk testowych. W szczególności umożliwia deweloperom tworzenie odtwarzalnych środowisk, które wymagają dynamicznej logiki konfiguracji, takich jak sieci testowe blockchain.
+
+W tym poradniku pakiet eth-network-package Kurtosis uruchamia lokalną sieć testową Ethereum z obsługą klienta warstwy wykonawczej (EL) [`geth`](https://geth.ethereum.org/), a także klientów warstwy konsensusu (CL) [`teku`](https://consensys.io/teku), [`lighthouse`](https://lighthouse.sigmaprime.io/) i [`lodestar`](https://lodestar.chainsafe.io/). Ten pakiet służy jako konfigurowalna i komponowalna alternatywa dla sieci w frameworkach takich jak Hardhat Network, Ganache i Anvil. Kurtosis oferuje deweloperom większą kontrolę i elastyczność nad sieciami testowymi, których używają, co jest głównym powodem, dla którego [Ethereum Foundation użyła Kurtosis do testowania Połączenia](https://www.kurtosis.com/blog/testing-the-ethereum-merge) i nadal używa go do testowania aktualizacji sieci.
+
+## Konfiguracja Kurtosis {#setting-up-kurtosis}
+
+Zanim przejdziesz dalej, upewnij się, że masz:
+
+- [Zainstalowany i uruchomiony silnik Docker](https://docs.kurtosis.com/install/#i-install--start-docker) na swoim komputerze lokalnym
+- [Zainstalowany Kurtosis CLI](https://docs.kurtosis.com/install#ii-install-the-cli) (lub zaktualizowany do najnowszej wersji, jeśli masz już zainstalowany CLI)
+- Zainstalowane [Node.js](https://nodejs.org/en), [yarn](https://classic.yarnpkg.com/lang/en/docs/install/#mac-stable) i [npx](https://www.npmjs.com/package/npx) (dla Twojego środowiska dApp)
+
+## Tworzenie lokalnej sieci testowej Ethereum {#instantiate-testnet}
+
+Aby uruchomić lokalną sieć testową Ethereum, wykonaj:
+
+```python
+kurtosis --enclave local-eth-testnet run github.com/kurtosis-tech/eth-network-package
+```
+
+Uwaga: to polecenie nazywa Twoją sieć: \"local-eth-testnet\" za pomocą flagi `--enclave`.
+
+Kurtosis wydrukuje kroki, które podejmuje w tle, podczas gdy interpretuje, waliduje, a następnie wykonuje instrukcje. Na końcu powinieneś zobaczyć dane wyjściowe podobne do poniższych:
+
+```python
+INFO[2023-04-04T18:09:44-04:00] ======================================================
+INFO[2023-04-04T18:09:44-04:00] || Created enclave: local-eth-testnet ||
+INFO[2023-04-04T18:09:44-04:00] ======================================================
+Name: local-eth-testnet
+UUID: 39372d756ae8
+Status: RUNNING
+Creation Time: Tue, 04 Apr 2023 18:09:03 EDT
+
+========================================= Files Artifacts =========================================
+UUID Name
+d4085a064230 cl-genesis-data
+1c62cb792e4c el-genesis-data
+bd60489b73a7 genesis-generation-config-cl
+b2e593fe5228 genesis-generation-config-el
+d552a54acf78 geth-prefunded-keys
+5f7e661eb838 prysm-password
+054e7338bb59 validator-keystore-0
+
+========================================== User Services ==========================================
+UUID Name Ports Status
+e20f129ee0c5 cl-client-0-beacon http: 4000/tcp -> {attrs.name}
+
+ {JSON.stringify(attrs.object, null, 2)}
+```
+
+Większość pól jest wyświetlana za pomocą [`JSON.stringify`](https://www.w3schools.com/js/js_json_stringify.asp).
+
+```tsx
+
+ { funs.length > 0 &&
+ <>
+ Functions:
+ -
+```
+
+Wyjątkiem są funkcje, które nie są częścią [standardu JSON](https://www.json.org/json-en.html), więc muszą być wyświetlane osobno.
+
+```tsx
+ {funs.map((f, i) =>
+```
+
+Wewnątrz JSX kod w nawiasach klamrowych `{` `}` jest interpretowany jako JavaScript. Następnie kod w nawiasach zwykłych `(` `)` jest ponownie interpretowany jako JSX.
+
+```tsx
+ (
- {f} ) + )} +``` + +React wymaga, aby znaczniki w [drzewie DOM](https://www.w3schools.com/js/js_htmldom.asp) miały odrębne identyfikatory. Oznacza to, że dzieci tego samego znacznika (w tym przypadku [lista nieuporządkowana](https://www.w3schools.com/tags/tag_ul.asp)) potrzebują różnych atrybutów `key`. + +```tsx +
Witaj ${loginResponse.extract.nameID}
+ + + `) + res.send(); +``` + +Wyślij odpowiedź HTML, aby pokazać użytkownikowi, że otrzymaliśmy dane logowania. + +```typescript + } catch (err) { + console.error('Błąd przetwarzania odpowiedzi SAML:', err); + res.status(400).send('Uwierzytelnianie SAML nie powiodło się'); + } + } +) +``` + +Poinformuj użytkownika w przypadku niepowodzenia. + +```typescript +spRouter.get('/login', +``` + +Utwórz żądanie logowania, gdy przeglądarka spróbuje uzyskać dostęp do tej strony. To jest procedura obsługi kroku 1 na powyższym diagramie sekwencji. + +```typescript + async (req, res) => { + const loginRequest = await sp.createLoginRequest(idp, "post") +``` + +Pobierz informacje, aby wysłać żądanie logowania. + +```typescript + res.send(` + + + +``` + +Ta strona automatycznie przesyła formularz (patrz poniżej). W ten sposób użytkownik nie musi nic robić, aby zostać przekierowanym. To jest krok 2 na powyższym diagramie sekwencji. + +```typescript + + + + `) + } +) + +app.use(express.urlencoded({extended: true})) +``` + +[Ten middleware](https://expressjs.com/en/5x/api.html#express.urlencoded) odczytuje treść [żądania HTTP](https://www.tutorialspoint.com/http/http_requests.htm). Domyślnie express je ignoruje, ponieważ większość żądań go nie wymaga. Potrzebujemy go, ponieważ POST używa treści. + +```typescript +app.use(`/${config.spDir}`, spRouter) +``` + +Zamontuj router w katalogu dostawcy usług (`/sp`). + +```typescript +app.get("/", (req, res) => { + res.send(` + + + + + + `) +}) +``` + +Jeśli przeglądarka spróbuje uzyskać dostęp do katalogu głównego, udostępnij jej link do strony logowania. + +```typescript +app.listen(config.spPort, () => { + console.log(`dostawca usług działa na http://${config.spHostname}:${config.spPort}`) +}) +``` + +Nasłuchuj na `spPort` za pomocą tej aplikacji express. + +#### src/idp.mts + +To jest dostawca tożsamości. Jest on bardzo podobny do dostawcy usług, poniższe wyjaśnienia dotyczą części, które się różnią. + +```typescript +const xmlParser = new (await import("fast-xml-parser")).XMLParser( + { + ignoreAttributes: false, // Zachowaj atrybuty + attributeNamePrefix: "@_", // Prefiks dla atrybutów + } +) +``` + +Musimy odczytać i zrozumieć żądanie XML, które otrzymujemy od dostawcy usług. + +```typescript +const getLoginPage = requestId => ` +``` + +Ta funkcja tworzy stronę z automatycznie przesyłanym formularzem, która jest zwracana w kroku 4 powyższego diagramu sekwencji. + +```typescript + + +Strona logowania
+ + + + +const idpRouter = express.Router() + +idpRouter.post("/loginSubmitted", async (req, res) => { + const loginResponse = await idp.createLoginResponse( +``` + +To jest procedura obsługi kroku 5 na powyższym diagramie sekwencji. [`idp.createLoginResponse`](https://github.com/tngan/samlify/blob/master/src/entity-idp.ts#L73-L125) tworzy odpowiedź na żądanie logowania. + +```typescript + sp, + { + authnContextClassRef: 'urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport', + audience: sp.entityID, +``` + +Odbiorcą jest dostawca usług. + +```typescript + extract: { + request: { + id: req.body.requestId + } + }, +``` + +Informacje wyodrębnione z żądania. Jedynym parametrem w żądaniu, który nas interesuje, jest requestId, który pozwala dostawcy usług dopasować żądania i ich odpowiedzi. + +```typescript + signingKey: { privateKey: idpPrivateKey, publicKey: config.idpCert } // Zapewnij podpisywanie +``` + +Potrzebujemy `signingKey`, aby mieć dane do podpisania odpowiedzi. Dostawca usług nie ufa niepodpisanym żądaniom. + +```typescript + }, + "post", + { + email: req.body.email +``` + +To jest pole z informacjami o użytkowniku, które odsyłamy do dostawcy usług. + +```typescript + } + ); + + res.send(` + + + + + + + + `) +}) +``` + +Ponownie, użyj automatycznie przesyłanego formularza. To jest krok 6 na powyższym diagramie sekwencji. + +```typescript + +// Punkt końcowy IdP dla żądań logowania +idpRouter.post(`/login`, +``` + +To jest punkt końcowy, który odbiera żądanie logowania od dostawcy usług. To jest procedura obsługi kroku 3 na powyższym diagramie sekwencji. + +```typescript + async (req, res) => { + try { + // Obejście, ponieważ nie mogłem sprawić, by parseLoginRequest zadziałało. + // const loginRequest = await idp.parseLoginRequest(sp, 'post', req) + const samlRequest = xmlParser.parse(Buffer.from(req.body.SAMLRequest, 'base64').toString('utf-8')) + res.send(getLoginPage(samlRequest["samlp:AuthnRequest"]["@_ID"])) +``` + +Powinniśmy być w stanie użyć [`idp.parseLoginRequest`](https://github.com/tngan/samlify/blob/master/src/entity-idp.ts#L127-L144), aby odczytać ID żądania uwierzytelnienia. Jednak nie udało mi się go uruchomić i nie było warto poświęcać na to dużo czasu, więc użyłem [uniwersalnego parsera XML](https://www.npmjs.com/package/fast-xml-parser). Informacją, której potrzebujemy, jest atrybut `ID` wewnątrz tagu `Proszę podpisać
+ ++ + + +` +} +``` + +Reszta to standardowy HTML. + +```typescript +idpRouter.get("/signature/:nonce/:account/:signature", async (req, res) => { +``` + +To jest procedura obsługi kroku 5 na diagramie sekwencji. + +```typescript + const requestId = nonces[req.params.nonce] + if (requestId === undefined) { + res.send("Zły nonce") + return ; + } + + nonces[req.params.nonce] = undefined +``` + +Pobierz identyfikator żądania i usuń nonce z `nonces`, aby upewnić się, że nie można go ponownie użyć. + +```typescript + try { +``` + +Ponieważ istnieje tak wiele sposobów, w jakie podpis może być nieważny, opakowujemy to w `try...` blok `catch`, aby przechwycić wszelkie zgłoszone błędy. + +```typescript + const validSignature = await verifyMessage({ + address: req.params.account, + message: `${loginPrompt}${req.params.nonce}`, + signature: req.params.signature + }) +``` + +Użyj [`verifyMessage`](https://viem.sh/docs/actions/public/verifyMessage#verifymessage) do zaimplementowania kroku 5.5 na diagramie sekwencji. + +```typescript + if (!validSignature) + throw("Zły podpis") + } catch (err) { + res.send("Błąd:" + err) + return ; + } +``` + +Reszta procedury obsługi jest równoważna z tym, co zrobiliśmy wcześniej w procedurze obsługi `/loginSubmitted`, z wyjątkiem jednej małej zmiany. + +```typescript + const loginResponse = await idp.createLoginResponse( + . + . + . + { + email: req.params.account + "@bad.email.address" + } + ); +``` + +Nie mamy rzeczywistego adresu e-mail (uzyskamy go w następnej sekcji), więc na razie zwracamy adres Ethereum i wyraźnie oznaczamy go jako niebędący adresem e-mail. + +```typescript +// Punkt końcowy IdP dla żądań logowania +idpRouter.post(`/login`, + async (req, res) => { + try { + // Obejście, ponieważ nie mogłem sprawić, by parseLoginRequest zadziałało. + // const loginRequest = await idp.parseLoginRequest(sp, 'post', req) + const samlRequest = xmlParser.parse(Buffer.from(req.body.SAMLRequest, 'base64').toString('utf-8')) + res.send(getSignaturePage(samlRequest["samlp:AuthnRequest"]["@_ID"])) + } catch (err) { + console.error('Błąd przetwarzania odpowiedzi SAML:', err); + res.status(400).send('Uwierzytelnianie SAML nie powiodło się'); + } + } +) +``` + +Zamiast `getLoginPage`, użyj teraz `getSignaturePage` w procedurze obsługi kroku 3. + +## Uzyskiwanie adresu e-mail + +Następnym krokiem jest uzyskanie adresu e-mail, identyfikatora wymaganego przez dostawcę usług. Aby to zrobić, używamy [Ethereum Attestation Service (EAS)](https://attest.org/). + +Najłatwiejszym sposobem na uzyskanie poświadczeń jest użycie [API GraphQL](https://docs.attest.org/docs/developer-tools/api). Używamy tego zapytania: + +``` +query GetAttestationsByRecipient { + attestations( + where: { + recipient: { equals: "${getAddress(ethAddr)}" } + schemaId: { equals: "0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977" } + } + take: 1 + ) { + data + id + attester + } +} +``` + +Ten [`schemaId`](https://optimism.easscan.org/schema/view/0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977) zawiera tylko adres e-mail. To zapytanie prosi o poświadczenia tego schematu. Temat poświadczenia nazywa się `recipient`. Jest to zawsze adres Ethereum. + +Ostrzeżenie: Sposób, w jaki uzyskujemy tutaj poświadczenia, ma dwa problemy z bezpieczeństwem. + +- Korzystamy z punktu końcowego API `https://optimism.easscan.org/graphql`, który jest scentralizowanym komponentem. Możemy pobrać atrybut `id`, a następnie sprawdzić on-chain, aby zweryfikować, czy poświadczenie jest prawdziwe, ale punkt końcowy API nadal może cenzurować poświadczenia, nie informując nas o nich. + + Ten problem nie jest niemożliwy do rozwiązania, moglibyśmy uruchomić własny punkt końcowy GraphQL i pobierać poświadczenia z logów łańcucha, ale jest to nadmierne dla naszych celów. + +- Nie sprawdzamy tożsamości poświadczającego. Każdy może podać nam fałszywe informacje. W rzeczywistej implementacji mielibyśmy zestaw zaufanych poświadczających i sprawdzalibyśmy tylko ich poświadczenia. + +Aby zobaczyć to w działaniu, zatrzymaj istniejące IdP i SP i uruchom te polecenia: + +```sh +git checkout email-address +pnpm install +pnpm start +``` + +Następnie podaj swój adres e-mail. Masz na to dwa sposoby: + +- Zaimportuj portfel za pomocą klucza prywatnego i użyj testowego klucza prywatnego `0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80`. + +- Dodaj poświadczenie dla własnego adresu e-mail: + + 1. Przejdź do [schematu w eksploratorze poświadczeń](https://optimism.easscan.org/schema/view/0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977). + + 2. Kliknij **Poświadcz za pomocą schematu**. + + 3. Wprowadź swój adres Ethereum jako odbiorcę, swój adres e-mail jako adres e-mail i wybierz **Onchain**. Następnie kliknij **Utwórz poświadczenie**. + + 4. Zatwierdź transakcję w swoim portfelu. Będziesz potrzebować trochę ETH w [łańcuchu bloków Optimism](https://app.optimism.io/bridge/deposit), aby zapłacić za gaz. + +Tak czy inaczej, po wykonaniu tej czynności przejdź do [http://localhost:3000](http://localhost:3000) i postępuj zgodnie z instrukcjami. Jeśli zaimportowałeś testowy klucz prywatny, otrzymany adres e-mail to `test_addr_0@example.com`. Jeśli użyłeś własnego adresu, powinien to być adres, który poświadczyłeś. + +### Szczegółowe wyjaśnienie + + + +Nowe kroki to komunikacja GraphQL, kroki 5.6 i 5.7. + +Ponownie, oto zmienione części `idp.mts`. + +```typescript +import { GraphQLClient } from 'graphql-request' +import { SchemaEncoder } from '@ethereum-attestation-service/eas-sdk' +``` + +Zaimportuj biblioteki, których potrzebujemy. + +```typescript +const graphqlEndpointUrl = "https://optimism.easscan.org/graphql" +``` + +Dla każdego łańcucha bloków istnieje [oddzielny punkt końcowy](https://docs.attest.org/docs/developer-tools/api). + +```typescript +const graphqlClient = new GraphQLClient(graphqlEndpointUrl, { fetch }) +``` + +Utwórz nowego klienta `GraphQLClient`, którego możemy użyć do odpytywania punktu końcowego. + +```typescript +const graphqlSchema = 'string emailAddress' +const graphqlEncoder = new SchemaEncoder(graphqlSchema) +``` + +GraphQL daje nam tylko nieprzezroczysty obiekt danych z bajtami. Aby go zrozumieć, potrzebujemy schematu. + +```typescript +const ethereumAddressToEmail = async ethAddr => { +``` + +Funkcja do konwersji adresu Ethereum na adres e-mail. + +```typescript + const query = ` + query GetAttestationsByRecipient { +``` + +To jest zapytanie GraphQL. + +```typescript + poświadczenia( +``` + +Szukamy poświadczeń. + +```typescript + where: { + recipient: { equals: "${getAddress(ethAddr)}" } + schemaId: { equals: "0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977" } + } +``` + +Poświadczenia, których chcemy, to te w naszym schemacie, gdzie odbiorcą jest `getAddress(ethAddr)`. Funkcja [`getAddress`](https://viem.sh/docs/utilities/getAddress#getaddress) upewnia się, że nasz adres ma poprawną [sumę kontrolną](https://github.com/ethereum/ercs/blob/master/ERCS/erc-55.md). Jest to konieczne, ponieważ w GraphQL wielkość liter ma znaczenie. "0xBAD060A7", "0xBad060A7" i "0xbad060a7" to różne wartości. + +```typescript + take: 1 +``` + +Niezależnie od tego, ile poświadczeń znajdziemy, chcemy tylko pierwsze. + +```typescript + ) { + data + id + attester + } + }` +``` + +Pola, które chcemy otrzymać. + +- `attester`: Adres, który przesłał poświadczenie. Zwykle służy to do decydowania, czy ufać poświadczeniu, czy nie. +- `id`: ID poświadczenia. Możesz użyć tej wartości, aby [odczytać poświadczenie on-chain](https://optimism.blockscout.com/address/0x4200000000000000000000000000000000000021?tab=read_proxy&source_address=0x4E0275Ea5a89e7a3c1B58411379D1a0eDdc5b088#0xa3112a64), aby zweryfikować, czy informacje z zapytania GraphQL są poprawne. +- `data`: Dane schematu (w tym przypadku adres e-mail). + +```typescript + const queryResult = await graphqlClient.request(query) + + if (queryResult.attestations.length == 0) + return "no_address@available.is" +``` + +Jeśli nie ma poświadczenia, zwróć wartość, która jest oczywiście nieprawidłowa, ale która wydawałaby się ważna dla dostawcy usług. + +```typescript + const attestationDataFields = graphqlEncoder.decodeData(queryResult.attestations[0].data) + return attestationDataFields[0].value.value +} +``` + +Jeśli istnieje wartość, użyj `decodeData` do zdekodowania danych. Nie potrzebujemy metadanych, które dostarcza, tylko samej wartości. + +```typescript + const loginResponse = await idp.createLoginResponse( + sp, + { + . + . + . + }, + "post", + { + email: await ethereumAddressToEmail(req.params.account) + } + ); +``` + +Użyj nowej funkcji, aby uzyskać adres e-mail. + +## A co z decentralizacją? + +W tej konfiguracji użytkownicy nie mogą udawać kogoś, kim nie są, o ile polegamy na godnych zaufania poświadczających w mapowaniu adresów Ethereum na adresy e-mail. Jednak nasz dostawca tożsamości jest nadal scentralizowanym komponentem. Każdy, kto ma klucz prywatny dostawcy tożsamości, może wysyłać fałszywe informacje do dostawcy usług. + +Może istnieć rozwiązanie wykorzystujące [obliczenia wielostronne (MPC)](https://en.wikipedia.org/wiki/Secure_multi-party_computation). Mam nadzieję napisać o tym w przyszłym samouczku. + +## Podsumowanie + +Przyjęcie standardu logowania, takiego jak podpisy Ethereum, stoi przed problemem jajka i kury. Dostawcy usług chcą dotrzeć do jak najszerszego rynku. Użytkownicy chcą mieć dostęp do usług bez martwienia się o obsługę ich standardu logowania. +Tworzenie adapterów, takich jak IdP Ethereum, może pomóc nam pokonać tę przeszkodę. + +[Zobacz więcej mojej pracy tutaj](https://cryptodocguy.pro/). diff --git a/public/content/translations/pl/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md b/public/content/translations/pl/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md index cf2a15cfcc5..d155d9ef78e 100644 --- a/public/content/translations/pl/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md +++ b/public/content/translations/pl/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md @@ -1,100 +1,101 @@ --- -title: Pierwsze kroki programowania w Ethereum za pomocą Alchemy -description: "To jest przewodnik dla początkujących, jak rozpocząć programowanie w Ethereum za pomocą Alchemy. Przeprowadzimy Cię od rejestracji w Alchemy, przez wysłanie żądania w wierszu poleceń, do napisania pierwszego skryptu web3! Nie jest wymagane doświadczenie w programowaniu blockchain!" +title: Pierwsze kroki w programowaniu w Ethereum +description: "To jest przewodnik dla początkujących, jak zacząć programować w Ethereum. Przeprowadzimy Cię od uruchomienia punktu końcowego API, przez wysłanie żądania z wiersza poleceń, aż po napisanie Twojego pierwszego skryptu web3! Doświadczenie w programowaniu blockchain nie jest wymagane!" author: "Elan Halpern" tags: - - "pierwsze kroki" - - "javascript" - - "ethers.js" - - "węzły" - - "zapytania" - - "alchemy" + [ + "JavaScript", + "ethers.js", + "węzły", + "zapytania", + "alchemy" + ] skill: beginner lang: pl published: 2020-10-30 -source: Średni +source: Medium sourceUrl: https://medium.com/alchemy-api/getting-started-with-ethereum-development-using-alchemy-c3d6a45c567f --- - + -To jest przewodnik dla początkujących po rozpoczęciu programowania w Ethereum przy użyciu [Alchemy](https://alchemyapi.io/), wiodącej platformy dla twórców blockchainów wykorzystywanej przez miliony użytkowników z 70% najlepszych aplikacji blockchain, w tym Maker, 0x, MyEtherWallet, Dharma i Kyber. +To jest przewodnik dla początkujących, jak zacząć programować w Ethereum. W tym samouczku będziemy używać [Alchemy](https://alchemyapi.io/), wiodącej platformy dla deweloperów blockchain, która obsługuje miliony użytkowników z 70% najlepszych aplikacji blockchain, w tym Maker, 0x, MyEtherWallet, Dharma i Kyber. Alchemy da nam dostęp do punktu końcowego API w łańcuchu Ethereum, dzięki czemu będziemy mogli odczytywać i zapisywać transakcje. -Zarejestruj się w Alchemy, aby napisać swój pierwszy skrypt web3! Nie jest wymagane doświadczenie w programowaniu blockchain! +Przeprowadzimy Cię od rejestracji w Alchemy do napisania pierwszego skryptu web3! Doświadczenie w programowaniu blockchain nie jest wymagane! -## 1\. Zarejestruj się na darmowym koncie Alchemy {#sign-up-for-a-free-alchemy-account} +## 1. Zarejestruj darmowe konto Alchemy {#sign-up-for-a-free-alchemy-account} -Tworzenie konta z Alchemy jest łatwe, [zarejestruj się za darmo tutaj](https://auth.alchemyapi.io/signup). +Utworzenie konta w Alchemy jest proste, [zarejestruj się za darmo tutaj](https://auth.alchemy.com/). -## 2\. Utwórz aplikację Alchemy {#create-an-alchemy-app} +## 2. Utwórz aplikację Alchemy {#create-an-alchemy-app} -Aby korzystać z produktów Alchemy, potrzebujesz klucza API do uwierzytelnienia swoich żądań. +Aby komunikować się z łańcuchem Ethereum i korzystać z produktów Alchemy, potrzebujesz klucza API do uwierzytelniania swoich żądań. -Możesz [tworzyć klucze API z panelu](http://dashboard.alchemyapi.io/). Aby utworzyć nowy klucz, przejdź do „Utwórz aplikację”, jak pokazano poniżej: +Możesz [utworzyć klucze API z pulpitu nawigacyjnego](https://dashboard.alchemy.com/). Aby utworzyć nowy klucz, przejdź do „Utwórz aplikację”, jak pokazano poniżej: -Specjalne podziękowania dla [_ShapeShift_](https://shapeshift.com/) _za umożliwienie nam pokazania ich panelu!_ +Specjalne podziękowania dla [_ShapeShift_](https://shapeshift.com/) _za umożliwienie nam pokazania ich pulpitu nawigacyjnego!_ - + -Wypełnij szczegóły w sekcji „Utwórz aplikację”, aby uzyskać swój nowy klucz. Możesz również zobaczyć aplikacje, które wcześniej stworzyłeś i aplikacje wykonane przez swój zespół tutaj. Pociągnij istniejące klucze, klikając „Wyświetl klucz” dla dowolnej aplikacji. +Wypełnij dane w sekcji „Utwórz aplikację”, aby otrzymać nowy klucz. Możesz tu również zobaczyć aplikacje utworzone wcześniej przez Ciebie i przez Twój zespół. Pobierz istniejące klucze, klikając „Wyświetl klucz” dla dowolnej aplikacji. - + -Możesz również ściągnąć istniejące klucze API, umieszczając kursor myszy nad „Aplikacje” i wybierając jeden. Możesz tutaj „Wyświetlić klucz”, a także „Edytować aplikację”, aby dodać określone domeny do białej listy, zobaczyć kilka narzędzi dla programistów i wyświetlić dane analityczne. +Możesz także pobrać istniejące klucze API, najeżdżając kursorem na „Aplikacje” i wybierając jedną z nich. Możesz tu „Wyświetlić klucz”, a także „Edytować aplikację”, aby dodać określone domeny do białej listy, zobaczyć kilka narzędzi dla deweloperów i wyświetlić analitykę. - + -## 3\. Zgłoś żądanie z wiersza poleceń {#make-a-request-from-the-command-line} +## 3. Wyślij żądanie z wiersza poleceń {#make-a-request-from-the-command-line} -Współpracuj z blockchainem Ethereum przez Alchemy, używając JSON-RPC i curl. +Wchodź w interakcje z blockchainem Ethereum za pośrednictwem Alchemy za pomocą JSON-RPC i curl. -Dla żądań ręcznych, zalecamy zastosowanie `JSON-RPC` poprzez `POST`. Wystarczy przekazać nagłówek `Content-Type: application/json` i zapytanie jako treść `POST` z następującymi polami: +W przypadku żądań ręcznych zalecamy interakcję z `JSON-RPC` za pośrednictwem żądań `POST`. Po prostu przekaż nagłówek `Content-Type: application/json` i swoje zapytanie jako treść `POST` z następującymi polami: -- `jsonrpc`: wersja JSON-RPC - obecnie obsługiwana jest tylko `2.0`. -- `method`: metoda ETH API. [Zobacz materiały dot. API.](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc) -- `params`: lista parametrów do przekazania do metody. -- `id`: identyfikator Twojego żądania. Zostanie zwrócony wraz z odpowiedzią, dzięki czemu można śledzić, do którego żądania należy odpowiedź. +- `jsonrpc`: Wersja JSON-RPC — obecnie obsługiwana jest tylko wersja `2.0`. +- `method`: Metoda API ETH. [Zobacz dokumentację API.](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc) +- `params`: Lista parametrów do przekazania do metody. +- `id`: ID Twojego żądania. Zostanie zwrócone w odpowiedzi, dzięki czemu możesz śledzić, do którego żądania należy dana odpowiedź. -Poniżej znajduje się przykład, który można uruchomić z wiersza poleceń, aby uzyskać aktualną cenę gazu: +Oto przykład, który możesz uruchomić z wiersza poleceń, aby pobrać aktualną cenę gazu: ```bash -curl [https://eth-mainnet.alchemyapi.io/v2/demo](https://eth-mainnet.alchemyapi.io/v2/demo) \ +curl https://eth-mainnet.alchemyapi.io/v2/demo \ -X POST \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":73}' ``` -**_UWAGA:_** _Zamień_ [_https://eth-mainnet.alchemyapi. o/v2/demo_](https://eth-mainnet.alchemyapi.io/jsonrpc/demo) _z własnym kluczem API_ [_https://eth-mainnet.alchemyapi.io/v2/your-api-key_](https://eth-mainnet.alchemyapi.io/jsonrpc/your-api-key)_._ +_**UWAGA:** Zastąp [https://eth-mainnet.alchemyapi.io/v2/demo](https://eth-mainnet.alchemyapi.io/jsonrpc/demo) własnym kluczem API `https://eth-mainnet.alchemyapi.io/v2/**your-api-key`._ -**Wynik:** +**Wyniki:** ```json -{ "id": 73,"jsonrpc": "2.0","result": "0x09184e72a000" // 100000000000000000 } +{ "id": 73,"jsonrpc": "2.0","result": "0x09184e72a000" // 10000000000000 } ``` -## 4\. Skonfiguruj swojego klienta Web3 {#set-up-your-web3-client} +## 4. Skonfiguruj swojego klienta Web3 {#set-up-your-web3-client} -**Jeśli masz istniejącego klienta,** zmień adres URL aktualnego dostawcy węzła na adres URL Alchemy z kluczem API: `"https://eth-mainnet.alchemyapi.io/v2/your-api-key"` +**Jeśli masz już istniejącego klienta,** zmień adres URL swojego obecnego dostawcy węzła na adres URL Alchemy z Twoim kluczem API: `“https://eth-mainnet.alchemyapi.io/v2/your-api-key\"` -**_UWAGA:_** Skrypty poniżej muszą być uruchomione w **kontekście węzłów** lub **zapisane w pliku**, nie uruchamiaj z wiersza poleceń. Jeśli nie masz jeszcze zainstalowanego węzła lub npm, sprawdź ten [przewodnik konfiguracji macs](https://app.gitbook.com/@alchemyapi/s/alchemy/guides/alchemy-for-macs). +**_UWAGA:_** Poniższe skrypty muszą być uruchamiane w **kontekście node** lub **zapisane w pliku**, a nie z wiersza poleceń. Jeśli nie masz jeszcze zainstalowanego Node lub npm, zapoznaj się z tym krótkim [przewodnikiem konfiguracji dla komputerów Mac](https://app.gitbook.com/@alchemyapi/s/alchemy/guides/alchemy-for-macs). -Istnieją tony [bibliotek Web3](https://docs.alchemyapi.io/guides/getting-started#other-web3-libraries) które możesz zintegrować z alchemy. zalecamy użycie [Alchemy Web3](https://docs.alchemy.com/reference/api-overview), upuszczonego zamiennika dla web3., zbudowany i skonfigurowany do bezproblemowej pracy z Alchemy. Zapewnia to wiele zalet, takich jak automatyczne próby i solidne wsparcie WebSocket. +Istnieje mnóstwo [bibliotek Web3](https://docs.alchemyapi.io/guides/getting-started#other-web3-libraries), które można zintegrować z Alchemy, jednak zalecamy użycie [Alchemy Web3](https://docs.alchemy.com/reference/api-overview), zamiennika dla web3.js, stworzonego i skonfigurowanego do bezproblemowej pracy z Alchemy. Zapewnia to wiele korzyści, takich jak automatyczne ponawianie prób i solidne wsparcie dla WebSocket. -Aby zainstalować AlchemyWeb3.js, **przejdź do katalogu projektu** i uruchom: +Aby zainstalować AlchemyWeb3.js, **przejdź do katalogu swojego projektu** i uruchom: -**Z Yarn:** +**Za pomocą Yarn:** ``` -yarn dodaj @alch/alchemy-web3 +yarn add @alch/alchemy-web3 ``` -**Z NPM:** +**Za pomocą NPM:** ``` npm install @alch/alchemy-web3 ``` -Aby wejść w interakcję z infrastrukturą węzła Alchemy, uruchom w NodeJS lub dodaj to do pliku JavaScript: +Aby wejść w interakcję z infrastrukturą węzłów Alchemy, uruchom w NodeJS lub dodaj to do pliku JavaScript: ```js const { createAlchemyWeb3 } = require("@alch/alchemy-web3") @@ -103,52 +104,53 @@ const web3 = createAlchemyWeb3( ) ``` -## 5\. Napisz swój pierwszy skrypt Web3! {#write-your-first-web3-script} +## 5. Napisz swój pierwszy skrypt Web3! {#write-your-first-web3-script} -Teraz, aby ubrudzić sobie ręce odrobiną programowania web3, napiszemy prosty skrypt, który wypisuje najnowszy numer bloku z sieci głównej Ethereum. +Teraz, aby trochę pobrudzić sobie ręce programowaniem w web3, napiszemy prosty skrypt, który wyświetla numer ostatniego bloku z sieci głównej Ethereum. -1. **Jeśli jeszcze tego nie zrobiłeś, w swoim terminalu utwórz nowy katalog projektów i przejdź do niego:** +**1. Jeśli jeszcze tego nie zrobiłeś, utwórz w terminalu nowy katalog projektu i przejdź do niego:** ``` -mkdir web3-examplecd web3-example +mkdir web3-example +cd web3-example ``` -**2\. Zainstaluj zależność Alchemy web3 (lub dowolny web3) w swoim projekcie, jeśli jeszcze tego nie zrobiłeś:** +**2. Zainstaluj w swoim projekcie zależność Alchemy web3 (lub dowolną web3), jeśli jeszcze tego nie zrobiłeś:** ``` npm install @alch/alchemy-web3 ``` -**3. Utwórz plik o nazwie** `index.js` **i dodaj następujące treści:** +**3. Utwórz plik o nazwie `index.js` i dodaj następującą zawartość:** -> Ostatecznie powinieneś zastąpić `demo` kluczem API Alchemy. +> Docelowo należy zastąpić `demo` swoim kluczem API HTTP Alchemy. ```js async function main() { const { createAlchemyWeb3 } = require("@alch/alchemy-web3") - const web3 = createAlchemyWeb3("https://eth- mainnet.alchemyapi.io/v2/demo") + const web3 = createAlchemyWeb3("https://eth-mainnet.alchemyapi.io/v2/demo") const blockNumber = await web3.eth.getBlockNumber() - console.log("The latest block number is " + blockNumber) + console.log("Najnowszy numer bloku to " + blockNumber) } main() ``` -Nie znasz rozwiązań asynchronicznych? Sprawdź to [Medium post](https://medium.com/better-programming/understanding-async-await-in-javascript-1d81bb079b2c). +Nie znasz rozwiązań asynchronicznych? Sprawdź ten [wpis na Medium](https://medium.com/better-programming/understanding-async-await-in-javascript-1d81bb079b2c). -**4\. Uruchom go w swoim terminalu, używając węzła** +**4. Uruchom to w terminalu za pomocą node** ``` node index.js ``` -**5. Powinieneś teraz zobaczyć najnowszy numer bloku w konsoli!** +**5. Powinieneś teraz zobaczyć w konsoli wynik z najnowszym numerem bloku!** ``` -The latest block number is 11043912 +Najnowszy numer bloku to 11043912 ``` -**Woo! Gratulacje! Właśnie napisałeś swój pierwszy skrypt web3 używając Alchemy 🎉** +**Woo! Gratulacje! Właśnie napisałeś swój pierwszy skrypt web3 przy użyciu Alchemy 🎉** -Nie jesteś pewien, co zrobić dalej? Spróbuj wdrożyć pierwszy kontrakt inteligentny i popracuj, programując w Solidity [_Hello World Smart_](https://docs.alchemyapi.io/tutorials/hello-world-smart-contract) _Contract Guide, lub sprawdź, co wiesz o pulpicie nawigacyjnym za pomocą_ [_Dashboard Demo App_](https://docs.alchemyapi.io/tutorials/demo-app)_!_ +Nie wiesz, co robić dalej? Spróbuj wdrożyć swój pierwszy smart kontrakt i pobrudź sobie ręce programowaniem w Solidity w naszym [przewodniku po smart kontraktach „Hello World”](https://www.alchemy.com/docs/hello-world-smart-contract) lub sprawdź swoją wiedzę o pulpicie nawigacyjnym za pomocą [aplikacji demonstracyjnej pulpitu nawigacyjnego](https://docs.alchemyapi.io/tutorials/demo-app)! -_[Zarejestruj się przy użyciu Alchemy za darmo](https://auth.alchemyapi.io/signup), sprawdź naszą [dokumentację](https://docs.alchemyapi.io/), oraz najnowsze wiadomości, obserwuj nas na [Twitterze](https://twitter.com/AlchemyPlatform)_. +_[Zarejestruj się w Alchemy za darmo](https://auth.alchemy.com/), sprawdź naszą [dokumentację](https://www.alchemy.com/docs/), a aby być na bieżąco z najnowszymi wiadomościami, obserwuj nas na [Twitterze](https://twitter.com/AlchemyPlatform)_. diff --git a/public/content/translations/pl/developers/tutorials/guide-to-smart-contract-security-tools/index.md b/public/content/translations/pl/developers/tutorials/guide-to-smart-contract-security-tools/index.md new file mode 100644 index 00000000000..128cd64046e --- /dev/null +++ b/public/content/translations/pl/developers/tutorials/guide-to-smart-contract-security-tools/index.md @@ -0,0 +1,102 @@ +--- +title: "Przewodnik po narzędziach bezpieczeństwa inteligentnych kontraktów" +description: "Przegląd trzech różnych technik testowania i analizy programu" +author: "Trailofbits" +lang: pl +tags: [ "solidity", "smart kontrakty", "bezpieczeństwo" ] +skill: intermediate +published: 2020-09-07 +source: Building secure contracts +sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis +--- + +Użyjemy trzech odrębnych technik testowania i analizy programu: + +- **Analiza statyczna z użyciem [Slither](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/).** Wszystkie ścieżki programu są aproksymowane i analizowane w tym samym czasie, poprzez różne reprezentacje programu (np. graf przepływu sterowania) +- **Fuzzing z użyciem [Echidna](/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/).** Kod jest wykonywany z pseudolosowym generowaniem transakcji. Fuzzer będzie próbował znaleźć sekwencję transakcji naruszającą daną właściwość. +- **Wykonanie symboliczne z użyciem [Manticore](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/).** Formalna technika weryfikacji, która tłumaczy każdą ścieżkę wykonania na formułę matematyczną, na której można sprawdzać ograniczenia. + +Każda technika ma zalety i wady i będzie przydatna w [określonych przypadkach](#determining-security-properties): + +| Technika | Narzędzie | Zastosowanie | Szybkość | Pominięte błędy | Fałszywe alarmy | +| --------------------- | --------- | ------------------------------ | -------- | --------------- | --------------- | +| Analiza statyczna | Slither | CLI i skrypty | sekundy | umiarkowany | niski | +| Fuzzing | Echidna | Właściwości Solidity | minuty | niski | brak | +| Wykonanie symboliczne | Manticore | Właściwości Solidity i skrypty | godziny | brak\* | brak | + +\* jeśli wszystkie ścieżki zostaną zbadane bez przekroczenia limitu czasu + +**Slither** analizuje kontrakty w ciągu kilku sekund, jednak analiza statyczna może prowadzić do fałszywych alarmów i będzie mniej odpowiednia do złożonych sprawdzeń (np. sprawdzeń arytmetycznych). Uruchom Slither przez API, aby uzyskać łatwy dostęp do wbudowanych detektorów lub przez API, aby uzyskać dostęp do sprawdzeń zdefiniowanych przez użytkownika. + +**Echidna** musi działać przez kilka minut i będzie generować tylko prawdziwie pozytywne wyniki. Echidna sprawdza właściwości bezpieczeństwa dostarczone przez użytkownika, napisane w Solidity. Może pominąć błędy, ponieważ opiera się na losowej eksploracji. + +**Manticore** wykonuje analizę \ Podobnie jak Echidna, Manticore weryfikuje właściwości dostarczone przez użytkownika. Potrzebuje więcej czasu na uruchomienie, ale może udowodnić poprawność właściwości i nie zgłasza fałszywych alarmów. + +## Sugerowany przepływ pracy {#suggested-workflow} + +Zacznij od wbudowanych detektorów Slither, aby upewnić się, że żadne proste błędy nie są obecnie obecne ani nie zostaną wprowadzone później. Użyj Slither do sprawdzania właściwości związanych z dziedziczeniem, zależnościami zmiennych i problemami strukturalnymi. W miarę rozrastania się bazy kodu użyj Echidny do testowania bardziej złożonych właściwości maszyny stanu. Wróć do Slither, aby opracować niestandardowe sprawdzenia zabezpieczeń niedostępnych w Solidity, takie jak ochrona przed nadpisaniem funkcji. Na koniec użyj Manticore do przeprowadzenia ukierunkowanej weryfikacji krytycznych właściwości bezpieczeństwa, np. operacji arytmetycznych. + +- Użyj CLI Slither do wykrywania typowych problemów +- Użyj Echidny do testowania właściwości bezpieczeństwa wysokiego poziomu Twojego kontraktu +- Użyj Slither do pisania niestandardowych sprawdzeń statycznych +- Użyj Manticore, aby uzyskać dogłębną pewność co do krytycznych właściwości bezpieczeństwa + +**Uwaga na temat testów jednostkowych**. Testy jednostkowe są niezbędne do tworzenia oprogramowania wysokiej jakości. Jednakże techniki te nie są najlepiej przystosowane do znajdowania luk w zabezpieczeniach. Zazwyczaj są one używane do testowania pozytywnych zachowań kodu (tj. kod działa zgodnie z oczekiwaniami w normalnym kontekście), podczas gdy luki w zabezpieczeniach mają tendencję do występowania w przypadkach brzegowych, których deweloperzy nie wzięli pod uwagę. W naszym badaniu dziesiątek przeglądów bezpieczeństwa inteligentnych kontraktów, [pokrycie testami jednostkowymi nie miało wpływu na liczbę ani wagę luk w zabezpieczeniach](https://blog.trailofbits.com/2019/08/08/246-findings-from-our-smart-contract-audits-an-executive-summary/), które znaleźliśmy w kodzie naszych klientów. + +## Określanie właściwości bezpieczeństwa {#determining-security-properties} + +Aby skutecznie testować i weryfikować swój kod, musisz zidentyfikować obszary, które wymagają uwagi. Ponieważ Twoje zasoby przeznaczone na bezpieczeństwo są ograniczone, ważne jest określenie słabych lub wartościowych części Twojej bazy kodu, aby zoptymalizować Twój wysiłek. Modelowanie zagrożeń może pomóc. Rozważ przejrzenie: + +- [Szybkie oceny ryzyka (Rapid Risk Assessments)](https://infosec.mozilla.org/guidelines/risk/rapid_risk_assessment.html) (nasze preferowane podejście, gdy brakuje czasu) +- [Przewodnik po modelowaniu zagrożeń systemu zorientowanego na dane](https://csrc.nist.gov/pubs/sp/800/154/ipd) (znany również jako NIST 800-154) +- [Modelowanie zagrożeń wg Shostacka](https://www.amazon.com/Threat-Modeling-Designing-Adam-Shostack/dp/1118809998) +- [STRIDE](https://wikipedia.org/wiki/STRIDE_\(security\)) / [DREAD](https://wikipedia.org/wiki/DREAD_\(risk_assessment_model\)) +- [PASTA](https://wikipedia.org/wiki/Threat_model#P.A.S.T.A.) +- [Użycie asercji](https://blog.regehr.org/archives/1091) + +### Komponenty {#components} + +Wiedza o tym, co chcesz sprawdzić, pomoże Ci również w wyborze odpowiedniego narzędzia. + +Szerokie obszary, które są często istotne dla inteligentnych kontraktów, obejmują: + +- **Maszyna stanu.** Większość kontraktów można przedstawić jako maszynę stanu. Rozważ sprawdzenie, czy (1) nie można osiągnąć żadnego nieprawidłowego stanu, (2) jeśli stan jest prawidłowy, to można go osiągnąć, oraz (3) żaden stan nie blokuje kontraktu. + + - Echidna i Manticore to narzędzia, które należy preferować do testowania specyfikacji maszyn stanów. + +- **Kontrola dostępu.** Jeśli Twój system ma uprzywilejowanych użytkowników (np. właściciela, kontrolerów, ...) musisz upewnić się, że (1) każdy użytkownik może wykonywać tylko autoryzowane działania oraz (2) żaden użytkownik nie może blokować działań bardziej uprzywilejowanego użytkownika. + + - Slither, Echidna i Manticore mogą sprawdzać poprawność kontroli dostępu. Na przykład Slither może sprawdzić, czy tylko funkcje z białej listy nie mają modyfikatora onlyOwner. Echidna i Manticore są przydatne do bardziej złożonej kontroli dostępu, takiej jak uprawnienie przyznawane tylko wtedy, gdy kontrakt osiągnie określony stan. + +- **Operacje arytmetyczne.** Sprawdzanie poprawności operacji arytmetycznych ma kluczowe znaczenie. Używanie `SafeMath` wszędzie jest dobrym krokiem w celu zapobiegania przepełnieniom/niedopełnieniom, jednak nadal musisz brać pod uwagę inne wady arytmetyczne, w tym problemy z zaokrąglaniem i błędy, które blokują kontrakt. + + - Manticore jest tutaj najlepszym wyborem. Echidna może być używana, jeśli arytmetyka jest poza zakresem solwera SMT. + +- **Poprawność dziedziczenia.** Kontrakty Solidity w dużym stopniu opierają się na wielokrotnym dziedziczeniu. Łatwo można wprowadzić błędy, takie jak przesłaniająca funkcja bez wywołania `super` i błędnie zinterpretowany porządek linearyzacji c3. + + - Slither jest narzędziem zapewniającym wykrycie tych problemów. + +- **Interakcje zewnętrzne.** Kontrakty wchodzą w interakcje ze sobą, a niektórym kontraktom zewnętrznym nie należy ufać. Na przykład, jeśli Twój kontrakt opiera się na zewnętrznych oracle'ach, czy pozostanie bezpieczny, jeśli połowa dostępnych oracle'i zostanie naruszona? + + - Manticore i Echidna to najlepszy wybór do testowania zewnętrznych interakcji z Twoimi kontraktami. Manticore ma wbudowany mechanizm do zaślepiania zewnętrznych kontraktów. + +- **Zgodność ze standardami.** Standardy Ethereum (np. ERC20) mają w swojej historii błędy projektowe. Bądź świadomy ograniczeń standardu, na którym budujesz. + - Slither, Echidna i Manticore pomogą Ci wykryć odchylenia od danego standardu. + +### Ściągawka doboru narzędzi {#tool-selection-cheatsheet} + +| Komponent | Narzędzia | Przykłady | +| ------------------------ | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Maszyna stanu | Echidna, Manticore | | +| Kontrola dostępu | Slither, Echidna, Manticore | [Ćwiczenie 2 Slither](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise2.md), [Ćwiczenie 2 Echidna](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-2.md) | +| Operacje arytmetyczne | Manticore, Echidna | [Ćwiczenie 1 Echidna](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-1.md), [Ćwiczenia 1-3 Manticore](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore/exercises) | +| Poprawność dziedziczenia | Slither | [Ćwiczenie 1 Slither](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise1.md) | +| Interakcje zewnętrzne | Manticore, Echidna | | +| Zgodność ze standardem | Slither, Echidna, Manticore | [`slither-erc`](https://github.com/crytic/slither/wiki/ERC-Conformance) | + +Inne obszary będą wymagały sprawdzenia w zależności od Twoich celów, ale te ogólne obszary zainteresowania są dobrym punktem wyjścia dla każdego systemu inteligentnych kontraktów. + +Nasze publiczne audyty zawierają przykłady zweryfikowanych lub przetestowanych właściwości. Rozważ przeczytanie sekcji `Automated Testing and Verification` w poniższych raportach, aby przejrzeć rzeczywiste właściwości bezpieczeństwa: + +- [0x](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) +- [Balancer](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) diff --git a/public/content/translations/pl/developers/tutorials/hello-world-smart-contract-fullstack/index.md b/public/content/translations/pl/developers/tutorials/hello-world-smart-contract-fullstack/index.md new file mode 100644 index 00000000000..99b5e8c5c77 --- /dev/null +++ b/public/content/translations/pl/developers/tutorials/hello-world-smart-contract-fullstack/index.md @@ -0,0 +1,1543 @@ +--- +title: "Inteligentny kontrakt „Witaj świecie” dla początkujących – Fullstack" +description: "Samouczek wprowadzający na temat pisania i wdrażania prostego inteligentnego kontraktu na Ethereum." +author: "nstrike2" +tags: + [ + "solidity", + "hardhat", + "alchemy", + "smart kontrakty", + "wdrażanie", + "eksplorator bloków", + "frontend", + "transakcje" + ] +skill: beginner +lang: pl +published: 2021-10-25 +--- + +Ten przewodnik jest dla Ciebie, jeśli jesteś nowy w tworzeniu blockchaina i nie wiesz, od czego zacząć lub jak wdrażać i wchodzić w interakcję z inteligentnymi kontraktami. Przeprowadzimy Cię przez proces tworzenia i wdrażania prostego inteligentnego kontraktu w sieci testowej Goerli przy użyciu [MetaMask](https://metamask.io), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org) i [Alchemy](https://alchemy.com/eth). + +Do ukończenia tego samouczka potrzebne będzie konto Alchemy. [Zarejestruj się, aby założyć darmowe konto](https://www.alchemy.com/). + +Jeśli masz jakieś pytania, skontaktuj się z nami na [Discordzie Alchemy](https://discord.gg/gWuC7zB)! + +## Część 1 – Utwórz i wdróż swój inteligentny kontrakt za pomocą Hardhat {#part-1} + +### Połącz się z siecią Ethereum {#connect-to-the-ethereum-network} + +Istnieje wiele sposobów na wysyłanie żądań do łańcucha Ethereum. Dla uproszczenia, użyjemy darmowego konta na Alchemy, platformie deweloperskiej i interfejsie API blockchaina, które pozwalają nam komunikować się z łańcuchem Ethereum bez konieczności samodzielnego uruchamiania węzła. Alchemy posiada również narzędzia deweloperskie do monitorowania i analityki. Skorzystamy z nich w tym samouczku, aby zrozumieć, co dzieje się pod maską podczas wdrażania naszego inteligentnego kontraktu. + +### Utwórz swoją aplikację i klucz API {#create-your-app-and-api-key} + +Po utworzeniu konta Alchemy, można wygenerować klucz API, tworząc aplikację. Umożliwi to wysyłanie żądań do sieci testowej Goerli. Jeśli nie znasz sieci testowych, możesz [przeczytać przewodnik Alchemy dotyczący wyboru sieci](https://www.alchemy.com/docs/choosing-a-web3-network). + +Na pulpicie nawigacyjnym Alchemy znajdź menu rozwijane **Aplikacje** w pasku nawigacyjnym i kliknij **Utwórz aplikację**. + + + +Nadaj swojej aplikacji nazwę „_Hello World_” i wpisz krótki opis. Wybierz **Staging** jako środowisko i **Goerli** jako sieć. + + + +_Uwaga: upewnij się, że wybrałeś **Goerli**, w przeciwnym razie ten samouczek nie zadziała._ + +Kliknij **Utwórz aplikację**. Twoja aplikacja pojawi się w poniższej tabeli. + +### Utwórz konto Ethereum {#create-an-ethereum-account} + +Aby wysyłać i odbierać transakcje, potrzebujesz konta Ethereum. Użyjemy MetaMask, wirtualnego portfela w przeglądarce, który pozwala użytkownikom zarządzać adresem konta Ethereum. + +Możesz pobrać i utworzyć konto MetaMask za darmo [tutaj](https://metamask.io/download). Podczas tworzenia konta, lub jeśli już je posiadasz, upewnij się, że przełączyłeś się na „Sieć testową Goerli” w prawym górnym rogu (aby nie mieć do czynienia z prawdziwymi pieniędzmi). + +### Krok 4: Dodaj ether z Faucet {#step-4-add-ether-from-a-faucet} + +Aby wdrożyć swój inteligentny kontrakt w sieci testowej, będziesz potrzebować trochę fałszywych ETH. Aby uzyskać ETH w sieci Goerli, przejdź do Faucet Goerli i wprowadź adres swojego konta Goerli. Należy pamiętać, że krany Goerli mogą być ostatnio nieco zawodne - sprawdź [stronę sieci testowych](/developers/docs/networks/#goerli), aby uzyskać listę opcji do wypróbowania: + +_Uwaga: ze względu na przeciążenie sieci może to trochę potrwać._ + +### Krok 5: Sprawdź swoje saldo {#step-5-check-your-balance} + +Aby dwukrotnie sprawdzić, czy ETH znajduje się w Twoim portfelu, wykonaj żądanie [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) za pomocą [narzędzia kompozytora Alchemy](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Zwróci to ilość ETH w naszym portfelu. Aby dowiedzieć się więcej, sprawdź [krótki samouczek Alchemy na temat korzystania z narzędzia kompozytora](https://youtu.be/r6sjRxBZJuU). + +Wprowadź swój adres konta MetaMask i kliknij **Wyślij żądanie**. Zobaczysz odpowiedź, która wygląda jak poniższy fragment kodu. + +```json +{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" } +``` + +> _Uwaga: Ten wynik jest w wei, nie w ETH. Wei jest używane jako najmniejsza jednostka etheru._ + +Uff! Wszystkie nasze fałszywe pieniądze są na miejscu. + +### Krok 6: Zainicjuj nasz projekt {#step-6-initialize-our-project} + +Najpierw musimy utworzyć folder dla naszego projektu. Przejdź do wiersza poleceń i wprowadź następujące informacje. + +``` +mkdir hello-world +cd 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, aby zainstalować Node.js i npm](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm). + +Dla celów tego samouczka nie ma znaczenia, jak odpowiesz na pytania inicjujące. Oto, jak zrobiliśmy to dla odniesienia: + +``` +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" +} +``` + +Zatwierdź plik package.json i gotowe! + +### Krok 7: Pobierz Hardhat {#step-7-download-hardhat} + +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: + +``` +npm install --save-dev hardhat +``` + +Sprawdź tę stronę, aby uzyskać więcej szczegółów na temat [instrukcji instalacji](https://hardhat.org/getting-started/#overview). + +### Krok 8: Utwórz projekt Hardhat {#step-8-create-hardhat-project} + +W naszym folderze projektu `hello-world` uruchom: + +``` +npx hardhat +``` + +Powinieneś wtedy zobaczyć wiadomość powitalną i opcję wyboru tego, co chcesz zrobić. Wybierz „utwórz pusty 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 + +👷 Witamy w Hardhat v2.0.11 👷 + +Co chcesz zrobić? … +Utwórz przykładowy projekt +❯ Utwórz pusty plik hardhat.config.js +Zamknij +``` + +Spowoduje to wygenerowanie pliku `hardhat.config.js` w projekcie. Użyjemy tego później w samouczku, aby określić konfigurację naszego projektu. + +### Krok 9: Dodaj foldery projektu {#step-9-add-project-folders} + +Aby utrzymać porządek w projekcie, utwórzmy dwa nowe foldery. W wierszu poleceń przejdź do katalogu głównego projektu `hello-world` i wpisz: + +``` +mkdir contracts +mkdir 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 {#step-10-write-our-contract} + +Możesz zadać sobie pytanie, kiedy napiszemy kod? Nadszedł czas! + +Otwórz projekt hello-world w swoim ulubionym edytorze. Inteligentne kontrakty najczęściej pisane są w Solidity, którego użyjemy do napisania naszego inteligentnego kontraktu. + +1. Przejdź do folderu `contracts` i utwórz nowy plik o nazwie `HelloWorld.sol` +2. Poniżej znajduje się przykładowy inteligentny kontrakt Witaj Świecie, którego będziemy używać w tym samouczku. Skopiuj poniższą zawartość do pliku `HelloWorld.sol`. + +_Uwaga: Pamiętaj, aby przeczytać komentarze, aby zrozumieć, co robi ten kontrakt._ + +``` +// Określa wersję Solidity, używając semantycznego wersjonowania. +// Dowiedz się więcej: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma +pragma solidity >=0.7.3; + +// Definiuje kontrakt o nazwie `HelloWorld`. +// Kontrakt jest zbiorem funkcji i danych (jego stanu). Po wdrożeniu kontrakt znajduje się pod określonym adresem w blockchainie Ethereum. Dowiedz się więcej: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html +contract HelloWorld { + + // Emitowane, gdy wywoływana jest funkcja aktualizacji + // Zdarzenia inteligentnych kontraktów to sposób, w jaki kontrakt komunikuje, że coś wydarzyło się na blockchainie do front-endu aplikacji, który może „nasłuchiwać” określonych zdarzeń i podejmować działania, gdy one wystąpią. + event UpdatedMessages(string oldStr, string newStr); + + // Deklaruje zmienną stanu `message` typu `string`. + // Zmienne stanu to zmienne, których wartości są trwale przechowywane w pamięci kontraktu. Słowo kluczowe `public` udostępnia zmienne spoza kontraktu i tworzy funkcję, którą inne kontrakty lub klienci mogą wywołać w celu uzyskania dostępu do wartości. + string public message; + + // Podobnie jak w wielu językach obiektowych opartych na klasach, konstruktor jest specjalną funkcją, która jest wykonywana tylko podczas tworzenia kontraktu. + // Konstruktory służą do inicjalizacji danych kontraktu. Dowiedz się więcej: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors + constructor(string memory initMessage) { + + // Akceptuje argument ciągu znaków `initMessage` i ustawia wartość w zmiennej pamięci kontraktu `message`). + message = initMessage; + } + + // Funkcja publiczna, która akceptuje argument w postaci ciągu znaków i aktualizuje zmienną pamięci masowej `message`. + function update(string memory newMessage) public { + string memory oldMsg = message; + message = newMessage; + emit UpdatedMessages(oldMsg, newMessage); + } +} +``` + +Jest to podstawowy inteligentny kontrakt, który przechowuje wiadomość po utworzeniu. Można go zaktualizować, wywołując funkcję `update`. + +### Krok 11: Podłącz MetaMask i Alchemy do swojego projektu {#step-11-connect-metamask-alchemy-to-your-project} + +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 portfela wymaga podpisu za pomocą Twojego unikalnego klucza prywatnego. Aby zapewnić naszemu programowi to uprawnienie, możemy bezpiecznie przechowywać nasz klucz prywatny w pliku środowiskowym. Będziemy tutaj również przechowywać klucz API dla Alchemy. + +> Aby dowiedzieć się więcej o wysyłaniu transakcji, sprawdź [ten samouczek](https://www.alchemy.com/docs/hello-world-smart-contract#step-11-connect-metamask--alchemy-to-your-project) na temat wysyłania transakcji za pomocą web3. + +Najpierw zainstaluj pakiet dotenv w katalogu swojego projektu: + +``` +npm install dotenv --save +``` + +Następnie utwórz plik `.env` w głównym katalogu projektu. Dodaj do niego swój klucz prywatny MetaMask i adres URL HTTP Alchemy API. + +Twój plik środowiskowy musi mieć nazwę `.env`, w przeciwnym razie nie zostanie rozpoznany jako plik środowiskowy. + +Nie nazywaj go `process.env` lub `.env-custom` ani w żaden inny sposób. + +- Postępuj zgodnie z [tymi instrukcjami](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key), aby wyeksportować swój klucz prywatny +- Poniżej dowiesz się, jak uzyskać adres URL interfejsu API HTTP Alchemy + + + +Twój plik `.env` powinien wyglądać następująco: + +``` +API_URL = "https://eth-goerli.alchemyapi.io/v2/your-api-key" +PRIVATE_KEY = "your-metamask-private-key" +``` + +Aby faktycznie połączyć je z naszym kodem, odwołamy się do tych zmiennych w naszym pliku `hardhat.config.js` w kroku 13. + +### Krok 12: Zainstaluj Ethers.js {#step-12-install-ethersjs} + +Ethers.js to biblioteka, która ułatwia interakcję i wysyłanie żądań do Ethereum poprzez opakowanie [standardowych metod JSON-RPC](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc) w bardziej przyjazne dla użytkownika metody. + +Hardhat pozwala nam na integrację [wtyczek](https://hardhat.org/plugins/) w celu uzyskania dodatkowych narzędzi i rozszerzonej funkcjonalności. Skorzystamy z [wtyczki Ethers](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) do wdrażania kontraktów. + +W katalogu projektu wpisz: + +```bash +npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0" +``` + +### Krok 13: Zaktualizuj hardhat.config.js {#step-13-update-hardhat-configjs} + +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: + +```javascript +/** + * @type import('hardhat/config').HardhatUserConfig + */ + +require("dotenv").config() +require("@nomiclabs/hardhat-ethers") + +const { API_URL, PRIVATE_KEY } = process.env + +module.exports = { + solidity: "0.7.3", + defaultNetwork: "goerli", + networks: { + hardhat: {}, + goerli: { + url: API_URL, + accounts: [`0x${PRIVATE_KEY}`], + }, + }, +} +``` + +### Krok 14: Skompiluj nasz kontrakt {#step-14-compile-our-contract} + +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: + +```bash +npx hardhat compile +``` + +Możesz otrzymać ostrzeżenie o `SPDX license identifier not provided in source file`, 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](https://discord.gg/u72VCg3). + +### Krok 15: Napisz nasz skrypt wdrożeniowy {#step-15-write-our-deploy-script} + +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ść: + +```javascript +async function main() { + const HelloWorld = await ethers.getContractFactory("HelloWorld") + + // Rozpocznij wdrażanie, zwracając obietnicę, która rozwiązuje się do obiektu kontraktu + 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 wykonuje niesamowitą robotę, wyjaśniając, co robi każda z tych linii kodu w swoim [samouczku dotyczącym kontraktów](https://hardhat.org/tutorial/testing-contracts.html#writing-tests), a my przyjęliśmy ich wyjaśnienia tutaj. + +```javascript +const HelloWorld = await ethers.getContractFactory("HelloWorld") +``` + +`ContractFactory` w ethers.js jest abstrakcją używaną do wdrażania nowych inteligentnych kontraktów, więc `HelloWorld` jest tutaj [fabryką](https://en.wikipedia.org/wiki/Factory_\(object-oriented_programming\)) dla instancji naszego kontraktu witaj świecie. Podczas korzystania z wtyczki `hardhat-ethers`, instancje `ContractFactory` i `Contract` są domyślnie połączone z pierwszym sygnatariuszem (właścicielem). + +```javascript +const hello_world = await HelloWorld.deploy() +``` + +Wywołanie `deploy()` w `ContractFactory` rozpocznie wdrażanie i zwróci `Promise`, które rozwiąże się do obiektu `Contract`. Jest to obiekt, który ma metodę dla każdej z naszych funkcji inteligentnego kontraktu. + +### Krok 16: Wdróż nasz kontrakt {#step-16-deploy-our-contract} + +Jesteśmy wreszcie gotowi do wdrożenia naszego inteligentnego kontraktu! Przejdź do wiersza poleceń i uruchom: + +```bash +npx hardhat run scripts/deploy.js --network goerli +``` + +Powinieneś wtedy zobaczyć coś takiego: + +```bash +Kontrakt wdrożony pod adresem: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570 +``` + +**Proszę zapisać ten adres**. Będziemy go używać w dalszej części samouczka. + +Jeśli przejdziemy do [Goerli etherscan](https://goerli.etherscan.io) 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 `From` powinien pasować do adresu konta MetaMask, a adres `To` będzie zawierał informację **Contract Creation**. Jeśli klikniemy w transakcję, zobaczymy adres naszego kontraktu w polu `Do`. + + + +Gratulacje! Właśnie wdrożyłeś inteligentny kontrakt w sieci testowej Ethereum. + +Aby zrozumieć, co dzieje się pod maską, przejdź do zakładki Eksplorator w naszym [pulpicie nawigacyjnym Alchemy](https://dashboard.alchemy.com/explorer). Jeśli masz wiele aplikacji Alchemy, upewnij się, że filtrujesz według aplikacji i wybierz **Hello World**. + + + +Tutaj zobaczysz kilka metod JSON-RPC, które Hardhat/Ethers stworzył dla nas pod maską, gdy wywołaliśmy funkcję `.deploy()`. Dwie ważne metody to [`eth_sendRawTransaction`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction), czyli żądanie zapisu naszego kontraktu w łańcuchu Goerli, oraz [`eth_getTransactionByHash`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_gettransactionbyhash), czyli żądanie odczytania informacji o naszej transakcji na podstawie jej hasza. Aby dowiedzieć się więcej o wysyłaniu transakcji, sprawdź [nasz samouczek na temat wysyłania transakcji za pomocą Web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/). + +## Część 2: Interakcja z Twoim inteligentnym kontraktem {#part-2-interact-with-your-smart-contract} + +Teraz, gdy pomyślnie wdrożyliśmy inteligentny kontrakt w sieci Goerli, nauczmy się, jak wchodzić z nim w interakcję. + +### Utwórz plik interact.js {#create-a-interactjs-file} + +To jest plik, w którym napiszemy nasz skrypt interakcji. Będziemy używać biblioteki Ethers.js, którą zainstalowałeś wcześniej w części 1. + +W folderze `scripts/` utwórz nowy plik o nazwie `interact.js` i dodaj następujący kod: + +```javascript +// interact.js + +const API_KEY = process.env.API_KEY +const PRIVATE_KEY = process.env.PRIVATE_KEY +const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS +``` + +### Zaktualizuj swój plik .env {#update-your-env-file} + +Będziemy używać nowych zmiennych środowiskowych, więc musimy je zdefiniować w pliku `.env`, który [utworzyliśmy wcześniej](#step-11-connect-metamask-&-alchemy-to-your-project). + +Będziemy musieli dodać definicję dla naszego `API_KEY` Alchemy i `CONTRACT_ADDRESS`, gdzie został wdrożony nasz inteligentny kontrakt. + +Plik `.env` powinien wyglądać następująco: + +```bash +# .env + +API_URL = "https://eth-goerli.alchemyapi.io/v2/
+ 
+
+
+
+)
+```
+
+Jeśli dokładnie przeanalizujesz ten kod, zauważysz, gdzie używamy naszych różnych zmiennych stanu w naszym interfejsie użytkownika:
+
+- W liniach 6-12, jeśli portfel użytkownika jest podłączony (tj. `walletAddress.length > 0`), wyświetlamy skróconą wersję `walletAddress` użytkownika w przycisku o identyfikatorze „walletButton”; w przeciwnym razie jest tam po prostu napis „Połącz portfel”.
+- W linii 17 wyświetlamy bieżącą wiadomość zapisaną w inteligentnym kontrakcie, która jest przechwytywana w ciągu znaków `message`.
+- W liniach 23-26 używamy [komponentu kontrolowanego](https://legacy.reactjs.org/docs/forms.html#controlled-components), aby zaktualizować naszą zmienną stanu `newMessage`, gdy zmienia się wpis w polu tekstowym.
+
+Oprócz naszych zmiennych stanu, zobaczysz również, że funkcje `connectWalletPressed` i `onUpdatePressed` są wywoływane, gdy odpowiednio klikane są przyciski o identyfikatorach `publishButton` i `walletButton`.
+
+Na koniec zajmijmy się tym, gdzie ten komponent `HelloWorld.js` jest dodawany.
+
+Jeśli przejdziesz do pliku `App.js`, który jest głównym komponentem w React, który działa jako kontener dla wszystkich innych komponentów, zobaczysz, że nasz komponent `HelloWorld.js` jest wstrzykiwany w linii 7.
+
+Na koniec sprawdźmy jeszcze jeden plik, który został dla Ciebie przygotowany, plik `interact.js`.
+
+#### Plik `interact.js` {#the-interact-js-file}
+
+Ponieważ chcemy trzymać się paradygmatu [M-V-C](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller), będziemy chcieli mieć osobny plik, który zawiera wszystkie nasze funkcje do zarządzania logiką, danymi i regułami naszej dapki, a następnie będziemy mogli wyeksportować te funkcje do naszego frontendu (naszego komponentu `HelloWorld.js`).
+
+👆🏽 To jest dokładny cel naszego pliku `interact.js`!
+
+Przejdź do folderu `util` w swoim katalogu `src`, a zauważysz, że dołączyliśmy plik o nazwie `interact.js`, który będzie zawierał wszystkie nasze funkcje i zmienne interakcji z inteligentnym kontraktem i portfelem.
+
+```javascript
+// interact.js
+
+//export const helloWorldContract;
+
+export const loadCurrentMessage = async () => {}
+
+export const connectWallet = async () => {}
+
+const getCurrentWalletConnected = async () => {}
+
+export const updateMessage = async (message) => {}
+```
+
+Na początku pliku zauważysz, że skomentowaliśmy obiekt `helloWorldContract`. Później w tym samouczku odkomentujemy ten obiekt i utworzymy instancję naszego inteligentnego kontraktu w tej zmiennej, którą następnie wyeksportujemy do naszego komponentu `HelloWorld.js`.
+
+Cztery niezaimplementowane funkcje po naszym obiekcie `helloWorldContract` robią następujące rzeczy:
+
+- `loadCurrentMessage` - ta funkcja obsługuje logikę ładowania bieżącej wiadomości zapisanej w inteligentnym kontrakcie. Wywoła ona żądanie _odczytu_ do inteligentnego kontraktu Witaj Świecie za pomocą [interfejsu API Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3).
+- `connectWallet` - ta funkcja połączy MetaMask użytkownika z naszą dappką.
+- `getCurrentWalletConnected` - ta funkcja sprawdzi, czy konto Ethereum jest już połączone z naszą dappką podczas ładowania strony i odpowiednio zaktualizuje nasz interfejs użytkownika.
+- `updateMessage` - ta funkcja zaktualizuje wiadomość zapisaną w inteligentnym kontrakcie. Wykona ona żądanie _zapisu_ do inteligentnego kontraktu Witaj Świecie, więc portfel MetaMask użytkownika będzie musiał podpisać transakcję Ethereum, aby zaktualizować wiadomość.
+
+Teraz, gdy rozumiemy, z czym pracujemy, dowiedzmy się, jak czytać z naszego inteligentnego kontraktu!
+
+### Krok 3: Odczyt z Twojego inteligentnego kontraktu {#step-3-read-from-your-smart-contract}
+
+Aby odczytać dane z inteligentnego kontraktu, musisz pomyślnie skonfigurować:
+
+- Połączenie API z łańcuchem Ethereum
+- Załadowana instancja Twojego inteligentnego kontraktu
+- Funkcja do wywołania funkcji inteligentnego kontraktu
+- Nasłuchiwacz do obserwowania aktualizacji, gdy zmieniają się dane, które odczytujesz z inteligentnego kontraktu
+
+To może brzmieć jak wiele kroków, ale nie martw się! Przeprowadzimy Cię przez każdy z nich krok po kroku! :\)
+
+#### Ustanów połączenie API z łańcuchem Ethereum {#establish-an-api-connection-to-the-ethereum-chain}
+
+Pamiętasz, jak w części 2 tego samouczka użyliśmy naszego klucza Alchemy Web3 do odczytu z naszego inteligentnego kontraktu ([https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract/interacting-with-a-smart-contract#step-1-install-web3-library](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract/interacting-with-a-smart-contract#step-1-install-web3-library))? Będziesz również potrzebować klucza Alchemy Web3 w swojej dapce, aby czytać z łańcucha.
+
+Jeśli go jeszcze nie masz, najpierw zainstaluj [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3), przechodząc do katalogu głównego `starter-files` i uruchamiając następujące polecenie w terminalu:
+
+```text
+npm install @alch/alchemy-web3
+```
+
+[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) to nakładka na [Web3.js](https://docs.web3js.org/), zapewniająca ulepszone metody API i inne kluczowe korzyści, które ułatwiają życie dewelopera web3. Został zaprojektowany tak, aby wymagał minimalnej konfiguracji, dzięki czemu możesz od razu zacząć go używać w swojej aplikacji!
+
+Następnie zainstaluj pakiet [dotenv](https://www.npmjs.com/package/dotenv) w katalogu projektu, abyśmy mieli bezpieczne miejsce do przechowywania naszego klucza API po jego pobraniu.
+
+```text
+npm install dotenv --save
+```
+
+Dla naszej dapki **będziemy używać naszego klucza API Websockets** zamiast klucza API HTTP, ponieważ pozwoli nam to skonfigurować nasłuchiwacza, który wykrywa, kiedy zmienia się wiadomość zapisana w inteligentnym kontrakcie.
+
+Po uzyskaniu klucza API, utwórz plik `.env` w swoim katalogu głównym i dodaj do niego adres URL Alchemy Websockets. Następnie plik `.env` powinien wyglądać następująco:
+
+```javascript
+REACT_APP_ALCHEMY_KEY = wss://eth-goerli.ws.alchemyapi.io/v2/Bieżąca wiadomość:
+{message}
+ +Nowa wiadomość:
+ +
+ setNewMessage(e.target.value)}
+ value={newMessage}
+ />
+
+
+{status}
+ + ++ {" "} + 🦊 + Musisz zainstalować MetaMask, wirtualny portfel Ethereum, w swojej + przeglądarce. + +
+ + ), + } + } +} +``` + +Więc co dokładnie robi ten gigantyczny blok kodu? + +Po pierwsze, sprawdza, czy `window.ethereum` jest włączone w przeglądarce. + +`window.ethereum` to globalny interfejs API wstrzykiwany przez MetaMask i innych dostawców portfeli, który pozwala stronom internetowym na żądanie dostępu do kont Ethereum użytkowników. Jeśli zostanie zatwierdzony, może odczytywać dane z blockchainów, z którymi użytkownik jest połączony, i sugerować, aby użytkownik podpisywał wiadomości i transakcje. Sprawdź [dokumentację MetaMask](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents), aby uzyskać więcej informacji! + +Jeśli `window.ethereum` _nie jest_ obecne, oznacza to, że MetaMask nie jest zainstalowany. Powoduje to zwrócenie obiektu JSON, w którym zwrócony `adres` jest pustym ciągiem, a obiekt `status` JSX informuje, że użytkownik musi zainstalować MetaMask. + +Teraz, jeśli `window.ethereum` _jest_ obecne, to wtedy robi się ciekawie. + +Używając pętli try/catch, spróbujemy połączyć się z MetaMask, wywołując [`window.ethereum.request({ method: "eth_requestAccounts" });`](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts). Wywołanie tej funkcji otworzy MetaMask w przeglądarce, gdzie użytkownik zostanie poproszony o podłączenie swojego portfela do Twojej dapki. + +- Jeśli użytkownik zdecyduje się połączyć, `method: "eth_requestAccounts"` zwróci tablicę zawierającą wszystkie adresy kont użytkownika, które połączyły się z dappką. W sumie nasza funkcja `connectWallet` zwróci obiekt JSON, który zawiera _pierwszy_ `adres` w tej tablicy (patrz linia 9) oraz wiadomość `status`, która prosi użytkownika o napisanie wiadomości do inteligentnego kontraktu. +- Jeśli użytkownik odrzuci połączenie, obiekt JSON będzie zawierał pusty ciąg dla zwróconego `adresu` oraz komunikat `status`, który odzwierciedla, że użytkownik odrzucił połączenie. + +Teraz, gdy napisaliśmy tę funkcję `connectWallet`, następnym krokiem jest wywołanie jej w naszym komponencie `HelloWorld.js`. + +#### Dodaj funkcję `connectWallet` do swojego komponentu interfejsu użytkownika HelloWorld.js {#add-the-connectWallet-function-to-your-HelloWorld-js-ui-component} + +Przejdź do funkcji `connectWalletPressed` w `HelloWorld.js` i zaktualizuj ją do następującej postaci: + +```javascript +// HelloWorld.js + +const connectWalletPressed = async () => { + const walletResponse = await connectWallet() + setStatus(walletResponse.status) + setWallet(walletResponse.address) +} +``` + +Zauważ, jak większość naszej funkcjonalności jest abstrahowana od naszego komponentu `HelloWorld.js` z pliku `interact.js`? Robimy tak, aby zachować zgodność z paradygmatem M-V-C! + +W `connectWalletPressed` po prostu wykonujemy wywołanie await do naszej zaimportowanej funkcji `connectWallet`, a za pomocą jej odpowiedzi aktualizujemy nasze zmienne `status` i `walletAddress` za pomocą ich hooków stanu. + +Teraz zapiszmy oba pliki (`HelloWorld.js` i `interact.js`) i przetestujmy nasz dotychczasowy interfejs użytkownika. + +Otwórz przeglądarkę na stronie [http://localhost:3000/](http://localhost:3000/) i naciśnij przycisk „Połącz portfel” w prawym górnym rogu strony. + +Jeśli masz zainstalowany MetaMask, powinieneś zostać poproszony o podłączenie swojego portfela do Twojej dapki. Zaakceptuj zaproszenie do połączenia. + +Powinieneś zobaczyć, że przycisk portfela odzwierciedla teraz, że Twój adres jest połączony! Jeeee 🔥 + +Następnie spróbuj odświeżyć stronę... to jest dziwne. Nasz przycisk portfela prosi nas o podłączenie MetaMask, mimo że jest już podłączony... + +Jednak nie ma się czego bać! Możemy łatwo to rozwiązać (zaadresować?) implementując `getCurrentWalletConnected`, który sprawdzi, czy adres jest już połączony z naszą dappką i odpowiednio zaktualizuje nasz interfejs użytkownika! + +#### Funkcja `getCurrentWalletConnected` {#the-getcurrentwalletconnected-function} + +Zaktualizuj swoją funkcję `getCurrentWalletConnected` w pliku `interact.js` do następującej postaci: + +```javascript +// interact.js + +export const getCurrentWalletConnected = async () => { + if (window.ethereum) { + try { + const addressArray = await window.ethereum.request({ + method: "eth_accounts", + }) + if (addressArray.length > 0) { + return { + address: addressArray[0], + status: "👆🏽 Wpisz wiadomość w polu tekstowym powyżej.", + } + } else { + return { + address: "", + status: "🦊 Połącz się z MetaMask za pomocą przycisku w prawym górnym rogu.", + } + } + } catch (err) { + return { + address: "", + status: "😥 " + err.message, + } + } + } else { + return { + address: "", + status: ( + ++ {" "} + 🦊 + Musisz zainstalować MetaMask, wirtualny portfel Ethereum, w swojej + przeglądarce. + +
+ + ), + } + } +} +``` + +Ten kod jest _bardzo_ podobny do funkcji `connectWallet`, którą właśnie napisaliśmy w poprzednim kroku. + +Główna różnica polega na tym, że zamiast wywoływać metodę `eth_requestAccounts`, która otwiera MetaMask, aby użytkownik mógł połączyć swój portfel, tutaj wywołujemy metodę `eth_accounts`, która po prostu zwraca tablicę zawierającą adresy MetaMask aktualnie połączone z naszą dapką. + +Aby zobaczyć tę funkcję w działaniu, wywołajmy ją w naszej funkcji `useEffect` naszego komponentu `HelloWorld.js`: + +```javascript +// HelloWorld.js + +useEffect(async () => { + const message = await loadCurrentMessage() + setMessage(message) + addSmartContractListener() + + const { address, status } = await getCurrentWalletConnected() + setWallet(address) + setStatus(status) +}, []) +``` + +Zauważ, że używamy odpowiedzi z naszego wywołania `getCurrentWalletConnected`, aby zaktualizować nasze zmienne stanu `walletAddress` i `status`. + +Teraz, gdy dodałeś ten kod, spróbujmy odświeżyć okno przeglądarki. + +Fajnieee! Przycisk powinien informować, że jesteś połączony i pokazywać podgląd adresu podłączonego portfela - nawet po odświeżeniu! + +#### Zaimplementuj `addWalletListener` {#implement-addwalletlistener} + +Ostatnim krokiem w konfiguracji portfela naszej dapki jest zaimplementowanie nasłuchiwacza portfela, aby nasz interfejs użytkownika aktualizował się, gdy zmieni się stan naszego portfela, na przykład gdy użytkownik się rozłączy lub zmieni konto. + +W pliku `HelloWorld.js` zmodyfikuj swoją funkcję `addWalletListener` w następujący sposób: + +```javascript +// HelloWorld.js + +function addWalletListener() { + if (window.ethereum) { + window.ethereum.on("accountsChanged", (accounts) => { + if (accounts.length > 0) { + setWallet(accounts[0]) + setStatus("👆🏽 Wpisz wiadomość w polu tekstowym powyżej.") + } else { + setWallet("") + setStatus("🦊 Połącz się z MetaMask za pomocą przycisku w prawym górnym rogu.") + } + }) + } else { + setStatus( ++ {" "} + 🦊 + Musisz zainstalować MetaMask, wirtualny portfel Ethereum, w swojej przeglądarce. + +
+ ) + } +} +``` + +Założę się, że w tym momencie nie potrzebujesz nawet naszej pomocy, aby zrozumieć, co się tutaj dzieje, ale dla porządku szybko to omówmy: + +- Najpierw nasza funkcja sprawdza, czy `window.ethereum` jest włączone (tj. MetaMask jest zainstalowany). + - Jeśli nie jest, po prostu ustawiamy naszą zmienną stanu `status` na ciąg JSX, który prosi użytkownika o zainstalowanie MetaMask. + - Jeśli jest włączone, ustawiamy nasłuchiwacz `window.ethereum.on("accountsChanged")` w linii 3, który nasłuchuje zmian stanu w portfelu MetaMask, co obejmuje sytuacje, gdy użytkownik podłącza dodatkowe konto do dapki, zmienia konta lub odłącza konto. Jeśli co najmniej jedno konto jest połączone, zmienna stanu `walletAddress` jest aktualizowana jako pierwsze konto w tablicy `konta` zwróconej przez nasłuchiwacz. W przeciwnym razie `walletAddress` jest ustawiany jako pusty ciąg. + +Na koniec musimy wywołać ją w naszej funkcji `useEffect`: + +```javascript +// HelloWorld.js + +useEffect(async () => { + const message = await loadCurrentMessage() + setMessage(message) + addSmartContractListener() + + const { address, status } = await getCurrentWalletConnected() + setWallet(address) + setStatus(status) + + addWalletListener() +}, []) +``` + +I to wszystko! Pomyślnie ukończyliśmy programowanie całej naszej funkcjonalności portfela! Teraz przejdźmy do naszego ostatniego zadania: aktualizacji wiadomości zapisanej w naszym inteligentnym kontrakcie! + +### Krok 6: Zaimplementuj funkcję `updateMessage` {#step-6-implement-the-updateMessage-function} + +Dobra, ekipa, dotarliśmy do ostatniej prostej! W `updateMessage` w swoim pliku `interact.js`, zrobimy następujące rzeczy: + +1. Upewnij się, że wiadomość, którą chcemy opublikować w naszym inteligentnym kontakcie, jest ważna +2. Podpisz naszą transakcję za pomocą MetaMask +3. Wywołaj tę funkcję z naszego komponentu frontendowego `HelloWorld.js` + +To nie potrwa długo; dokończmy tę dappkę! + +#### Obsługa błędów wejściowych {#input-error-handling} + +Naturalnie, sensowne jest posiadanie jakiejś formy obsługi błędów wejściowych na początku funkcji. + +Będziemy chcieli, aby nasza funkcja zakończyła się wcześniej, jeśli nie ma zainstalowanego rozszerzenia MetaMask, nie jest podłączony portfel (tj. przekazany `address` jest pustym ciągiem znaków) lub `message` jest pustym ciągiem znaków. Dodajmy następującą obsługę błędów do `updateMessage`: + +```javascript +// interact.js + +export const updateMessage = async (address, message) => { + if (!window.ethereum || address === null) { + return { + status: + "💡 Połącz swój portfel MetaMask, aby zaktualizować wiadomość na blockchainie.", + } + } + + if (message.trim() === "") { + return { + status: "❌ Twoja wiadomość nie może być pustym ciągiem znaków.", + } + } +} +``` + +Teraz, gdy mamy właściwą obsługę błędów wejściowych, nadszedł czas, aby podpisać transakcję za pomocą MetaMask! + +#### Podpisywanie naszej transakcji {#signing-our-transaction} + +Jeśli jesteś już zaznajomiony z tradycyjnymi transakcjami Ethereum web3, kod, który napiszemy dalej, będzie bardzo znajomy. Poniżej kodu obsługi błędów wejściowych dodaj następujący kod do `updateMessage`: + +```javascript +// interact.js + +// ustaw parametry transakcji +const transactionParameters = { + to: contractAddress, // Wymagane z wyjątkiem publikacji kontraktów. + from: address, // musi pasować do aktywnego adresu użytkownika. + data: helloWorldContract.methods.update(message).encodeABI(), +} + +// podpisz transakcję +try { + const txHash = await window.ethereum.request({ + method: "eth_sendTransaction", + params: [transactionParameters], + }) + return { + status: ( + + ✅{" "} + + Zobacz status swojej transakcji na Etherscan! + ++ ℹ️ Gdy transakcja zostanie zweryfikowana przez sieć, wiadomość zostanie + zaktualizowana automatycznie. + + ), + } +} catch (error) { + return { + status: "😥 " + error.message, + } +} +``` + +Przeanalizujmy, co się dzieje. Najpierw ustawiamy parametry naszej transakcji, gdzie: + +- `to` określa adres odbiorcy (nasz inteligentny kontrakt) +- `from` określa sygnatariusza transakcji, zmienną `address`, którą przekazaliśmy do naszej funkcji +- `data` zawiera wywołanie metody `update` naszego inteligentnego kontraktu Witaj Świecie, otrzymując jako dane wejściowe naszą zmienną ciągu znaków `message` + +Następnie wykonujemy wywołanie await, `window.ethereum.request`, w którym prosimy MetaMask o podpisanie transakcji. Zauważ, że w liniach 11 i 12 określamy naszą metodę eth, `eth_sendTransaction` i przekazujemy nasze `transactionParameters`. + +W tym momencie w przeglądarce otworzy się MetaMask i poprosi użytkownika o podpisanie lub odrzucenie transakcji. + +- Jeśli transakcja się powiedzie, funkcja zwróci obiekt JSON, w którym ciąg JSX `status` prosi użytkownika o sprawdzenie Etherscan w celu uzyskania dalszych informacji o transakcji. +- Jeśli transakcja się nie powiedzie, funkcja zwróci obiekt JSON, w którym ciąg znaków `status` przekaże komunikat o błędzie. + +W sumie nasza funkcja `updateMessage` powinna wyglądać tak: + +```javascript +// interact.js + +export const updateMessage = async (address, message) => { + // obsługa błędów wejściowych + if (!window.ethereum || address === null) { + return { + status: + "💡 Połącz swój portfel MetaMask, aby zaktualizować wiadomość na blockchainie.", + } + } + + if (message.trim() === "") { + return { + status: "❌ Twoja wiadomość nie może być pustym ciągiem znaków.", + } + } + + // ustaw parametry transakcji + const transactionParameters = { + to: contractAddress, // Wymagane z wyjątkiem publikacji kontraktów. + from: address, // musi pasować do aktywnego adresu użytkownika. + data: helloWorldContract.methods.update(message).encodeABI(), + } + + // podpisz transakcję + try { + const txHash = await window.ethereum.request({ + method: "eth_sendTransaction", + params: [transactionParameters], + }) + return { + status: ( + + ✅{" "} + + Zobacz status swojej transakcji na Etherscan! + +
+ ℹ️ Gdy transakcja zostanie zweryfikowana przez sieć, wiadomość zostanie + zaktualizowana automatycznie. + + ), + } + } catch (error) { + return { + status: "😥 " + error.message, + } + } +} +``` + +Na koniec musimy połączyć naszą funkcję `updateMessage` z naszym komponentem `HelloWorld.js`. + +#### Połącz `updateMessage` z frontendem `HelloWorld.js` {#connect-updatemessage-to-the-helloworld-js-frontend} + +Nasza funkcja `onUpdatePressed` powinna wykonać wywołanie await do zaimportowanej funkcji `updateMessage` i zmodyfikować zmienną stanu `status`, aby odzwierciedlić, czy nasza transakcja się powiodła, czy nie: + +```javascript +// HelloWorld.js + +const onUpdatePressed = async () => { + const { status } = await updateMessage(walletAddress, newMessage) + setStatus(status) +} +``` + +To super czyste i proste. I zgadnij co... TWOJA DAPPKA JEST UKOŃCZONA!!! + +Śmiało przetestuj przycisk **Aktualizuj**! + +### Stwórz swoją własną dappkę {#make-your-own-custom-dapp} + +Hura, dotarłeś do końca samouczka! Podsumowując, nauczyłeś się, jak: + +- Podłącz portfel MetaMask do swojego projektu dapp +- Odczytaj dane ze swojego inteligentnego kontraktu za pomocą interfejsu API [Alchemy Web3](https://docs.alchemy.com/alchemy/documentation/alchemy-web3) +- Podpisz transakcje Ethereum za pomocą MetaMask + +Teraz jesteś w pełni wyposażony, aby zastosować umiejętności z tego samouczka do zbudowania własnego, niestandardowego projektu dapp! Jak zawsze, jeśli masz jakieś pytania, nie wahaj się skontaktować z nami w celu uzyskania pomocy na [Discordzie Alchemy](https://discord.gg/gWuC7zB). 🧙♂️ + +Po ukończeniu tego samouczka daj nam znać, jak Ci poszło lub czy masz jakieś uwagi, oznaczając nas na Twitterze [@alchemyplatform](https://twitter.com/AlchemyPlatform)! diff --git a/public/content/translations/pl/developers/tutorials/hello-world-smart-contract/index.md b/public/content/translations/pl/developers/tutorials/hello-world-smart-contract/index.md new file mode 100644 index 00000000000..51f58532f80 --- /dev/null +++ b/public/content/translations/pl/developers/tutorials/hello-world-smart-contract/index.md @@ -0,0 +1,367 @@ +--- +title: "Inteligentny kontrakt Hello World dla początkujących" +description: "Samouczek wprowadzający na temat pisania i wdrażania prostego inteligentnego kontraktu na Ethereum." +author: "elanh" +tags: + [ + "solidity", + "hardhat", + "alchemy", + "smart kontrakty", + "wdrażanie" + ] +skill: beginner +lang: pl +published: 2021-03-31 +--- + +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](https://metamask.io/), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/) i [Alchemy](https://www.alchemy.com/) (nie martw się, jeśli jeszcze nie rozumiesz, co to wszystko znaczy, wyjaśnimy to). + +W [części 2](https://docs.alchemy.com/docs/interacting-with-a-smart-contract) tego samouczka omówimy, jak wejść w interakcję z naszym inteligentnym kontraktem po jego wdrożeniu, a w [części 3](https://www.alchemy.com/docs/submitting-your-smart-contract-to-etherscan) omówimy, jak opublikować go na Etherscan. + +Jeśli w dowolnym momencie będziesz mieć pytania, śmiało odezwij się na [Discordzie Alchemy](https://discord.gg/gWuC7zB)! + +## Krok 1: Połącz się z siecią Ethereum {#step-1} + +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](https://dashboard.alchemy.com/signup). + +## Krok 2: Stwórz swoją aplikację (i klucz API) {#step-2} + +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ę](/developers/docs/networks/). + +1. 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ę" + + + +2. 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ć. + + + +3. 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) {#step-3} + +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](/developers/docs/transactions/). + +Możesz pobrać MetaMask i utworzyć darmowe konto Ethereum [tutaj](https://metamask.io/download). 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) {#step-4} + +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](/developers/docs/networks/#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 {#step-5} + +Aby upewnić się, że nasze saldo tam jest, wykonajmy żądanie [eth_getBalance](/developers/docs/apis/json-rpc/#eth_getbalance) za pomocą [narzędzia kompozytora 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). 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ź: + +```json +{ "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 = 1018 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
.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.
+.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.
+