Slik lærer du soliditet: Den ultimate opplæringen for koding av Ethereum

Denne guiden vil lede deg trinn for trinn i læring av soliditet. For en grundig utforskning av soliditet kan du sjekke ut våre blockchain-kurs.

Ethereum Foundation har rystet blockchain-verdenen siden prosjektets tidlige dager, rundt slutten av 2013 og tidlig i 2014. Ethereum startet virkelig “Bitcoin 2.0” og det vi tenker på som “blockchain” -bevegelsen, etter den første store Bitcoin “boble” opp over $ 1000 USD på markedene fikk alles oppmerksomhet. Ethereum er et blockchain-prosjekt med en kryptovaluta, Ether, i likhet med Bitcoin, men Ethereum har den ekstra funksjonen til et (nesten) Turing-komplett virtuelt maskinspråk og prosesseringsevne innebygd i nodeimplementeringen.

Ethereum Virtual Machine (EVM) tillater Ethereum-noder å faktisk lagre og behandle data i bytte mot betaling, svare på hendelser i den virkelige verden og tillate mange nye muligheter for å støtte on-chain-applikasjoner som aldri før var tilgjengelige for utviklere og virkelige verdensbrukere. Jeg hadde flaks å faktisk være i Sveits tidlig i 2014, og få besøke et Ethereum “holon” ​​og henge med noen av Ethereum-grunnleggerne før Ether-token-salget, tilbake da de ble “selvfinansiert”.

Jeg spurte Mihai Alisie hva en eterisk smart kontrakt er, og han forklarte:

“Smarte kontrakter er en måte for mennesker over hele kloden å gjøre forretninger med hverandre, selv om de ikke snakker samme språk eller bruker samme valuta.”

Så det er virkelig det perspektivet jeg begynner med, ideen om at vi programmatisk kan definere reglene til en forretningskontrakt, på et enkelt maskinspråk, for å bringe mennesker sammen og la dem drive forretninger på en pålitelig, sikker og automatisert måte.

#Crypto ExchangeBenefits

1

Binance
Best exchange


VISIT SITE
  • ? The worlds biggest bitcoin exchange and altcoin crypto exchange in the world by volume.
  • Binance provides a crypto wallet for its traders, where they can store their electronic funds.

2

Coinbase
Ideal for newbies


Visit SITE
  • Coinbase is the largest U.S.-based cryptocurrency exchange, trading more than 30 cryptocurrencies.
  • Very high liquidity
  • Extremely simple user interface

3

eToro
Crypto + Trading

VISIT SITE
  • Multi-Asset Platform. Stocks, crypto, indices
  • eToro is the world’s leading social trading platform, with thousands of options for traders and investors.

Solidity Language i seg selv er et verktøy som vi bruker til å generere maskinnivåkode som kan kjøres på EVM, det er et språk med en kompilator som tar vår menneskelige lesbare kode på høyt nivå og deler den opp i enkle instruksjoner som “sette data i et register”, “legge til data fra to registre”, “hoppe tilbake til instruksjon på minnepunkt xxxxx”, som danner grunnlaget for hvilket som helst mikroprosessor-kjørbart program.

Så Soliditetsspråket er bare ett av flere språk som kan kompileres til EVM bytecode, et annet språk som gjør det samme kalles Slange. Hvert språk kan ha flere kompilatorverktøy, men de gjør alle det samme, det vil si å generere EVM-maskinkonsentrat-bytekode som skal kjøres på ethereum-nodene, for betaling.

Hvordan lære soliditet

#CRYPTO BROKERSBenefits

1

eToro
Best Crypto Broker

VISIT SITE
  • Multi-Asset Platform. Stocks, crypto, indices
  • eToro is the world’s leading social trading platform, with thousands of options for traders and investors.

2

Binance
Cryptocurrency Trading


VISIT SITE
  • ? Your new Favorite App for Cryptocurrency Trading. Buy, sell and trade cryptocurrency on the go
  • Binance provides a crypto wallet for its traders, where they can store their electronic funds.

#BITCOIN CASINOBenefits

1

Bitstarz
Best Crypto Casino

VISIT SITE
  • 2 BTC + 180 free spins First deposit bonus is 152% up to 2 BTC
  • Accepts both fiat currencies and cryptocurrencies

2

Bitcoincasino.io
Fast money transfers


VISIT SITE
  • Six supported cryptocurrencies.
  • 100% up to 0.1 BTC for the first
  • 50% up to 0.1 BTC for the second

Soliditet i seg selv er et ganske enkelt språk, så langt som programmeringsspråk.

Faktisk er det en målrettet slanket ned, løst skrevet språk med en syntaks som ligner på ECMAScript (Javascript). Det er noen viktige punkter å huske fra Begrunnelse for Ethereum Design dokumentet, nemlig at vi jobber innenfor en stack-and-memory-modell med en 32-byte instruksjonsordstørrelse, gir EVM oss tilgang til programmet “stable” som er som et registerrom hvor vi også kan feste minneadresser for å gjøre Program Counter loop / jump (for sekvensiell programkontroll), en utvidbar midlertidig “hukommelse” og en mer permanent “Oppbevaring” som faktisk er skrevet inn i den permanente blockchain, og viktigst av alt, EVM krever total determinisme innenfor smarte kontrakter.

Dette kravet til determinisme er grunnen til at du ikke vil se “tilfeldig ()” -funksjonen på fasthetsspråket. Når en “etereumblokk” blir “utvunnet”, blir distribusjon av smarte kontrakter og funksjonsanrop i den blokken (det vil si de som er stilt opp for å skje innen den siste varigheten av blokkeringen) utført på noden som utvinner blokken, og den nye tilstanden endres til lagringsplasser eller transaksjoner innenfor den smarte kontrakten faktisk skjer på den gruveknutepunktet. Deretter blir den nye blokken spredt ut til alle de andre nodene, og hver node prøver å uavhengig verifisere blokken, som inkluderer å gjøre de samme tilstandsendringene i deres lokale kopi av blockchain også. Her vil det mislykkes hvis smartkontrakten fungerer ikke-deterministisk. Hvis de andre nodene ikke kan bli enige om tilstanden til blockchain etter at den nye blokken og dens kontrakter blir utført, kan nettverket bokstavelig talt stoppe.

Dette er grunnen til at smarte kontrakter for eterum (og smarte kontrakter generelt i ethvert blockchain-system) må være deterministiske: slik at nettverket av noder alltid kan validere og opprettholde enighet om de nye blokkene som kommer inn, for å fortsette å kjøre.

En annen begrensning du finner i EVM-smarte kontrakter, er manglende evne til å få tilgang til data utenfor “minne” og “lagring”, (vi vil ikke at smartkontrakten skal kunne lese eller slette harddiskene til nodene den kjører på), og manglende evne til å spørre utenfor ressurser som med en JQuery. Vi har egentlig ikke tilgang til mange biblioteksfunksjoner som for å analysere JSON-strukturer eller gjøre flytende-aritmetikk, og det er faktisk kostnadskrevende å gjøre disse underrutinene eller lagre mye data i selve eterblokkjeden..

Når du ringer til en smart kontrakt som utfører noe statlig arbeid eller beregning (enhver handling i tillegg til bare å lese fra lagring), vil du pådra deg en gass ​​”koster” for arbeidet utført av den smarte kontrakten, og denne gasskostnaden er relatert til mengden beregningsarbeid som kreves for å utføre funksjonen din. Det er en slags “mikropenger for mikrocomputer” -system, der du kan forvente å betale en bestemt mengde gass for en bestemt mengde beregning, for alltid.

Prisen på gass i seg selv er ment å holde seg konstant, noe som betyr at når Ether går opp på de globale markedene, vil pris gass ​​mot eter skal gå ned. Når du utfører en funksjonsanrop til en smart-kontrakt, kan du få en estimering av mengden gass du må betale på forhånd, men du må også spesifisere pris (i eter per gass) som du er villig til å betale, og gruveknutepunktene kan bestemme om det er en god nok sats for at de skal hente smart-kontrakt-funksjonsanropet i neste blokk.

Smartkontrakter har sin egen adresse, hvorfra de kan motta og sende Ether. Smarte kontrakter kan spore funksjonen “innringeren” på en verifiserbar måte, slik at den kan avgjøre om en av funksjonene blir kalt av en privilegert “eier” eller “admin” -konto, og handle tilsvarende for administrative funksjoner. De har muligheten til å lese data fra ethereum blockchain, og få tilgang til informasjon om transaksjoner i eldre blokker. Men er smarte kontrakter “låst” i sin egen lille deterministiske verden, bare i stand til å være klar over data som er lagret i selve eterblokkjeden?

Ikke i det hele tatt! Det er hvor “Orakler” kom inn. Vi kan ringe til et orakel som vil fortelle oss noe om omverdenen på en pålitelig måte, og handle på grunnlag av disse dataene innenfor den smarte kontrakten. Nøkkelpunktet her er at selv om hendelser i den virkelige verden ikke er deterministiske, kan Oracle stole på å alltid svare på hver nodes forespørsel om hva som skjedde på en deterministisk måte, slik at alle noder fremdeles kan komme til enighet. Så dette fungerer den pålitelige Oracle i teorien: et “orakel” vil ta noen data, si en ticker-feed om en reell aksjekurs, og registrere dataene i “lagring” i en enkel Oracle smart-kontrakt, noe som dette

(se også forklaringen her):

function storeTickerData (bytes8 symbol, uint åpen, uint høy, uint lav, uint lukk)

onlyOracle

returnerer (bool suksess)

{

# lagre ticker data on-chain

tickerData [symbol] [block.number] = [åpen, høy, lav, lukk]

# tickerData er et kart over kart, streng => uint => array [uint, uint, uint, uint]

returner sant;

}

Det er selskaper som spesialiserer seg i å være det pålitelige oraklet, og designe systemer for å skille seg fra å måtte stole på datafeed. Hvis vi tar en titt på Oraclize dokumentasjon vi ser dette interessante sitatet:

Spesielt er ikke målet å tvinge smarte kontraktutviklere til å måtte stole på Oraclize med dataene de trenger. Uten støtte fra ektheten kunne Oraclize lett tukle med dataene. For å fullføre denne komplekse oppgaven, returnerer Oraclize de forespurte dataene sammen med et bevis på ektheten: det vil si at dataene kommer fra dataleverandøren som har blitt eksplisitt krevd av den smarte kontrakten..

Så du bør sjekke ut denne dokumentseksjonen om “ekthetsbevis” for mer informasjon, men ideen er at selv når nye eterinnerder, på et fjernt tidspunkt i fremtiden, spinner opp eterumnodene og begynner å synkronisere blokkjedene til nettverket , alle dataene de trenger for å utføre alle de “orakelavhengige” smarte kontraktene, kan de lastes ned trygt for alltid. Spørsmålet om hvem som betaler “gassen” for oraklet for å gjøre all denne dataskrivingen om hendelser i den virkelige verden (blockchain-lagring “tilstandsendring” koster bensin) er et annet tema, men i utgangspunktet blir det forskuddsbetalt av databehandleren i en av flere måter. Det kule her er at selv om vi ikke kan skrive en smart-kontrakt som “kaster terninger” i betydningen av å inkludere faktisk tilfeldighet, er faktisk mulig å skrive en smart kontrakt som reagerer på kastet av en terning, som betjent av et orakel.

Grunnleggende om soliditet

Grunnleggende kodebakgrunn og oppsett

Så la oss komme i gang med en grunnleggende etereum-smartkontrakt, skrevet på Solidity-språk. Den beste måten å lære er å gjøre! Vi kan se fra det lille kodebiten ovenfor at vi har en ganske enkel funksjonsdeklarasjonssyntaks, og noen grunnleggende datatyper som ‘uint’ (usignert heltall) og ‘streng’, og vi ser i dokumentene at vi også har variabeltyper som ‘adresse’, som inneholder ‘.balanse’ og ‘.transfer’ -metoder, som forutsigbart returnerer balansen på et Ethereum adresse, og la smartkontrakten faktisk sende Ether til den adressen, med enheter pålydende Wei.

Vi har dine grunnleggende matriser, enums, operatorer, hash-datastrukturer kalt ‘mappings’, og noen spesielle forhåndsdefinerte enheter og globale vars som inkluderer ting som blokkhøyde, tidsstempel for siste blokk og noen praktiske SHA-hash- og adresse- / nøkkelmanipuleringsfunksjoner. En viktig særeie om soliditet når du arbeider med flerdimensjonale matriser: indeksering er i “omvendt” rekkefølge fra de fleste språk bare under erklæring, som nevnt i dokumentene:

En matrise med fast størrelse k og elementtype T skrives som T [k], en matrise med dynamisk størrelse som T []. Som et eksempel er en matrise med 5 dynamiske matriser av uint uint [] [5] (merk at notasjonen er omvendt sammenlignet med noen andre språk). For å få tilgang til den andre uinten i den tredje dynamiske matrisen, bruker du x [2] [1] (indeksene er nullbaserte og tilgang fungerer på motsatt måte av erklæringen …)

Ok, vi har nok grunnleggende verktøy her for å være farlige. La oss komme i gang. La oss gjøre en slags grunnleggende sosial app der folk kan ha noen bilder og litt grunnleggende informasjon om seg selv lagt ut i blockchain. Hver bruker vil ha en etereadresse og et “håndtak” eller brukernavn knyttet til kontoen sin. Vi har noen grunnleggende demografiske data som folk kan eller ikke kan legge inn, og så har vi en enkel søkeside der du kan slå opp brukere i en grunnleggende katalog, og sjekke ut bildene de har lagt til / notarisert til brukeren. profil.

Her er et bilde av hvordan det endelige brukergrensesnittproduktet vårt for eteritet Solidity smart-contract Decentralized App (Ðapp) vil se ut, med brukere og notariserte bilder lagt til:

Hvordan lære soliditet: Den ultimate Ethereum-kodingsveiledningen

Jeg har autorisert et fint bilde av meg selv for dere, og et bilde av en Galium Arsenide Crystal-struktur fra skoledagene mine for dere. Du kan se SH256 notary hashes og tidsstempler for hvert bilde og et lite hake som indikerer at de notariserte bildedataene fremdeles samsvarer med notary hash som ble opprettet i den angitte tidsstempelet. Så jeg kommer til å gå gjennom hvordan jeg bygget denne appen, og påpeke interessante ting for deg, med alle koblingene og kodeeksemplene du trenger for fremtidig referanse. Høres bra? La oss gå!

Det første jeg skal gjøre er å sette opp en Trøffel “Test-seng” som gjør at jeg enkelt kan teste kompilering av min smarte kontrakt. Å kompilere og distribuere smarte kontrakter innebærer å generere lange signerte transaksjoner, men Truffle vil tillate meg å kompilere / distribuere og teste smartkontrakten min ved hjelp av enkle kommandoer. Det er en rekke verktøy som kan gjøre dette, men jeg liker tilfeldigvis denne opplæringen om smart solid-kontrakt-video som bruker Trøffel verktøy. Jeg har en demo github-prosjekt mappen jeg har laget akkurat for denne opplæringen, slik at alle kan følge med. Jeg begynner med noen enkle oppsettkommandoer (under et Debian Linux-miljø):

tectract @ blockgeeks / ethereum-demo-verktøy> npm i -g trøffel

# hvis du støter på tillatelsesfeil globalt ved å installere nodemoduler, se her

tectract @ blockgeeks / ethereum-demo-verktøy> mkdir Geekt # Jeg skal ringe den sosiale applikasjonen min "Geekt"

tectract @ blockgeeks / ethereum-demo-verktøy> cd Geekt

tectract @ blockgeeks / ethereum-demo-tools / Geekt> truffle init # dette skaper noen få mapper og oppsettfiler i Geekt / mappen

tectract @ blockgeeks / ethereum-demo-tools / Geekt > ls

kontrakter migrasjoner test truffle.js # vi har opprettet tre mapper, og en ny fil kalt truffle.js

tectract @ blockgeeks / ethereum-demo-tools / Geekt > Våre kontrakter /

ConvertLib.sol MetaCoin.sol Migrations.sol # vi har noen grunnleggende malkontrakter generert av Truffle

tectract @ blockgeeks / ethereum-demo-tools / Geekt > er migrasjoner /

1_initial_migration.js 2_deploy_contracts.js # et par filer for kompilerings- / migreringsinnstillinger med Truffle

Et enkelt soliditetseksempel på soliditet

Ok, jeg skal lage en kontrakt som heter Geekt.sol, i / Geekt / contract-mappen som ble generert da jeg kalte ‘truffle init’. Du kan se full kontraktskode her, og jeg vil peke på de mest interessante bitene her. Øverst i filen har vi en linje som spesifiserer kompilatorversjonen og noen grunnleggende kontraktsdefinisjonssyntaks og variabeldefinisjoner.

pragmasoliditet ^ 0.4.4;

kontrakt Geekt {

adresse GeektAdmin;

kartlegging (bytes32 => notarizedImage) notarizedImages; // dette gjør det mulig å slå opp notarizedImages av deres SHA256notaryHash

bytes32 [] imagesByNotaryHash; // dette er som en hvit side av alle bilder, av SHA256notaryHash

kartlegging (adresse => Bruker) brukere; // dette gjør det mulig å slå opp brukere etter deres etereadresse

adresse [] brukereByAddress; // dette er som en hvit side for alle brukere, etter ethereum-adresse

Når du kaller en tilstandsendrende funksjon i den virkelige verden, må du spesifisere hvor mye eter du vil betale for det, men heldigvis kan du be om et estimat av kostnadene når det gjelder bensinkostnad og gasspris ( i gass / eter) på forhånd, og det er vanligvis veldig nøyaktig. Ethereum gruvearbeidere vil bestemme om du har betalt nok, og inkludere din statlige transaksjon i neste blokk, så du må faktisk vente på at disse funksjonene skal komme tilbake når neste blokk er funnet. Å lese data ut av disse “lagringsstrukturene” er gratis, og du trenger ikke å vente på neste blokk heller, noder vil bare lese dataene og returnere dem til deg med en gang.

Brukere kartlegging er vårt viktigste lagringsobjekt som lar oss lage brukerobjekter og slå dem opp etter adresse. Kartlegginger er supereffektive for å lagre data og hente dem raskt, men det er ingen enkel måte å gjenta et kart på, så du kan se at jeg også opprettet en brukereByAddress adressefelt som inneholder alle kjente adresser til en bruker i systemet vårt, som hvite sider for alle brukere. Jeg opprettet

Jeg opprettet notarized Images kartlegging for å tillate oss å lage “image” -objekter i lagring og slå dem opp med en tilknyttet SHA256-hash av bildedataene, og disse notaryHash-indeksene er 32 byte lange.

Vi har også en ImagesByNotaryHash bytes32-array som er en liste over alle notaryHashes, som hvite sider som lar oss gjenta alle bildene som er godkjent.

struct notarizedImage {

streng imageURL;

uint timeStamp;

}

struct User {

streng håndtak;

bytes32 by;

bytes32-tilstand;

bytes32 land;

bytes32 [] myImages;

}

Disse (over) er veldig grunnleggende strukturer, og de representerer også “lagrings” -objekter, så de koster ekte eter å “lage” og dataene i dem lagres faktisk i ethereum blockchain, og det koster ekte eter å endre “tilstanden” ”Av deres interne variabler. Vi brukte egentlig bare ytre kartlegginger og matriser for å holde rede på hvor i blockchain-minnet disse bildene / brukerstrukturene ligger. Våre notarizedImage struct lagrer ganske enkelt en URL til et bilde, et sted på nettet antagelig, og en tidsstempel som varsler når bildet ble notarisert. Våre Bruker struct lagrer noen grunnleggende brukere: håndtak, by, delstat, land, og den lagrer også en rekke bilder som brukeren har godkjent og “lagt til” i brukerkontoen, som en mini-bruker-for-bruker-versjon av den globale imagesByNotaryHash objekt med hvite sider.

funksjonsregisterNy bruker (strenghåndtak, bytes32 by, bytes32 tilstand, bytes32 land) returnerer (bool suksess) {

adresse thisNewAddress = msg.sender;

// ikke overskriv eksisterende oppføringer, og sørg for at håndtaket ikke er null

hvis (byte (Brukere [msg.sender] .håndtak) .lengde == 0 && byte (håndtak) .lengde! = 0) {

Brukere [thisNewAddress] .handle = håndtak;

Brukere [thisNewAddress] .city = by;

Brukere [thisNewAddress] .state = state;

Brukere [thisNewAddress] .country = land;

usersByAddress.push (thisNewAddress); // legger til en oppføring for denne brukeren til brukeren ‘whitepages’

returner sant;

} annet {

returner falsk; // enten håndtaket var null, eller det eksisterte allerede en bruker med dette håndtaket

}

}

Her er vår registerNewUser funksjon. Det tar håndtak, by, stat, land som inputvariabler og returnerer sant eller usant for å indikere suksess eller fiasko. Hvorfor skulle det mislykkes? Vel, vi vil ikke tillate brukere å overskrive hverandres håndtak, så dette kommer til å bli som et første krav system for håndtak. Hvis en bruker med dette håndtaket allerede eksisterer, returnerer vi null, så jeg har plassert en “if” -linje der for å se etter det. Vi tillater heller ikke oppretting av et brukernavn uten håndtak. En ting vi bemerker er thisNewAddress som er den som ringer til funksjonen, kan du se at vi bruker spesialen msg.sender funksjon for å hente dataene, dette er adressen som “gjør denne funksjonen” -transaksjonen ble sendt fra når noen (noen) kaller vår smart-contract-funksjon, og de betaler virkelig eter for å gjøre det. Så et “kartleggings” -objekt er null som standard, og når vi ringer:

Brukere [thisNewAddress] .handle = håndtak;

Dette skaper et nytt brukerobjekt, i vår brukerkartlegging, og setter håndtaket. Samme med by, stat, land. Vær oppmerksom på at vi også skyver den nye brukerens adresse inn i brukernesByAddress globale brukere “hvite sider” -objekt før vi kommer tilbake til det der.

funksjon addImageToUser (streng imageURL, bytes32 SHA256notaryHash) returnerer (bool suksess) {

adresse thisNewAddress = msg.sender;

if (bytes (Users [thisNewAddress] .handle) .length! = 0) {// sørg for at denne brukeren først har opprettet en konto

hvis (bytes (imageURL) .length! = 0) {//) {// ikke kunne få bytes32 null-sjekk til å fungere, å vel!

// forhindre brukere i å kjempe om sha->bildeoppføringer på de hvite sidene, men tillater dem likevel å legge til en personlig referanse til hvilken som helst sha

if (bytes (notarizedImages [SHA256notaryHash] .imageURL) .length == 0) {

imagesByNotaryHash.push (SHA256notaryHash); // legger til oppføring for dette bildet i bildesidesidene våre

}

notarizedImages [SHA256notaryHash] .imageURL = imageURL;

notarizedImages [SHA256notaryHash] .timeStamp = block.timestamp; // merk at oppdatering av et bilde også oppdaterer tidsstempelet

Brukere [thisNewAddress] .myImages.push (SHA256notaryHash); // legg til bildeshash til denne brukerne .myImages-array

returner sant;

} annet {

returner falsk; // enten imageURL eller SHA256notaryHash var null, kunne ikke lagre bildet

}

returner sant;

} annet {

returner falsk; // bruker hadde ikke en konto ennå, kunne ikke lagre bildet

}

}

Våre addImageToUser til brukerfunksjon er ganske lik registerNewUser funksjon. Det ser deg opp etter sendeadressen din via spesialen msg.sender objekt og sjekker at det er en registrert bruker (ved håndtak) for den adressen før den prøver å legge til et bilde for brukeroppføringen din. Vi tillater brukere å legge til notaryHash til de globale hvite sidene til bilder bare hvis den ikke eksisterer, for å forhindre brukere i å kjempe om oppføringer på de globale hvite sidene, men vi tillater dem å legge til / oppdatere enhver notaryHash-oppføring i deres egne mini-hvite sider av sine egne bilder. Ingenting til det!

function getUsers () konstant retur (adresse []) {return usersByAddress; }

funksjonen getUser (adresse userAddress) konstant returnerer (streng, bytes32, bytes32, bytes32, bytes32 []) {

returnere (Brukere [brukerAdresse] .håndtak, Brukere [brukerAdresse] .by, Brukere [brukerAdresse] .stat, Brukere [brukerAdresse] .land, Brukere [brukerAdresse] .myImages);

}

funksjon getAllImages () konstant retur (bytes32 []) {return imagesByNotaryHash; }

funksjon getUserImages (adresse userAddress) konstant retur (bytes32 []) {return Brukere [userAddress] .myImages; }

funksjon getImage (bytes32 SHA256notaryHash) konstant retur (streng, uint) {

retur (notarizedImages [SHA256notaryHash] .imageURL, notarizedImages [SHA256notaryHash] .timeStamp);

}

Til slutt tillater (over) tilgangsfunksjonene oss å bare lese opp hver bruker eller bilde, eller få fullstendige hvite sidelister over alle brukere eller alle bilder. Legg merke til at disse funksjonene kommer tilbake konstant data, som i utgangspunktet betyr at de er skrivebeskyttet, ikke “endrer seg” og at de er gratis å ringe og de returnerer dataene med en gang, trenger du ikke å vente til neste blokkering. Vi kaller i utgangspunktet bare inn våre globale kartlegginger / arrays og returnerer relevante data: brukere etter adresse eller bilder av notaryHash.

Kompilering & Testing av en Smart-kontrakt

Nå ønsker vi å teste smartkontrakten vår lokalt, i et testmiljø. Det er veldig enkelt å bruke enkle trøffelkommandoer, men først trenger vi faktisk en lokal etereumnode å teste mot. Det er hvor Ethereum TestRPC kommer inn. TestRPC er i utgangspunktet en falsk node, et slank program som bare later til å være en node og reagerer som en node ville svare på din lokale vertsmaskin. TestRPC kjører på port 8545 som en vanlig etereumnode, og den har muligheten til å kompilere Solidity-smarte kontrakter i EVM-kode og kjøre den koden også, pluss at du får øyeblikkelige svar for testing, i stedet for å måtte vente på det virkelige eterinnettverket finn neste blokk. Nå kan du kjøre kommandoer for Truffle-testkompilering / distribusjon mot en ekte etereumnode, men det vil koste ekte Ether, pluss det er tidkrevende og minnekrevende å kjøre din egen node hvis du ikke trenger det. Så vi gjør noen få installasjonskommandoer raskt:

npm i -g ethereum-testrpc

testrpc -m “prøve hund kommer år spray gjennomgang lære generelt oppdage sølv gelé pilot”

Dette starter TestRPC med en spesifisert “seed” -frase, og du bør se noe som dette som utdata:

EthereumJS TestRPC v3.0.5

Tilgjengelige kontoer

===================

(0) 0x0ac21f1a6fe22241ccd3af85477e5358ac5847c2

(1) 0xb0a36610de0912f2ee794d7f326acc4b3d4bc7bc

(9) 0x4c1cc45ef231158947639c1eabec5c5cb187401c

Private nøkler

===================

(0) 91e639bd434790e1d4dc4dca95311375007617df501e8c9c250e6a001689f2c7

(1) afaeff0fc68439c4057b09ef1807aaf4e695294db57bd631ce0ddd2e8332eea7

(9) dcc51540372fa2cf808efd322c5e158ad5b0dbf330a809c79b540f553c6243d7

HD lommebok

===================

Mnemonic: prøve hund kommer år spray crawl lære generelt oppdage sølv gelé pilot

Base HD-bane: m / 44 ‘/ 60’ / 0 ‘/ 0 / {account_index}

Lytter på lokal vert: 8545

Du vil se litt aktivitet her i dette vinduet mens TestRPC kjører når du distribuerer og interagerer med smartkontrakten din via Truffle eller Web3.js. Ok, vi er klare for distribusjon av test. Du må endre filen /migrations/2_deploy_contracts.js å inkludere navnet på smartkontrakten din, for trøffel å vite å kompilere og distribuere den. Vi gjør denne kommandoen:

trøffel kompilerer

Hvis alt går bra, vil du se en melding om at det er “lagring av gjenstander”, og ingen feilmeldinger. Jeg kommer ikke til å lyve. Hvis kontrakten din har syntaksfeil eller andre problemer, vil kompilatorfeilmeldingene du ser sannsynligvis være mystiske og vanskelig å tolke! Hvis du får en feil om “stakkstørrelsen”, betyr det sannsynligvis at du har for mange variabler som sendes inn / ut av et funksjonsanrop, en god regel å huske er at 16 variabler som er inn- eller utdata er maks, generelt. Husk også at smidighetskontrakter med soliditet ikke kan returnere egendefinerte strukturdatatyper, så du må også omgå det, vanligvis returnerer jeg bare matriser og peker / adresser til andre strukturer i de interne tilordningene mine. Hvis du får kjøretid feilmelding om “stacken”, det kan bety at du har en dårlig betinget kode.

trøffel migrerer

Denne kommandoen (over) utfører faktisk distribusjonen av smartkontrakten din på TestRPC-noden din. Jeg ser denne utgangen returnere:

Kjører migrasjon: 1_initial_migration.js

Implementere migrasjoner…

Migrasjoner: 0xd06a1935230c5bae8c7ecf75fbf4f17a04564ed8

Lagrer vellykket migrering til nettverket…

Lagrer gjenstander…

Kjører migrasjon: 2_deploy_contracts.js

Implementerer Geekt…

Geekt: 0xe70ff0fa937a25d5dd4172318fa1593baba5a027

Lagrer vellykket migrering til nettverket…

Lagrer gjenstander..

Vår smarte kontrakt (kalt “Geekt”) får en adresse på Ethereum blockchain når den distribueres med suksess. Du kan se ovenfor, adressen er 0xe70ff0fa937a25d5dd4172318fa1593baba5a027. På et ekte, live eterinnettverk betaler du bensin for å distribuere kontrakten, og adressen endres aldri. Hvis du lukker TestRPC, vil den glemme alt på TestRPC, og når du starter TestRPC på nytt, må du distribuere kontrakten på nytt, og du får en annen adresse for smartkontrakten. Adressen til smartkontrakten din er der folk kan sende transaksjoner med meldinger for å samhandle med den, for å gjøre statlige transaksjoner eller bare lese data ut av etherum blockchain. Smarte kontrakter kan også samhandle direkte med hverandre via disse adressene, ved hjelp av “meldinger”. Smarte kontrakter som samhandler med andre smarte kontrakter for å lagre, endre eller lese data via disse eteriske blockchain-“meldinger” er kjent Desentraliserte autonome organisasjoner, eller DAO’er.

Ok, nå kommer den morsomme delen. Vi er klare til å faktisk gjøre noen innledende tester og samhandle med smartkontrakten vår. Vi starter Truffle-konsollen og gjør noen spørsmål mot TestRPC-lokalhostnoden vår, for å sikre at alt fungerer, og vi kan legge til brukere og bilder og hente dem ordentlig.

trøffelkonsoll

> Geekt = Geekt. Distribuert ()

> Geekt.then (funksjon (forekomst) {retur JSON.stringify (forekomst.abi);})

> Geekt.then (funksjon (forekomst) {return instance.registerNewUser ("Tektrakt","Denver","CO","USA");})

> Geekt.then (function (instance) {return instance.addImageToUser (‘www.myimageURL.com’, ‘0x6c3e007e281f6948b37c511a11e43c8026d2a16a8a45fed4e83379b66b0ab927’);})

> Geekt.then (function (instance) {return instance.getUser (‘0x0ac21f1a6fe22241ccd3af85477e5358ac5847c2’);}) > Geekt.then (funksjon (forekomst) {retur forekomst.getUsers ();})

> Geekt.then (funksjon (forekomst) {retur forekomst.getImages ();})

> Geekt.then (function (instance) {return instance.getImage (‘0x6c3e007e281f6948b37c511a11e43c8026d2a16a8a45fed4e83379b66b0ab927’);})

Et viktig konsept her er ABI, som er et javascript-formatert objekt som beskriver funksjonsnavn og innganger / utganger for å samhandle med smart-kontrakten din, det er omtrent som API-beskrivelse (Application Programmer Interface) for din smart-kontrakt, som forteller folk hvordan de skal lage meldinger for det. Min registerNewUser () -funksjon fungerer! Jeg ser dette som svar på registeroppdateringen () av ​​brukeren () i konsollvinduet:

{tx: ‘0x1b9f55971871921ccd23a9aa7620620c6c958a893af334087283926d4c6d60b1’,

kvittering:

{transactionHash: ‘0x1b9f55971871921ccd23a9aa7620620c6c958a893af334087283926d4c6d60b1’,

transactionIndex: 0,

blockHash: ‘0x2be4fab68daaf8db199e2a6adea101c0f1ed06f46aba21e8e4c06e752ca3325c’,

blockNumber: 5,

gassBrukt: 145215,

cumulativeGasUsed: 145215,

contractAddress: null,

tømmerstokker: [] },

tømmerstokker: [] }

AddImageToUser () -funksjonen returnerer suksess på samme måte, og når jeg nå kan hente individuelle brukerposter eller notariserte bildeposter fra ethereum blockchain. Funksjonssamtalen min getUser () returnerer:

[‘Tektrakt’,

‘0x44656e76657200000000000000000000000000000000000000000000000000000000’,

‘0x434f0000000000000000000000000000000000000000000000000000000000000000’,

‘0x55534100000000000000000000000000000000000000000000000000000000000000’,

[‘0x6c3e007e281f6948b37c511a11e43c8026d2a16a8a45fed4e83379b66b0ab927’]]

og jeg kan hente bildedataene via 32-byte SHA256Notary hash-strengen jeg har assosiert med den, min getImage () -funksjon returnerer:

[‘www.myimageURL.com’,

{[String: ‘1496256315’] s: 1, e: 9, c: [1496256315]}]

Alt dette ser bra ut. Alt fungerer, testet i TestRPC og Truffle, og vi er klare til å faktisk bygge et kult grafisk brukergrensesnitt for vår Ðapp slik at verden kan samhandle med brukerregistreringen og bildeadministratoren vår på ethereum blockchain.

Grunnleggende Ethereum ÐApp Design

Localhost Design & Testing

Vi er klare til å sette i gang, vår soliditetsspråklige smarte kontrakt er vellykket utarbeidet og distribuert til vår lokale testRPC ethereum node. Nå kan vi raskt bygge en enkel ÐApp som lar brukerne samhandle med smart-kontrakten via nettleseren sin, ved hjelp av noen grunnleggende webprogrammering og den spesielle Web3.js javascript-modul, laget spesielt for å samhandle med Ethereum-noder og smarte kontrakter over nettet.

jeg har laget denne demoen (open source github repositories) som en referanse for folk å bruke mens de bygger Ethereum ÐApps ved hjelp av web3.js. Denne demoen ble laget med et brukervennlig verktøy kalt Opprett-reager-app, den bruker et Facebook-internt webspråk React, men vi fokuserer ikke på noen React-kode, bare de javascript-kommandoene web.js som trengs. Koden min er i CommonJS, den er nesten nøyaktig den samme som vanlig ES6-javascript.

Så i webappen din installerer du nodemodulen web3 via en kommando som “npm i -S web3”, og den lagres i package.json-filen din, hvis du bruker en. Så du vil ha, inne i en “” -kode eller i en .js-fil, en linje som denne for å laste selve web3-modulen:

importere Web3 fra ‘web3’;

(eller i ES6-javascript)

var Web3 = krever (‘web3’);

Vi må fortelle Web3 om noen detaljer om vår node og vår smarte kontrakt, slik at den kan koble til. Du ser linjer som dette:

# denne linjen spesifiserer IP-adressen til lokalhostnoden: portinnstillinger

var web3 = ny Web3 (ny Web3.providers.HttpProvider ("http: // localhost: 8545"));

# vår smartkontraktadresse, ovenfra

var GeektAddress = ‘0xe70ff0fa937a25d5dd4172318fa1593baba5a027’;

# vår smarte kontrakt ABI, som rå javascript-objekt, ikke sitert streng!

var GeektABI = [{"konstant":ekte,"innganger": [],"Navn":"getUsers","utganger": [{"Navn":"", (…)

# dette laster smartkontrakten inn i web3-objektet vårt

GeektContract = web3.eth.contract (GeektABI) .at (GeektAddress);

# dette finner standardkontoen som er oppført for nodeforbindelsen (konto 0 fra TestRPC ovenfor)

defaultAccount = web3.eth.accounts [0];

Her er noen linjer som viser skrivebeskyttede funksjoner som grensesnitt med vår smarte kontrakt, via web3:

# funksjonen nedenfor er aktivert når siden lastes inn, for å hente "hvite sider" av alle kjente brukeradresser

GeektContract.getUsers (funksjon (err, usersResult) {

# funksjonen nedenfor tar et bilde etter behov, og lagrer dem i nettleserminnet…

GeektContract.getImage (imageHash, function (err, imageResult) {

Denne enkle demonstrasjonen ÐApp laster bare inn alle de kjente brukeradressene og tar tak i de faktiske detaljene for brukerbildet, og bildet registrerer seg selv etter behov. Her er et skjermbilde:

Hvordan lære soliditet: Den ultimate Ethereum-kodingsveiledningen

På dette punktet (bildet over) har jeg oppdatert TestRPC-klienten min og nettopp utført “truffle migrate” -kommandoen som distribuerer smartkontrakten mot min lokale host TestRPC-node. Du kan se at grensesnittet er klart for meg å klikke på knappen og “registrere” den første brukeren. Når jeg klikker på dette knappen, blir registerNewUser () -funksjonen min fra smart-kontrakten kalt, og legger til disse brukerdataene til min (localhost testing) ethereum blockchain-node på smartkontraktsadressen vi noterte ovenfor. Å legge til brukerdata til “lagring” av blockchain vil koste bensin, og vi må finne ut hvor mye gass vi skal betale, i stedet for bare å ta et vitenskapelig vill-giss (SWAG). Her er koden som faktisk blir kalt når denne “Signer gjestebok” -knappen blir klikket:

GeektContract.registerNewUser.estimateGas (

outerThis.state.defaultHandle,

outerThis.state.defaultCity,

outerThis.state.defaultState,

outerThis.state.defaultCountry,

{from: defaultAccount},

funksjon (feil, resultat) {

var myGasNum = resultat;

GeektContract.registerNewUser.sendTransaction (

outerThis.state.defaultHandle,

outerThis.state.defaultCity,

outerThis.state.defaultState,

outerThis.state.defaultCountry,

{from: defaultAccount, gas: myGasNum},

funksjon (feil, resultat) {

Så du kan se at når vi gjør en statlig endringstransaksjon som vi faktisk må betale for med etergummi (ekte eller testnettgass), vil vi kalle dette registerNewUser.estimateGas () funksjon før hånden, og bruk deretter den estimerte mengden gass når vi kaller den tilstandsendrende funksjonen på ekte, ved hjelp av registerNewUser.sendTransaction () funksjon.

Da vi startet TestRPC og det spytter ut noen testlommebokadresser for oss, er disse kontoene lik kontoen du ville hatt hvis du kjørte en full node og gjorde en getAccounts RPC-kommando mot den, som en full-node lommebok. TestRPC gir deg noen gratis testnetmynter, 100 testnet Ether per konto når den starter opp.

Når vi kaller disse tilstandsendrende funksjonene som registerNewUser () eller addImageToUser (), i testfasen localhost, mot TestRPC-noden vår, betaler TestRPC bare testnettgassen for deg og returnerer resultatet av transaksjonen med en gang. På en full lokalhostnode må du “låse opp” kontoen før transaksjonen vil lykkes på mainnet, og du må vente på mainnet til neste blokk for å hente transaksjonen, forutsatt at bensinanslaget vårt var nok! Men det er alltid en bedre måte, vennene mine &# x1f642;

Tilkobling av Ðapp til Mainnet

Jeg har satt opp og distribuert smart-kontrakt på ethereum Mainnet, og denne demo-appen på en av webserverne mine, på www.enledger.io/etherereum-demo-tools. Hvis du besøker dette nettstedet og ikke har en TestRPC eller full ethereum-node som kjører på localhost: 8545, og du besøker dette nettstedet, vil du sannsynligvis se noe sånt:

Sagforbindelse til nettverk: !

Så standard konto: (ingen web3.eth nodelink)

Så betyr dette at du trenger en full etereumnode som kjører, eller en Virtual Private Server (VPS) full node for å koble til, for å kunne samhandle med ethereum Mainnet? Inntil nylig var det sant, men nå har vi denne flotte krompluggen kalt Metamask (for Chrome-nettleseren), som lar deg koble til ethereum Mainnet i nettleseren din, og Metamask-gutta gir i utgangspunktet en forbindelse til en full node for deg , akkurat der, gratis, så rekvisitter til dem!

Du kan se i koden min at jeg oppdager det spesielle “injiserte” web3-objektet fra metamask-pluginet som setter opp nodeforbindelsen til deres fullstendige node. Her er den relevante koden som automatisk bytter til din vanlige klient (localhost) eller metamask web3-tilkobling:

funksjon loadWeb3 () {

la web3Injected = window.web3;

hvis (typeof web3Injected! == ‘udefinert’) {

console.log ("sag injisert web3!");

web3 = ny Web3 (web3Injected.currentProvider);

} annet {

console.log ("så ikke web3 injisert!");

web3 = ny Web3 (ny Web3.providers.HttpProvider ("http: // localhost: 8545"));

}

}

På bildet nedenfor, merk deg Metamask Fox-logoen øverst til høyre, jeg har installert Metamask Plugin og koblet til ethereum Mainnet i nettleseren min! Du kan se at jeg allerede har lagt til et par brukere i gjesteboken i “Geekt” Guestbook demo smart-contract. ÐApp-grensesnittet lar deg velge brukere og bla gjennom bildene deres, og du vil se Sign Guestbook-siden hvis du kobler til fra en adresse som ikke har registrert en bruker ennå.

Jeg la til litt kode slik at du bare kan lime inn URL-en til et bilde du vil legge til i brukerkontoen din, og det vil hente SHA256 notarihash for at du skal legge til i bildet, og det vil også sjekke SHA256 notarihash av bilder når de er lastet inn på siden, og gir deg et lite grønt hakemerke eller et rødt ‘X’ basert på om bildet på den nettadressen og notarihash fortsatt samsvarer. Jeg legger til “BlockGeeks” -logobildet under Ryan M.-brukerkontoen min her, og jeg har klikket på knappen for å legge til bildet for denne brukeren.

Metamask-pluginet har oppdaget at jeg trenger å betale for denne web3-eterumtransaksjonen med ekte Ethereum-gass, og den har dukket opp et lite vindu for å be meg om jeg vil godta denne transaksjonen. Jeg har sendt litt ekte Ether til denne Metamask-lommeboken, og den har nok til å fjerne transaksjonen, så jeg klikker ‘godta’.

Hvordan lære soliditet: Den ultimate Ethereum-kodingsveiledningen

Endelige tanker, dype refleksjoner

Det er det, det fungerer! Denne demo-artikkelen og kodelageret skal i stor grad hjelpe deg med å bli et flott Ethereum Solidity Language og ÐApp-utvikler! Du kan installere Metamask Plugin, koble til Ethereum Mainnet og besøke www.enledger.io/etherereum-demo-tools og du vil se Gjesteboken / Notary Demo-appen min og de samme brukerne og bildene, og du kan til og med signere gjesteboken og notere bilder også, hvis du vil &# x1f642;

Bare slik at dere ikke blir for ute av kontroll med denne tingen, la jeg til litt moderasjonsevne til “eieren” av smartkontrakten, som jeg har satt internt til adressen til den som opprinnelig betalte for å distribuere smarten. kontrakt til mainnet, som er meg. Jeg vil vise deg veldig raskt hvordan den spesielle adminfunksjonen fungerer fordi det er ganske vanlig å se denne typen admin-brukerkodemønster:

adresse GeektAdmin;

funksjon Geekt () betales {// dette er KONSTRUKTØREN (samme navn som kontrakten) den blir kalt EN gang når kontrakten først distribueres

GeektAdmin = msg.sender; // bare sett administratoren, slik at de kan fjerne dårlige brukere eller bilder om nødvendig, men ingen andre kan

}

bare modifikatorAdmin () {

hvis (msg.sender! = GeektAdmin)

kaste;

// Ikke glem "_;"! Den vil bli erstattet av den faktiske funksjonen når modifikatoren brukes.

_;

}

funksjon removeUser (adresse badUser) bareAdmin returnerer (bool suksess) {

slett brukere [badUser];

returner sant;

}

funksjon removeImage (bytes32 badImage) bareAdmin returnerer (bool suksess) {

slett notarizedImages [badImage];

returner sant;

}

Vi har en spesiell konstruktorfunksjon, Geekt (), med samme navn som selve kontrakten, som bare blir kalt en gang, når kontrakten først distribueres til blockchain. Denne funksjonen setter administratorbrukeren til adressen til msg.sender som betalte for å distribuere smartkontrakten. Vi har også en spesiell bareAdmin () modifiseringsfunksjon som deretter brukes på våre removeUser () og removeImage () -funksjoner, for å begrense disse funksjonene slik at de bare kan aktiveres hvis msg.sender-adressen er adminbrukeradressen.

Nå har jeg en måte å fjerne alle dårlige brukere, om nødvendig &# x1f642; Ikke få meg til å gjøre det!

Et annet siste punkt jeg vil nevne er at vi bare har skrapet overflaten her. En slags grunnleggende funksjon jeg ikke dekket over er Solidity “events”, som er en måte for deg å presse oppdateringer ned til nettleseren, som en “socket” -forbindelse som ser på og aktiverer nettleserhendelser når nye registrerte brukere bildet oppdages. De virkelig kuleste delene av eter og soliditet kommer fra smarte kontrakter som samhandler med Oracles, og smarte kontrakter som snakker og handler mellom hverandre ved hjelp av “meldinger” (DAO). Det er også noen

De virkelig kuleste delene av eter og soliditet kommer fra smarte kontrakter som samhandler med Oracles, og smarte kontrakter som snakker og handler mellom hverandre ved hjelp av “meldinger” (DAO). Det er også noen ganske alvorlig sikkerhetshensyn du bør lære om, før du prøver å lagre ekte etereum i smartkontrakten din og sende den ut til folk basert på funksjonsanrop, tapte en haug mennesker rundt M dollar på den ene, og det endte med å splitte eterinnettverket i en omstridt hardgaffel. Det er noe du virkelig bør passe på, og det burde jeg selvfølgelig dekke i en annen artikkel &# x1f642; Denne artikkelen skal være bra for å komme i gang og være “farlig” som jeg sa, og jeg oppfordrer deg til å lære det, til og med få et hyggelig selskap til å betale deg for å lære det hvis du kan, men det er fortsatt mer på denne veien.

Et annet, det siste punktet jeg vil snakke om, er selve strukturen til ethereum og den reelle kostnaden ved å bruke smarte kontrakter, akkurat nå. ethereum er et nettverk som kjører på en stor, enkelt, offentlig blockchain, der alle kan betale for å få tilgang til og lagre data der inne. Imidlertid faktisk holder på med det er noe dyrt. Du kan se ovenfor på bildet mitt, jeg ble belastet 0,004182 Ether, som i dag tilsvarer $ 0,96 i ekte amerikanske dollar, for å lagre en bilde-URL, SHA256 notarihash og tidsstempel, bestående av 196 byte, til Ethereum Mainnet. Dette regner med en datalagringskostnad på $ 5 159,03 per MB!

Det er bokstavelig talt sinnsykt dyrt. Den opprinnelige ideen om bensinkostnad beskrevet i Whitepaper ethereum sier at bensinkostnadene ideelt sett er ment å være noe konstant, men gasskostnadene er knyttet til blokknummer, i den virkelige implementeringen, og blokknummeret går ikke opp nesten like raskt som dagens markedspris på eterum, så gass blir mye dyrere i reelle termer. Hard-gaffelsituasjonen viser også at dette virkelig er en offentlig kjede, og hvis noe virkelig omstridt skjer på det, kan det gaffel og dataene dine kan teoretisk være gjenstand for tilbakeføring, eller den underliggende aktivaklassen kan falle i pris bratt. Den store utgiften til data og de store havene med data der ute som venter på å bli lagret, betyr at mengden data som kan lagres i en hvilken som helst kjede, kanskje trenger å være begrenset, eller kan være selvbegrensende.

ethereum kan være best egnet for ting som bare trenger en liten mengde offentlig tilgjengelig datalagring for å være on-chain, som kanskje et online omdømmesystem eller et dataregistreringsprosjekt. Det kan ikke være fornuftig å bygge et blockchain-prosjekt for å legge ut all data fra den amerikanske widgetindustrien på ethereum blockchain, for eksempel fordi du kanskje ikke vil ha all den informasjonen offentlig tilgjengelig, og du må få transaksjonsgebyrene helt ned for din widget-bransjespesifikke bruksområder. Du kan vurdere at en proof-of-stake blockchain-modell kan være mer energieffektiv, selv om det kan representere en teoretisk svekkelse av konsensus-sikkerhetsmodellen kontra Nakamoto proof-of-stake for blockchain-prosjektet ditt..

Jeg foreslår at før du begynner på et nytt blockchain-prosjekt, bør du vurdere nøye plattformen du vil bruke, se på de nyeste tingene der ute og ikke være redd for å utforske, og også vurdere nøye nodeinsentiv som vil tiltrekke folk til å laste ned den kule nodekoden din, og kjøre den! Det beste komplimentet en programmerer kan få, er ganske enkelt at folk bruker koden sin i den virkelige verden, og er produktive med den.

Secret Crazy Bonus-seksjonen

Distribuere meg opp til Mainnet, kaptein

Jeg er tilbake, med flere fantastiske ting for deg og eterumsamfunnet! Så jeg hoppet over en viktig detalj ovenfor, har du kanskje lagt merke til. Når du har skrevet smartkontrakten din, kan du teste å kompilere den tusen ganger til den fungerer, distribusjon, localhost teste alle fungerer. Nå, hvordan helvete får du denne tingen på Mainnet !? Det er liksom

Det er litt vanskelig og innebærer vanligvis å måtte kjøre din egen fullstendige etereumnode, eller betale noen for å kjøre en for deg og la deg få tilgang til den (som via en VPS). Så det var veldig upraktisk for meg, fordi jeg er utålmodig og jeg skriver denne artikkelen under en frist, folkens! Jeg har ikke tid til å vente på at min nye ethereum full node skal synkroniseres, og jeg har ikke lyst til å sprenge bort et par hundre konserter med harddiskplass og en av boksene mine for å knuse ethereum tx på heltid, og jeg Jeg er også for billig til å betale for en VPS for å gjøre det for meg, lol.

Så jeg brukte noen spesielle javascript-web-kung-fu, og fant ut hvordan jeg kan lage en webside med en rute og en knapp, hvor du bare kan lime inn kontrakten, klikke på knappen og distribuere en Smart-kontrakt med Solidity direkte til Mainnet, via Metamask Plugin. Hovedsakelig gjorde jeg dette bare for enkelhets skyld, for å skrive denne artikkelen, men det viste seg å være et overraskende nyttig verktøy, så jeg la det opp på nettet for alle å bruke. For første gang kan du gjøre alle testene dine og til og med full distribusjon av smartkontrakt til ethereum Mainnet, uten at du trenger en egen full etereknute! La meg introdusere EthDeployer verktøy, det er gratis for dere fordi gratis programvare gir oss frihet &# x1f642;

Her er en lenke til EthDeployer Repo på Github, og du kan også rett og slett få tilgang til min live running Tectract’s EthDeployer og distribuere kontraktene dine direkte derfra, du trenger bare å installere Metamask Plugin og koble til Ethereum Mainnet først, pluss at du trenger litt Ether i din Metamask-lommebok for å betale Mainnet smart-kontrakt distribusjonsgebyr også, selvfølgelig!

Dette verktøyet bruker Browser-Solc verktøy, som bare er et nettleserformet, minifisert lasterverktøy for å laste opp javascript-versjonen av Solidity Compiler, direkte i klientens nettleser, for parsing / kompilering av en smart-kontrakt på farten. Dette gjør verktøyet helt frittstående og bærbart, noe som betyr at du ikke trenger å bekymre deg for å installere Solc-kompilatoren på datamaskinen din, og jeg trenger ikke å bekymre deg for å installere det på serveren min, noe som er utmerket for alle. La meg påpeke koden som laster inn den siste tilgjengelige soliditets kompilatoren:

Jeg har minifisert javascript for nettleser-solc.min.js lastet inn via toppnivå index.html-siden, noe som gjør window.BrowserSolc gjenstand tilgjengelig for mine lavere nivå-reaksjonsskript. Dette er en annen veldig enkel create-react-app som kan installeres og distribueres på få minutter på din egen maskin, jeg ga til og med en faktisk nyttig readme.md i github repo som viser deg hvordan du gjør det.

setupCompiler () {

var ytre Dette = dette;

setTimeout (funksjon () {

// console.debug (window.BrowserSolc);

window.BrowserSolc.getVersions (funksjon (soljsonSources, soljsonReleases) {

var compilerVersion = soljsonReleases [_. keys (soljsonReleases) [0]];

console.log ("Browser-solc kompilatorversjon: " + compilerVersion);

window.BrowserSolc.loadVersion (compilerVersion, funksjon (c) {

kompilator = c;

outerThis.setState ({statusMessage:"klar!"},funksjon(){

console.log ("Solc-versjon lastet: " + compilerVersion);

});

});

});

}, 1000);

}

SetupCompiler-funksjonen venter et sekund på vinduet.BrowserSolc-objektet skal være tilgjengelig etter at siden er lastet inn, så gjør det interne .getVersions () og .loadVersion () -funksjoner, det er virkelig ikke mye til det, og vi har en funksjonell Solc-kompilator tilgjengelig for oss direkte i et fullt klientmiljø, hyggelig! For fullstendighet vil jeg vise noen relevante linjer som faktisk håndterer kompilering og distribusjon av kontrakten fra en javascript-funksjon når “kompilere & utplassere!” trykkes på knappen:

compileAndDeploy () {

var result = compiler.compile (this.state.contractText, optimalize);

var abi = JSON.parse (result.contracts [_. keys (result.contracts) [0]]. interface);

var bytecode = "0x" + result.contracts [_. keys (result.contracts) [0]]. bytecode;

var myContract = web3.eth.contract (abi);

web3.eth.estimateGas ({data: bytecode}, funksjon (err, gasEstimate) {

myContract.new ({from: web3.eth.accounts [0], data: bytecode, gas: inflatedGasCost}, function (err, newContract) {

thisTxHash: newContract.transactionHash,

thisAddress: newContract.address

Vi har alle våre kjente gjenstander fra før, kaller vi compiler.compile () på kontraktsteksten, og få et kompilert “resultat” -objekt som vi trekker ut abi og bytekode fra, og sender det i en ny transaksjon. Vi ser vår gamle kjente .estimateGas () -funksjon kastet inn her for godt mål også. Vi tar tak i transaksjons-ID og den nye kontraktsadressen for å vises tilbake til brukeren når kontrakten er distribuert. Bam, ferdig! La oss se det i aksjon:

“Å ja, hvis du får en feilmelding om distribusjon, sørg for å faktisk sjekke transaksjons-ID-lenken. Kontrakten har sannsynligvis DID faktisk distribuert vellykket, noen ganger mislykkes Metamask bare å hente transaksjonsstatus for distribusjonssuksess og ny kontraktadresse og returnere disse til nettlesermiljøet vårt. “

Hvordan lære soliditet: Den ultimate Ethereum-kodingsveiledningen

Den lever fortsatt. Dette gjør meg så glad! Secret Crazy Extra Bonus ulåst! Så jeg betalte 0,02268 Ether i gass, som er omtrent $ 5,30 USD (1. juni 2017), for å distribuere denne kontrakten på ethereum Mainnet. Husk at dette skulle være en superenkel demo-app, med bokstavelig talt bare to mulige datastrakter. Det var bare som $ 2 for et par uker siden, dette er vilt! Men fortsatt rimelig, bør du ikke virkelig trenger å distribuere kontrakten til hovedkjeden som ofte, egentlig bare en gang, burde gjøre det.

Det er alt jeg har for deg denne gangen, gutter! Håper du syntes denne opplæringen var supernyttig, og at du kan bruke EthDeployer-verktøyet godt i dev-eventyrene dine der ute. Jeg gleder meg til å høre spørsmål og kommentarer, takk!

Ryan Molecke

Ryan Molecke, Chief Technology Officer (CTO) for EnLedger Corp.., er en svært tverrfaglig akademisk beregningsvitenskapelig forsker, som overgikk til en verden av finansteknologi og handelssystemer. Han har jobbet i flere bemerkelsesverdige og vellykkede finansteknologiske oppstart, hjulpet arkitekthandelssystemer og megling / utveksling, og er nå fokusert på tillatte ledgers og blockchain-systemintegrasjoner, tokeniseringer og studiepoengprogrammer. Han har en B.S.E. i datateknikk og en doktorgrad innen nanovitenskap og mikrosystemteknikk, begge fra UNM

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