Wysyłanie transakcji przy użyciu Viem

transakcje

viem

Alchemy

Początkujący

Elan Halpern

4 listopada 2020

10 minut czytania

To przyjazny dla początkujących przewodnik po wysyłaniu transakcji Ethereum przy użyciu biblioteki Viem (otwiera się w nowej karcie). Istnieją trzy główne kroki, aby wysłać transakcję do blockchaina Ethereum: utworzenie, podpisanie i rozgłoszenie. Przejdziemy przez wszystkie trzy, mając nadzieję, że odpowiemy na wszelkie Twoje pytania! W tym samouczku użyjemy Alchemy (otwiera się w nowej karcie) do wysyłania naszych transakcji do łańcucha Ethereum. Możesz utworzyć darmowe konto Alchemy tutaj (otwiera się w nowej karcie).

UWAGA: Ten przewodnik dotyczy podpisywania transakcji na backendzie Twojej aplikacji. Jeśli chcesz zintegrować podpisywanie transakcji na frontendzie, sprawdź API dostawcy MetaMask (otwiera się w nowej karcie).

Podstawy

Podobnie jak większość programistów blockchain na początku swojej drogi, mogłeś szukać informacji o tym, jak wysłać transakcję (coś, co powinno być dość proste) i natknąć się na mnóstwo przewodników, z których każdy mówił co innego, pozostawiając Cię nieco przytłoczonym i zdezorientowanym. Jeśli jesteś w takiej sytuacji, nie martw się; wszyscy kiedyś w niej byliśmy! Zanim więc zaczniemy, wyjaśnijmy kilka kwestii:

1. Alchemy nie przechowuje Twoich kluczy prywatnych

Oznacza to, że Alchemy nie może podpisywać i wysyłać transakcji w Twoim imieniu. Powodem tego są względy bezpieczeństwa. Alchemy nigdy nie poprosi Cię o udostępnienie klucza prywatnego i nigdy nie powinieneś udostępniać swojego klucza prywatnego hostowanemu węzłowi (ani nikomu innemu).
Możesz odczytywać dane z blockchaina za pomocą głównego API Alchemy, ale aby do niego zapisywać, będziesz musiał użyć czegoś innego do podpisania swoich transakcji przed wysłaniem ich przez Alchemy (dotyczy to również każdej innej usługi węzła).

2. Czym jest „signer”?

Signery podpisują transakcje za Ciebie przy użyciu Twojego klucza prywatnego. W tym samouczku użyjemy Viem (otwiera się w nowej karcie) do podpisania naszej transakcji, ale możesz również użyć dowolnej innej biblioteki Web3.
Na frontendzie dobrym przykładem signera jest MetaMask (otwiera się w nowej karcie), który podpisuje i wysyła transakcje w Twoim imieniu.

3. Dlaczego muszę podpisywać swoje transakcje?

Każdy użytkownik, który chce wysłać transakcję w sieci Ethereum, musi ją podpisać (przy użyciu swojego klucza prywatnego), aby potwierdzić, że nadawca transakcji jest tym, za kogo się podaje.
Niezwykle ważne jest, aby chronić ten klucz prywatny, ponieważ dostęp do niego daje pełną kontrolę nad Twoim kontem Ethereum, pozwalając Tobie (lub komukolwiek z dostępem) na wykonywanie transakcji w Twoim imieniu.

4. Jak chronić mój klucz prywatny?

Istnieje wiele sposobów na ochronę klucza prywatnego i używanie go do wysyłania transakcji. W tym samouczku użyjemy pliku .env. Możesz jednak również użyć oddzielnego dostawcy, który przechowuje klucze prywatne, użyć pliku magazynu kluczy (keystore) lub innych opcji.

5. Jaka jest różnica między `eth_sendTransaction` a `eth_sendRawTransaction`?

eth_sendTransaction i eth_sendRawTransaction to funkcje API Ethereum, które rozgłaszają transakcję w sieci Ethereum, aby została dodana do przyszłego bloku. Różnią się one sposobem obsługi podpisywania transakcji.

eth_sendTransaction służy do wysyłania niepodpisanych transakcji, co oznacza, że węzeł, do którego wysyłasz, musi zarządzać Twoim kluczem prywatnym, aby mógł podpisać transakcję przed rozgłoszeniem jej w łańcuchu. Ponieważ Alchemy nie przechowuje kluczy prywatnych użytkowników, nie obsługuje tej metody.
eth_sendRawTransaction (otwiera się w nowej karcie) służy do rozgłaszania transakcji, które zostały już podpisane. Oznacza to, że najpierw musisz podpisać transakcję swoim kluczem prywatnym (w Viem, używając signTransaction (otwiera się w nowej karcie) z kontem lokalnym (otwiera się w nowej karcie)), a następnie przekazać wynik do eth_sendRawTransaction.

Podczas korzystania z Viem, dostęp do eth_sendRawTransaction uzyskuje się poprzez wywołanie funkcji sendRawTransaction (otwiera się w nowej karcie).

To właśnie tego będziemy używać w tym samouczku.

6. Czym jest biblioteka Web3?

Biblioteka Web3 to wrapper (nakładka) na standardowe wywołania JSON-RPC, który jest dość powszechnie używany w programowaniu na Ethereum.
Istnieje wiele bibliotek Web3 dla różnych języków. W tym samouczku użyjemy Viem (otwiera się w nowej karcie), która jest napisana w TypeScript i działa w każdym projekcie JavaScript. Możesz sprawdzić inne opcje tutaj, takie jak Ethers.js (otwiera się w nowej karcie).

Dobra, skoro mamy już za sobą kilka z tych pytań, przejdźmy do samouczka. Śmiało zadawaj pytania w dowolnym momencie na Discordzie (otwiera się w nowej karcie) Alchemy!

7. Jak wysyłać bezpieczne, zoptymalizowane pod kątem gazu i prywatne transakcje?

Alchemy posiada zestaw zasobów dotyczących transakcji (otwiera się w nowej karcie). Możesz ich użyć do wysyłania transakcji, symulowania transakcji przed ich wykonaniem, wysyłania prywatnych transakcji oraz wysyłania transakcji zoptymalizowanych pod kątem gazu.
Możesz również użyć webhooków Alchemy (otwiera się w nowej karcie), aby otrzymywać powiadomienia, gdy Twoja transakcja zostanie pobrana z mempoola i dodana do łańcucha.

UWAGA: Ten przewodnik wymaga konta Alchemy, adresu Ethereum lub portfela MetaMask, a także zainstalowanych Node.js i npm. Jeśli ich nie masz, wykonaj następujące kroki:

Utwórz darmowe konto Alchemy (otwiera się w nowej karcie)
Utwórz konto MetaMask (otwiera się w nowej karcie) (lub zdobądź adres Ethereum)
Zainstaluj Node.js i npm (otwiera się w nowej karcie)

Kroki do wysłania Twojej transakcji

1. Utwórz aplikację Alchemy w sieci testowej Sepolia

Przejdź do swojego pulpitu nawigacyjnego Alchemy (otwiera się w nowej karcie) i utwórz nową aplikację, wybierając Sepolia (lub dowolną inną sieć testową) jako swoją sieć.

2. Poproś o ETH z kranika Sepolia

Postępuj zgodnie z instrukcjami na kraniku Alchemy Sepolia (otwiera się w nowej karcie), aby otrzymać ETH, lub użyj jednego z innych kraników Sepolia. Kraniki rozdają małe kwoty (kranik Alchemy daje 0,1 ETH dziennie), co w zupełności wystarczy do tego samouczka. Upewnij się, że podajesz swój adres Ethereum w sieci Sepolia (z MetaMask), a nie w innej sieci. Po wykonaniu instrukcji sprawdź dwukrotnie, czy otrzymałeś ETH w swoim portfelu.

3. Utwórz nowy katalog projektu i przejdź do niego za pomocą `cd`

Utwórz nowy katalog projektu z wiersza poleceń (terminal na Macach) i przejdź do niego:

mkdir sendtx-example
cd sendtx-example

4. Zainstaluj Viem (lub dowolną bibliotekę Web3)

Uruchom następujące polecenie w katalogu swojego projektu, aby zainstalować Viem (otwiera się w nowej karcie):

Uwaga, jeśli wolisz użyć biblioteki Ethers.js, postępuj zgodnie z instrukcjami tutaj (otwiera się w nowej karcie).

npm init -y
npm install viem

5. Zainstaluj dotenv

Użyjemy pliku .env, aby bezpiecznie przechowywać nasz klucz API i klucz prywatny.

npm install dotenv

6. Utwórz plik `.env`

Utwórz plik .env w katalogu swojego projektu i dodaj następujące dane (zastępując „your-api-url” i „your-private-key”)

Aby znaleźć swój adres URL API Alchemy, przejdź do strony szczegółów aplikacji, którą właśnie utworzyłeś w swoim panelu, kliknij „View Key” w prawym górnym rogu i skopiuj adres URL HTTP.
Aby znaleźć swój klucz prywatny za pomocą MetaMask, zapoznaj się z tym przewodnikiem (otwiera się w nowej karcie). Użyj konta, które przechowuje tylko ETH z sieci testowej.

API_URL="your-api-url"
PRIVATE_KEY="your-private-key"

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

7. Utwórz plik `sendTx.js`

Świetnie, teraz, gdy nasze wrażliwe dane są chronione w pliku .env, zacznijmy kodować. W naszym przykładzie wysyłania transakcji wyślemy 0,001 ETH na inny kontrolowany przez Ciebie adres, taki jak drugie konto w MetaMask.

Utwórz plik sendTx.js, w którym skonfigurujemy i wyślemy naszą przykładową transakcję, i dodaj do niego następujące wiersze kodu:

require("dotenv").config({ quiet: true })
const { createPublicClient, createWalletClient, http, parseEther } = require("viem")
const { privateKeyToAccount } = require("viem/accounts")
const { sepolia } = require("viem/chains")

async function main() {
  const { API_URL, PRIVATE_KEY } = process.env
  const account = privateKeyToAccount(
    PRIVATE_KEY.startsWith("0x") ? PRIVATE_KEY : `0x${PRIVATE_KEY}`
  )
  const publicClient = createPublicClient({
    chain: sepolia,
    transport: http(API_URL),
  })
  const walletClient = createWalletClient({
    account,
    chain: sepolia,
    transport: http(API_URL),
  })

  const nonce = await publicClient.getTransactionCount({
    address: account.address,
    blockTag: "pending",
  }) // nonce zaczyna liczyć od 0

  const transaction = await walletClient.prepareTransactionRequest({
    to: "0xYourSecondAddress", // TODO: zastąp adresem, na który chcesz wysłać ETH
    value: parseEther("0.001"), // 0.001 ETH
    gas: 21000n,
    nonce,
    // opcjonalne pole danych do wysłania wiadomości lub wykonania inteligentnego kontraktu
  })

  const signedTx = await walletClient.signTransaction(transaction)

  try {
    const hash = await walletClient.sendRawTransaction({
      serializedTransaction: signedTx,
    })
    console.log("🎉 The hash of your transaction is:", hash)

    const receipt = await publicClient.waitForTransactionReceipt({ hash })
    console.log(`Transaction ${receipt.status} in block ${receipt.blockNumber}`)
  } catch (error) {
    console.log(
      "❗Something went wrong while submitting your transaction:",
      error.details ?? error.message
    )
  }
}

main()

Pamiętaj, aby zastąpić 0xYourSecondAddress adresem, na który chcesz wysłać ETH. Skrypt wyprowadza Twój własny adres (wysyłający) z PRIVATE_KEY, więc nie musisz go wprowadzać.

Zanim przejdziemy do uruchomienia tego kodu, pomówmy o niektórych jego elementach.

account: Konto lokalne utworzone z Twojego klucza prywatnego za pomocą privateKeyToAccount (otwiera się w nowej karcie). Podpisywanie odbywa się na Twoim komputerze, a klucz prywatny nigdy nie jest wysyłany do Alchemy.
publicClient i walletClient: Klienci Viem, którzy wysyłają żądania JSON-RPC do Twojego adresu URL Alchemy. Klient publiczny odczytuje dane z łańcucha, a klient portfela przygotowuje i podpisuje transakcje dla Twojego konta.
nonce: Specyfikacja nonce służy do śledzenia liczby transakcji wysłanych z Twojego adresu. Potrzebujemy tego ze względów bezpieczeństwa i aby zapobiec atakom typu replay. Aby uzyskać liczbę transakcji wysłanych z Twojego adresu, używamy getTransactionCount (otwiera się w nowej karcie). Viem również by to za Ciebie wypełnił, ale pobieramy to tutaj jawnie, aby pokazać, skąd to się bierze.
transaction: Obiekt transakcji ma kilka aspektów, które musimy określić. prepareTransactionRequest (otwiera się w nowej karcie) wypełnia za nas resztę, w tym chainId oraz pola opłat EIP-1559 maxFeePerGas i maxPriorityFeePerGas, w oparciu o bieżące warunki sieciowe.
- to: To jest adres, na który chcemy wysłać ETH.
- value: To jest kwota, którą chcemy wysłać, określona w wei, gdzie 10^18 wei = 1 ETH. parseEther (otwiera się w nowej karcie) konwertuje dla nas kwotę ETH na wei. Twoje konto potrzebuje nieco więcej, ponieważ płaci również za gaz.
- gas: Istnieje wiele sposobów na określenie odpowiedniej ilości gazu do dołączenia do transakcji. Alchemy obsługuje webhooki (otwiera się w nowej karcie), które mogą powiadamiać Cię o aktywności onchain. W przypadku transakcji w Sieci głównej dobrą praktyką jest sprawdzanie bieżących warunków gazu, aby określić odpowiednią jego ilość. Zwykły transfer ETH na zwykły adres zawsze zużywa dokładnie 21000 gazu, co jest minimum dla każdej transakcji, więc wpisujemy tutaj 21000. Jeśli pominiesz gas, Viem oszacuje go za Ciebie.
- nonce: Zobacz definicję nonce powyżej. Nonce zaczyna liczyć od zera.
- [OPCJONALNIE] data: Używane do wysyłania dodatkowych informacji wraz z transferem lub wywoływania inteligentnego kontraktu, niewymagane w przypadku transferów salda, sprawdź uwagę poniżej.
signedTx: Do podpisania naszego obiektu transakcji użyjemy metody signTransaction, która podpisuje go lokalnie za pomocą konta utworzonego z naszego PRIVATE_KEY.
sendRawTransaction: Gdy mamy już podpisaną transakcję, możemy ją wysłać, aby została uwzględniona w kolejnym bloku, używając sendRawTransaction, co wywołuje eth_sendRawTransaction.
waitForTransactionReceipt: Czeka, aż transakcja zostanie uwzględniona w bloku i zwraca jej pokwitowanie.

Uwaga dotycząca danych (data) Istnieją dwa główne typy transakcji, które można wysłać w Ethereum.

Transfer salda: Wysyłanie ETH z jednego adresu na drugi. Pole danych nie jest wymagane, jednak jeśli chcesz wysłać dodatkowe informacje wraz z transakcją, możesz dołączyć te informacje w formacie HEX w tym polu.
- Na przykład, powiedzmy, że chcieliśmy zapisać hash dokumentu IPFS w łańcuchu Ethereum, aby nadać mu niezmienny znacznik czasu. Nasze pole danych powinno wtedy wyglądać tak: data: toHex("IPFS hash"), używając funkcji toHex (otwiera się w nowej karcie) z Viem. I teraz każdy może odpytać łańcuch i zobaczyć, kiedy ten dokument został dodany.
Transakcja inteligentnego kontraktu: Wykonanie kodu inteligentnego kontraktu w łańcuchu. W tym przypadku pole danych powinno zawierać funkcję inteligentnego kontraktu, którą chcesz wykonać, wraz z wszelkimi parametrami.
- Praktyczny przykład znajdziesz w samouczku Hello World Smart Contract.

8. Uruchom kod używając `node sendTx.js`

Wróć do swojego terminala lub wiersza poleceń i uruchom:

node sendTx.js

9. Zobacz swoją transakcję w eksploratorze bloków

Skrypt drukuje hash transakcji, gdy tylko węzeł zaakceptuje transakcję, a następnie czeka, aż zostanie ona uwzględniona w bloku (zazwyczaj w ciągu kilku sekund) i drukuje wynik. Aby zobaczyć szczegóły, wklej hash do eksploratora bloków Sepolia, takiego jak Sepolia Etherscan (otwiera się w nowej karcie) lub Blockscout (otwiera się w nowej karcie). Tam możesz obserwować, jak transakcja przechodzi ze stanu oczekującej do uwzględnionej, i zobaczyć kwotę, opłaty oraz blok, w którym się znalazła.

Jeśli zamiast tego zobaczysz błąd insufficient funds (niewystarczające środki), Twoje konto nie ma wystarczającej ilości Sepolia ETH, aby pokryć wartość plus gaz. Wróć do kroku 2 i poproś o więcej z kranika.

Hura! Właśnie wysłałeś swoją pierwszą transakcję Ethereum przy użyciu Alchemy 🎉

Aby przekazać opinie i sugestie dotyczące tego przewodnika, napisz do Elana na Discordzie (otwiera się w nowej karcie) Alchemy!

Pierwotnie opublikowane przez Alchemy.