Hogyan készítsünk Blockchain alkalmazást a Python segítségével

Blockchain fejlesztő lévén az átlagnál sokkal többet fog tudni az emberekről arról, hogyan működnek a dolgok a motorháztető alatt. Ismeri a blokkokat, hasheket, csomópontokat, tranzakciókat, különféle adattípusokat és még sok minden mást. Ha azonban van ötlete arról, hogyan lehet egy blokkláncot egy adott környezetben megvalósítani az alkalmi felhasználókkal, nem osztja meg velük minden bölcsességét, nemhogy arra kényszerítse őket, hogy megtanulják, hogyan kell minden egyes műveletet elvégezni. A kortárs felhasználók kényelmesen el vannak kényeztetve, és kiváló felhasználói felülettel rendelkező interfészek, amelyek nagyszerű felhasználói élményt nyújtanak. Ha azt szeretné, hogy a blockchain projektje vonzóbb legyen, mint azt legalább meg kellene könnyítenie a használatát. Itt játszanak szerepet a decentralizált alkalmazások vagy a dApps.

A decentralizált alkalmazások a szoftverfejlesztés új trendjei. Népszerűvé váltak a 2017-ben kezdődött ICO-őrület után. A dApps legfőbb megkülönböztető jellemzője, hogy teljes mértékben a blokkláncra támaszkodnak, ezért harmadik fél nem tudja őket ellenőrizni vagy leállítani. Ezenkívül a dApps intelligens szerződéseket is felhasználhat, amelyekről korábban tárgyaltunk, hogy különféle műveleteket biztonságosan és autonóm módon hajtson végre. Ellenkező esetben a dApps hasonlít a központosított alkalmazásokhoz, és bármi lehet, a cserétől a játékig. Néhányat ellenőrizhet a 10 dApps listánkról itt.

Bár vannak külön dedikált programozási nyelvek az intelligens szerződéses és dApp programozáshoz, mint például a Solidity, a Vyper és az Simplicity, más nyelvek is használhatók erre a célra. A bemutató céljára a Pythont választottuk, mivel ez az egyik legátfogóbb és legsokoldalúbb nyelv. Ma bemutatunk egy egyszerű, a Python segítségével létrehozott alkalmazást, elindítjuk és elmagyarázzuk, hogyan működik. Ne halogassuk tovább és kezdjünk dolgozni!

A dApp szerkezete és tulajdonságai

Először vázoljuk, hogyan kell kinéznie egy dApp-nak, és nézzük át az elemeit. A dApp-nak két fő része van:

  • Elülső vég

  • Hátul

A kezelőfelület tartalmaz mindent, amit a felhasználó megmutat. Például, amikor végiggörgeti Facebook-profilját, akkor a Facebook kezelőfelületével lép kapcsolatba. Általában HTML, CSS és JavaScript segítségével írják, de más módon is megteheti. A hátsó rész olyan, mint egy autó motorja. A mechanikán kívül senki sem nézi, de ez működőképessé teszi a dolgokat. Míg a centralizált alkalmazások tárhelyszolgáltatásokat és különféle keretrendszereket használnak, például a Django és a NodeJS, a decentralizáltak inkább blokkláncokat használnak. Mindkét esetben kommunikáció a frontend között & a háttér JSON-formátumú üzeneteken keresztül történik.

Azt is meg kell jegyeznünk, hogy mivel a háttéralkalmazások olyan blokkláncon történnek, ahol minden megváltoztathatatlan, a dApp-ot építő mérnöknek többször ellenőriznie kell a projektjét annak biztosítására, hogy ne legyenek sebezhetők a kódban. Ezáltal a dApps építése inkább hardver, mint szoftver gyártására hasonlít, amely menet közben módosítható. Ami a jó oldal, ha egy dApp tökéletesen meg van írva, akkor az gyakorlatilag feltörhetetlen, mivel nincs meghibásodás központi pontja. Másodszor, a dApps kódját általában nyílt forráskódként teszik közzé. Ellenkező esetben a közösségnek bizalmi problémái vannak, és elkerüli egyes alkalmazások használatát.

Háttér létrehozása

Most, hogy tudjuk, hogy egy dApp a blokkláncra támaszkodik, hozzunk létre egyet Python-nal helyben. Ez biztonságosabb megközelítés a dolgok elsajátításához és teszteléséhez, mivel nem akarunk egy valódi hálózatot zsúfolni felesleges kódokkal. Sőt, ez a bemutató hajlamosabb megmutatni a dolgok működésének alapelveit – a valós világ dApps sokkal összetettebb.

Mivel minden a számítógépén fog történni, a blokklánc fizikailag a merevlemezen lesz, lényegében csomóponttá téve azt. Erre a célra hozzon létre egy mappát, ahol tetszik, és hívja „Projektnek”. A mappán belül hozzunk létre egy másik mappát, hívjuk „blockchain” -nak, és ott kódoljuk meg az első blokkot. Hozzon létre egy szövegfájlt, és nyissa meg a kívánt kódszerkesztőben. Atomot fogunk használni.

A genezis blokk inicializálása

Az első blokkban megadjuk, hogy a fizető ezer érmét fizetett a kedvezményezettnek. Amire valószínűleg emlékszik a hash powerről szóló cikkünkből, minden blokk feje kivonatolódik, és minden blokk hashja bekerül a következőbe annak biztosítására, hogy a hálózatot ne hamisítsák meg. Egy genezis blokk előtt nincs blokk, tehát üres hash lesz.

Genesis blokkoljaKép: U.Today

Ezután a blokklánccal rendelkező mappánkba hozzunk létre egy fájlt a szkript segítségével. Kezdje a JSON könyvtár importálásával, mivel ezt a formázást fogjuk használni. Folytassa az ‘if __name__ == paranccsal "__fő__": ’Utasítás, amely lehetővé teszi annak ellenőrzését, hogy a parancsfájl a konzolról indul-e vagy sem. Ez a lépés segít az importálás során. A helyi blokklánc működéséhez írnunk kell egy olyan funkciót, amely új blokkokat hoz létre. Ezen felül rendelkeznie kell egy funkcióval annak ellenőrzésére, hogy a blokklánc módosult-e vagy sem.

Új blokkok írása

Kódoljuk a függvényt a következő blokkok létrehozásához a láncban. Ehhez meg kell adnunk az összes adattípust, amelyet a genezis blokkba írtunk. Ezután létrehozunk egy ‘with’ utasítást egy funkcióval, hogy új fájlt hozzunk létre, hogy az új blokkokban lévő kód alkalmasabb legyen az olvasásra, és adja meg a behúzást. Miután elkészült, futtathatjuk a szkriptet, és megszerezhetünk egy fájlt a tesztblokkunkkal.

Új tesztblokk & amp; ForgatókönyvKép: U.Today

A tesztfunkció működik! Most kibővíthetjük adatok fogadására, és beírhatjuk a következő blokkokba. Ehhez a kedvezményezett, az összeg, a fizető és a p_hash (előző blokk hash) argumentumokat tesszük a függvénybe. T Ezután meg kell adnunk a függvénynek, hogy a blokkokat a megfelelő mappába írja. Ebből a célból importálja az operációs rendszert a számítógép fájlrendszerével való együttműködéshez. Ezután határozzuk meg a függvényben azt a könyvtárat, amelyet a blokkjainkhoz az „os.curdir” segítségével hoztunk létre. Ezután adja meg ezt a nyilatkozatot az új fájlt író utasításban.

Tovább haladva nem hagyhatjuk a tesztfájlt úgy, ahogy van, azt akarjuk, hogy minden új blokkot egymás után nevezzenek el. Mivel a genetikai blokkunk „0”, a következő blokknak 1-nek és így tovább kell lennie. Ez meglehetősen egyszerű, funkciónknak képesnek kell lennie a blokklánc mag könyvtárának elemzésére. Keresse meg a legújabb blokk legújabb számát, növelje egy számmal a számot, és nevezze el a következő blokkot. Az összes blokk megszerzéséhez az operációs rendszer „listdir” -jét fogjuk használni, és megadjuk neki a blockchain könyvtár változót. Ne feledje, hogy a „listdir” nem rendezi a blokkokat a nevük szerint, ezért a legfrissebb fájl ebben az esetben nem biztos, hogy szükségünk lenne rá. Ezért fel kell használnunk a lista megértését, hogy az összes fájlnévre egész számokat adjunk vissza, és a „rendezett” függvényen keresztül rendezzük őket. Végül tanítsuk meg blokkláncunkat blokkok feliratozására az utolsó blokk nevének visszaadásával és eggyel növelésével. Győződjön meg róla, hogy a címkét visszaállította karakterláncra, és a blokk nevét hozzáadta a ’with’ funkcióhoz.

Funkció blokkok lekéréséreKép: U.Today

Hash

A szkript futtatásakor most új blokkot kap. Ez azonban még mindig nem blokklánc, mivel a csomópontoknak képesnek kell lenniük az adatok integritásának és ezért biztonságának ellenőrzésére is. Mindegyik blokknak hash-ja lesz az előzőhöz. Kezdjük az adatok hasításával a blokkokon belül. Először a „hashlib” modult importáljuk. Ezután létrehozunk egy függvényt, amely beolvassa a blokk tartalmát, futtatja az SHA-256 kivonatoló algoritmuson, és kivonatot ad vissza. Felhívjuk figyelmét, hogy itt meg kell adnia a „blockchain” mappa helyét, különben a funkció nem talál blokkokat. A blokkokat létrehozó függvényben definiáljon egy változót egy korábbi hash számára, amely elindítja az előző blokk hash függvényét. Tesztelés közben láthatjuk, hogy az új blokk tartalmazza az előző hash-ját. Könnyedén ellenőrizheti a kivonatot, ha az 1. számú blokk tartalmát átmásolja egy online SHA256 generátorba, és összehasonlítja az eredményeket.

Hashing funkcióKép: U.Today

Blokkellenőrzés

Eddig megvan a blokk létrehozási és a hash függvény. Itt az ideje bevezetni egy ellenőrző algoritmust csomópontunkhoz. Az általunk létrehozott függvény képes lesz megszerezni a blokklánc összes fájljának listáját, elolvasni az előző blokk hashait a második blokktól kezdve, újra előállítani az előző blokkok kivonatát, összehasonlítani és visszaadni az eredményt.

Először deklarálunk egy változót, amely az összes fájlt megkapja a „blockchain” könyvtárban, egy változót, amely visszaadja a fájlok listáját, és egy változót, amely növekvő sorrendben rendezi a blokkokat. A következő dolog, amit meg kell tennünk, hogy a függvény képes legyen iterálni a blokkokon és elolvassa az előző blokkok hashait. Ez megtehető egy „for” cikluson keresztül, amely az összes adatot betölti egy blokkból, és csak azt adja vissza, ami megfelel a „hash” -nak. Most a hash újbóli létrehozásával annak ellenőrzése, hogy egy függvény kap-e. A „for” hurok belsejében hagyunk egy „true_h” változót, amely elindítja az előző blokk kivonatoló funkcióját. Az utolsó lépés a hash-ok összehasonlítása ‘if / else’ utasítás segítségével. Az eredményeket egy tömbbe írjuk, amelyet beállítottunk nekik, és minden megjelenik a konzolon.

BlokkellenőrzésKép: U.Today

Néhány elbocsátás megtisztítása után van egy helyi blokkláncunk, amelyet a Python kódol.

Frontend építése

Annak ellenére, hogy az összes szükséges funkciót 60 sornyi kód alá sikerült beillesztenünk, egy átlagos felhasználó számára ez még mindig egy csomó fecsegésnek tűnik. Ezért meg kell könnyítenünk a megértést és a kezelőfelület használatát. Ebben az oktatóanyagban a Flask keretrendszert fogjuk használni a HTML, CSS és JavaScript mellett.

A környezet beállítása

A projekt főkönyvtárában hozzon létre egy mappát a virtuális környezet számára, amely háttérként fog működni. Ha korábban még nem tette meg, töltse le Piton a hivatalos oldalról vagy az operációs rendszer parancssorán keresztül (az OSX-ben a homebrew-t használjuk), és telepítse. Továbblépve telepítse a Virtualenv alkalmazást & Adja át a megfelelő parancssori parancsokat. Ezt követően indítson el egy virtuális környezetet a parancssorból az „UI” mappában, új mappát kap, ha mindent helyesen csinált. Ideje aktiválni és telepíteni a lombikot a Pip-en keresztül.

Venv létrehozása és aktiválásaKép: U.Today

Tegyük a hátulunkat a frontend mellé. Vágja ki a „blockchain” mappát és a szkriptet, és illessze be a fő könyvtár „app” mappájába. A háttérmappán belül létre kell hoznunk a fő szkriptfájlt.

A szerkezet létrehozása

Fő szkriptünkben először be kell importálnunk a Lombikot, és egy hivatkozást kell elhelyeznünk a fájl nevére, hogy a Lombik megértse az utakat. Helyeznünk kell egy szabványos utasítást is, amely ellenőrzi, hogy a parancsfájl elindult-e a konzolról és futtatja-e az alkalmazásunkat. Győződjön meg arról, hogy hozzáadta a „debug” elemet, hogy a lombik újratöltődhessen, amikor valamit megváltoztat a kódban.

Üres alkalmazásKép: U.Today

Ha ezen a ponton elindítja a szkriptet, láthatja, hogy a localhost: 5000 fent van, de megjeleníti a 404 hibát. Ez normális, mivel az alkalmazás még mindig üres. Kezdjük kitölteni egy olyan funkció létrehozásával, amely csomópontunk feldolgozza a felhasználók kérdéseit. Ezen belül (a „@” betű elhelyezésével a függvény elé) indexfunkciót teszünk. Ez létrehozza a helyi URL-ek struktúráját és a megfelelő funkciókat. Az ’index’ függvény az index.html felhasználókat fogja megjeleníteni a ’render_template’ modulon keresztül.

App megjelenítési funkcióvalKép: U.Today

Most folytathatjuk a HTML-struktúra létrehozását. Két fájl lesz, az egyik az általános információkért, a másik pedig az első oldal felhasználói felületéért. Az base.html fájlba importáljuk a Bootstrap könyvtárat az elrendezés CSS-en keresztüli létrehozásához. Hozzunk létre egy központosított oszlopot, és tegyünk egy blokkot a tartalomhoz olyan formátumban, amelyet a lombik Jinja értelmezhet.

Első oldal html-benKép: U.Today

A felhasználói felület összeállítása

Alkalmazásunk egyszerű fizetési rendszer lesz. Lesz fizető, kedvezményezett és átutalt pénzösszeg. Minden a blockchainen keresztül fog történni, de egy felhasználó számára ez egy szokásos alkalmazásnak fog kinézni. Amikor pénzt utal át az interneten, általában kitölt valamilyen űrlapot, és elküldi. A Bootstrap különféle formákkal rendelkezik, amelyek segítséget nyújtanak nekünk néhány előre beállított beállításnál. Másolhatja azt, amelyikből választottunk itt és másolja a kódot az index.html fájlba. Az előre megírt űrlapon csak két mező és egy jelölőnégyzet lesz, eltávolítjuk a jelölőnégyzetet, és hozzáadunk egy mezőt. Ezután beállítjuk a megfelelő címkéket, azonosítókat, típusokat és helyőrzőket. Végül indexfunkciónkat az űrlaphoz rendeljük. Amikor a felhasználó megadja a nevét, az összegét és a számlálót, akkor az összes információt el kell menteni valahova, majd blokkba kell foglalni. Ehhez módosítsuk a beviteli mezőket a „név” és az „érték” hozzáadásával. Az érték a „get” metódust használja annak kibontására, amelyet a felhasználó a „Fizető” mezőbe tesz. Ne felejtsen el megadni egy üres karakterláncot, ha a felhasználó nem ír be semmit.

FormaKép: U.Today

Térjünk vissza a fő forgatókönyvünkhöz. A parancsfájlnak képesnek kell lennie megérteni, hogy a felhasználó által küldött kérés POST-e vagy sem. Ennek engedélyezéséhez importáljuk a kérelem modult a lombikból, és megadjuk a módszereket az alkalmazásunkban. Az alkalmazáson belül olyan változásokat deklarálunk, amelyek a megfelelő adatokat kérik az űrlapból.

Frissített alkalmazásKép: U.Today

Továbbhaladva az összes összegyűjtött adatot át kell adnunk egy új blokknak. Ehhez meg kell kötnünk a fő szkriptet ahhoz, amely blokkokat ír. Ehhez a kérés típusát ellenőrző „if” utasításon belül egy „write” függvényt helyezünk el a blokkjainkban szereplő argumentumokkal megegyező argumentumokkal.

A felhasználói felület összekapcsolása a háttérrendszerrelKép: U.Today

Most, ha visszatérünk a böngészőnkhöz és benyújtunk egy tranzakciót, egy új blokkot kapunk a blokklánc mappánkba, amely tartalmazza a közölt információkat. Láthatja azonban, hogy a mezők nem frissültek. Ehhez át kell irányítanunk egy felhasználót az index.html új példányára. Ne felejtse el importálni az általunk használt modulokat a Lombikból. Voila, minden felfrissül, miután benyújtotta.

ÁtirányításKép: U.Today

A felhasználói felületünk utolsó érintése a gomb ez arra készteti csomópontunkat, hogy ellenőrizze-e a blokkláncunkban előforduló biztonsági megsértéseket. Ehhez létrehozunk egy másik útvonalat az ellenőrzéshez, benne egy funkcióval. Ezután térjünk vissza a base.html fájlunkra, és adjunk meg még két tárolót egy gombhoz, és az ellenőrzési eredményeket az 5-ös felső margókkal tegyük. Tegyen egy blokkot egy konténerbe és az index.html-be is.

Letiltás ellenőrzés céljábólKép: U.Today

A következő lépéshez választunk egy gombot a Bootstrap könyvtárból, és űrlapként az base.html fájlba helyezzük. Az űrlapban tegye műveletként az „ellenőrizni” függvényünket, és csatolja a fő parancsfájl „ellenőrzés” függvényéhez. Ha ez megtörtént, térjen vissza a fő szkripthez, és helyezze a blokkokat létrehozó szkriptből az ellenőrző függvényt a check függvénybe. Menj a base.html oldalra, itt egy ‘for’ ciklust szeretnénk készíteni az ‘results’ tömb minden változójához. A ‘for’ ciklusban létrehozunk egy div-t, amely az ellenőrzési eredményeket jeleníti meg.

A hurok ellenőrzéseKép: U.Today

A dApp tesztelése

Tehát itt van. Térjen vissza a böngészőhöz, és frissítse az oldalt. Mostantól a dApp a tranzakciókat rögzítheti a blokkláncra, és ellenőrizheti, hogy valamelyik blokkot feltörték-e. Annak érdekében, hogy minden működjön, küldjön be egy tranzakciót az Ön által kiválasztott adatokkal, és lépjen a blockchain mappába. Új szövegfájlnak kell ott lennie a megadott fizetővel, összeggel és kedvezményezettel, valamint az előző blokk hashjával.

dApp felületKép: U.TodayÚj blokkKép: U.Today

Térjen vissza a böngészőhöz, tegyen még néhány blokkot, és indítsa el az ellenőrzési folyamatot. Látni fogja, hogy ezen a ponton az összes blokk eredeti. Ideje feltörni a csomópontunkat! Lépjen a blockchain mappába, és változtassa meg az egyiket, amelyet a legutóbbi előtt készített. Most térjen vissza a böngészőhöz, és ellenőrizze még egyszer a láncunkat. Amint láthatja, csomópontunk jelzi, hogy egy blokk sérült, és nem szabad megbíznunk ennek a blokkláncnak az adataiban.

Hamis tömbökKép: U.Today

Összegzés

Összefoglalva: ma megmutattunk egy egyszerű decentralizált alkalmazást egy helyben működtetett blokkláncon. Az alkalmazások decentralizált módon történő építésének megvannak a maga jellemzői, de hasonló a rendszeres alkalmazások építéséhez is. Végül is az alkalmazások a végfelhasználó számára készültek, így a felszínen valószínűleg nem találna sok különbséget.

Ha a dApps kódolásával foglalkozik, ismernie kell a blockchain technológia elveit és meg kell értenie, hogyan kell írni mind a frontendhez, mind a backendhez. Ilyen magas szintű szükséges ismeretek mellett jobb, ha olyan gyors és egyszerű programozási nyelvet választ, mint a Python. A Python segítségével kompatibilis kódot készíthet, és gond nélkül futtathat egy helyi szervert. Ez utóbbi nagyon fontos, mivel a közzététel előtt minden szükséges biztonsági ellenőrzést el akar végezni, mert a blokklánc megváltoztathatatlan.

Reméljük, hogy ez a bemutató sokat segített a dApps megértésében. Élvezd!