Come costruire un’applicazione Blockchain con Python

Essendo uno sviluppatore blockchain, conoscerai molto più della media delle persone su come funzionano le cose sotto il cofano. Avrai familiarità con blocchi, hash, nodi, transazioni, vari tipi di dati e molti altri. Tuttavia, se hai un’idea di come implementare la blockchain in un ambiente specifico con utenti occasionali, non condividerai tutta la tua saggezza con loro, figuriamoci costringerli a imparare come viene eseguita ogni singola operazione. Gli utenti contemporanei sono viziati con interfacce facili e con interfacce utente eccezionali che garantiscono un’ottima esperienza utente. Se vuoi rendere il tuo progetto blockchain più accattivante di quanto dovresti, almeno rendilo facile da usare. È qui che entrano in gioco le applicazioni decentralizzate o le dApp.

Le app decentralizzate sono una nuova tendenza nello sviluppo di software. Sono diventati popolari dopo la mania delle ICO iniziata nel 2017. La principale caratteristica distintiva delle dApp è che si basano completamente sulla blockchain e quindi non possono essere controllate o chiuse da terze parti. Inoltre, le dApp possono anche utilizzare contratti intelligenti, di cui abbiamo discusso in precedenza, per eseguire varie operazioni in modo sicuro e autonomo. Altrimenti, le dApp assomigliano ad app centralizzate e potrebbero essere qualsiasi cosa, dagli scambi ai giochi. Puoi verificarne alcuni dal nostro elenco di 10 dApp qui.

Sebbene esistano alcuni linguaggi di programmazione dedicati per smart contract e programmazione dApp, come Solidity, Vyper e Simplicity, è possibile utilizzare anche altri linguaggi per questo scopo. Ai fini di questo tutorial, abbiamo scelto Python perché è uno dei linguaggi più completi e versatili in circolazione. Oggi vi mostreremo una semplice app creata con Python, la lanciamo e vi spiegheremo come funziona. Non rimandiamo oltre e mettiamoci al lavoro!

Struttura e proprietà di una dApp

Innanzitutto, descriviamo come dovrebbe apparire una dApp e esaminiamo i suoi elementi. Ci sono due parti principali di una dApp:

  • Fine frontale

  • Back end

Il front-end contiene tutto ciò che viene mostrato a un utente. Ad esempio, quando scorri il tuo profilo Facebook, stai interagendo con il front-end di Facebook. Di solito è scritto utilizzando HTML, CSS e JavaScript, ma ci sono altri modi per farlo. Il back-end è come il motore di un’auto. Nessuno, tranne i meccanici, lo guarda, ma fa funzionare le cose. Mentre le applicazioni centralizzate utilizzano servizi di hosting e vari framework come Django e NodeJS, quelle decentralizzate utilizzano invece blockchain. In entrambi i casi, comunicazione tra frontend & backend avviene tramite messaggi in formato JSON.

Dobbiamo anche notare che poiché le attività di backend avvengono sulla blockchain dove tutto è immutabile, un ingegnere che costruisce una dApp dovrebbe eseguire più controlli approfonditi del proprio progetto per assicurarsi che non ci siano vulnerabilità nel codice. Ciò rende la creazione di dApp più simile alla creazione di hardware, piuttosto che software, che può essere ottimizzato al volo. Il lato positivo è che se una dApp è scritta perfettamente, è praticamente inattaccabile in quanto non esiste un punto centrale di errore. In secondo luogo, il codice per le dApp viene solitamente pubblicato come open source. In caso contrario, la comunità avrà problemi di fiducia ed eviterà di utilizzare alcune applicazioni.

Creazione di un backend

Ora che sappiamo che una dApp si basa sulla blockchain, creiamone una con Python localmente. Questo è un approccio più sicuro per imparare e testare le cose, poiché non vogliamo congestionare una rete reale con codice non necessario. Inoltre, questa dimostrazione è più propensa a mostrarti i principi di come funzionano le cose: le dApp del mondo reale sono molto più complesse.

Poiché tutto accadrà sul tuo computer, la blockchain si troverà fisicamente sul tuo disco rigido, rendendolo essenzialmente un nodo. A questo scopo, crea una cartella da qualche parte e chiamala “Progetto”. All’interno della cartella creiamo un altro, chiamiamolo “blockchain” e codifichiamo un primo blocco lì. Crea un file di testo e aprilo nel tuo editor di codice preferito. Useremo Atom.

Inizializzazione del blocco genesi

Nel primo blocco, specificheremo che un pagatore ha pagato un beneficiario mille monete. Come probabilmente ricorderai dal nostro articolo sul potere hash, la testa di ogni blocco viene sottoposta ad hashing e l’hash di ogni blocco è incluso in quello successivo per garantire che la rete non sia stata manomessa. Un blocco genesis non ha un blocco prima, quindi ci sarà un hash vuoto.

Blocco GenesisImmagine di U.Today

Successivamente, nella nostra cartella con la blockchain creiamo un file con lo script. Inizia con l’importazione della libreria JSON poiché utilizzeremo questa formattazione. Procedi con “if __name__ == "__principale__": ‘Per consentire la verifica se lo script verrà avviato o meno dalla console. Questo passaggio ti aiuterà durante l’importazione. Affinché la nostra blockchain locale funzioni, dovremmo scrivere una funzione che crei nuovi blocchi. Inoltre, dovrebbe esserci una funzione per verificare se la blockchain è stata modificata o meno.

Scrivere nuovi blocchi

Codifichiamo la funzione per creare i seguenti blocchi nella catena. Per fare ciò, dobbiamo specificare tutti i tipi di dati che abbiamo scritto nel blocco genesis. Quindi creiamo un’istruzione “with” con una funzione per creare un nuovo file per rendere il codice all’interno di nuovi blocchi più adatto alla lettura, specificando il rientro. Una volta terminato, possiamo eseguire lo script e ottenere un file con il nostro blocco di prova.

Nuovo blocco di prova & amp; ScriptImmagine di U.Today

La funzione di test funziona! Ora possiamo estenderlo per ricevere dati e scriverlo nei blocchi successivi. Per farlo, inseriremo gli argomenti del beneficiario, importo, pagatore e p_hash (hash del blocco precedente) nella funzione. Quindi, dobbiamo fare in modo che la funzione scriva i blocchi nella rispettiva cartella. A tale scopo, importa il sistema operativo per lavorare con il file system del computer. Successivamente, nella funzione definiamo la directory che abbiamo creato per i nostri blocchi tramite “os.curdir”. Quindi, specificare questa dichiarazione nell’istruzione che scrive un nuovo file.

Andando oltre, non possiamo lasciare il file di test etichettato così com’è, vogliamo che ogni nuovo blocco abbia un nome in modo consecutivo. Poiché il nostro blocco genesi è “0”, il blocco successivo dovrebbe essere 1 e così via. Questo è piuttosto semplice, la nostra funzione dovrebbe essere in grado di analizzare la directory principale della blockchain. Trova l’ultimo numero del blocco più recente, incrementa quel numero di uno e assegna un nome al blocco successivo. Per ottenere tutti i blocchi utilizzeremo “listdir” del sistema operativo e forniremo la nostra variabile di directory blockchain ad esso. Tieni presente che “listdir” non ordina i blocchi in base ai loro nomi, quindi il file più recente, in questo caso, potrebbe non essere quello di cui abbiamo bisogno. Quindi, dobbiamo utilizzare la comprensione dell’elenco per restituire numeri interi per tutti i nomi di file e ordinarli tramite la funzione “ordinata”. Infine, insegniamo alla nostra blockchain ad etichettare i blocchi restituendo il nome dell’ultimo blocco e incrementandolo di uno. Assicurati di riconvertire l’etichetta in stringa e di aggiungere il nome del blocco alla funzione “with”.

Funzione per ottenere blocchiImmagine di U.Today

Hashing

Ora ogni volta che esegui lo script, otterrai un nuovo blocco. Tuttavia, questa non è ancora una blockchain, in quanto i nodi dovrebbero anche essere in grado di controllare l’integrità e quindi la sicurezza dei dati. Ciascuno dei blocchi avrà un hash di uno precedente. Cominciamo con l’hashing dei dati all’interno dei blocchi. Per prima cosa, importeremo il modulo “hashlib”. Quindi, creeremo una funzione che leggerà il contenuto di un blocco, lo eseguirà attraverso l’algoritmo di hashing SHA-256 e restituirà un hash. Tieni presente che devi specificare la posizione della cartella “blockchain” qui, altrimenti la funzione non troverà i blocchi. Nella funzione che crea blocchi definisci una variabile per un hash precedente che lancerà la nostra funzione di hashing per il blocco precedente. Mentre lo testiamo, possiamo vedere che il nuovo blocco contiene l’hash del precedente. Puoi facilmente verificare l’hash copiando il contenuto del blocco numero 1 su un generatore SHA256 online e confrontare i risultati.

Funzione di hashingImmagine di U.Today

Blocca la verifica

Finora abbiamo la funzione di creazione del blocco e la funzione di hashing. È ora di introdurre un algoritmo di verifica per il nostro nodo. La funzione che creeremo sarà in grado di ottenere l’elenco di tutti i file nella blockchain, leggere gli hash del blocco precedente partendo dal secondo blocco, generare nuovamente un hash di ogni blocco precedente, confrontarli e restituire il risultato.

Inizieremo dichiarando una variabile che ottiene tutti i file nella directory “blockchain”, una variabile che restituisce l’elenco dei file e una che ordina i blocchi in ordine crescente. La prossima cosa che dovremmo fare è rendere la funzione in grado di iterare attraverso i blocchi e leggere gli hash dei blocchi precedenti. Questo può essere fatto tramite un ciclo “for” che carica tutti i dati da un blocco e restituisce solo ciò che corrisponde all ‘”hash”. Ora per creare l’hash ancora una volta per verificarlo rispetto a quello ricevuto da una funzione. All’interno del ciclo “for” lasceremo una variabile “true_h” che avvierà la funzione di hashing per il blocco precedente. L’ultimo passaggio consiste nel confrontare gli hash utilizzando un’istruzione “if / else”. I risultati verranno scritti in un array che abbiamo impostato per loro e tutto verrà mostrato nella console.

Blocca la verificaImmagine di U.Today

Dopo aver eliminato alcune ridondanze, abbiamo una blockchain locale codificata in Python.

Costruire un frontend

Anche se siamo riusciti a mettere tutte le funzioni necessarie in meno di 60 righe di codice, per un utente medio questo sembrerebbe ancora un mucchio di parole senza senso. Quindi, dobbiamo renderlo facile da capire e da usare con un’interfaccia front-end. In questo tutorial, utilizzeremo il framework Flask insieme a HTML, CSS e JavaScript.

Predisporre l’ambiente

Nella directory principale del progetto crea una cartella per l’ambiente virtuale che fungerà da backend. Se non l’hai ancora fatto, scarica Pitone dalla pagina ufficiale o tramite una riga di comando nel tuo sistema operativo (usiamo homebrew in OSX) e installalo. Andando oltre, installa Virtualenv & Pip tramite i comandi della riga di comando appropriati. Successivamente, avvia un ambiente virtuale dalla riga di comando all’interno della cartella “UI”, otterrai una nuova cartella se tutto è stato eseguito correttamente. È ora di attivarlo e installare il flask tramite Pip.

Creazione e attivazione di venvImmagine di U.Today

Mettiamo il nostro back-end accanto al frontend. Taglia la cartella “blockchain” e lo script e incollali nella cartella “app” nella directory principale. All’interno della cartella backend, dobbiamo creare il file di script principale.

Creazione della struttura

Nel nostro script principale, dovremmo prima importare Flask e inserire un collegamento al nome del file per consentire a Flask di comprendere i percorsi. Dovremmo anche inserire un’istruzione standard che controlli se lo script viene avviato dalla console ed esegue la nostra applicazione. Assicurati di aggiungere “debug” per consentire il ricaricamento di Flask ogni volta che modifichi qualcosa nel codice.

App vuotaImmagine di U.Today

Se avvii lo script a questo punto, puoi vedere che localhost: 5000 è attivo, ma visualizza l’errore 404. Questo è normale, poiché l’app è ancora vuota. Cominciamo a riempirlo creando una funzione che farà in modo che il nostro nodo elabori le query degli utenti. Al suo interno (inserendo “@” prima della funzione) inseriremo una funzione di indice. Questo creerà una struttura di URL locali e funzioni corrispondenti. La funzione “index” mostrerà agli utenti index.html tramite il modulo “render_template”.

App con funzione displayImmagine di U.Today

Ora possiamo procedere alla creazione della nostra struttura HTML. Ci saranno due file, uno per le informazioni generali e un altro per l’interfaccia utente della prima pagina. In base.html importeremo la libreria Bootstrap per creare layout tramite CSS. Creiamo una colonna centrata e inseriamo un blocco per i contenuti in un formato che possa essere interpretato dalla Jinja di Flask.

Prima pagina in htmlImmagine di U.Today

Composizione dell’interfaccia utente

La nostra applicazione sarà un semplice sistema di pagamento. Ci sarà un pagatore, un beneficiario e una quantità di denaro trasferita. Tutto verrà eseguito tramite blockchain, ma per un utente sembrerà una normale app. Quando trasferisci denaro su Internet, di solito compili un modulo e lo invii. Bootstrap ha varie forme per aiutarci con alcuni preset. Puoi copiare quello da cui abbiamo scelto Qui e copia il codice nel tuo index.html. Ci saranno solo due campi nel modulo pre-scritto e una casella di controllo, rimuoveremo la casella di controllo e aggiungeremo un campo. Quindi modificheremo le etichette, gli ID, i tipi e i segnaposto corretti. Infine, attribuiremo la nostra funzione di indice al form. Quando un utente inserirà il proprio nome, importo e un agente contatore, tutte le informazioni devono essere salvate da qualche parte e quindi incluse in un blocco. A tal fine, modifichiamo i nostri campi di input aggiungendo “nome” e “valore”. Il valore utilizzerà il metodo “get” per estrarre tutto ciò che un utente inserisce nel campo “Payer”. Non dimenticare di specificare una stringa vuota nel caso in cui un utente non inserisca nulla.

ModuloImmagine di U.Today

Torniamo al nostro script principale. Lo script dovrebbe essere in grado di capire se la richiesta inviata da un utente è POST o meno. Per abilitarlo, importeremo il modulo di richiesta dal flask e specificheremo i metodi nella nostra app. All’interno dell’app, dichiareremo le variabili che richiederanno i rispettivi dati dal modulo.

App aggiornataImmagine di U.Today

Andando oltre, dovremo passare tutti i dati raccolti a un nuovo blocco. Ciò richiede di collegare lo script principale a quello che scrive i blocchi. Per farlo all’interno dell’istruzione “if” che controlla il tipo di richiesta inseriremo una funzione “write” con argomenti corrispondenti a ciò che abbiamo nei nostri blocchi.

Collegamento dell'interfaccia utente al backendImmagine di U.Today

Ora se torniamo al nostro browser e inviamo una transazione, otterremo un nuovo blocco nella nostra cartella blockchain che conterrà le informazioni che abbiamo comunicato. Tuttavia, puoi vedere che i campi non sono stati aggiornati. A tal fine, dobbiamo reindirizzare un utente a una nuova istanza di index.html. Non dimenticare di importare i moduli che utilizziamo da Flask. Voilà, tutto si aggiorna dopo l’invio.

ReindirizzamentoImmagine di U.Today

Il tocco finale alla nostra interfaccia utente sarà un pulsante che fa in modo che il nostro nodo controlli eventuali violazioni della sicurezza nella nostra blockchain. Per fare ciò, creeremo un altro instradamento per la verifica con una funzione al suo interno. Successivamente, torniamo al nostro base.html e specifica altri due contenitori per un pulsante e i risultati della verifica con i margini superiori definiti come 5. Metti un blocco all’interno di un contenitore e anche all’interno di index.html.

Blocca per verificaImmagine di U.Today

Per il passaggio successivo, sceglieremo un pulsante dalla libreria Bootstrap e lo inseriremo in base.html in un modulo. Nel modulo inserisci la nostra funzione “verifica” come azione e allegala alla funzione “verifica” nello script principale. Una volta terminato, torna allo script principale e inserisci la funzione di verifica dallo script per la creazione di blocchi nella funzione di controllo. Vai a base.html, qui vogliamo creare un ciclo “for” per ogni variabile nell’array “results”. Nel ciclo “for” creeremo un div che mostrerà i risultati della verifica.

Verifica per loopImmagine di U.Today

Testare la dApp

Così il gioco è fatto. Torna al tuo browser e aggiorna la pagina. D’ora in poi la nostra dApp può registrare le transazioni sulla blockchain e verificare se qualcuno dei blocchi è stato violato. Per assicurarti che tutto funzioni invia una transazione con i dati che preferisci e vai nella cartella blockchain. Dovresti avere un nuovo file di testo lì con il pagatore, l’importo e il beneficiario che hai specificato e l’hash del blocco precedente.

Interfaccia dAppImmagine di U.TodayNuovo bloccoImmagine di U.Today

Torna al browser, crea altri blocchi e avvia il processo di verifica. Vedrai che a questo punto tutti i blocchi sono autentici. È ora di hackerare il nostro nodo! Vai alla cartella blockchain e cambia uno dei blocchi che hai creato prima di quello più recente. Ora torna di nuovo al browser e verifica ancora una volta la nostra catena. Come puoi vedere, il nostro nodo segnala che un blocco è danneggiato e non dobbiamo fidarci dei dati di questa blockchain.

Blocchi falsiImmagine di U.Today

Sommario

Per riassumere, oggi vi abbiamo mostrato una semplice applicazione decentralizzata su una blockchain gestita localmente. La creazione di applicazioni in modo decentralizzato ha le sue caratteristiche, ma è anche simile alla creazione di applicazioni regolari. Dopotutto, le applicazioni sono pensate per l’utente finale, quindi in superficie, probabilmente non si troverebbe molta differenza.

Se stai cercando di codificare le dApp, devi conoscere i principi della tecnologia blockchain e capire come scrivere sia per il frontend che per il backend. Con un livello di conoscenza così avanzato richiesto, faresti meglio a scegliere un linguaggio di programmazione facile e veloce come Python. Con Python, sarai in grado sia di creare un codice compatto che di eseguire un server locale senza problemi. Quest’ultimo è molto importante, poiché vuoi fare tutti i controlli di sicurezza necessari prima della pubblicazione perché la blockchain è immutabile.

Ci auguriamo che questo tutorial ti abbia aiutato molto a comprendere le dApp. Godere!