Drugie kroki

    W tej sekcji przedstawimy kilka potężnych narzędzi, które ułatwią Ci tworzenie oprogramowania. Zainstalujemy środowisko programistyczne o nazwie Truffle, zbadamy Solidity, omówimy podstawy inteligentnego kontraktu (stworzymy nawet własne!) I uruchomimy nasz własny węzeł na naszej lokalnej maszynie. Po pomyślnym wdrożeniu lokalnie użyjemy Remiksu do interakcji z naszą umową i głębiej zagłębimy się w proces rozwoju!

    Zapoznanie się z truflą

    Trufla

    Truffle to doskonałe środowisko programistyczne, które umożliwia zarówno łączenie się, jak i testowanie przy użyciu maszyny wirtualnej Ethereum. Truffle został stworzony, aby ułatwić programowanie, a interakcje zachodzące lokalnie pomagają zmniejszyć stres związany z wdrażaniem zarówno w sieci testowej (takiej jak Ropsten lub Rinkeby), jak i głównej.

    Aby uzyskać więcej dokumentacji na temat trufli, zajrzyj tutaj:

    Zrzut ekranu 2020 08 26 o godzinie 5 49 43


    Aby zainstalować Truffle w swoim terminalu, wykonaj następujące czynności:

    npm zainstaluj truflę -g

    Uwaga: zalecenia dla systemu Windows

    Jeśli używasz Truffle w systemie Windows, możesz napotkać konflikty nazw, które mogą uniemożliwić prawidłowe wykonanie Truffle. Proszę zobaczyć sekcja dotycząca rozwiązywania konfliktów nazw dla rozwiązań.

    Nadzienie 

    Skoro już o tym mowa, zainstalujmy CLI dla ganache

    Krótkie podsumowanie ganache jest takie, że jest to osobisty łańcuch bloków, którego można używać lokalnie, aby szybko uruchamiać i testować funkcjonalność projektów. Ganache to narzędzie, którego możesz używać przez cały cykl rozwoju. Nie tylko możesz rozwijać, ale także wdrażać i testować swoje aplikacje dApps. Wszystko to dzieje się lokalnie na twoim komputerze, więc jest to środowisko o najniższym tarcie / ryzyku do pracy nad twoimi projektami!

    Korzystanie z npm:

    npm install -g ganache-cli

    Ok, wracając do trufli!

    Niektóre z ofert Truffle zapewnia:

    • Wbudowana kompilacja inteligentnych umów, łączenie, wdrażanie i zarządzanie plikami binarnymi.
    • Zautomatyzowane testy kontraktowe w celu szybkiego rozwoju.
    • Wdrożenie z możliwością obsługi skryptów i możliwością rozbudowy & ramy migracji.
    • Zarządzanie siecią w celu wdrożenia do dowolnej liczby odbiorców & sieci prywatne.
    • Zarządzanie pakietami z EthPM & NPM przy użyciu standardu ERC190.
    • Interaktywna konsola do bezpośredniej komunikacji z umową.
    • Konfigurowalny proces kompilacji z obsługą ścisłej integracji.
    • Zewnętrzny program uruchamiający skrypty, który wykonuje skrypty w środowisku Truffle.

    W naszym samouczku zamierzamy zbudować coś od podstaw, jednak absolutnie zachęcamy do zapoznania się z niektórymi projektami kotłów, które Truffle już stworzyła o nazwie Truffle Boxes (znaleziono tutaj).

    Skoro mamy już zainstalowane trufle i ganache, porozmawiajmy o solidności!

    Solidność 

    Solidity to niezwykle popularny, zorientowany obiektowo język wysokiego poziomu do wdrażania inteligentnych kontraktów, które działają na maszynie wirtualnej Ethereum (EVM). Inteligentne kontrakty to programy, które zarządzają zachowaniem kont w stanie Ethereum. Jeśli nigdy wcześniej nie spojrzałeś na linię Solidity, ale znasz C ++ i / lub JavaScript, zauważysz więcej niż kilka podobieństw. 

    Solidity to język z typami statycznymi, który obsługuje między innymi dziedziczenie, biblioteki i złożone typy zdefiniowane przez użytkownika. Dzięki Solidity możesz tworzyć umowy do celów takich jak głosowanie, finansowanie społecznościowe, a nawet aukcje w ciemno, aby wymienić tylko kilka przypadków zastosowań. 

    Solidity jest kompilowany do kodu bajtowego wykonywalnego na EVM. Dzięki Solidity programiści mogą pisać aplikacje, które implementują samowzmacniającą się logikę biznesową zawartą w inteligentnych kontraktach, pozostawiając niezaprzeczalny zapis transakcji. Inteligentne kontrakty pozwalają użytkownikom ufać kodowi, który pomaga w tworzeniu pozbawionego zaufania środowiska, w którym potencjalne zepsucie ludzkie jest znacznie usunięte. 

    Pamiętaj, że wdrażając umowy, zawsze należy zwracać uwagę na używaną wersję. Przełomowe zmiany, nowe funkcje i poprawki błędów są wprowadzane regularnie (pamiętaj o tym, jeśli korzystasz z samouczków online, mogą wystąpić błędy, więc zachowaj dokumentacja blisko Ciebie). 

    Rozpoczęcie projektu truflowego 

    Mając to na uwadze, zacznijmy nasz projekt i nazwijmy go „eth-hello-world”

    Wskocz do terminala i utwórzmy nowy pusty folder 

    mkdir eth-hello-world

    Gdy już mamy nasz pusty katalog, wskocz do folderu i uruchom polecenie

    init trufli

    Po zakończeniu procesu powinniśmy być w stanie wyświetlić niektóre pliki, które zostały dla nas utworzone:

    Zrzut ekranu 2020 08 26 o godzinie 7 21 53

    Mamy teraz kontakty, migracje, folder testowy i plik truffle-config. Przyjrzyjmy się tym plikom i omówmy na wyższym poziomie, czym one są.

    Umowy

    Ten folder będzie zawierał wszystkie Twoje inteligentne kontrakty (które w tym przykładzie będziemy tworzyć za pomocą Solidity). Jeśli nigdy nie słyszałeś o inteligentnych kontaktach, możesz o nich myśleć; fragmenty kodu działające w łańcuchu bloków (może to być sieć lokalna, testowa lub główna), które gwarantują te same wyniki dla każdego, kto je uruchamia. Inteligentne kontrakty są używane w ramach dApps (zdecentralizowanych aplikacji) i mają ogromną liczbę przypadków użycia. Głosowanie, gry, łańcuch dostaw, waluty, dane finansowe i to tylko kilka z nich!

    Aby jeszcze bardziej to rozłożyć, Nick Szabo podaje przykład automatu sprzedającego. Jeśli włożysz odpowiednią ilość monet do automatu, ty (i wszyscy przed / po tobie) możesz spodziewać się tego samego dokładnego wyniku w wymianie. To samo dotyczy inteligentnych kontaktów zbudowanych na Ethereum, zawierają one wartość i dopóki nie zostaną spełnione ich warunki (tj. Odpowiednia ilość monet w naszym przykładzie), odblokują i udostępnią informacje, które próbujesz odzyskać.

    Wrócimy do omówienia Solidity i inteligentnych kontraktów nieco później, przejdźmy do migracji!

    Migracje

    Migracje to pliki JavaScript, które umożliwiają wdrażanie kontraktów w sieci Ethereum. Najbardziej interesujące w nich jest to, że istnieje podstawowe założenie, że Twoja praca będzie ewoluować, a wdrażanie będzie się zmieniać w czasie. Wprowadzając aktualizacje, będziesz tworzyć nowe skrypty migracji w trakcie ewolucji projektu. Można myśleć o plikach migracji, ponieważ są one głównie odpowiedzialne za przemieszczanie i wdrażanie zadań. Najprostszym sposobem, aby o nich pomyśleć, jest to, że migracje to zestaw zarządzanych skryptów wdrażania. Podczas aktualizowania pracy dziennik wcześniej przeprowadzonych migracji jest rejestrowany w łańcuchu za pośrednictwem wbudowanej umowy migracji.

    Spójrz sam, masz już kontrakt migracyjny! Przejdź do katalogu umów i otwórz go, zobaczysz plik Migrations.sol zawierający umowę, która powinna wyglądać mniej więcej tak:

    Zrzut ekranu 2020 08 27 o 4 49 03 rano

    To jest domyślny kontrakt, który jest tworzony dla nas, kiedy uruchamiamy truffle init. Truffle z natury wymaga zawarcia umowy migracyjnej, aby móc korzystać z funkcji migracji, więc nie usuwaj tego!

    Uwaga: aby skorzystać z funkcji migracji, musisz wdrożyć tę umowę podczas pierwszej migracji.

    Teraz, gdy mieliśmy okazję przyjrzeć się naszej umowie migracyjnej, możemy przejść do katalogu migracji i zobaczymy plik o nazwie 1_inital_migrations.js

    Uwaga: Spójrz na konwencję nazewnictwa tego pliku, jest on poprzedzony numerem i zakończony opisem. Numerowany prefiks jest wymagany do zarejestrowania, czy migracja przebiegła pomyślnie. Przyrostek jest przeznaczony wyłącznie dla czytelności dla człowieka

    Zrzut ekranu 2020 08 27 o 5 09 25 rano

    Tworząc umowy, musisz upewnić się, że masz plik migracji.js w połączeniu z nimi. Bez zbytniego zagłębiania się w artefakty. Require (), deployer.deploy itp tutaj to doskonała dokumentacja od zespołu ds. trufli, w celu dalszego wyjaśnienia stosowania tych metod.

    Aby skompilować projekt Truffle, przejdź do katalogu głównego katalogu, w którym znajduje się projekt, a następnie wpisz następujące polecenie w terminalu:

    kompilacja trufli

    Aby uruchomić migracje w terminalu, ostatecznie uruchomisz (jednak poczekaj, nie musimy jeszcze tego robić!)

    trufle migrują

    Spowoduje to uruchomienie wszystkich migracji znajdujących się w katalogu migracji Twojego projektu.

    Warto zauważyć, że to polecenie uruchomi tylko nowo utworzone migracje. Jeśli więc poprzednia migracja przebiegła pomyślnie, nie uruchomi jej ponownie. Ponadto, jeśli nie istnieją żadne nowe migracje do uruchomienia, po prostu nie zostaną uruchomione. W razie potrzeby możesz użyć opcji –reset, aby uruchomić wszystkie migracje od początku.

    Inne opcje poleceń są udokumentowane tutaj.

    Uwaga: Zainstalowaliśmy wcześniej, ale do testów lokalnych upewnij się, że masz testowy łańcuch blokowy, taki jak Nadzienie zainstalowane i uruchomione przed wykonaniem migracji.

    Testowanie

    Jeśli chodzi o pisanie testów, trufla jest wyposażona w doskonałe narzędzia, które sprawiają, że jest to intuicyjne. Zwłaszcza jeśli planujesz wdrożyć swoje kontrakty w sieci głównej (ale jest to dobra praktyka, nawet w sieci testowej), bardzo ważne jest, aby przeprowadzać testy i sprawdzać umowy najlepiej, jak potrafisz. Truffle sprawił, że przeglądanie / testowanie Twojego rozwoju jest proste i łatwe w zarządzaniu.

    Truffle używa rozszerzenia Mokka framework testowy i Chai asercji, aby zapewnić solidną strukturę do pisania testów JavaScript. 

    Uwaga: jeśli nie wiesz, jak pisać testy jednostkowe w języku mokka, zapoznaj się z sekcją Dokumentacja Mocha przed kontynuowaniem.

    Uwaga dodatkowa: Doskonałym narzędziem do dokładnego przeglądu umów jest Mythx, czołowa usługa analizy bezpieczeństwa w tej dziedzinie, oferująca dogłębne przeglądy inteligentnych kontraktów. Ich misją jest nie tylko unikanie kosztownych błędów, ale także ogólne uczynienie Ethereum bardziej bezpieczną i godną zaufania platformą.

    Wszystkie pliki testowe powinny znajdować się w katalogu./test. Truffle uruchomi tylko pliki testowe z następującymi rozszerzeniami plików: .js, .ts, .es, .es6, .jsx i.sol. Wszystkie inne pliki są ignorowane.

    Aby uruchomić wszystkie testy, po prostu uruchom:

    test truflowy

    Teraz, gdy omówiliśmy, co tworzy truflowy init i rusztowania naszego projektu, przejdźmy teraz do przodu i dodajmy nasz inteligentny kontrakt do naszego projektu!

    Pisanie inteligentnej umowy

    Przejdźmy do katalogu umów i napiszmy naszą pierwszą umowę, którą planujemy wdrożyć w naszym lokalnym środowisku testowym (ganache)!

    Zaczniemy od stworzenia naszego pliku.sol, któremu nadamy nazwę HelloWorld.sol

    Następnie możemy dodać nasz podstawowy kontrakt, który będzie wyglądał mniej więcej tak

    pragma solidność >= 0,5,8 <0,7,0; kontrakt HelloWorld {string public message; konstruktor (pamięć łańcuchowa initMessage) public {message = initMessage; } aktualizacja funkcji (pamięć łańcuchowa newMessage) public {message = newMessage; }}

    Przyglądając się bliżej naszej umowie, możemy rozbić kilka elementów

    Pamiętaj, umowa to zbiór funkcji i danych (stan).

    Słowo kluczowe pragma może służyć do włączania niektórych funkcji lub kontroli kompilatora. Dyrektywa pragma jest zawsze lokalna dla pliku źródłowego, więc musisz dodać pragmę do wszystkich plików, jeśli chcesz włączyć ją w swoim projekcie. Bez deklaracji pragmy na początku naszego (lub jakiegokolwiek) pliku dotyczącego solidności, nasz kontrakt nie będzie wiedział, jak skompilować.

    (tutaj jest linkiem do dokumentacji solidity, aby poznać tajniki niuansów solidności)

    Ostatecznie umowa to zbiór funkcji i danych (ich stan), który znajduje się pod określonym adresem w łańcuchu blokowym Ethereum.

    Patrząc na funkcjonalność naszej umowy, widzimy, że ustawiamy naszą wiadomość jako widoczną publiczną ciąg znaków. 

    Słowo kluczowe „public” udostępnia zmienne spoza kontraktu i tworzy funkcję, którą inne kontrakty lub zestawy SDK mogą wywoływać w celu uzyskania dostępu do ciągu wartości public message.

    kontrakt HelloWorld {string public message;

    Oto funkcja, która działa tylko podczas tworzenia umowy 

    konstruktor (pamięć łańcuchowa initMessage) public {message = initMessage; }

    Pobiera wartość ciągu i przechowuje wartość w obszarze przechowywania danych w pamięci, ustawiając wiadomość na tę wiadomość o wartości, tj. InitMessage.

    Następnie możemy zainicjować wiadomość, która jest przekazywana jako parametr i może być zmieniana / aktualizowana za pomocą funkcji aktualizacji.

    Jest to publicznie dostępna funkcja, która przyjmuje ciąg jako parametr i aktualizuje „komunikat” (patrz poniżej).

    aktualizacja funkcji (pamięć string newMessage) public {message = newMessage; }}

    Masz to, podstawowy, ale przyswajalny kontrakt HelloWorld!

    Teraz, gdy dodaliśmy nasz kontrakt, możemy teraz upewnić się, że ma on możliwość kompilacji!

    Udaj się do folderu migracji w naszym projekcie, a teraz utworzymy plik a.js poświęcony naszej umowie HelloWorld.

    Utworzymy nowy plik o nazwie 2_deploy_contracts.js

    Pamiętaj o wcześniejszej uwadze dotyczącej konwencji nazewnictwa!

    const HelloWorld = artifacts.require ("Witaj świecie"); module.exports = function (deployer) {deployer.deploy (HelloWorld, "strunowy"); };

    Dobra robota! Jesteśmy prawie gotowi do wdrożenia naszej umowy, ale najpierw musimy się upewnić, że nasze pliki konfiguracyjne truffle wiedzą, z kim rozmawiać. Jak wspomniano wcześniej, w tej sekcji skupimy się na naszym środowisku lokalnym, ale w sekcji 3 (spolier) nie tylko tworzymy i wdrażamy lokalnie, ale przenosimy je do sieci testowej!

    Przewiń w dół w pliku truffle-config.js, aż zobaczysz sekcję dotyczącą sieci

    odkomentuj / dodaj następujące 

    sieci: {programowanie: {host: "127.0.0.1", port: 8545, identyfikator_sieci: "*", },

    Teraz twój plik powinien wyglądać mniej więcej tak:

     

    Zrzut ekranu 2020 08 31 o 6 14 45 rano

    To, co się tutaj dzieje, to to, że przekazujemy naszemu plikowi konfiguracyjnemu szczegółowe wskazówki dotyczące tego, z czym się połączyć. W tym przypadku, jak wkrótce się przekonasz, będziemy łączyć się z naszym narzędziem ganache-cli.

    Uruchom Ganache

    Powiedziawszy to, zacznijmy i zacznijmy nasz ganache 

    w swoim terminalu, śmiało uciekaj 

    ganache-cli

    Zrzut ekranu 2020 08 31 o 6 20 12 rano

    Sprawdź to! Teraz uruchamiasz swój własny TestRPC w swoim terminalu! 

    (więcej na ten temat tutaj)

    Uwaga: pozostaw tę kartę otwartą w terminalu, ale idź dalej i otwórz nową, aby rozwiązać problem.

    Szybki przegląd 

    Wróćmy do naszego projektu i przyjrzyjmy się szybko temu, co zrobiliśmy. 

    • Stworzyliśmy nowy projekt
    • Zainicjowana trufla
    • Zrobiłem szybką wycieczkę po rusztowaniu
    • Stworzyliśmy nasz kontrakt HelloWorld
    • Dodano logikę do naszego folderu migracji dla naszej umowy
    • Weszliśmy do naszego pliku konfiguracyjnego i dostosowaliśmy informacje o naszej sieci 

    Czas zacząć obowiązywać nasz kontrakt! 

    W naszym nowym oknie terminala (ponieważ w drugim mamy uruchomiony ganache) 

    chodźmy do przodu i uciekajmy 

    kompilacja trufli

    Powinieneś teraz zobaczyć to jako wynik w swoim terminalu:

    Zrzut ekranu 2020 08 31 o godzinie 7 07 17

    Jeśli przejdziesz teraz do swojego projektu, zobaczysz, że nad folderem kontraktów znajduje się folder build / contract zawierający dwa pliki.json. Powinieneś zobaczyć: 

    • HelloWorld.json
    • Migrations.json 

    Plik.json na wysokim poziomie opisuje wdrożony kontrakt i jego funkcje. Pozwala nam kontekstualizować umowę i wywoływać jej funkcje.

    Jeśli zajrzymy do środka, zobaczymy całą masę informacji:

     

    Zrzut ekranu 2020 08 31 o 8 01 28 rano

    Zagłębiamy się w te informacje głębiej w kroku trzecim, ale czymś ważnym, na co należy zwrócić uwagę, jest ABI.

    Interfejs binarny aplikacji to schemat kodowania danych używany w Ethereum do pracy z inteligentnymi kontraktami.

    Przyglądając się informacjom, ich zrozumienie jest stosunkowo intuicyjne. ABI definiuje również, w jaki sposób użytkownik może wywoływać funkcje – to znaczy lokalizację funkcji w odniesieniu do adresu inteligentnej umowy. Podsumowaniem wysokiego poziomu jest ABI to opis interfejsu kontraktu. Nie zawiera kodu i nie może działać samodzielnie. Następnie mamy kod bajtowy, który jest wykonywalnym kodem EVM, ale sam w sobie jest bez kontekstu.

    Czas na migrację

    ok! 

    Więc teraz, gdy mamy uruchomione ganache-cli i skompilowaliśmy nasz inteligentny kontrakt, więc teraz nadszedł czas na migrację naszych kontraktów! 

    w swoim terminalu, śmiało uciekaj 

    trufle migrują

    TAK! Zrobiłeś to!

    Zrzut ekranu 2020 08 31 o godzinie 8 37 37

    Widzimy, że pomyślnie wdrożyliśmy nasz inteligentny kontrakt. Możesz zobaczyć kilka naprawdę przydatnych informacji, a jeśli przejdziesz do drugiej karty z uruchomionym ganachi-cli, powinieneś zobaczyć TransactionReceipt (spójrz na siebie).

    Przetestuj ETH 

    Zanim przejdziemy do Remiksu, musimy zdobyć trochę testowego ETH, abyśmy mogli uiścić opłaty za benzynę za Remix (nie martw się, to nie będzie Cię kosztować). 

    Udaj się do ten kran i weź trochę Rinkeby. Zagłębiamy się w to, czym jest test ETH w kroku 3, ale w tym kroku po prostu wiemy, że będziemy używać Rinkeby, która jest siecią Proof of Authority, w przeciwieństwie do, powiedzmy, Ropsten, która jest testową siecią Proof of Work (która jest bardziej podobna do publicznej netto). Po wykonaniu kroków 2 i 3 będziesz mieć część z nich w portfelu MetaMask do eksperymentowania!

    Remiks

    Ok, teraz, gdy mamy trochę testów EHT, czas przejść do Remiksowania i wdrożyć naszą umowę poza naszym lokalnym środowiskiem, a nawet mieć możliwość interakcji z nim!

    „Co to do cholery jest Remiks?” 

    Cieszę się, że zapytałeś! 

    Remix to potężne narzędzie typu open source, które pomaga pisać kontrakty Solidity bezpośrednio z przeglądarki. Jednym z naprawdę niesamowitych elementów, w szczególności w przypadku Remix, jest to, że obsługuje zarówno użycie w przeglądarce, jak i lokalnie! Remiks obsługuje testowanie, debugowanie i wdrażanie kontraktów, aby wymienić kilka kluczowych funkcji. Remiks należy traktować jako podstawowe narzędzie programisty w procesie tworzenia. Rozpoczynanie od lokalnego wdrożenia (tak jak to zrobiliśmy wcześniej) z ganache to doskonała podstawa, przechodząc od lokalnego wdrożenia możemy eksperymentować i wchodzić w interakcje z naszą umową w Remix.

    Przyjmowanie odpowiednich przekonań i testowanie (raz po raz) swojego rozwoju przed potencjalnym uruchomieniem w głównej sieci Ethereum może uratować cię być może więcej niż ból głowy!

    Teraz weźmy tę samą umowę i wdróżmy ją poza naszym środowiskiem lokalnym za pomocą Remix 

    Połączyć tutaj 

    Nasz kontrakt 

    Kliknij nowy plik i nazwijmy go HelloWorld.sol

    (oto umowa, z której będziemy korzystać ponownie) 

    pragma solidność >= 0,5,8 <0,7,0; kontrakt HelloWorld {string public message; konstruktor (pamięć łańcuchowa initMessage) public {message = initMessage; } aktualizacja funkcji (pamięć łańcuchowa newMessage) public {message = newMessage; }}

    Możemy teraz iść dalej i dodać nasz kontrakt w terenie. (Sprawdź to poniżej) 

    Zrzut ekranu 2020 08 31 o godzinie 9 47 48

    Zajrzyjmy teraz do lewego menu z pytaniem o wybraną wersję kompilatora.

    Kompilator

    Pamiętaj, że w ramach naszej umowy zadeklarowaliśmy zakres naszych kompilatorów.

    Pamiętaj, że słowo kluczowe pragma służy do włączania pewnych funkcji lub kontroli kompilatora. 

    Więc możemy ustawić nasz kompilator na 0.6.0, który mieści się w naszym podanym zakresie (patrz cios) 

    Zrzut ekranu 2020 09 08 o godzinie 8 44 41

    Nasza umowa powinna się automatycznie skompilować, jeśli nie, przejdź dalej i kliknij Kompiluj HelloWorld.sol

    Następnie skonfigurujemy nasze środowisko, aby wdrożyć naszą umowę! 

    Wdrażaj i uruchamiaj transakcje

    Środowisko 

    Wybierając środowisko, zauważysz kilka różnych opcji:

    Maszyna wirtualna JavaScript: Wszystkie transakcje będą realizowane w łańcuchu bloków sandbox w przeglądarce. Oznacza to, że po ponownym załadowaniu strony nic nie zostanie utrwalone. JsVM jest własnym łańcuchem bloków i przy każdym przeładowaniu uruchomi nowy łańcuch bloków, stary nie zostanie zapisany.

    Dostawca wstrzyknięty: Remiks połączy się z wstrzykniętym dostawcą web3. Metamask jest przykładem dostawcy, który wstrzykuje web3.

    Dostawca Web3: Remix połączy się ze zdalnym węzłem. Będziesz musiał podać adres URL do wybranego dostawcy: geth, parzystość lub dowolnego klienta Ethereum.

    W tym przykładzie użyjemy: Injected Web3

    Użyjemy naszego portfela MetaMask i upewnimy się, że jesteśmy połączeni z naszą siecią testową Rinkeby 

    Widzimy po lewej stronie, że jesteśmy połączeni z Rinkeby, a także widzimy adres naszego połączonego konta! 

    Zrzut ekranu 2020 09 08 o godzinie 8 30 29

    Gdy wszystko będzie gotowe, przejdźmy do realizacji naszej umowy!

    Zrzut ekranu 2020 09 08 o 8 57 35 rano

    &# 127881; Zrobiliśmy to! &# 127881; 

    Sprawdź dostarczony terminal i możesz zobaczyć potwierdzenie

    Zrzut ekranu 2020 09 08 o 8 58 11 rano

    Teraz mamy możliwość podglądu naszej wdrożonej umowy, możemy zaktualizować naszą wiadomość (musimy zarówno podpisać, jak i uiścić opłatę za gaz, ponieważ aktualizujemy stan)

    Gdy otrzymamy potwierdzenie, możemy zobaczyć, że nasza wiadomość została zaktualizowana!

    Zrzut ekranu 2020 09 08 o godzinie 9 18 54

    &# 129395; Dobra robota! &# 129395; 

    Podjęliśmy umowę, z którą początkowo zaczynaliśmy lokalnie, i wdrożyliśmy tę umowę w Remix, aby uzyskać wizualną reprezentację interakcji między umowami. To zdrowy przepływ dla deweloperów, którzy zaczynają budować w tej przestrzeni. Remiks to niesamowite narzędzie, z którego powinno się często korzystać. W kroku 3 pójdziemy o krok dalej i zawiążemy wszystkie informacje, których nauczyliśmy się w kroku 1 & 2 i połącz razem Truffle + Infura + React! 

      Wdrażanie programistów: krok 1Wprowadzenie do programu krok 1

      Wdrażanie programistów: krok 1

      Wdrażanie programistów: krok 3Wprowadzenie do programu krok po kroku 3

      Wdrażanie programistów: krok 3

      10-minutowa orientacja w Ethereum10-minutowa orientacja w Ethereum

      10-minutowa orientacja w Ethereum

    Mike Owergreen Administrator
    Sorry! The Author has not filled his profile.
    follow me