In questo articolo, ti mostrerò come realizzare un NFT senza competenze di ingegneria del software. Quindi impareremo come creare NFT personalizzabili illimitati con Brownie , Python e Chainlink . E vedremo come rendere e vendere la nostra creazione sul mercato NFT di OpenSea .

Se stai cercando un tutorial che utilizzi Truffle, JavaScript e divertenti personaggi medievali, dai un'occhiata a come costruire, distribuire e vendere il tuo NFT qui .

Cos'è un NFT?

Gli NFT (Non-Fungible Tokens) possono essere riassunti in una parola: "unico". Si tratta di contratti intelligenti distribuiti su una blockchain che rappresentano qualcosa di unico.

ERC20 vs ERC721

Gli NFT sono uno standard di token blockchain simile a ERC20 , come AAVE, SNX e LINK (tecnicamente un ERC677). Gli ERC20 sono token "fungibili", che significa "sostituibili" o "intercambiabili".

Ad esempio, la tua banconota da un dollaro varrà 1 $ indipendentemente dalla banconota da un dollaro che usi. Il numero di serie sulla banconota da un dollaro potrebbe essere diverso, ma le banconote sono intercambiabili e varranno sempre 1 $, qualunque cosa accada.

Gli NFT, d'altra parte, sono "non fungibili" e seguono il proprio standard di token, l'ERC721. Ad esempio, la Gioconda è "non fungibile". Anche se qualcuno può farne una copia, ci sarà sempre solo una Monna Lisa. Se la Gioconda fosse creata su una blockchain, sarebbe una NFT.

A cosa servono gli NFT?

Gli NFT forniscono valore a creatori, artisti, progettisti di giochi e altro avendo una cronologia permanente di distribuzione archiviata sulla chain.

Saprai sempre chi ha creato la NFT, chi possedeva la NFT, da dove proveniva e altro ancora, dando loro molto valore rispetto all'arte tradizionale. Nell'arte tradizionale, può essere difficile capire cosa sia un "falso", mentre sulla chain la storia è facilmente tracciabile.

E poiché i contratti intelligenti e gli NFT sono programmabili al 100%, gli NFT possono anche avere royalties integrate e qualsiasi altra funzionalità aggiunta. Ricompensare gli artisti è sempre stato un problema, poiché spesso il lavoro di un artista viene distribuito senza alcuna attribuzione.

Sempre più artisti e ingegneri stanno saltando su questo enorme valore aggiunto, perché è finalmente un ottimo modo per gli artisti di essere ricompensati per il loro lavoro. Oltre a questo, gli NFT sono un modo divertente per mostrare la tua creatività e diventare un collezionista in un mondo digitale.

Il valore degli NFT

Gli NFT hanno fatto molta strada e continuiamo a vedere vendite di NFT da record, come "Everydays: The First 5.000 Days" venduto per $ 69,3 milioni.

Quindi c'è molto valore qui, ed è anche un modo divertente, dinamico e coinvolgente di creare arte nel mondo digitale oltre che di a imparare la creazione di contratti intelligenti. Quindi ora ti insegnerò tutto ciò che devi sapere sulla creazione di NFT.

Come fare un NFT

Cosa non tratteremo

Ora, il modo più semplice per creare un NFT è semplicemente andare su una piattaforma come Opensea , Rarible o Mintible e seguire la loro guida passo passo per l'implementazione sulla loro piattaforma.

Puoi prendere questa strada al 100%, tuttavia potresti rimanere legato alla piattaforma e bloccato nelle sue funzionalità. Non puoi ottenere la personalizzazione illimitata o utilizzare davvero nessuno dei vantaggi offerti dagli NFT. Ma se sei un ingegnere del software alle prime armi, o non molto tecnico, questa è la strada che fa per te.

Invece se stai cercando di diventare un ingegnere del software più forte, imparare un po' di solidity e ottenere le capacità di creare qualcosa con creatività illimitata, continua a leggere!

Se sei nuovo nell'usare solidity, non ti preoccupare, parleremo delle basi anche in questo caso.

Come creare un NFT con personalizzazione illimitata

Ti farò fare un salto di qualità con questo Brownie Mix NFT . Questo è un repository funzionante con molto codice boilerplate.

Prerequisiti

Per iniziare abbiamo bisogno di alcune cose installate:

• Python
• Nodejs e npm
• Metamask

Se non hai familiarità con Metamask, puoi seguire questo tutorial per configurarlo.

Rinkeby Testnet ETH e LINK

Lavoreremo anche sul testnet Rinkeby di Ethereum, quindi implementeremo i nostri contratti su una vera blockchain, gratuitamente!

I testnet sono ottimi modi per testare come si comportano i nostri contratti intelligenti nel mondo reale. Abbiamo bisogno di Rinkeby ETH e Rinkeby LINK, che possiamo ottenere gratuitamente dai link agli ultimi faucet dalla documentazione di Chainlink .

Dovremo anche aggiungere il token LINK rinkeby al nostro metamask, cosa che possiamo fare seguendo la documentazione di acquisizione LINK .

Se sei ancora confuso, puoi seguire questo video , assicurati di usare Rinkeby invece di Ropsten.

Quando lavoriamo con una piattaforma di smart contract come Ethereum, dobbiamo pagare un po' di ETH e quando riceviamo dati da off-chain, dobbiamo pagare un po' di LINK. Questo è il motivo per cui abbiamo bisogno di testnet LINK ed ETH.

Fantastico, iniziamo. Questa è l'NFT che implementeremo su OpenSea.

Avvio rapido

git clone https://github.com/PatrickAlphaC/nft-mix
cd nft-mix

Stupendo! Ora dobbiamo installare ganache-cli e eth-brownie.

pip install eth-brownie
npm install -g ganache-cli

Ora possiamo impostare le nostre variabili d'ambiente . Se non hai familiarità con le variabili di ambiente, puoi semplicemente aggiungerle al tuo file .env e quindi eseguire:

source .env

Un esempio di file .env dovrebbe essere nel repository che hai appena clonato con le variabili di ambiente commentate. Decommentale per usarle!

Avrai bisogno di un WEB3_INFURA_PROJECT_ID e un PRIVATE_KEY. WEB3_INFURA_PROJECT_ID puoi trovarlo registrando gratuitamente un account Infura. Questo ci darà un modo per inviare transazioni alla blockchain.

Avremo anche bisogno di una chiave privata, che puoi ottenere dal tuo Metamask. Premi i 3 puntini e fai clic su Account Details ed Export Private Key. Per favore NON condividere questa chiave con nessuno se ci metti soldi veri!

export PRIVATE_KEY=YOUR_KEY_HERE
export WEB3_INFURA_PROJECT_ID=YOUR_PROJECT_ID_HERE

Ora possiamo distribuire il nostro contratto NFT e creare il nostro primo oggetto da collezione con i seguenti due comandi.

brownie run scripts/simple_collectible/deploy_simple.py --network rinkeby
brownie run scripts/simple_collectible/create_collectible.py --network rinkeby

Il primo script distribuisce il nostro contratto NFT sulla blockchain di Rinkeby e il secondo crea il nostro primo oggetto da collezione.

Hai appena implementato il tuo primo contratto intelligente!

Non fa molto, ma non preoccuparti: ti mostrerò come renderizzarlo su OpenSea nella parte avanzata di questo tutorial. Ma prima, diamo un'occhiata allo standard del token ERC721.

Lo standard del token ERC721

Diamo un'occhiata al contratto che abbiamo appena distribuito, nel file SimpleCollectible.sol.

// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract SimpleCollectible is ERC721 {
    uint256 public tokenCounter;
    constructor () public ERC721 ("Dogie", "DOG"){
        tokenCounter = 0;
    }

    function createCollectible(string memory tokenURI) public returns (uint256) {
        uint256 newItemId = tokenCounter;
        _safeMint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);
        tokenCounter = tokenCounter + 1;
        return newItemId;
    }

}

Stiamo usando il pacchetto OpenZepplin per il token ERC721. Questo pacchetto che abbiamo importato ci consente di utilizzare tutte le funzioni di un tipico token ERC721. Questo definisce tutte le funzionalità che avranno i nostri token, come transfer che sposta i token a nuovi utenti, safeMint che crea nuovi token e altro ancora.

Puoi trovare tutte le funzioni che vengono fornite al nostro contratto controllando il contratto token OpenZepplin ERC721 . Il nostro contratto eredita queste funzioni su questa riga:

contract SimpleCollectible is ERC721 {

È così che solidity fa eredità. Quando distribuiamo un contratto, il  constructor viene chiamato automaticamente e richiede alcuni parametri.

constructor () public ERC721 ("Dogie", "DOG"){
        tokenCounter = 0;
    }

Usiamo anche il costruttore di ERC721, nel nostro costruttore, e dobbiamo solo dargli un nome e un simbolo. Nel nostro caso, sono "Dogie" e "DOG". Ciò significa che ogni NFT che creiamo sarà di tipo Dogie/DOG.

Questo è come il caso delle carte di Pokemon in cui ognuna di essa è ancora un pokemon, o ogni giocatore di baseball su una carta collezionabile è ancora un giocatore di baseball. Ogni giocatore di baseball è unico, ma rimangono comunque tutti giocatori di baseball. Stiamo solo usando il tipo DOG.

Abbiamo tokenCounter in alto che conta quanti NFT abbiamo creato di questo tipo. Ogni nuovo token ottiene un tokenId basato sul tokenCounter corrente .

Possiamo effettivamente creare un NFT con la funzione createCollectible. Questo è ciò che chiamiamo nel nostro script create_collectible.py.

function createCollectible(string memory tokenURI) public returns (uint256) {
        uint256 newItemId = tokenCounter;
        _safeMint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);
        tokenCounter = tokenCounter + 1;
        return newItemId;
    }

La funzione _safeMint crea il nuovo NFT e lo assegna a chi ha chiamato createdCollectible, alias the msg.sender, con un newItemId derivato da tokenCounter. In questo modo possiamo tenere traccia di chi possiede cosa, controllando il proprietario del tokenId.

Noterai che chiamiamo anche _setTokenURI. Parliamo di questo.

Cosa sono i metadati NFT e TokenURI?

Quando vennero creati i contratti intelligenti e quindi creati gli NFT, le persone si sono subito rese conto che è davvero costoso distribuire molti dati sulla blockchain. Immagini di appena un KB possono facilmente costare oltre 1 milione di dollari per l'archiviazione .

Questo è chiaramente un problema per gli NFT, poiché avere un'arte creativa significa che devi archiviare queste informazioni da qualche parte. Volevano anche un modo leggero per archiviare gli attributi su un NFT, ed è qui che entrano in gioco tokenURI e metadati.

TokenURI

Il tokenURI su un NFT è un identificatore univoco di come "sembra" il token. Un URI potrebbe essere una chiamata API su HTTPS, un hash IPFS o qualsiasi altra cosa univoca.

Seguono uno standard di visualizzazione dei metadati simile a questo:

{
    "name": "name",
    "description": "description",
    "image": "https://ipfs.io/ipfs/QmTgqnhFBMkfT9s8PHKcdXBn1f5bG3Q5hmBaR4U6hoTvb1?filename=Chainlink_Elf.png",
    "attributes": [
        {
            "trait_type": "trait",
            "value": 100
        }
    ]
}

Questi mostrano l'aspetto di un NFT e i suoi attributi. La sezione image punta a un altro URI di come appare l'NFT. Ciò rende facile per le piattaforme NFT come Opensea, Rarible e Mintable eseguire il rendering di NFT sulle loro piattaforme, poiché sono tutti alla ricerca di questi metadati.

Metadati off-chain vs metadati on-chain

Ora potresti pensare "aspetta... se i metadati non sono on-chain, significa che il mio NFT potrebbe andare via a un certo punto"? E avresti ragione.

Avresti anche ragione nel pensare che avere i metadati off-chain significa che non puoi utilizzare quei metadati per far interagire i tuoi contratti intelligenti tra loro.

Questo è il motivo per cui vogliamo concentrarci sui metadati on-chain, in modo da poter programmare i nostri NFT per interagire tra loro.

Tuttavia, abbiamo ancora bisogno della parte image dei metadati off-chain, poiché non abbiamo un ottimo modo per archiviare immagini di grandi dimensioni on-chain. Ma non preoccuparti, possiamo farlo gratuitamente su una rete decentralizzata usando ancora IPFS .

Ecco un esempio di imageURI di IPFS che mostra l' Elfo Chainlink creato nel tutorial di Dungeons and Dragons.

Non abbiamo impostato un tokenURI per il semplice NFT perché volevamo mostrare solo un esempio di base.

Passiamo ora all'NFT avanzato, così possiamo vedere alcune delle straordinarie funzionalità che possiamo ottenere con i metadati on-chain, avere il rendering NFT su opensea e creare Dogie!

Se vuoi un video di ripasso sulla sezione che abbiamo appena esaminato, segui la distribuzione di un semplice video NFT.

NFT dinamici e avanzati

Gli NFT dinamici sono NFT che possono cambiare nel tempo o avere funzionalità a catena che possiamo utilizzare per farli interagire tra loro. Questi sono gli NFT che nel nostro caso, hanno la personalizzazione illimitata per creare interi giochi, mondi o opere d'arte interattive di qualche tipo. Passiamo alla sezione avanzata.

Avvio rapido avanzato

Assicurati di avere abbastanza testnet ETH e LINK nel tuo metamask, quindi esegui quanto segue:

brownie run scripts/advanced_collectible/deploy_advanced.py --network rinkeby
brownie run scripts/advanced_collectible/create_collectible.py --network rinkeby

Il nostro oggetto da collezione qui è una razza di cane casuale restituita dal Chainlink VRF. Chainlink VRF è un modo per ottenere numeri casuali dimostrabili e quindi una vera rarità nei nostri NFT. Quindi vogliamo creare i suoi metadati.

brownie run scripts/advanced_collectible/create_metadata.py --network rinkeby

Possiamo quindi caricare facoltativamente questi dati su IPFS in modo da poter avere un tokenURI. Ti mostrerò come farlo più tardi. Per ora, useremo solo il tokenURI di esempio di:

https://ipfs.io/ipfs/Qmd9MCGtdVz2miNumBHDbvj8bigSgTwnr4SbyH6DNnpWdt?filename=1-PUG.json

Se scarichi IPFS Companion nel tuo browser, puoi utilizzare quell'URL per vedere cosa restituisce l'URI. Assomiglierà  a qualcosa del genere:

{
    "name": "PUG",
    "description": "An adorable PUG pup!",
    "image": "https://ipfs.io/ipfs/QmSsYRx3LpDAb1GZQm7zZ1AuHZjfbPkD6J7s9r41xu1mf8?filename=pug.png",
    "attributes": [
        {
            "trait_type": "cuteness",
            "value": 100
        }
    ]
}

Quindi possiamo eseguire il nostro script  set_tokenuri.py:

brownie run scripts/advanced_collectible/set_tokenuri.py --network rinkeby

E otterremo un output come questo:

Running 'scripts/advanced_collectible/set_tokenuri.py::main'...
Working on rinkeby
Transaction sent: 0x8a83a446c306d6255952880c0ca35fa420248a84ba7484c3798d8bbad421f88e
  Gas price: 1.0 gwei   Gas limit: 44601   Nonce: 354
  AdvancedCollectible.setTokenURI confirmed - Block: 8331653   Gas used: 40547 (90.91%)

Awesome! You can view your NFT at https://testnets.opensea.io/assets/0x679c5f9adC630663a6e63Fa27153B215fe021b34/0
Please give up to 20 minutes, and hit the "refresh metadata" button

E possiamo premere il link fornito per vedere come appare su Opensea! Potrebbe essere necessario premere il pulsante refresh metadata e attendere qualche minuto.

La razza casuale

Parliamo di quello che abbiamo appena fatto. Ecco il nostro AdvancedCollectible.sol:

pragma solidity 0.6.6;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@chainlink/contracts/src/v0.6/VRFConsumerBase.sol";

contract AdvancedCollectible is ERC721, VRFConsumerBase {
    uint256 public tokenCounter;
    enum Breed{PUG, SHIBA_INU, BRENARD}
    // add other things
    mapping(bytes32 => address) public requestIdToSender;
    mapping(bytes32 => string) public requestIdToTokenURI;
    mapping(uint256 => Breed) public tokenIdToBreed;
    mapping(bytes32 => uint256) public requestIdToTokenId;
    event requestedCollectible(bytes32 indexed requestId); 


    bytes32 internal keyHash;
    uint256 internal fee;
    uint256 public randomResult;
    constructor(address _VRFCoordinator, address _LinkToken, bytes32 _keyhash)
    public 
    VRFConsumerBase(_VRFCoordinator, _LinkToken)
    ERC721("Dogie", "DOG")
    {
        tokenCounter = 0;
        keyHash = _keyhash;
        fee = 0.1 * 10 ** 18;
    }

    function createCollectible(string memory tokenURI, uint256 userProvidedSeed) 
        public returns (bytes32){
            bytes32 requestId = requestRandomness(keyHash, fee, userProvidedSeed);
            requestIdToSender[requestId] = msg.sender;
            requestIdToTokenURI[requestId] = tokenURI;
            emit requestedCollectible(requestId);
    }

    function fulfillRandomness(bytes32 requestId, uint256 randomNumber) internal override {
        address dogOwner = requestIdToSender[requestId];
        string memory tokenURI = requestIdToTokenURI[requestId];
        uint256 newItemId = tokenCounter;
        _safeMint(dogOwner, newItemId);
        _setTokenURI(newItemId, tokenURI);
        Breed breed = Breed(randomNumber % 3); 
        tokenIdToBreed[newItemId] = breed;
        requestIdToTokenId[requestId] = newItemId;
        tokenCounter = tokenCounter + 1;
    }

    function setTokenURI(uint256 tokenId, string memory _tokenURI) public {
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721: transfer caller is not owner nor approved"
        );
        _setTokenURI(tokenId, _tokenURI);
    }
}

Usiamo il Chainlink VRF per creare una razza casuale da un elenco di PUG, SHIBA_INU, BRENARD. Questa volta chiamando createCollectible, abbiamo effettivamente avviato una richiesta al nodo Chainlink VRF off-chain e siamo tornati con un numero casuale per creare l'NFT con una di quelle 3 razze.

L'uso della vera casualità nei tuoi NFT è un ottimo modo per creare una vera rarità e l'uso di un numero casuale di un oracolo Chainlink significa che il tuo numero è probabilmente casuale e non può essere influenzato dai minatori.

Puoi saperne di più su Chainlink VRF nella documentazione .

Il nodo Chainlink risponde chiamando la funzione fulfillRandomness e crea l'oggetto da collezione in base al numero casuale. Quindi dobbiamo ancora chiamare _setTokenURI per dare al nostro NFT l'aspetto di cui ha bisogno.

Qui non abbiamo fornito i nostri attributi NFT, ma gli attributi sono un ottimo modo per far combattere e interagire i nostri NFT. Puoi vedere un ottimo esempio di NFT con attributi in questo esempio di Dungeons and Dragons .

Metadati da IPFS

Stiamo usando IPFS per memorizzare due file:

1. L'immagine dell'NFT (l'immagine del carlino)
2. Il file tokenURI (il file JSON che include anche il collegamento dell'immagine)

Usiamo IPFS perché è una piattaforma decentralizzata gratuita. Possiamo aggiungere i nostri tokenURI e immagini a IPFS scaricando IPFS desktop e premendo il pulsante import.

Quindi, possiamo condividere l'URI premendo i 3 punti accanto al file che vogliamo condividere, premendo share link e copiando il collegamento fornito. Possiamo quindi aggiungere questo collegamento nel nostro file  set_tokenuri.py per modificare l'URI del token che vogliamo utilizzare.

Persistenza

Tuttavia, se il tokenURI è solo sul nostro nodo, significa che quando il nostro nodo è inattivo, nessun altro può visualizzarlo. Quindi vogliamo che altri pin siano nel nostro NFT. Possiamo utilizzare un servizio di pinning come Pinata per mantenere in vita i nostri dati anche quando il nostro nodo IPFS è inattivo.

Immagino che in futuro sempre più metadati verranno archiviati su IPFS e altre piattaforme di archiviazione decentralizzate. I server centralizzati possono non funzionare e significherebbe che l'arte di quegli NFT è persa per sempre. Assicurati di controllare dove si trova il tokenURI dell'NFT che usi!

Mi aspetto anche che più persone utilizzeranno piattaforme dStorage come Filecoin, poiché anche l'utilizzo di un servizio di pinning non è decentralizzato come dovrebbe essere.

Andando avanti

Se desideri una video guida sull'NFT avanzato, puoi guardare il video NFT avanzato .

Ora hai le capacità per creare NFT divertenti, personalizzabili e interattivi e renderli su un mercato.

Gli NFT sono modi divertenti e potenti per avere artisti accuratamente compensati per tutto il duro lavoro che fanno. Buona fortuna e ricordati di divertirti!

di Sean Han

Secondo Wikipedia, una blockchain è:

Un database distribuito utilizzato per mantenere un elenco di record in continua crescita, chiamati blocchi .

Sembra carino, ma come funziona?

Per illustrare una blockchain, utilizzeremo un'interfaccia a riga di comando open source chiamata Blockchain CLI .

Ho anche creato una versione basata su browser di questo qui .

Installazione della versione dell'interfaccia della riga di comando

Se non lo hai già fatto, installa Node.js .

Quindi esegui quanto segue nel tuo terminale:

# Clona questo repository
$ git clone https://github.com/seanseany/blockchain-cli

# Vai nel repository
$ cd blockchain-cli

# Installa le dipendenze
$ npm install

# Avvia l'app
$ npm start

Dovresti vedere ? Welcome to Blockchain CLI! e il prompt  blockchain → pronto a ricevere comandi.

Che aspetto ha un blocco?

Per vedere la tua blockchain attuale, inserisci blockchain o bc nel prompt dei comandi. Dovresti vedere un blocco come l'immagine qui sotto.

• Indice (blocco n.): quale blocco è? (Il blocco Genesis ha indice 0)
• Hash: il blocco è valido?
• Hash precedente: il blocco precedente è valido?
• Timestamp: quando è stato aggiunto il blocco?
• Dati: quali informazioni sono memorizzate nel blocco?
• Nonce: quante iterazioni abbiamo passato prima di trovare un blocco valido?

Blocco Genesis

Ogni blockchain inizierà con ? Genesis Block. Come vedrai più avanti, ogni blocco sulla blockchain dipende dal blocco precedente. Quindi, il blocco Genesis è necessario per estrarre il nostro primo blocco.

Cosa succede quando viene estratto un nuovo blocco?

Estraiamo il nostro primo blocco.  Digita mine freeCodeCamp♥︎ nel prompt.

La blockchain esamina l'ultimo blocco sulla blockchain per l'indice e l'hash precedente. In questo caso il blocco Genesis è l'ultimo blocco.

• Indice: o+1 = 1
• Hash precedente: 0000018035a828da0…
• Timestamp: quando viene aggiunto il blocco
• Dati: freeCodeCamp❤
• Hash: ??
• Nonce: ??

Come viene calcolato l'hash?

Un valore hash è un valore numerico di lunghezza fissa che identifica i dati in modo univoco.

L'hash viene calcolato prendendo l'indice, l'hash del blocco precedente, il timestamp, i dati del blocco e nonce come input.

CryptoJS.SHA256(index + previousHash + timestamp + data + nonce)

L'algoritmo SHA256 calcolerà un hash univoco, dati questi input. Gli stessi input restituiranno sempre lo stesso hash.

Hai notato i quattro 0 iniziali nell'hash del blocco?

I quattro 0 iniziali sono un requisito minimo per un hash valido. Il numero di 0 iniziali richiesti è chiamato difficoltà .

function isValidHashDifficulty(hash, difficulty) {
  for (var i = 0, b = hash.length; i < b; i ++) {
      if (hash[i] !== '0') {
          break;
      }
  }
  return i >= difficulty;
}

Questo è anche noto come il sistema Proof-of-Work .

Cos'è un nonce?

Un nonce è un numero utilizzato per trovare un hash valido.

let nonce = 0;
let hash;
let input;

while(!isValidHashDifficulty(hash)) {     
  nonce = nonce + 1;
  input = index + previousHash + timestamp + data + nonce;
  hash = CryptoJS.SHA256(input)
}

Il nonce itera finché l'hash non è valido. Nel nostro caso, un hash valido ha almeno quattro 0 iniziali. Il processo per trovare un nonce che corrisponda a un hash valido è il mining .

All'aumentare della difficoltà, il numero di possibili hash validi diminuisce. Con meno hash validi possibili, ci vuole più potenza di elaborazione per trovare un hash valido.

Perché è importante?

È importante perché mantiene immutabile la blockchain.

Se abbiamo la seguente blockchain A → B → C, e qualcuno vuole cambiare i dati sul Blocco A. Ecco cosa succede:

1. Modifiche ai dati sul blocco A.
2. L'hash del blocco A cambia perché i dati vengono utilizzati per calcolare l'hash.
3. Il blocco A diventa non valido perché il suo hash non ha più quattro 0 iniziali.
4. L'hash del blocco B cambia perché l'hash del blocco A è stato utilizzato per calcolare l'hash del blocco B.
5. Il blocco B diventa non valido perché il suo hash non ha più quattro 0 iniziali.
6. L'hash del blocco C cambia perché l'hash del blocco B è stato utilizzato per calcolare l'hash del blocco C.
7. Il blocco C diventa non valido perché il suo hash non ha più quattro 0 iniziali.

L'unico modo per mutare un blocco sarebbe minare di nuovo il blocco e tutti i blocchi successivi. Poiché vengono sempre aggiunti nuovi blocchi, è quasi impossibile mutare la blockchain.

Spero che questo tutorial ti sia stato utile!

Se desideri provare una versione web della demo, vai su http://blockchaindemo.io

Se sei appassionato di tecnologia, ci sono buone possibilità che tu abbia sentito i termini Bitcoin, Crypto, Ethereum o anche "registri distribuiti e decentralizzati".

Probabilmente hai sentito parlare di criptovaluta e algoritmi di crittografia, della fine degli "intermediari" e così via.

Comunemente si è portati a pensare che le criptovalute (es: Bitcoin, Ripple, Ethereum, Litecoin, ecc.) e la Blockchain siano la stessa cosa. Ma non così.

Le criptovalute sono un'applicazione intelligente di una tecnologia molto più intelligente: la Blockchain .

In questo post tratterò alcuni dei concetti di base della Blockchain in modo da capire di cosa si tratta, come deve essere concettualizzata e cosa si può costruire su di essa.

Ma come per tutte le cose, ha più senso se capisci perché sono state inventate, prima di entrare in quello che fanno. In questo modo ti sarà più facile capire per quale problema da risolvere è stata progettata la blockchain.

Perché usare blockchain?

Ottima domanda. Sono così felice che tu l'abbia chiesto. Sediamoci e facciamo un piccolo esperimento mentale.

Cosa succede se tu e il tuo migliore amico conducete indipendentemente e separatamente la stessa campagna di petizioni? Diciamo che è per la causa "Liberate i criceti".

Diciamo che la conduci rispettando una sequenza identica al tuo amico e nello stesso sobborgo, ma tiri fuori un diverso numero di adesioni alla petizione. Quale versione della petizione firmata è la “fonte di verità”?

Dovresti risalire lungo i due elenchi di firme, una firma alla volta, per individuare l'ultima discrepanza. E poi dovresti lavorare più indietro per identificare il primo risultato che diverge tra le due liste. Prima di tale punto di origine della divergenza, tutte le altre firme nei due elenchi dovrebbero corrispondere.

Quindi una cosa è sicura. Prima di questo punto di divergenza, entrambe le liste sono in accordo, quindi quelle firme rappresentano il numero minimo di persone che hanno firmato per sostenere la liberazione dei criceti.

Sebbene possa funzionare bene per criceti e piccoli sondaggi suburbani, non funziona così bene nel mondo digitale. Oppure votazioni, operazioni bancarie, transazioni finanziarie, trasferimento di proprietà fondiarie, adempimento di obblighi contrattuali, ecc. Sono necessarie "terze parti di fiducia" indipendenti per verificare una catena di eventi e rassicurarti solennemente che la "catena di custodia" non è stata interrotta.

Una "catena di custodia" a volte può anche essere chiamata "provenienza" - entrambe significano la stessa cosa: la sequenza di eventi storici relativi ai dati in questione.

Ecco perché ci sono governi che hanno l'ultima parola sulla tua identità, e i voti devono essere contati fisicamente e ricontati da centinaia di volontari, e gli impiegati in uffici squallidi tengono registri e certificati per confermare se possiedi o meno la tua fattoria o la staccionata bianca del bungalow.

Ecco perché hai bisogno di intermediari finanziari per assicurarti che quando acquisti il tuo pupazzo da collezione di Darth Vader, utilizzando una carta di credito, il denaro (valore) venga "rimosso" dal tuo account e "immesso" sul conto del venditore.

Questo è tecnicamente chiamato il "problema della doppia spesa": come ci si assicura di non spendere gli stessi soldi due volte? Senza qualcuno che lo faccia, potresti spendere i soldi e allo stesso tempo continuare a possedere quei soldi stessi.

Quindi è davvero un grosso problema: la vita moderna richiede che ci affidiamo, ci fidiamo e paghiamo intermediari di terze parti "fidati" per garantire che il valore (il denaro) effettivamente "passi di mano" digitalmente. Ecco perché esistono Visa e MasterCard e perché PayPal e altri si collegano ai tuoi conti bancari.

Al centro del perché della Blockchain c'è questo problema: come fai a sapere che una sequenza di eventi non è stata manomessa per alterare lo stato attuale?

È qui che si inserisce la Blockchain. Chiaro finora?

Come funziona Blockchain

Allo scopo di comunicare un concetto con semplicità, posso prendermi delle libertà con alcuni degli aspetti tecnici e nascosti di questa tecnologia. Il mio obiettivo è farti capire di cosa si tratta e avere un modello mentale di come funziona. Per questo, potrei aver bisogno di essere un po' sciolto con la precisione al fine di migliorare le probabilità di comprensione, specialmente per i non madrelingua.

Per la precisione, è essenziale ricordare che la Blockchain è una tecnologia, un codice software matematicamente complesso. E Bitcoin (o Ethereum o qualsiasi altra criptovaluta offerta) sono solo applicazioni di questa tecnologia.

Quindi i principi chiave sono:

• Le blockchain vengono "estratte" (prodotte attraverso il dispendio di sforzi, come nell'estrazione dell'oro) da computer potenti e affamati di risorse – chiamati nodi, che si trovano sulla stessa rete.
• Catene di registrazioni di transazioni crittografate digitalmente e con timestamp sono raggruppate in "blocchi", che vengono mantenuti su un "registro" da ciascun nodo. Quando le transazioni vengono aggiunte a un blocco, i blocchi vengono collegati tra loro in modo lineare e cronologico come "catene". Quindi l'intero record/registro viene sincronizzato attraverso la rete di nodi in modo tale che tutte le "catene" di blocchi sui nodi dovrebbero raccontare la stessa identica cosa circa l'iter di una determinata transazione. Quindi otteniamo "blocco + catena = blockchain". È una lunga e complicata lista concatenata.
• Ogni blocco in una catena ha il proprio ID, un hash crittografico unico e specifico per ogni blocco. Quell'hash viene anche memorizzato nel blocco successivo della catena, causando un collegamento. Un blocco può memorizzare migliaia di transazioni e la più piccola modifica ai dati di quel blocco risulterebbe in un nuovo hash. Quindi, se un hash cambia ma il blocco successivo ha un hash diverso, sappiamo che alcuni dati nel blocco precedente sono stati manomessi.
• Man mano che centinaia diventano migliaia di nodi (e ne vengono aggiunti altri continuamente), ogni nodo deve "concordare" sulla cronologia dei blocchi/registro – questo è chiamato "consenso critico". Uno dei modi in cui si ottiene il consenso è attraverso l'hash crittografico di cui abbiamo parlato prima.
• In caso di discrepanze nel registro (ad esempio l'hash di un blocco non corrisponde al riferimento del blocco successivo all'hash del blocco precedente), il registro con la catena più lunga di transazioni valide incorporate sarà quello “corretto” – la fonte di verità. Eventuali nodi che lavorano su altri nodi (versioni più corte) della catena passano a quella più lunga. Ciò mantiene il consenso critico (questo concetto è estremamente semplificato, ma per ora sufficiente).
• Qualsiasi intercettazione o modifica malevola di un registro (di nuovo, ad esempio, quando l'hash di un blocco non corrisponde) creerebbe immediatamente una discrepanza con tutte le altre versioni. Avrebbe anche una "storia" di blocco più breve a confermarlo, il che rende quella versione manomessa un elemento sospetto nella rete blockchain dove la lunghezza conta (ehm).
• Replicare quella discrepanza su tutte le versioni registro - l'intera rete blockchain - è un compito così enorme che è poco pratico dal punto di vista computazionale e accadrebbe solo se i malintenzionati avessero improvvisamente il controllo sulla maggior parte dei nodi che estraggono blockchain e li cambiassero tutti piuttosto rapidamente. Questo tipo di attacco coordinato alla maggior parte dei nodi della rete è spesso chiamato attacco del 51% .

È interessante notare che Satoshi Nakamoto afferma nel white paper originale di Bitcoin ,

“ In quanto tale, la verifica è affidabile fintanto che i nodi onesti controllano la rete, ma è più vulnerabile se la rete è sopraffatta da un utente malintenzionato. "

Tuttavia, altrove lui/lei/l'organizzazione (non sappiamo chi sia "Satoshi") sottolinea con calma che modificare le passate transazioni nei blocchi, sull'intera rete di nodi, richiederebbe all'attaccante di rifare la catena di custodia in quei blocchi, e tutti i blocchi aggiunti dopo. Quindi dovrebbe correre come un pazzo per raggiungere e superare il lavoro dei nodi che non sono sotto il suo controllo (in modo che possa riscrivere il registro, per così dire).

E per questo motivo, la "probabilità che un attaccante lento recuperi il ritardo, diminuisce esponenzialmente man mano che vengono aggiunti blocchi successivi".

L'assoluta complessità programmatica, il ritmo e il volume delle attività nodali rendono difficile per i falsari/attaccanti recuperare il ritardo, per non parlare di superare i nuovi blocchi costantemente estratti.

Questo ha senso. È come la bugia che dici a un membro della famiglia sul motivo per cui non hai potuto partecipare al saggio di flauto dei loro figli. E poi devi inseguire pazzamente tutti gli altri membri della famiglia e assicurarti di aver detto loro la stessa bugia in modo che quando la persona interessata a cui hai mentito tira fuori l'argomento, tutti siano consapevoli di questa bugia e tengano il tuo gioco. Sembra estenuante.

Per concludere, la caratteristica distintiva di una blockchain è che è un registro distribuito su molti, molti nodi ed è estremamente intensivo dal punto di vista computazionale (costoso) aggiungere nodi a quella rete.

Pertanto, ogni registro deve essere "consapevole" di tutte le transazioni e deve avere una versione concordata (che avrà la "catena di custodia" più lunga dietro di sé) attraverso l'intera rete a cui verrà aggiunta la transazione successiva.

Come dichiara Satoshi Nakamoto nel white paper originale di Bitcoin, "L'unico modo per confermare l'assenza di una transazione è essere a conoscenza di tutte le transazioni."

È importante sottolineare che la blockchain "dis-intermediata" è fidata, quindi non dobbiamo pagare commissioni di transazione a "terze parti fidate" per essere affidabili e mantenerci onesti noi e le controparti con cui trattiamo . La blockchain garantisce in modo programmatico la verità (provenienza) della cronologia delle transazioni in essa contenute.

Allora perché dovremmo preoccuparci?

Ebbene, eliminando la necessità di “intermediari di fiducia” qualsiasi intermediario che fa pagare un compenso modesto per averci dato il dono della certezza ha bisogno di trovare un nuovo lavoro. E questo ha un impatto sulle banche che tradizionalmente offrono tali servizi assicurativi.

Significa anche che possiamo programmare "contratti intelligenti" tra il promittente e il promesso che si accorgono automaticamente (digitalmente) se quella promessa è stata mantenuta o meno.

Ciò ha consentito a un'artista davvero esperta di tecnologia come Imogen Heap di vendere la sua musica direttamente al suo pubblico di ascolto e di riscuotere le sue quote direttamente da loro piuttosto che perdere la maggior parte dei guadagni per etichette discografiche, manager e altri "intermediari di fiducia".

Probabilmente cambierà il modo in cui la proprietà intellettuale sarà protetta, accessibile, condivisa, distribuita e sviluppata su Internet.

Potrebbe anche significare che la flotta di conducenti di Uber effettua transazioni direttamente con le persone che desiderano un passaggio piuttosto che affidarsi a Uber per coordinare e controllare il flusso di informazioni e denaro.

Potrebbe significare che potrei inviarti direttamente piccole somme di denaro praticamente senza commissioni (microtransazioni). Potrebbe significare che i milioni di persone senza banca nel mondo che hanno uno smartphone possono iniziare a effettuare transazioni ben oltre i loro tradizionali confini del mondo fisico.

In modo sorprendente, i governi stanno guardando oltre la semplice criptovaluta pensando al modo con cui implementare questa tecnologia , ad esempio per registrare la proprietà terriera .

In effetti, potremmo creare un mondo di vere transazioni digitali peer-to-peer per il trasferimento di valore che sia distribuito, orizzontale, rimuova la necessità di fare affidamento sulla fiducia e soprattutto richieda una straordinaria potenza di calcolo per manometterlo. Queste transazioni potrebbero essere tra persone, macchine e dispositivi.

Potrebbe quindi offrire un nuovo paradigma di sicurezza per la protezione dei dati raccolti e trasferiti attraverso "l'internet delle cose".

Personalmente credo che la complessità del mondo moderno sia oscurata dietro i touchscreen intuitivi. La tecnologia blockchain sarà rapidamente integrata nel nostro universo tecnologico senza che noi ne saremo pienamente consapevoli, proprio come utilizziamo il DNA ricombinante del lievito per la produzione di insulina sintetica dagli anni '70.

I cambiamenti e i risparmi sui costi saranno ampiamente definiti cambiamenti tecnologici, come quella "cosa interweby" o qualche altra frase vaga e all-inclusive.

Un problema: funzionerà finché possiamo confidare che un "sistema senza fiducia" codificato e progettato dagli esseri umani (di chi ci fidiamo?) promuoverà la causa di processi senza-fiducia in un mondo diffidente e inaffidabile . Potrebbe essere necessario leggere questa frase più volte.

Ricapitolando

OK – ora dovresti essere ragionevolmente consapevole delle basi della blockchain. Ma se sei interessato c'è molto altro da imparare.

Puoi discutere se la blockchain sia utile o troppo pubblicizzata, rivoluzionaria o noiosa. Ma è difficile ignorare che è piuttosto interessante come concetto.

Ecco un video davvero fantastico di Anders Brownworth che spiega il tutto con un modello blockchain. Consiglio vivamente di guardarlo.

E come esercizio di apprendimento, puoi costruire la tua blockchain direttamente nel tuo browser o nella tua riga di comando. Ecco un breve tutorial su come costruire la tua blockchain.

Se hai commenti su questo articolo o pensi che avrei potuto spiegare meglio alcune parti di questo, twittami su @ZubinPratap

Se vuoi saperne di più sul mio viaggio nel codice, dai un'occhiata all'episodio 53 del podcast freeCodeCamp , dove Quincy (fondatore di freeCodeCamp) e io condividiamo le nostre esperienze come cambi di carriera che potrebbero aiutarti nel tuo viaggio. Puoi anche accedere al podcast su iTunes , Stitcher e Spotify.

Terrò anche alcuni AMA e webinar nei prossimi mesi. Se questo ti interessa, per favore fatemelo sapere andando qui . E, naturalmente, puoi anche twittarmi su @ZubinPratap .

In questo articolo imparerai come creare dApp full stack con React, Ethers.js, Solidity e Hardhat.

Puoi trovare il codice per questo progetto qui . Il video corso per questo tutorial è qui.

Di recente mi sono unito a Edge & Node come Developer Relations Engineer e ho approfondito lo sviluppo di contratti intelligenti con Ethereum. Ho scelto quello che penso sia lo stack migliore per la creazione di dApp full stack con Solidity:

• Client Framework – React
• Ambiente di sviluppo Ethereum – Hardhat
• Libreria Web client di Ethereum – Ethers.js
• Livello API: Il protocollo Graph

Però mi sono imbattuto in un problema mentre cercavo di capire tutto questo. Sebbene sia disponibile individualmente una documentazione abbastanza buona per ciascuno di questi strumenti, non c'è molto che ti aiuti a metterli tutti insieme e capire come funzionano tra loro.

Ci sono alcuni standard davvero buoni là fuori come scaffold-eth (che include anche Ethers, Hardhat e The Graph), ma potrebbero essere troppo da comprendere per le persone che hanno appena iniziato.

Volevo una guida end-to-end che mi mostrasse come creare app Ethereum full stack utilizzando le risorse, le librerie e gli strumenti più aggiornati.

Ecco cosa mi interessava:

1. Come creare, distribuire e testare smart contract Ethereum su local, test e mainnet
2. Come spostarsi tra ambienti/reti locali, di test e di produzione
3. Come connettersi e interagire con i contratti utilizzando vari ambienti da un front-end come React, Vue, Svelte o Angular

Dopo aver passato un po' di tempo a capire tutto questo, sono finalmente riuscito a usare lo stack di cui mi sentivo davvero a mio agio. Quindi ho pensato che sarebbe stato bello scrivere come costruire e testare un'app Ethereum full stack usando questo stack.

Spero che questa guida sia utile non solo per altre persone là fuori che potrebbero essere interessate a questo stack, ma anche per me stesso come riferimento futuro. Questo è quel riferimento.

La tecnologia che useremo

Esaminiamo i pezzi principali che utilizzeremo e come si inseriscono nell'insieme.

1. Ambiente di sviluppo di Ethereum

Quando crei contratti intelligenti, avrai bisogno di un modo per distribuire i tuoi contratti, eseguire test ed eseguire il debug del codice Solidity senza dover gestire ambienti live.

Avrai anche bisogno di un modo per compilare il tuo codice Solidity in codice che può essere eseguito in un'applicazione lato client, nel nostro caso, un'app React. Impareremo di più su come questo funziona un più avanti.

Hardhat è un ambiente di sviluppo Ethereum e un framework progettato per lo sviluppo full stack, ed è il framework che userò per questo tutorial.

Altri strumenti simili nell'ecosistema sono Ganache e Truffle .

2. Libreria Web client di Ethereum

Nella nostra app React, avremo bisogno di un modo per interagire con gli smart contract che sono stati implementati. Avremo bisogno di un modo per leggere i dati e inviare nuove transazioni.

ethers.js mira ad essere una libreria completa e compatta per interagire con Ethereum Blockchain e il suo ecosistema da applicazioni JavaScript lato client come React, Vue, Angular o Svelte. È la libreria che useremo.

Un'altra opzione popolare nell'ecosistema è web3.js

3. Metamask

Metamask ti aiuta a gestire la gestione dell'account e a connettere l'utente corrente alla blockchain. MetaMask consente agli utenti di gestire i propri account e chiavi in ​​diversi modi isolandoli dal contesto del sito.

Una volta che un utente ha connesso il proprio portafoglio MetaMask, tu come sviluppatore puoi interagire con l'API Ethereum disponibile a livello globale (window.ethereum) che identifica gli utenti di browser compatibili con web3 (come gli utenti MetaMask). Ogni volta che richiedi una firma di transazione, MetaMask la richiederà all'utente in modo comprensibile.

4. React

React è una libreria JavaScript front-end per la creazione di applicazioni Web, interfacce utente e componenti dell'interfaccia utente. È gestito da Facebook e da molti sviluppatori e aziende individuali.

React e il suo ampio ecosistema di metaframework come Next.js, Gatsby, Redwood, Blitz.js e altri abilitano tutti i tipi di target di distribuzione inclusi SPA tradizionali, generatori di siti statici, rendering lato server e una combinazione di tutti e tre.

React continua apparentemente a dominare lo spazio front-end e penso che continuerà a farlo nel prossimo futuro e forse anche oltre.

5. The Graph

Per la maggior parte delle app basate su blockchain come Ethereum, è difficile e dispendioso in termini di tempo leggere i dati direttamente dalla chain. Quindi in passato vedevi persone e aziende costruire il proprio server di indicizzazione centralizzato e servire le richieste API da questi server. Ciò richiede molte risorse ingegneristiche e hardware e interrompe le proprietà di sicurezza richieste per la decentralizzazione.

The Graph è un protocollo di indicizzazione per interrogare i dati blockchain, che ti consente di creare applicazioni completamente decentralizzate. Risolve questo problema esponendo un ricco livello di query GraphQL che le app possono utilizzare.

In questa guida non creeremo un sottografo per la nostra app, ma lo faremo in un tutorial futuro.

Cosa costruiremo

In questo tutorial creeremo, implementeremo e ci collegheremo a un paio di contratti intelligenti di base:

1. Un contratto per la creazione e l'aggiornamento di un messaggio sulla blockchain di Ethereum
2. Un contratto per il conio di token, che consente al proprietario del contratto di inviare token ad altri e di leggere i saldi dei token e consente ai proprietari dei nuovi token di inviarli anche ad altri.

Realizzeremo anche un front-end React che consentirà a un utente di:

1. Leggere il saluto dal contratto distribuito sulla blockchain
2. Aggiornare il saluto
3. Inviare i token appena coniati dal loro indirizzo a un altro indirizzo
4. Una volta che qualcuno ha ricevuto i token, consentire loro di inviare i propri token anche a qualcun altro
5. Leggere il saldo del token dal contratto distribuito sulla blockchain

Prerequisiti

1. Node.js installato sul tuo computer locale
2. Estensione MetaMask Chrome installata nel tuo browser

Non è necessario possedere alcun Ethereum per questa guida poiché utilizzeremo Ether falso/test su una rete di test per l'intero tutorial.

Come iniziare con create-react-app

Per iniziare, creeremo una nuova applicazione React:

npx create-react-app react-dapp

Quindi, passa alla nuova directory e installa ethers.js e  hardhat utilizzando NPM o Yarn :

npm install ethers hardhat @nomiclabs/hardhat-waffle ethereum-waffle chai @nomiclabs/hardhat-ethers

Come installare e configurare un ambiente di sviluppo Ethereum

Quindi, inizializza un nuovo ambiente di sviluppo Ethereum con Hardhat:

npx hardhat

? What do you want to do? Create a sample project
? Hardhat project root: <Choose default path>

Ora dovresti vedere i seguenti file e cartelle creati per te nella tua directory principale:

• hardhat.config.js – L'intera configurazione di Hardhat (ovvero la configurazione, i plug-in e le attività personalizzate) è contenuta in questo file.
• scripts – Una cartella contenente uno script denominato sample-script.js che distribuirà il tuo smart contract una volta eseguito
• test – Una cartella contenente uno script di test di esempio
• contracts : una cartella contenente uno smart contract di Ethereum di esempio

A causa di un problema di configurazione di MetaMask , dobbiamo aggiornare l'ID della catena sulla nostra configurazione di HardHat in modo che sia 1337 . Abbiamo anche bisogno di aggiornare la posizione della cartella artifacts per i nostri contratti compilati in modo che siano nella directory src della nostra app React.

Per effettuare questi aggiornamenti, apri hardhat.config.js e aggiorna il file module.exports in modo che assomigli a questo:

module.exports = {
  solidity: "0.8.3",
  paths: {
    artifacts: './src/artifacts',
  },
  networks: {
    hardhat: {
      chainId: 1337
    }
  }
};

Il nostro smart contract

Quindi, diamo un'occhiata al contratto di esempio che abbiamo in contract/Greeter.sol :

//SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

import "hardhat/console.sol";


contract Greeter {
  string greeting;

  constructor(string memory _greeting) {
    console.log("Deploying a Greeter with greeting:", _greeting);
    greeting = _greeting;
  }

  function greet() public view returns (string memory) {
    return greeting;
  }

  function setGreeting(string memory _greeting) public {
    console.log("Changing greeting from '%s' to '%s'", greeting, _greeting);
    greeting = _greeting;
  }
}

Questo è un contratto intelligente molto semplice. Quando viene distribuito, imposta una variabile Greeting ed espone una funzione (greet) che può essere chiamata per restituire il saluto.

Espone inoltre una funzione che consente a un utente di aggiornare il saluto (setGreeting). Una volta distribuiti sulla blockchain di Ethereum, questi metodi saranno disponibili per l'interazione di un utente.

Apportiamo una piccola modifica allo smart contract. Poiché impostiamo la versione di solidity del nostro compilatore su 0.8.3 in hardhat.config.js, assicuriamoci anche di aggiornare il nostro contratto per utilizzare la stessa versione di solidity:

// contracts/Greeter.sol
pragma solidity ^0.8.3;

Come leggere e scrivere sulla blockchain di Ethereum

Esistono due modi per interagire con uno smart contract: lettura o scrittura delle transazioni. Nel nostro contratto, greet può essere considerato transazione in lettura e setGreeting può essere considerato transazione in scrittura.

Quando si scrive o si inizializza una transazione, è necessario pagare affinché la transazione venga scritta sulla blockchain. Per farlo funzionare, devi pagare il gas che è la commissione o il prezzo richiesto per condurre con successo una transazione ed eseguire un contratto sulla blockchain di Ethereum.

Finché stai solo leggendo dalla blockchain e non modifichi o aggiorni nulla, non è necessario effettuare una transazione e non ci saranno gas o costi per farlo. La funzione che chiami viene poi svolta solo dal nodo a cui sei connesso, quindi non devi pagare alcun gas e la lettura è gratuita.

Dalla nostra app React, interagiremo con lo smart contract utilizzando una combinazione della libreria  ethers.js, indirizzo del contratto e ABI che verrà creato dal contratto da Hardhat.

Che cos'è un ABI? ABI sta per interfaccia binaria dell'applicazione. Puoi pensarla come l'interfaccia tra la tua applicazione lato client e la blockchain di Ethereum in cui viene distribuito lo smart contract con cui interagirai.

Gli ABI sono in genere compilati da smart contract di Solidity con un framework di sviluppo come Hardhat. Spesso puoi trovare gli ABI per uno smart contract anche su Etherscan

Come compilare l'ABI

Ora che abbiamo esaminato lo smart contract di base e sappiamo cosa sono gli ABI, compiliamo un ABI per il nostro progetto.

Per farlo, vai alla riga di comando ed esegui il seguente comando:

npx hardhat compile

Ora dovresti vedere una nuova cartella denominata artifacts nella directory src . Il file artifacts/contracts/Greeter.json contiene l'ABI come una delle proprietà. Quando dobbiamo usare l'ABI, possiamo importarlo dal nostro file JavaScript:

import Greeter from './artifacts/contracts/Greeter.sol/Greeter.json'

Possiamo quindi fare riferimento all'ABI in questo modo:

console.log("Greeter ABI: ", Greeter.abi)

Nota che Ethers.js abilita anche ABI leggibili dall'uomo , ma non ne parleremo durante questo tutorial.

Come distribuire e utilizzare una rete locale / Blockchain

Quindi, distribuiamo il nostro contratto intelligente su una blockchain locale in modo da poterlo testare.

Per eseguire la distribuzione nella rete locale, devi prima avviare il nodo di test locale. Per fare ciò, apri la CLI ed esegui il seguente comando:

npx hardhat node

Quando eseguiamo questo comando, dovresti vedere un elenco di indirizzi e chiavi private.

Si tratta di 20 account di prova e indirizzi creati per noi che possiamo utilizzare per implementare e testare i nostri contratti intelligenti. Ogni account è anche caricato con 10.000 falsi Ether. Tra poco impareremo come importare l'account di prova in MetaMask in modo da poterlo utilizzare.

Successivamente, dobbiamo distribuire il contratto alla rete di test. Per prima cosa aggiorna il nome di scripts/sample-script.js in scripts/deploy.js .

Ora possiamo eseguire lo script di distribuzione e dare un flag alla CLI in modo da distribuire sulla nostra rete locale:

npx hardhat run scripts/deploy.js --network localhost

Una volta eseguito questo script, lo smart contract dovrebbe essere distribuito sulla rete di test locale e dovremmo essere quindi in grado di iniziare a interagire con esso.

Quando il contratto è stato distribuito, utilizzava il primo account creato quando abbiamo avviato la rete locale.

Se guardi l'output della CLI, dovresti essere in grado di vedere qualcosa del genere:

Greeter deployed to: 0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0

Questo indirizzo è quello che useremo nella nostra applicazione client per parlare con lo smart contract. Mantieni questo indirizzo disponibile poiché dovremo usarlo quando ci connettiamo ad esso dall'applicazione client.

Per inviare transazioni allo smart contract, dovremo connettere il nostro portafoglio MetaMask utilizzando uno degli account creati quando abbiamo eseguito npx hardhat node. Nell'elenco dei contratti che la CLI ha stampato, dovresti vedere sia un numero di conto che una chiave privata :

➜  react-defi-stack git:(main) npx hardhat node
Started HTTP and WebSocket JSON-RPC server at http://127.0.0.1:8545/

Accounts
========
Account #0: 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266 (10000 ETH)
Private Key: 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80

...

Possiamo importare questo account in MetaMask per iniziare a utilizzare alcuni dei falsi Eth disponibili lì. Per fare ciò, prima apri MetaMask e aggiorna la rete in modo che sia Localhost 8545:

Successivamente, in MetaMask, fai clic su Import Account dal menu degli account:

Copia, quindi incolla una delle chiavi private stampate nella CLI e fai clic su Import. Una volta importato l'account, dovresti vedere l'Eth nell'account:

Ora che abbiamo distribuito il nostro contratto intelligente e configurato il nostro account, possiamo iniziare a interagire con esso dall'app React.

Come collegare il client React

In questo tutorial non ci preoccuperemo di creare una bella interfaccia utente con CSS e tutto il resto: invece ci concentreremo al 100% sulle funzionalità di base per renderti operativo velocemente. Da lì poi, puoi prenderlo e farlo sembrare bello, se lo desideri.

Detto questo, esaminiamo i due obiettivi che desideriamo dalla nostra applicazione React:

1. Recupera il valore corrente di greeting dal contratto intelligente
2. Consenti a un utente di aggiornare il valore di greeting

Quindi, come lo realizziamo? Ecco le cose che dobbiamo fare perché ciò avvenga:

1. Creare un campo di input e uno stato locale per gestire il valore dell'input (per aggiornare il greeting)
2. Consentire all'applicazione di connettersi all'account MetaMask dell'utente per firmare le transazioni
3. Creare le funzioni per leggere e scrivere sullo smart contract

Per fare ciò, apri src/App.js e aggiornalo con il seguente codice, impostando il valore di greeterAddress all'indirizzo del tuo smart contract:

import './App.css';
import { useState } from 'react';
import { ethers } from 'ethers'
import Greeter from './artifacts/contracts/Greeter.sol/Greeter.json'

// Aggiorna con l'indirizzo del contratto stampato dalla CLI quando è stato distribuito 
const greeterAddress = "indirizzo-del-tuo-contratto"

function App() {
  // memorizza il saluto nella stato locale
  const [greeting, setGreetingValue] = useState()

  // richiede l'accesso all'account MetaMask dell'utente
  async function requestAccount() {
    await window.ethereum.request({ method: 'eth_requestAccounts' });
  }

  // chiama lo smart contract, legge il valore attuale del saluto 
  async function fetchGreeting() {
    if (typeof window.ethereum !== 'undefined') {
      const provider = new ethers.providers.Web3Provider(window.ethereum)
      const contract = new ethers.Contract(greeterAddress, Greeter.abi, provider)
      try {
        const data = await contract.greet()
        console.log('data: ', data)
      } catch (err) {
        console.log("Error: ", err)
      }
    }    
  }

  // chiama lo smart contract, invia un aggiornamento
  async function setGreeting() {
    if (!greeting) return
    if (typeof window.ethereum !== 'undefined') {
      await requestAccount()
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const signer = provider.getSigner()
      const contract = new ethers.Contract(greeterAddress, Greeter.abi, signer)
      const transaction = await contract.setGreeting(greeting)
      await transaction.wait()
      fetchGreeting()
    }
  }

  return (
    <div className="App">
      <header className="App-header">
        <button onClick={fetchGreeting}>Fetch Greeting</button>
        <button onClick={setGreeting}>Set Greeting</button>
        <input onChange={e => setGreetingValue(e.target.value)} placeholder="Set greeting" />
      </header>
    </div>
  );
}

export default App;

Per testarlo, avvia il server React:

npm start

Quando l'app viene caricata, dovresti essere in grado di recuperare il saluto corrente e stamparlo sulla console. Dovresti anche essere in grado di aggiornare il saluto firmando il contratto con il tuo portafoglio MetaMask e spendendo il falso Ether.

Come distribuire e utilizzare una rete di test dal vivo

Esistono diverse reti di test di Ethereum come Ropsten, Rinkeby o Kovan a cui possiamo anche distribuire per avere una versione pubblicamente accessibile del nostro contratto disponibile senza doverla distribuire sulla mainnet.

In questo tutorial verrà distribuito nella rete di test Ropsten .

Per iniziare, aggiorna prima il tuo portafoglio MetaMask per connetterti alla rete Ropsten.

Quindi, invia a te stesso un Ether di prova da utilizzare durante il resto di questo tutorial visitando questo faucet di prova .

Possiamo accedere a Ropsten (o a qualsiasi altra rete di test) iscrivendoci a un servizio come Infura o Alchemy (sto usando Infura per questo tutorial).

Dopo aver creato l'app in Infura o Alchemy, ti verrà assegnato un endpoint simile a questo:

https://ropsten.infura.io/v3/your-project-id

Assicurati di impostare ALLOWLIST ETHEREUM ADDRESSES nella configurazione dell'app Infura o Alchemy per includere l'indirizzo del portafoglio dell'account da cui eseguirai la distribuzione.

Per eseguire il deployment nella rete di test, è necessario aggiornare la nostra configurazione di Hardhat con alcune informazioni di rete aggiuntive. Una delle cose che dobbiamo impostare è la chiave privata del portafoglio da cui eseguiremo il deployment.

Per ottenere la chiave privata, puoi esportarla da MetaMask.

Suggerirei di non codificare questo valore nella tua app, ma invece di impostarlo come una variabile di ambiente.

Quindi, aggiungi una proprietà networks con la seguente configurazione:

module.exports = {
  defaultNetwork: "hardhat",
  paths: {
    artifacts: './src/artifacts',
  },
  networks: {
    hardhat: {},
    ropsten: {
      url: "https://ropsten.infura.io/v3/your-project-id",
      accounts: [`0x${your-private-key}`]
    }
  },
  solidity: "0.7.3",
};

Per eseguire la distribuzione, avviare il seguente script:

npx hardhat run scripts/deploy.js --network ropsten

Una volta distribuito il contratto, dovresti essere in grado di iniziare a interagire con esso. Ora dovresti essere in grado di visualizzare il contratto live su Etherscan Ropsten Testnet Explorer

Come coniare i gettoni

Uno dei casi d'uso più comuni degli smart contract è la creazione di token. Diamo un'occhiata a come possiamo farlo. Dal momento che sappiamo un po' di più su come funziona tutto questo, andremo un po' più veloci.

Nella directory principale dei contracts, crea un nuovo file denominato Token.sol .

Quindi, aggiorna Token.sol con il seguente contratto intelligente:

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;

import "hardhat/console.sol";

contract Token {
  string public name = "Nader Dabit Token";
  string public symbol = "NDT";
  uint public totalSupply = 1000000;
  mapping(address => uint) balances;

  constructor() {
    balances[msg.sender] = totalSupply;
  }

  function transfer(address to, uint amount) external {
    require(balances[msg.sender] >= amount, "Gettoni non sufficienti");
    balances[msg.sender] -= amount;
    balances[to] += amount;
  }

  function balanceOf(address account) external view returns (uint) {
    return balances[account];
  }
}

Tieni presente che questo contratto token è solo a scopo dimostrativo e non è conforme a ERC20 . Tratteremo i token ERC20 in seguito.

Questo contratto creerà un nuovo token chiamato "Nader Dabit Token" e imposterà la fornitura a 1000000.

Quindi, compila questo contratto:

npx hardhat compile

Ora, aggiorna lo script di distribuzione su scripts/deploy.js per includere questo nuovo contratto Token:

const hre = require("hardhat");

async function main() {
  const [deployer] = await hre.ethers.getSigners();

  console.log(
    "Distribuzione di contratti con l'account:",
    deployer.address
  );
  
  const Greeter = await hre.ethers.getContractFactory("Greeter");
  const greeter = await Greeter.deploy("Hello, World!");

  const Token = await hre.ethers.getContractFactory("Token");
  const token = await Token.deploy();
  
  await greeter.deployed();
  await token.deployed();

  console.log("Greeter distribuito a:", greeter.address);
  console.log("Token distribuito a:", token.address);
}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });

Ora possiamo distribuire questo nuovo contratto sulla rete locale o Ropsten:

npx hardhat run scripts/deploy.js --network localhost

Una volta distribuito il contratto, puoi iniziare a inviare questi token ad altri indirizzi.

Per fare ciò, aggiorniamo il codice client di cui avremo bisogno per farlo funzionare:

import './App.css';
import { useState } from 'react';
import { ethers } from 'ethers'
import Greeter from './artifacts/contracts/Greeter.sol/Greeter.json'
import Token from './artifacts/contracts/Token.sol/Token.json'

const greeterAddress = "il-tuo-indirizzo-di-contratto"
const tokenAddress = "il-tuo-indirizzo-di-contratto"

function App() {
  const [greeting, setGreetingValue] = useState()
  const [userAccount, setUserAccount] = useState()
  const [amount, setAmount] = useState()

  async function requestAccount() {
    await window.ethereum.request({ method: 'eth_requestAccounts' });
  }

  async function fetchGreeting() {
    if (typeof window.ethereum !== 'undefined') {
      const provider = new ethers.providers.Web3Provider(window.ethereum)
      console.log({ provider })
      const contract = new ethers.Contract(greeterAddress, Greeter.abi, provider)
      try {
        const data = await contract.greet()
        console.log('data: ', data)
      } catch (err) {
        console.log("Error: ", err)
      }
    }    
  }

  async function getBalance() {
    if (typeof window.ethereum !== 'undefined') {
      const [account] = await window.ethereum.request({ method: 'eth_requestAccounts' })
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const contract = new ethers.Contract(tokenAddress, Token.abi, provider)
      const balance = await contract.balanceOf(account);
      console.log("Balance: ", balance.toString());
    }
  }

  async function setGreeting() {
    if (!greeting) return
    if (typeof window.ethereum !== 'undefined') {
      await requestAccount()
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      console.log({ provider })
      const signer = provider.getSigner()
      const contract = new ethers.Contract(greeterAddress, Greeter.abi, signer)
      const transaction = await contract.setGreeting(greeting)
      await transaction.wait()
      fetchGreeting()
    }
  }

  async function sendCoins() {
    if (typeof window.ethereum !== 'undefined') {
      await requestAccount()
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const signer = provider.getSigner();
      const contract = new ethers.Contract(tokenAddress, Token.abi, signer);
      const transation = await contract.transfer(userAccount, amount);
      await transation.wait();
      console.log(`${amount} Coins successfully sent to ${userAccount}`);
    }
  }

  return (
    <div className="App">
      <header className="App-header">
        <button onClick={fetchGreeting}>Fetch Greeting</button>
        <button onClick={setGreeting}>Set Greeting</button>
        <input onChange={e => setGreetingValue(e.target.value)} placeholder="Set greeting" />

        <br />
        <button onClick={getBalance}>Get Balance</button>
        <button onClick={sendCoins}>Send Coins</button>
        <input onChange={e => setUserAccount(e.target.value)} placeholder="Account ID" />
        <input onChange={e => setAmount(e.target.value)} placeholder="Amount" />
      </header>
    </div>
  );
}

export default App;

Quindi, esegui l'app:

npm start

Dovremmo essere in grado di fare clic su Get Balance e vedere che abbiamo 1.000.000 di monete nel nostro account stampato sulla console.

Dovresti anche essere in grado di visualizzarli in MetaMask facendo clic su Add Token:

Quindi fai clic su Custom Token e inserisci l'indirizzo del contratto del token e poi Add Token . Ora i token dovrebbero essere disponibili nel tuo portafoglio:

Quindi, proviamo a inviare quelle monete a un altro indirizzo.

Per fare ciò, copia l'indirizzo di un altro account e invialo a quell'indirizzo utilizzando l'interfaccia utente di React aggiornata. Quando controlli l'importo del token, dovrebbe essere uguale all'importo originale meno l'importo che hai inviato all'indirizzo.

Come costruire un token ERC20

Lo standard dei token ERC20 definisce un insieme di regole che si applicano a tutti i token ERC20 che consentono loro di interagire facilmente tra loro. ERC20 rende davvero facile per qualcuno coniare i propri token che avranno interoperabilità con altri sulla blockchain di Ethereum.

Diamo un'occhiata a come possiamo costruire il nostro token utilizzando lo standard ERC20.

Innanzitutto, installa la libreria di smart contract ERC20  OpenZepplin in cui importeremo il token di base:

npm install @openzeppelin/contracts

Successivamente, creeremo il nostro token estendendo (o ereditando) il contratto ERC20:

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract NDToken is ERC20 {
    constructor(string memory name, string memory symbol) ERC20(name, symbol) {
        _mint(msg.sender, 100000 * (10 ** 18));
    }
}

Il costruttore consente di impostare il nome e il simbolo del token e la funzione _mint consente di coniare i token e di impostare l'importo.

Per impostazione predefinita, ERC20 imposta il numero di decimali a 18, quindi nella nostra funzione _mint moltiplichiamo 100.000 per 10 alla potenza 18 per coniare un totale di 100.000 gettoni, ciascuno con 18 cifre decimali (in modo simile a come 1 Eth è composto da 10 a 18 wei .

Per distribuire, dobbiamo passare i valori del costruttore (name e symbol), quindi potremmo fare qualcosa del genere nel nostro script di distribuzione:

const NDToken = await hre.ethers.getContractFactory("NDToken");
const ndToken = await NDToken.deploy("Nader Dabit Token", "NDT");

Estendendo il token ERC20 originale, il tuo token erediterà tutte le seguenti funzioni e funzionalità:

function name() public view returns (string)
function symbol() public view returns (string)
function decimals() public view returns (uint8)
function totalSupply() public view returns (uint256)
function balanceOf(address _owner) public view returns (uint256 balance)
function transfer(address _to, uint256 _value) public returns (bool success)
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)
function approve(address _spender, uint256 _value) public returns (bool success)
function allowance(address _owner, address _spender) public view returns (uint256 remaining)

Una volta implementato, puoi utilizzare una qualsiasi di queste funzioni per interagire con il nuovo contratto intelligente. Per un altro esempio di token ERC20, dai un'occhiata a Solidity by example qui: https://solidity-by-example.org/app/erc20/ .

Conclusione

Ok, abbiamo trattato molto in questo articolo. Ma per me questo è una specie di pane quotidiano / essenziale per iniziare con questo stack.

È un po' quello che volevo avere, non solo come qualcuno che sta imparando tutte queste cose, ma anche in futuro, se mai avessi bisogno di fare riferimento a qualcosa di cui potrei aver bisogno. Spero che tu abbia imparato molto.

Se desideri supportare più portafogli oltre a MetaMask, dai un'occhiata a Web3Modal che semplifica l'implementazione del supporto per più provider nella tua app con una configurazione abbastanza semplice e personalizzabile.

Nei miei futuri tutorial e guide, mi immergerò nello sviluppo di contratti intelligenti più complessi e anche su come distribuirli come sottografi per esporre un'API GraphQL su di essi e implementare cose come l'impaginazione e la ricerca full-text.

Tratterò anche di come utilizzare tecnologie come IPFS e database Web3 per archiviare i dati in modo decentralizzato.

Se hai domande o suggerimenti per futuri tutorial, fammi sapere.

Ultimamente, ho parlato del mio passaggio allo spazio Web3 , Ethereum e crypto, cioè da quando sono passato da una conoscenza tradizionale del Web, mobile e cloud.

Da quando ho fatto ciò, un numero impressionante di persone mi ha contattato e anche loro stanno pensando di fare lo stesso.

È davvero fantastico vedere così tante altre persone interessate a questi campi. E se devo essere onesto, è confortante sapere che anche così tanti altri sono in osservazione e sono anche così profondamente interessati al questo contesto.

Quanto a me, ero nervoso all'idea di cambiare carriera. Il passaggio a un'area di specializzazione completamente nuova, con una tecnologia su cui mi stavo ancora potenziando e una comunità in cui non ero ancora coinvolto, è stato un grande salto. Soprattutto rispetto a un lavoro molto comodo in un'azienda FAANG, con un'ottimo stipendio (e una squadra che ho davvero amato).

Dopo oltre un mese, non ho rimpianti per il cambiamento. Sono anche più felice e sono eccitato e pieno di energia per le cose su cui ho l'opportunità di lavorare ogni giorno.

Ho deciso di scrivere questo post per fornire indicazioni a chiunque cerchi di entrare in blockchain, criptovalute, Ethereum e Web3 da un background di sviluppo tradizionale. Posso indirizzare le persone a questo mio post sul blog la prossima volta che mi verrà chiesto su come entrare in questo ambito.

Dividerò questo articolo in alcune parti principali:

1. Tecnologie e risorse per imparare
2. Compromessi e considerazioni
3. Persone da seguire
4. Aziende che assumono e fanno cose interessanti
5. Suggerimenti generali e ottenimento di un lavoro

Iniziamo.

Tecnologie e risorse per conoscere Ethereum e Blockchain

Quello che mi interessa di più è di solito cercare di prevedere dove la tecnologia andrà nel prossimo futuro e dove vedo l'attuale slancio. Quindi è su questo che mi concentrerò qui (ed è quello che sto facendo personalmente).

Per me, le parti più interessanti di questo spazio sono la decentralizzazione, la DeFi , la governance / DAO e l'infrastruttura web decentralizzata .

Per questo motivo, mi sto concentrando sia sullo sviluppo di Ethereum che su Solidity. Con il linguaggio di programmazione Solidity, puoi programmare contratti intelligenti per Ethereum e per molti altri blockchain compatibili con EVM .

Al momento della stesura di questo articolo, Ethereum ha anche la potente e importante combinazione di slancio, condivisione mentale degli sviluppatori e dapp di produzione esistenti .

Anche Ethereum sta attualmente passando a un nuovo meccanismo di consenso, proof of stake . Questo risolve le preoccupazioni ambientali che avevo su come funziona la criptovaluta a livello centrale.

Dopo aver appreso le basi di come funziona il tutto, ti incoraggio a controllare altri blockchain e progetti al di fuori di Ethereum ed EVM.

Questo ti darà una migliore comprensione del settore nel suo insieme. Ti aiuterà anche a vedere se ci sono altri progetti che ti attraggono o che ritieni siano approcci migliori per raggiungere l'obiettivo che è Web3.

Considera di esaminare Solana , Polkadot , Near , Avalanche o Cosmos .

Per iniziare ad imparare lo sviluppo della blockchain con Ethereum e Solidity, ti suggerisco di fare quanto segue:

1. Leggi la documentazione di Ethereum

Esplora la documentazione di Ethereum. Assicurati di controllare la sezione Introduzione a Ethereum e qualsiasi altra cosa che attiri la tua attenzione.

Assicurati anche di dare un'occhiata alla vetrina di dapp per avere una buona comprensione delle app di successo create e utilizzate nell'attuale ecosistema.

2. Leggi la documentazione di Solidity

La documentazione di Solidity è un ottimo punto di partenza, in particolare la Solidity tramite esempio . Questo ti offre alcuni esempi di contratti intelligenti popolari come il voto, un'asta, l'acquisto a distanza e i micropagamenti.

Puoi copiare e incollare questi contratti nell'IDE Remix per iniziare a eseguirli e modificarli per vedere come funzionano.

Ho anche fatto un video sulla procedura dettagliata del contratto di voto qui .

3. Mettiti comodo con Remix IDE

È davvero facile giocare e iniziare a creare contratti intelligenti senza dover configurare alcun tipo di ambiente di sviluppo utilizzando Remix IDE . Fa parte del Remix Project , finanziato dalla Ethereum Foundation .

Questo Remix IDE ti consente di creare, modificare ed eseguire contratti intelligenti direttamente dal tuo browser. Offre un ambiente perfetto per imparare come funziona Solidity. È anche ottimo per creare vari tipi di contratti intelligenti e giocarci mentre impari sia Solidity che come interagire con Ethereum

4. Prova a creare un dapp full stack

Oltre a Solidity, le altre parti dello stack di sviluppo includono un ambiente Ethereum locale come Hardhat o Truffle , un portafoglio come Metamask , nonché una libreria lato client che ti consente di interagire con la blockchain, come Ethers.js o Web3.js .

Per capire come tutto questo si adatta insieme, è utile creare da zero un dapp full stack su questo complesso di elementi. Puoi impostare il progetto front-end e l'ambiente di sviluppo locale e distribuire, eseguire e interagire con uno smart contract sulla blockchain.

Ecco due corsi introduttivi per iniziare con questo:

1. Tutorial di programmazione Ethereum - DeFi, Solidity, Truffle, Web3.js
2. La guida completa allo sviluppo di Full Stack Ethereum ( ed eccola anche sotto forma di articolo )

5. Considera la lettura di questi libri

Lo spazio stesso si muove molto rapidamente, quindi i libri tecnici spesso diventano obsoleti altrettanto rapidamente. I fondamenti di ciò che è Web3, tuttavia, non sono cambiati molto.

Ci sono alcuni libri davvero fantastici che mi hanno aiutato non solo a cogliere lo stato attuale di ogni cosa, ma che mi hanno anche aiutato ad aprire gli occhi sulle possibilità e opportunità future che si trovano al suo interno.

Token Economy - Come il Web3 reinventa Internet

Se hai intenzione di leggere solo uno di questi libri, questo è quello che direi che è il più importante. È un'immersione magistrale in tutte le carenze del web come lo conosciamo, cosa vuole essere il Web3, come influenzerà le varie parti della nostra vita attuale e cosa deve accadere affinché questa visione si realizzi .

Puoi visualizzare il libro qui .

The Infinite Machine - Come un esercito di cripto-hacker sta costruendo la prossima Internet con Ethereum

Questa è la straordinaria storia di come è nato Ethereum, guidandoti attraverso la storia di tutto questo. È un resoconto molto approfondito e divertente della storia delle origini di Ethereum, consiglio vivamente di provarlo.

Puoi visualizzare il libro qui .

New Village - Ritorno al potere delle persone

Questa è una storia davvero interessante su come le tecnologie blockchain e il decentramento influenzeranno il futuro del mondo.

Puoi visualizzare il libro qui

How to DeFi

Come probabilmente puoi intuire dal titolo, questo libro si concentra su come puoi iniziare a utilizzare la DeFi oggi. Ti dà una buona comprensione di come puoi usarla oggi e di alcune sue applicazioni che vedremo in futuro.

Puoi visualizzare il libro qui

The Spatial Web

The Spatial Web è un libro che esplora il futuro del web e tutte le implicazioni, non solo del Web3 e del decentramento, ma come tutto si unirà per consentire cose che potremmo non aver ancora considerato.

Fa un buon lavoro soppesando gli aspetti positivi e negativi, nonché i modi in cui potremmo essere in grado di affrontare eventuali esiti negativi di ciò che verrà.

Puoi visualizzare il libro qui

Ed ecco un paio di libri su solidity:

• Sviluppo pratico di contratti intelligenti con Solidity ed Ethereum
• Padroneggiare Ethereum

6. Ascolta questi podcast

Ecco alcuni buoni podcast:

• Fondatori di Web 3 – Le persone che stanno creando e costruendo la prossima fase di Internet.
• Bankless : la guida definitiva alla criptofinanza
• Into the Ether – Podcast su Ethereum
• Cripto 101
• Epicenter : scopri le tecnologie Crypto, Blockchain, Ethereum, Bitcoin e distribuite

7. Guarda questi canali YouTube

• Fondazione Ethereum
• Eat the Blocks – Brevi video sullo sviluppo della blockchain
• Finematics – Condivisione di video DeFi interessanti
• Dapp University – Video nello spazio di Ethereum
• BlockGeeks – Formazione Blockchain generale
• Il quotidiano Gwei
• Austin Griffith

Ho anche iniziato a fare video e tutorial su Ethereum e Solidity, quindi considera di dare un'occhiata al mio canale YouTube.

Compromessi e considerazioni sul cambio di carriera

Ci sono sempre cose da considerare quando si effettua una transizione di carriera, ma soprattutto quando si considera questo contesto.

Ci sono molti aspetti positivi, ma ci sono anche incognite come anche aspetti negativi. Parliamo di alcuni di loro.

È una tecnologia nascente

Mentre ci sono molte dapp esistenti e aziende già fiorenti, questo spazio sta ancora nascendo in molti modi.

Ci sono molti problemi che dobbiamo ancora risolvere e non ci sono risposte chiare per molte domande che avrai. I problemi da risolvere sono spesso complessi, a volte combinano uno o più aspetti dei sistemi distribuiti, teoria dei giochi, crittografia, economia, scienze sociali e politiche, identità, psicologia e altro ancora.

Per questo motivo, ci sono ancora cose che non possiamo finora costruire con le soluzioni esistenti che sono attualmente disponibili.

Personalmente penso che questa sia una delle cose più eccitanti di tutto ciò, ma non è per tutti.

È uno spazio volatile

Molti dei progetti sono costruiti attorno a vari tipi di token. Il valore di molti di questi gettoni aumenta e diminuisce drasticamente e spesso si vede che le persone guadagnano e perdono interesse all'argomento in base a queste oscillazioni.

Se non hai fondamentalmente accettato le idee alla base del decentramento stesso, potresti trovare questi alti e bassi mentalmente faticosi.

È pieno di speculazione

Poiché molta gente acquista determinati token unicamente a scopo speculativo, ciò attira alcune persone solo per i soldi.

Vedi cose come truffatori che cercano di avere la meglio sulle persone e rubare i loro soldi, discorsi interminabili sulle oscillazioni dei prezzi da parte di persone che speculano e veri e propri progetti truffa che spesso screditano l'industria nel suo insieme.

Questa è una parte fastidiosa e non penso che se terminerà presto.

Questa discussione

Vorrei anche che tu dia un'occhiata a questa discussione su Twitter. Anche se non ho sperimentato tutte queste cose, sta sicuramente chiarendo alcune delle cose che ho visto.

Suggerimenti generali e come ottenere un lavoro Blockchain o relativo alle criptovalute

Ci sono molte aree all'interno dello spazio su cui puoi concentrarti e magari poi fornire un impatto positivo su una squadra. Esaminerei le diverse aree come governance, DeFi, NFT e protocolli web decentralizzati per vedere cosa ti interessa di più e poi concentrarti su quello.

Ci sono molte opportunità e molti modi per distinguersi e farsi notare. Se trovi un progetto interessante e vorresti essere coinvolto, entra subito nella loro comunità ed ecosistema e inizia ad imparare. Quindi vedi dove potresti essere in grado di dare una mano. Unisciti a Discord o guarda i loro problemi su GitHub per trovare modi in cui puoi contribuire.

Questo ti darà l'opportunità di incontrare persone coinvolte nel progetto e aprirà discussioni per ottenere potenzialmente un ruolo con loro. In effetti, è molto comune che le persone all'interno dei team prendano nota dei partecipanti più attivi della comunità, quindi spesso ti contattano e cercheranno di reclutarti senza nemmeno candidarti.

La paga è generalmente buona. A seconda da dove vieni, potrebbe essere maggiore o minore, ma probabilmente non sarà ai livelli elevati di quello che vedi nelle aziende FAANG.

Probabilmente c'è più potenziale di rialzo. La maggior parte delle aziende offre una combinazione di retribuzione base + equità sotto forma di token digitale, quindi se rimani e puoi contribuire a rendere il progetto di successo e il valore del token aumenta, spesso puoi guadagnare di più di quanto faresti in molti altre aree.

Persone da seguire su Twitter

Ecco alcune persone che potresti considerare di seguire su Twitter:

Vitalik
Ashleigh Schapp
Arthur Hayes
Stani Kulechov
Gloria Kimbwala
Niran Babalola
Ric Burton
Dennison Bertram
Mana Silvora
Austin Griffith
Santiago Palladino
Zaki Manian
Anthony Sassano

Ho anche trovato questo elenco completo creato da qualcuno su Twitter.

Alcune persone nel mio team di Edge & Node :
Yaniv Tal
Tegan Kline
Eva Beylin
Adam Fuller
Brandon Ramirez

Squadre che fanno cose interessanti (e assunzioni)

Compound
Uniswap
Chainlink
Skynet Labs
Aave
Matic
Livepeer
Consensys
ENS
OpenZeppelin
Foundation
Zora
Synthetix
Digital Currency Group

Puoi anche trovare un elenco abbastanza decente di opportunità di lavoro in criptovaluta qui .

Inoltre, il mio team di Edge & Node sta assumendo !

Conclusione

Ho già detto che questo spazio è volatile? Preparati per alcuni alti e bassi, ma anche per alcuni dei momenti più divertenti che potresti avere nella tua carriera.

Lavorerai al fianco di alcune delle persone più intelligenti nell'ambito della tecnologia cercando di risolvere alcuni dei problemi più complessi che penso che alla fine avranno un enorme impatto positivo sull'umanità.