Segons passos
En aquesta secció introduirem algunes eines poderoses per facilitar la vostra experiència de desenvolupament. Instal·larem un entorn de desenvolupament anomenat Truffle, explorarem Solidity, cobrirem els fonaments d’un contracte intel·ligent (fins i tot el farem nostre) i iniciarem el nostre propi node a la nostra màquina local. Un cop hàgim implementat amb èxit localment, utilitzarem Remix per interactuar amb el nostre contracte i aprofundir en el procés de desenvolupament!
Conèixer la tòfona
Tòfona
Truffle és un entorn de desenvolupament excel·lent que us permet connectar-vos i provar-los amb la màquina virtual Ethereum. Truffle es va crear per facilitar el desenvolupament i, amb les interaccions que es produeixen localment, això ajuda a reduir l’estrès del desplegament tant en un testnet (com Ropsten o Rinkeby) com en mainnet.
Per obtenir més documentació sobre la tòfona, consulteu-la aquí:
Per instal·lar Truffle al terminal, seguiu endavant i executeu el següent:
npm instal·la la tòfona -g
Nota: recomanacions per a Windows
Si feu servir Truffle al Windows, és possible que tingueu alguns conflictes de noms que puguin evitar que Truffle s’executi correctament. Siusplau mira la secció sobre la resolució de conflictes de noms per a solucions.
Ganache
Mentre hi estem, anem endavant i instal·lem la CLI per a ganache
Un resum ràpid de ganache és que es tracta d’una cadena de blocs personal que podeu utilitzar localment per generar ràpidament i provar la funcionalitat dels projectes. Ganache és una eina que podeu utilitzar durant tot el cicle de desenvolupament. No només podeu desenvolupar, sinó també implementar i provar els vostres dApps. Tot això passa localment a la vostra màquina, de manera que aquest és l’entorn de fricció / risc més baix per treballar en els vostres projectes!
Utilitzant npm:
npm install -g ganache-cli
D’acord, torna a la tòfona!
Algunes de les ofertes que ofereix Truffle són:
- Recopilació de contractes intel·ligents, enllaços, desplegament i gestió binària integrats.
- Proves de contractes automatitzades per al desenvolupament ràpid.
- Desplegament extensible i scriptable & marc de migracions.
- Gestió de la xarxa per desplegar-la a qualsevol públic & xarxes privades.
- Gestió de paquets amb EthPM & NPM, mitjançant l’estàndard ERC190.
- Consola interactiva per a comunicació directa per contracte.
- Canalització de construcció configurable amb suport per a una integració estreta.
- Corredor de scripts externs que executa scripts en un entorn Truffle.
Per al nostre tutorial anem a construir alguna cosa des de la base, però us animem a veure alguns dels projectes de caldera que Truffle ja ha creat anomenats Truffle Boxes (trobats aquí).
Ara que tenim la tòfona i el ganache instal·lats, parlem de la solidesa!
Solidesa
Solidity és un increïble llenguatge d’alt nivell orientat a objectes i popular per implementar contractes intel·ligents que s’executen a la màquina virtual Ethereum (EVM). Els contractes intel·ligents són programes que regeixen el comportament dels comptes a l’estat d’Ethereum. Si no heu vist mai cap línia de Solidity abans, però esteu familiaritzat amb C ++ o JavaScript, notareu més que algunes similituds.
Solidity és un llenguatge de tipus estàtic que admet herències, biblioteques i tipus complexos definits per l’usuari, entre altres funcions. Amb Solidity podeu crear contractes per a usos com el vot, el crowdfunding i fins i tot les subhastes a cegues per citar només alguns casos d’ús.
La solidesa es compila en un bytecode que s’executa a l’EVM. Amb Solidity, els desenvolupadors són capaços d’escriure aplicacions que implementin una lògica empresarial autoimplementada incorporada als contractes intel·ligents, deixant un registre de transaccions que no repudi. Els contractes intel·ligents permeten als usuaris confiar en el codi, cosa que ajuda a crear un entorn sense confiança on s’elimini molt la possible corrupció humana.
Tingueu en compte quan desplegueu contractes, sempre heu de fixar-vos en la versió que utilitzeu. S’introdueixen regularment canvis, funcions noves i correccions d’errors (recordeu-ho si us trobeu seguint tutorials en línia, podríeu tenir errors, documentació propera).
Començar un projecte de tòfona
Dit això, iniciem el nostre projecte i l’anomenem “eth-hello-world”
Ves al terminal i creem una nova carpeta buida
mkdir eth-hola-world
Un cop tinguem el directori buit, aneu a la carpeta i executeu l’ordre
tòfona init
Un cop finalitzat el procés, hauríem de poder visualitzar alguns dels fitxers creats per a nosaltres:
Ara tenim contactes, migracions, una carpeta de prova i un fitxer de configuració de trufes. Vegem aquests fitxers i analitzem a un nivell superior què són.
Contractes
Aquesta carpeta contindrà tots els vostres contractes intel·ligents (que en aquest exemple crearem amb Solidity). Si mai no heu sentit a parlar de contactes intel·ligents, és una manera de pensar-hi; trossos de codi que s’executen a la cadena de blocs (pot ser local, de prova o mainnet) que tenen la garantia de produir els mateixos resultats per a tothom que els executa. Els contractes intel·ligents s’utilitzen a les dApps (aplicacions descentralitzades) i tenen una gran quantitat de casos d’ús. Votació, jocs, cadena de subministrament, monedes, registres financers, i això és només per citar-ne alguns!
Per desglossar això encara més, Nick Szabo posa l’exemple de la màquina expenedora. Si introduïu la quantitat correcta de monedes a la màquina, podreu esperar el mateix resultat exacte (i tothom abans / després). El mateix passa amb els contactes intel·ligents basats en Ethereum, que contenen un valor i fins que es compleixin les seves condicions (és a dir, la quantitat correcta de monedes del nostre exemple), desbloquejarà i publicarà la informació que intenteu recuperar.
Tornarem a debatre sobre Solidity i els contractes intel·ligents una mica més endavant, passem a les migracions!
Migracions
Les migracions són fitxers Javascript que us permeten desplegar els vostres contractes a la xarxa Ethereum. El que és realment interessant és que hi ha un supòsit subjacent que el vostre treball evolucionarà i que el vostre desplegament canviarà amb el pas del temps. A mesura que feu actualitzacions, anireu creant nous scripts de migració durant l’evolució del vostre projecte. Una manera de pensar sobre els fitxers de migració és que són els principals responsables de la realització i el desplegament de les vostres tasques. Una manera senzilla de pensar-hi és que les migracions són un conjunt d’escriptures de desplegament gestionat. A mesura que actualitzeu el vostre treball, un registre de les migracions executades anteriorment es registra en cadena mitjançant un contracte de migracions incorporat.
Feu-hi una ullada, ja teniu un contracte de migració! Dirigiu-vos al directori del contracte i obriu-lo, veureu un fitxer Migrations.sol que conté un contracte que hauria de ser semblant a aquest:
Aquest és un contracte predeterminat que es crea per a nosaltres quan executem l’inici de trufa. La tòfona per naturalesa requereix que tingueu un contracte de migració per poder utilitzar la funció de migració, així que no l’elimineu!
Nota: heu de desplegar aquest contracte dins de la vostra primera migració per aprofitar la funció Migracions.
Ara que hem tingut l’oportunitat de veure el nostre contracte de migració, podem dirigir-nos al directori de migració i veurem un fitxer anomenat 1_inital_migrations.js
Nota: doneu un cop d’ull a la convenció de noms d’aquest fitxer, que té un número i el prefix d’una descripció. El prefix numerat és necessari per registrar si la migració s’ha executat correctament. El sufix és exclusivament per a la llegibilitat humana
A mesura que creeu contractes, haureu d’assegurar-vos que teniu un fitxer migration.js juntament amb ells. Sense bussejar massa a fons en artifacts.require (), deployer.deploy, etc. aquí és una excel·lent documentació de l’equip de tòfona per explicar encara més l’ús d’aquests mètodes.
Per compilar un projecte Truffle, canvieu a l’arrel del directori on es troba el projecte i, a continuació, escriviu el següent en un terminal:
compilació de tòfones
Per executar les migracions al terminal, finalment executareu (espera, però, encara no cal que ho fem!)
migrar la tòfona
Això executarà totes les migracions ubicades al directori de migracions del vostre projecte.
El que és interessant de tenir en compte és que aquesta ordre només executarà migracions de nova creació. Per tant, si la vostra migració anterior s’ha executat correctament, no la tornarà a executar. A més, si no s’executen migracions noves, simplement no s’executarà. Si cal, podeu utilitzar l’opció –reset per executar totes les vostres migracions des del principi.
Es documenten altres opcions d’ordres aquí.
Nota: Hem instal·lat anteriorment, però per fer proves locals, assegureu-vos de tenir una cadena de blocs de prova com Ganache instal·lat i en execució abans d’executar migrate.
Proves
A l’hora d’escriure proves, la tòfona ve carregada d’unes excel·lents eines per fer-ho intuïtiu. Sobretot si teniu previst desplegar els vostres contractes a mainnet (però és una bona pràctica, fins i tot a testnet), és molt important fer proves i comprovar els vostres contractes al màxim de les vostres capacitats. Truffle ha fet que sigui senzill i manejable revisar / provar el vostre desenvolupament.
Truffle utilitza el Mocha marc de proves i Chai per obtenir afirmacions que us proporcionin un marc sòlid per escriure les proves de JavaScript.
Nota: si no esteu familiaritzats amb la redacció de proves unitàries a Mocha, consulteu Documentació de Mocha abans de continuar.
Nota lateral: és una eina excel·lent per revisar els vostres contractes a fons Mític, el principal servei d’anàlisi de seguretat en el camp que ofereix revisions en profunditat de contractes intel·ligents. La seva missió és no només assegurar-vos d’evitar costosos errors, sinó també fer d’Ethereum una plataforma més segura i fiable en general.
Tots els fitxers de prova s’han de trobar al directori./test. Truffle només executarà fitxers de prova amb les extensions de fitxer següents: .js, .ts, .es, .es6, .jsx i.sol. La resta de fitxers s’ignoren.
Per executar totes les proves, simplement executeu:
prova de tòfona
Ara que hem cobert el que crea l’inici de la tòfona i les bastides del nostre projecte, anem ara i afegim el nostre contracte intel·ligent al nostre projecte!
Redacció d’un contracte intel·ligent
Passem al directori de contractes i escrivim el nostre primer contracte que tenim previst desplegar al nostre entorn de prova local (ganache)!
Començarem creant el fitxer our.sol, que anomenarem HelloWorld.sol
A continuació, podem afegir el nostre contracte bàsic que tindrà un aspecte semblant
solidesa del pragma >= 0,5,8 <0,7,0; contracte HelloWorld {string missatge públic; constructor (memòria de cadena initMessage) públic {missatge = initMessage; } actualització de la funció (memòria de cadena newMessage) pública {message = newMessage; }}
Si mirem el nostre contracte una mica més de prop, podem desglossar alguns elements
Recordeu, un contracte és una col·lecció de funcions i dades (el seu estat).
La paraula clau pragma es pot utilitzar per habilitar determinades funcions o comprovacions del compilador. Una directiva pragma sempre és local a un fitxer font, de manera que heu d’afegir el pragma a tots els vostres fitxers si voleu que estigui activat al vostre projecte. Sense una declaració de pragma a l’inici del nostre (o cap) fitxer de solidesa, el nostre contracte no sabrà compilar.
(aquí és un enllaç als documents de solidesa per conèixer els aspectes i aspectes dels matisos de solidesa
En última instància, un contracte és una col·lecció de funcions i dades (el seu estat) que resideix en una adreça específica de la cadena de blocs Ethereum.
En veure la funcionalitat del nostre contracte, podem veure que estem configurant el nostre missatge per ser una cadena pública visible.
La paraula clau “públic” fa que les variables siguin accessibles des de fora d’un contracte i crea una funció que altres contractes o SDK poden anomenar per accedir al missatge públic de la cadena de valors.
contracte HelloWorld {string missatge públic;
Aquí hi ha una funció que només s’executa durant la creació del contracte
constructor (memòria de cadena initMessage) públic {missatge = initMessage; }
Pren un valor de cadena i emmagatzema el valor a l’àrea d’emmagatzematge de dades de memòria, configurant el missatge en aquest missatge de valor, és a dir, initMessage.
A continuació, podem inicialitzar un missatge que es transmet com a paràmetre i que es pot modificar / actualitzar amb la funció d’actualització.
Aquesta és una funció accessible públicament que pren una cadena com a paràmetre i actualitza el “missatge” (vegeu més avall).
actualització de la funció (memòria de cadena newMessage) pública {message = newMessage; }}
Aquí el teniu, un contracte bàsic però digerible de HelloWorld!
Ara que tenim el nostre contracte afegit, ara ens podem assegurar que tingui la capacitat de compilar!
Aneu a la carpeta Migració del nostre projecte i ara crearem un fitxer a.js dedicat al nostre contracte HelloWorld.
Crearem un fitxer nou i el nom és 2_deploy_contracts.js
Recordeu la nota sobre les convencions de nomenament anteriors!
const HelloWorld = artifacts.require ("Hola món"); module.exports = funció (desplegador) {deployer.deploy (HelloWorld, "corda"); };
Bon treball! Estem gairebé a punt per desplegar el nostre contracte, però primer hem d’assegurar-nos que els nostres fitxers de configuració de trufes saben amb qui parlar. Com es va esmentar anteriorment, ens centrarem en el nostre entorn local en aquesta secció, però a la secció 3 (spolier) no només creem i implementem localment, sinó que la portem a una xarxa de prova!
Desplaceu-vos cap avall al fitxer truffle-config.js fins que vegeu la secció relativa a les xarxes
descomenteu / afegiu el següent
xarxes: {desenvolupament: {host: "127.0.0.1", port: 8545, network_id: "*", },
Ara el fitxer hauria de tenir un aspecte semblant a aquest:
El que passa aquí és que se’ns indica el fitxer de configuració amb instruccions específiques sobre amb què connectar. En aquest cas, com veureu aviat, ens connectarem a la nostra eina ganache-cli.
Inicia Ganache
Dit això, anem endavant i posem en marxa la nostra ganache
al terminal, segueix endavant i corre
ganache-cli
Comprova-ho! Ara esteu executant el vostre propi TestRPC allà mateix al vostre terminal!
(més sobre això aquí)
Nota: manteniu aquesta pestanya oberta al terminal, però seguiu endavant i obriu-ne una de nova per treure’n partit.
Ràpida revisió
Tornem al nostre projecte i repassem ràpidament el que hem fet.
- Vam crear un nou projecte
- Tòfona inicialitzada
- Vaig fer un ràpid recorregut per les bastides
- Vam crear el nostre contracte HelloWorld
- S’ha afegit una lògica a la nostra carpeta de migracions del nostre contracte
- Vam entrar al nostre fitxer de configuració i vam ajustar la informació de la nostra xarxa
És hora de posar en marxa el nostre contracte!
A la nostra nova finestra de terminal (ja que tenim ganache en execució a l’altra)
anem endavant i correm
compilació de tòfones
Ara hauríeu de veure això com a resultat al vostre terminal:
Si ara aneu al vostre projecte, veureu que ara teniu una carpeta de construcció / contractes a sobre de la carpeta de contractes que conté fitxers two.json. Hauríeu de veure:
- HelloWorld.json
- Migrations.json
El fitxer.json a un nivell alt descriu el contracte desplegat i les seves funcions. Ens permet contextualitzar el contracte i anomenar-ne les funcions.
Si fem una ullada a l’interior, podem veure tota una sèrie d’informació:
Ens endinsem en aquesta informació més profundament al tercer pas, però alguna cosa important a tenir en compte és l’ABI.
La interfície binària d’aplicació és un esquema de codificació de dades utilitzat a Ethereum per treballar amb contractes intel·ligents.
Fent una ullada a la informació és relativament intuïtiu d’entendre. L’ABI també defineix com l’usuari pot trucar a les funcions, és a dir, la ubicació de la funció en relació amb l’adreça del contracte intel·ligent. Un resum d’alt nivell és el ABI és la descripció de la interfície del contracte. No conté codi i no té la capacitat d’executar-se per si sol. Aleshores teniu el bytecode, que és el codi EVM executable, però per si sol no té context.
És hora de migrar
D’acord!
Ara que tenim el ganache-cli en funcionament i hem compilat el nostre contracte intel·ligent, ara és el moment de migrar els nostres contractes!
al terminal, segueix endavant i corre
migrar la tòfona
SÍ! Ho vas fer!
Podem veure que hem desplegat amb èxit el nostre contracte intel·ligent. Podeu veure que es va generar informació realment útil i, si aneu a la vostra altra pestanya amb Ganachi-cli en execució, hauríeu de veure un rebut de transacció (feu una ullada per vosaltres mateixos).
Prova ETH
Abans d’anar a Remix, hem d’aconseguir una prova d’ETH per poder pagar les taxes de gasolina de Remix (no us preocupeu, això no us costarà diners).
Dirigeix-te a aquesta aixeta i agafa una mica de Rinkeby. Ens endinsem en quina prova es tracta de l’ETH al pas 3, però en aquest pas només sabem que utilitzarem Rinkeby, que és una xarxa de prova d’autoritat oposada a, per exemple, Ropsten, que és una prova de treball Testnet (que és més similar a la xarxa pública principal). net). Després de completar els passos 2 i 3, en tindreu alguns a la cartera MetaMask per experimentar!
Remix
D’acord, ara que tenim una prova EHT, és hora d’anar a Remix i desplegar el nostre contracte fora del nostre entorn local i fins i tot tenir la capacitat d’interactuar-hi!
“Què diables és el Remix?”
M’alegro que hagi preguntat!
Remix és una potent eina de codi obert que us ajuda a escriure contractes Solidity directament des del navegador. Un element realment sorprenent en particular sobre Remix és que admet tant l’ús al navegador com a nivell local. Remix admet proves, depuració i desplegament de contractes per citar algunes funcions clau. El remix s’hauria de considerar una eina bàsica per a un desenvolupador en el seu procés de construcció. Començar amb el desplegament local (com hem fet anteriorment) amb ganache és una base excel·lent, passant del desplegament local, podem experimentar i interactuar amb el nostre contracte a Remix..
Prendre les persuasions adequades i provar (una i altra vegada) el vostre desenvolupament abans d’un possible llançament a la xarxa principal d’ethereum us pot estalviar més que un mal de cap!
Ara prenem el mateix contracte i el desplegem fora del nostre entorn local mitjançant Remix
Enllaç aquí
El nostre contracte
Feu clic al fitxer nou i anomenem-lo HelloWorld.sol
(aquí teniu el contracte que tornarem a utilitzar)
solidesa del pragma >= 0,5,8 <0,7,0; contracte HelloWorld {string missatge públic; constructor (memòria de cadena initMessage) públic {missatge = initMessage; } actualització de la funció (memòria de cadena newMessage) pública {message = newMessage; }}
Ara podem seguir endavant i afegir el nostre contracte sobre el terreny. (Mireu-ho a continuació)
Consulteu ara el menú de l’esquerra que us demana la versió del compilador seleccionat.
Compilador
Tingueu en compte dins del nostre contracte que hem declarat la nostra gamma de compiladors.
Recordeu que la paraula clau pragma s’utilitza per habilitar determinades funcions o comprovacions del compilador.
Per tant, podem configurar el nostre compilador a 0.6.0, que es troba entre l’interval proporcionat (vegeu el cop)
El nostre contracte hauria de compilar-se automàticament, si no, continuar i fer clic a Compila HelloWorld.sol
A continuació, configurarem el nostre entorn per desplegar el nostre contracte!
Desplegar i executar transaccions
Medi ambient
Al seleccionar el vostre entorn, notareu algunes opcions diferents:
VM de JavaScript: Totes les transaccions s’executaran en una cadena de blocs de sandbox al navegador. Això vol dir que no es persistirà res quan torneu a carregar la pàgina. El JsVM és la seva pròpia cadena de blocs i en cada recàrrega començarà una nova cadena de blocs, l’antiga no es desarà.
Proveïdor injectat: Remix es connectarà a un proveïdor web3 injectat. Metamask és un exemple de proveïdor que injecta web3.
Proveïdor Web3: Remix es connectarà a un node remot. Haureu de proporcionar l’URL al proveïdor seleccionat: geth, paritat o qualsevol client d’Ethereum.
En aquest exemple utilitzarem: Injected Web3
Utilitzarem la nostra cartera MetaMask i ens assegurarem que estiguem connectats a la nostra xarxa de proves de Rinkeby
Podem veure a la part esquerra que estem connectats a Rinkeby i també veure l’adreça del nostre compte connectat!
Un cop ho tinguem tot definit, anem endavant i implementem el nostre contracte!
&# 127881; Ho hem fet! &# 127881;
Consulteu el terminal proporcionat i podreu veure la confirmació
Ara tenim la possibilitat de veure el nostre contracte desplegat, podem actualitzar el nostre missatge (hem de signar i pagar la taxa de gasolina per això ja que actualitzem l’estat)
Un cop tinguem confirmació, podrem veure que el nostre missatge s’ha actualitzat!
&# 129395; Ben fet! &# 129395;
Hem contractat localment el contracte amb què vam començar inicialment i l’hem desplegat a Remix per tenir una representació visual de la interacció del contracte. Aquest és un flux saludable per als desenvolupadors a mesura que comencen a construir-se en aquest espai. Remix és una eina increïble que s’ha d’utilitzar sovint. Al pas 3 farem un pas més enllà i lligarem tota la informació que hem après als passos 1 & 2 i lliga Trufa + Infura + Reacciona junts!
- Integració per a desenvolupadors: pas 1
Integració per a desenvolupadors: pas 1
Integració per a desenvolupadors: pas 3
Integració per a desenvolupadors: pas 3
Orientació Ethereum de 10 minuts