Hur man lär sig fasthet: Den ultimata kursen för Ethereum-kodning

Denna guide hjälper dig steg för steg när du lär dig soliditet. För en djupgående utforskning av soliditet, kolla in våra blockchain-kurser.

Ethereum Foundation har skakat upp världen av blockchain sedan projektets tidiga dagar, runt slutet av 2013 och början av 2014. Ethereum startade verkligen “Bitcoin 2.0” och vad vi tänker på som “blockchain” -rörelsen, efter den första stora Bitcoin “bubblade” över $ 1000 USD på marknaderna fick allas uppmärksamhet. Ethereum är ett blockchain-projekt med en kryptovaluta, Ether, som liknar Bitcoin, men Ethereum har den extra funktionen av ett (nästan) Turing-komplett virtuellt maskinspråk och bearbetningsförmåga inbäddat i nodimplementeringen.

Ethereum Virtual Machine (EVM) tillåter Ethereum-noder att faktiskt lagra och bearbeta data i utbyte mot betalning, svara på verkliga händelser och möjliggöra många nya möjligheter att stödja kedjeapplikationer som aldrig tidigare var tillgängliga för utvecklare och verkliga världsanvändare. Jag hade turen att faktiskt vara i Schweiz i början av 2014 och få besöka ett Ethereum “holon” ​​och umgås med några av Ethereums grundare innan Ether-token-försäljningen, tillbaka när de var “självfinansierade”.

Jag frågade Mihai Alisie vad ett eteriskt smart kontrakt är, och han förklarade:

“Smarta kontrakt är ett sätt för människor över hela världen att göra affärer med varandra även om de inte talar samma språk eller använder samma valuta.”

Så det är verkligen det perspektiv jag börjar med, tanken att vi programmatiskt kan definiera reglerna för ett affärsavtal, på ett enkelt maskinspråk, för att sammanföra människor och låta dem bedriva affärer på ett pålitligt, säkert och automatiserat sätt.

#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.

Soliditetsspråket i sig är ett verktyg som vi använder för att generera kod på maskinnivå som kan köras på EVM, det är ett språk med kompilator som tar vår högnivå läsbara kod och bryter ner den i enkla instruktioner som “sätta data i ett register”, “lägga till data från två register”, “hoppa tillbaka till instruktion vid minnepunkt xxxxx”, som ligger till grund för alla körbara program för mikroprocessorer.

Så fasthetsspråket är bara ett av flera språk som kan sammanställas till EVM-bytkod, ett annat språk som gör samma sak kallas Orm. Varje språk kan ha flera kompilatorverktyg men de gör alla samma sak, det vill säga att generera EVM-maskinens bytkod som ska köras på eteromenoderna, för betalning.

Hur man lär sig fasthet

#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 sig är ett ganska enkelt språk så långt som programmeringsspråk går.

I själva verket är det en målmedvetet minskat, löst skrivet språk med en syntax som mycket liknar ECMAScript (Javascript). Det finns några viktiga punkter att komma ihåg från Ethereum Design Rationalale dokument, nämligen att vi arbetar inom en stack-och-minnesmodell med en 32-bitars instruktionsordstorlek, ger EVM oss tillgång till programmet “stack” vilket är som ett registerutrymme där vi också kan hålla minnesadresser för att göra Program Counter loop / jump (för sekventiell programkontroll), en utbyggbar tillfällig “minne” och en mer permanent “lagring” vilket faktiskt är skrivet i den permanenta blockkedjan, och viktigast av allt, EVM kräver totalt determinism inom smarta kontrakt.

Detta krav på determinism är anledningen till att du inte ser funktionen ”slumpmässig ()” på fasthetsspråket. När ett eterblock “bryts” körs smarta kontraktsdistributioner och funktionsanrop inom det blocket (vilket innebär att de som är uppradade för att hända inom den senaste blockvaraktigheten) körs på noden som bryter blocket, och det nya tillståndet ändras till alla lagringsutrymmen eller transaktioner inom det smarta kontraktet faktiskt inträffar på den här gruvnoden. Sedan sprids det nya blocket ut till alla andra noder och varje nod försöker oberoende verifiera blocket, vilket inkluderar att göra samma tillståndsändringar i deras lokala kopia av blockchain också. Här misslyckas det om smartkontraktet agerar icke-deterministiskt. Om de andra noder inte kan nå enighet om blockchain-tillståndet efter det nya blocket och dess kontrakt har genomförts, kan nätverket bokstavligen stoppas.

Det är därför eteriska smarta kontrakt (och smarta kontrakt i allmänhet i alla blockchain-system) måste vara deterministiska: så att nätverket av noder alltid kan validera och upprätthålla enighet om de nya blocken som kommer in för att fortsätta att köra.

En annan begränsning som du hittar i EVM-smartkontrakt är oförmågan att komma åt data utanför “minnet” och “lagring”, (vi vill inte att smartkontraktet ska kunna läsa eller ta bort hårddiskarna på noder det körs på) och oförmågan att fråga utanför resurser som med en JQuery. Vi har inte riktigt tillgång till många biblioteksfunktioner som för att analysera JSON-strukturer eller göra flytpunktsberäkning, och det är faktiskt kostnadskrävande att göra dessa underrutiner eller lagra mycket data i själva ethereum blockchain.

När du ringer till ett smart-kontrakt som utför något statligt arbete eller beräkning (någon åtgärd förutom annat än att bara läsa från lagring) kommer du att drabbas av en gas “kostnad” för det arbete som utförs av det smarta kontraktet, och denna gaskostnad är relaterad till mängden beräkningsarbete som krävs för att utföra din funktion. Det är ett slags “mikrobetalning för mikrodatorer” -system, där du kan förvänta dig att betala en viss mängd gas för en bestämd mängd beräkning, för alltid.

Priset på gas i sig är tänkt att vara i allmänhet konstant, vilket innebär att när Ether går upp på de globala marknaderna, pris gas mot eter borde gå ner. När du utför ett funktionsanrop till ett smart kontrakt kan du alltså få en uppskattning av mängden gas du måste betala i förväg, men du måste också ange pris (i eter per gas) som du är villig att betala, och gruvnoderna kan bestämma om det är tillräckligt bra för dem att hämta ditt smart-contract-funktionssamtal i nästa block.

Smarta kontrakt har sin egen adress, från vilken de kan ta emot och skicka Ether. Smarta kontrakt kan spåra funktionens “samtal” på ett verifierbart sätt, så det kan avgöra om någon av dess funktioner anropas av ett privilegierat “ägare” eller “admin” -konto och agera därefter för administrativa funktioner. De har förmågan att läsa data från ethereum blockchain och få tillgång till information om transaktioner i äldre block. Men är smarta kontrakt “inlåsta” i sin egen lilla deterministiska värld, bara kunna vara medvetna om data som lagras i själva ethereum blockchain?

Inte alls! Det är där “Orakel” komma in. Vi kan ringa ett orakel som kommer att berätta något om omvärlden på ett pålitligt sätt och agera på den informationen inom det smarta kontraktet. Nyckelpunkten här är att även om verkliga händelser i sig inte är deterministiska, kan Oracle lita på att alltid svara på varje nods begäran om vad som hände på ett deterministiskt sätt, så att alla noder fortfarande kan komma till enighet. Så det är så det pålitliga Oracle fungerar i teorin: ett “orakel” kommer att ta lite data, säg en ticker-prisflöde om ett verkligt aktiekurs och registrera den informationen i “lagring” i ett enkelt Oracle-smartkontrakt, något så här

(se även förklaringen här):

function storeTickerData (bytes8 symbol, uint open, uint high, uint low, uint close)

endastOracle

returnerar (bool framgång)

{

# lagra ticker-data i kedjan

tickerData [symbol] [block.number] = [öppen, hög, låg, stäng]

# tickerData är en karta över kartor, string => uint => array [uint, uint, uint, uint]

återvänd sant;

}

Det finns företag som specialiserar sig på att vara det betrodda oraklet och utforma system för att skilja sig från att behöva lita på datafedet. Om vi ​​tittar på Oraclize-dokumentation vi ser detta intressanta citat:

Syftet är särskilt inte att tvinga smarta kontraktsutvecklare att behöva lita på Oraclize med de uppgifter de behöver. Utan någon äkthetsstöd kan Oraclize enkelt manipulera data. För att slutföra denna komplexa uppgift returnerar Oraclize de begärda uppgifterna tillsammans med ett bevis på äktheten: det vill säga att uppgifterna kommer från den dataleverantör som har krävts av det smarta kontraktet.

Så du bör kolla in det här dokumentavsnittet om “äkthetsbevis” för mer information, men tanken är att även när nya eterumnördar, vid en längre tid i framtiden, snurrar upp sina eterumnoder och börjar synkronisera sina blockkedjor till nätverket , all information de behöver för att utföra alla dessa “orakelberoende” smarta kontrakt är säkert i kedjan för att de ska kunna laddas ner, för alltid. Frågan om vem som betalar “gasen” för oraklet för att göra all denna dataskrivning om verkliga händelser (blockchain-lagring “tillståndsförändring” kostar gas) är ett annat ämne, men i grund och botten blir det förbetalt av dataansökaren i ett av flera sätt. Det häftiga här är att även om vi inte kan skriva ett smart kontrakt som “kastar tärningar” i betydelsen att inkludera faktisk slumpmässighet, så är faktiskt möjligt att skriva ett smart kontrakt som reagerar på kastet av en matris, som tjänat av ett orakel.

Grundläggande handledning för soliditet

Grundläggande kodbakgrund och inställning

Så låt oss komma igång med ett grundläggande etereum-smartkontrakt, skrivet på fasthetsspråk. Det bästa sättet att lära sig är att göra! Vi kan se från det lilla kodavsnittet ovan att vi har en ganska enkel funktionsdeklarationssyntax och några grundläggande datatyper som ‘uint’ (osignerat heltal) och ‘sträng’, och vi ser i dokumenten att vi också har variabeltyper som ‘adress’, som innehåller ‘.balans’ och ‘.transfer’ -metoder, som förutsägbart returnerar balansen vid ett Ethereum adress och tillåta smartkontraktet att faktiskt skicka Ether till den adressen, med enheter denominerade i Wei.

Vi har dina grundläggande matriser, enums, operatörer, hashdatastrukturer som kallas “mappings” och några speciella fördefinierade enheter och globala vars som inkluderar saker som blockhöjd, sista block tidsstämpel och några praktiska SHA-hash- och adress- / tangentmanipulationsfunktioner. En viktig egenskap om soliditet när man arbetar med flerdimensionella matriser: indexering är i “omvänd” ordning från de flesta språk endast under deklarationen, som anges i dokumenten:

En matris med fast storlek k och elementtyp T skrivs som T [k], en matris med dynamisk storlek som T []. Som ett exempel är en matris med fem dynamiska matriser med uint uint [] [5] (notera att notationen är omvänd jämfört med vissa andra språk). För att komma åt den andra uinten i den tredje dynamiska matrisen använder du x [2] [1] (index är nollbaserade och åtkomst fungerar på motsatt sätt av deklarationen …)

Okej, vi har tillräckligt med grundläggande verktyg här för att vara farliga, låt oss börja. Låt oss göra någon form av grundläggande social app där människor kan ha några bilder och lite grundläggande information om sig själva publicerade i blockchain. Varje användare kommer att ha en etereadress och ett “handtag” eller användarnamn kopplat till sitt konto. Vi har några grundläggande demografiska data som människor kanske eller inte kan ange, och sedan har vi en enkel söksida där du kan leta upp användare i en grundläggande katalog och kolla in bilderna de har lagt till / notariserat till sin användare profil.

Här är en bild av hur vårt slutliga SmartContract App (Ðapp) Smart Interface-avtal (Ðapp) kommer att se ut, med användare och notariserade bilder tillagda:

Hur man lär sig soliditet: Den ultimata Ethereum-kodningsguiden

Jag har notiserat en fin bild av mig själv för er och en bild av en Galium Arsenide Crystal-struktur från min skolgång för er. Du kan se SH256-noteringens hash och tidsstämplar för varje bild och en liten bock som indikerar att den notiserade bildinformationen fortfarande matchar notishashen som skapades vid den angivna tidsstämpeln. Så jag kommer att gå igenom hur jag byggde den här appen och peka på de intressanta sakerna för dig, med alla länkar och kodexempel du kan behöva för framtida referens. Låter bra? Nu går vi!

Det första jag ska göra är att ställa in en Tryffel “Testbädd” som gör att jag enkelt kan testa att kompilera mitt smarta kontrakt. Att kompilera och distribuera smarta kontrakt innebär att generera långa signerade transaktioner, men Truffle tillåter mig att kompilera / distribuera och testa mitt smarta kontrakt med enkla kommandon. Det finns en massa verktyg som kan göra detta, men jag råkar gilla den här videotutorialen för smarta kontrakt som använder Tryffel verktyg. jag har en demo github-projekt mapp som jag har skapat just för den här guiden för att alla ska följa med. Jag börjar med några enkla inställningskommandon (under en Debian Linux-miljö):

tectract @ blockgeeks / ethereum-demo-verktyg> npm i -g tryffel

# om du stöter på behörighetsfel som globalt installerar nodmoduler, se här

tectract @ blockgeeks / ethereum-demo-verktyg> mkdir Geekt # Jag ska ringa min sociala applikation "Geekt"

tectract @ blockgeeks / ethereum-demo-verktyg> cd Geekt

tectract @ blockgeeks / ethereum-demo-tools / Geekt> tryffel init # detta skapar några mappar och installationsfiler inom Geekt / mappen

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

kontrakt migrations test truffle.js # vi har skapat tre mappar och en ny fil som heter truffle.js

tectract @ blockgeeks / ethereum-demo-tools / Geekt > Våra kontrakt /

ConvertLib.sol MetaCoin.sol Migrations.sol # vi har några grundläggande mallkontrakt genererade av Truffle

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

1_initial_migration.js 2_deploy_contracts.js # ett par filer för sammanställning / migreringsinställningar med Truffle

Ett enkelt exempel på enkelhetskontrakt

Okej, jag ska skapa ett kontrakt som heter Geekt.sol, i mappen / Geekt / contract som skapades när jag kallade “tryffelinit”. Du kan se fullständig kontraktskod här, och jag kommer att peka på de mest intressanta bitarna här. Högst upp i filen har vi en rad som specificerar kompilatorversionen och några grundläggande syntaxer och variabeldefinitioner.

pragmasoliditet ^ 0.4.4;

kontrakt Geekt {

adress GeektAdmin;

mapping (bytes32 => notarizedImage) notarizedImages; // detta gör det möjligt att slå upp notarizedImages av deras SHA256notaryHash

bytes32 [] imagesByNotaryHash; // det här är som en vit sida av alla bilder, av SHA256notaryHash

mapping (adress => Användare) Användare; // detta gör det möjligt att slå upp användare efter deras etereadress

adress [] användareByAddress; // det här är som en whitepages för alla användare, efter ethereum-adress

När du ringer till en statsförändringsfunktion i den verkliga världen måste du ange hur mycket eter du ska betala för det, men lyckligtvis kan du begära en uppskattning av kostnaden i termer av bensinkostnad och gaspris ( i gas / eter) i förväg, och det är vanligtvis mycket exakt. Ethereum-gruvarbetarna kommer att avgöra om du har betalat tillräckligt och inkludera din tillståndsförändrande transaktion i nästa block, så du måste faktiskt vänta på att dessa funktioner ska återvända när nästa block hittas. Att läsa ut data från dessa “lagringsstrukturer” är gratis och du behöver inte vänta på nästa block heller, noder läser bara data och returnerar dem direkt.

Så den Användare mapping är vårt huvudsakliga lagringsobjekt som låter oss skapa användarobjekt och slå upp dem efter adress. Kartläggningar är supereffektiva för att lagra data och hämta dem snabbt, men det finns inget enkelt sätt att itera en karta, så du kan se att jag också skapade en usersByAddress adressmatris som innehåller alla kända adresser för en användare i vårt system, som en vit sida för alla användare. Jag skapade

Jag skapade notarizedImages kartläggning för att tillåta oss att skapa ”bild” -objekt i lagring och slå upp dem med en associerad SHA256-hash av bilddata, och dessa notaryHash-index är 32 byte långa.

Vi har också en ImagesByNotaryHash bytes32-array som är en lista över alla notaryHashes, som en vit sida som gör att vi kan upprepa alla bilder som har notariserats.

struct notarizedImage {

strängbildURL;

uint timeStamp;

}

struct User {

stränghandtag;

bytes32 stad;

tillstånd bytes32;

bytes32 land;

bytes32 [] myImages;

}

Dessa (ovan) är väldigt grundläggande strukturer, och de representerar också “lagringsobjekt”, så de kostar riktig eter att “skapa” och data i dem lagras faktiskt i ethereum blockchain, och det kostar riktig eter att ändra “tillståndet ”Av deras interna variabler. Vi använde egentligen bara de yttre mappningarna och matriserna för att hålla reda på var i blockchain-minnet dessa bilder / användarstrukturer finns. Vår notarizedImage struct lagrar helt enkelt en URL till en bild, antagligen någonstans på webben, och en tidsstämpel som meddelar när bilden notariserades. Vår Användare struct lagrar en del grundläggande användare: handtag, stad, delstat, land och det lagrar också en matris med alla bilder som den här användaren har godkänt och “lagt till” i sitt användarkonto, som en miniversion för användare av den globala imagesByNotaryHash vita sidobjekt.

funktionsregisterNyUser (stränghandtag, bytes32 stad, bytes32 tillstånd, bytes32 land) returnerar (bool framgång) {

adress thisNewAddress = msg.sender;

// skriv inte över befintliga poster och se till att handtaget inte är noll

if (bytes (Användare [msg.sender] .handtag) .längd == 0 && byte (handtag) .längd! = 0) {

Användare [thisNewAddress] .handle = handtag;

Användare [thisNewAddress] .city = stad;

Användare [thisNewAddress] .state = state;

Användare [thisNewAddress] .country = land;

usersByAddress.push (thisNewAddress); // lägger till en post för den här användaren till användaren ‘whitepages’

återvänd sant;

} annat {

returnera falsk; // antingen handtaget var noll, eller så existerade en användare med det här handtaget redan

}

}

Här är vår registerNewUser fungera. Det tar handtag, stad, stat, land som inmatningsvariabler och returnerar sant eller falskt för att indikera framgång eller misslyckande. Varför skulle det misslyckas? Tja, vi vill inte tillåta användare att skriva över varandras handtag, så det här kommer att bli som ett system med första krav för handtag. Om en användare med det här handtaget redan finns returnerar vi null, så jag har placerat en ”if” -linje där för att söka efter det. Vi tillåter inte skapandet av ett användarnamn utan handtag. En sak vi noterar är thisNewAddress som är den som ringer till funktionen kan du se att vi använder specialen msg.sender funktion för att fånga den informationen, det här är adressen som “gör den här funktionen” -transaktionen skickades från när någon (någon) ringer till vår smarta kontraktsfunktion, och de betalar riktig eter för att göra det. Så ett “mapping” -objekt är null som standard, och när vi ringer:

Användare [thisNewAddress] .handle = handtag;

Detta skapar ett nytt användarobjekt i vår användarkartläggning och ställer in handtaget. Samma som stad, stat, land. Observera att vi också trycker den nya användarens adress till våra användareByAddress globala användare “vita sidor” -objekt innan vi återvänder till det där.

function addImageToUser (string imageURL, bytes32 SHA256notaryHash) returnerar (bool-framgång) {

adress thisNewAddress = msg.sender;

om (byte (användare [dennaNewAddress] .handtag) .längd! = 0) {// se till att den här användaren har skapat ett konto först

om (bytes (imageURL) .length! = 0) {//) {// inte kunde få bytes32 null-kontroll att fungera, jaha!

// hindra användare från att slåss om sha->bildlistor på de vita sidorna, men ändå tillåta dem att lägga till en personlig ref till alla sha

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

imagesByNotaryHash.push (SHA256notaryHash); // lägger till post för den här bilden till våra bildsidor

}

notarizedImages [SHA256notaryHash] .imageURL = imageURL;

notarizedImages [SHA256notaryHash] .timeStamp = block.timestamp; // notera att uppdatering av en bild också uppdaterar tidsstämpeln

Användare [thisNewAddress] .myImages.push (SHA256notaryHash); // lägg till bildhash till den här användaren .myImages-array

återvänd sant;

} annat {

returnera falsk; // antingen imageURL eller SHA256notaryHash var null, kunde inte lagra bilden

}

återvänd sant;

} annat {

returnera falsk; // användaren hade inget konto ännu, kunde inte lagra bilden

}

}

Vår addImageToUser till användarfunktionen är ganska lik den registerNewUser fungera. Det slår dig upp efter din sändningsadress via specialen msg.sender objekt och kontrollerar att det finns en registrerad användare (med handtag) för den adressen innan den försöker lägga till en bild för din användarinmatning. Vi tillåter användare att lägga till sin notaryHash på de globala vita sidorna med bilder endast om den inte finns, för att hindra användare från att slåss om poster i de globala vita sidorna, men vi tillåter dem att lägga till / uppdatera alla notaryHash-poster inom deras egna mini-vita sidor av sina egna bilder. Inget till det!

function getUsers () konstant returnerar (adress []) {return usersByAddress; }

funktion getUser (adress userAddress) konstant returnerar (sträng, bytes32, bytes32, bytes32, bytes32 []) {

return (Användare [userAddress] .handle, Users [userAddress] .city, Users [userAddress] .state, Users [userAddress] .country, Users [userAddress] .myImages);

}

funktion getAllImages () konstant returnerar (bytes32 []) {return imagesByNotaryHash; }

funktion getUserImages (adress userAddress) konstant returnerar (bytes32 []) {return Användare [userAddress] .myImages; }

funktion getImage (bytes32 SHA256notaryHash) konstant returnerar (sträng, uint) {

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

}

Slutligen tillåter (ovan) accessor-funktionerna oss att enkelt läsa upp varje användare eller bild eller få de fullständiga listorna över vita sidor för alla användare eller alla bilder. Observera att dessa funktioner återgår konstant data, vilket i grund och botten betyder att de är skrivskyddade, inte “tillståndsförändrande” och att de är fria att ringa och de returnerar data direkt, du behöver inte vänta till nästa block. Vi kallar i princip bara in våra globala mappningar / matriser och returnerar relevant data: användare efter adress eller bilder av notaryHash.

Sammanställning & Testa ett Smart-kontrakt

Nu vill vi faktiskt testa vårt smarta kontrakt lokalt, i en testmiljö. Det är väldigt enkelt att använda enkla tryffelkommandon, men först behöver vi faktiskt en lokal eteromenod att testa mot. Det är där Ethereum TestRPC kommer in. TestRPC är i grunden en falsk nod, ett smalt program som bara låtsas vara en nod och svarar som en nod skulle svara på din lokala värdmaskin. TestRPC körs på port 8545 som en vanlig ethereum-nod, och den har förmågan att kompilera Solidity-smartkontrakt till EVM-kod och köra den koden också, plus att du får omedelbara svar för testning, istället för att behöva vänta på det verkliga eterinnätverket hitta nästa block. Nu kan du köra Truffle test kompilera / distribuera kommandon mot en riktig eter-nod, men det skulle kosta riktig Ether, plus det är tidskrävande och minneskrävande att köra din egen nod om du inte behöver. Så vi gör några snabba installationskommandon:

npm i -g ethereum-testrpc

testrpc -m “prov hund kommer år spray krypa lära sig allmänt upptäcka silver gelé pilot”

Detta startar TestRPC med en specificerad “frö” -fras, och du bör se något liknande som utgången:

EthereumJS TestRPC v3.0.5

Tillgängliga konton

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

(0) 0x0ac21f1a6fe22241ccd3af85477e5358ac5847c2

(1) 0xb0a36610de0912f2ee794d7f326acc4b3d4bc7bc

(9) 0x4c1cc45ef231158947639c1eabec5c5cb187401c

Privata nycklar

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

(0) 91e639bd434790e1d4dc4dca95311375007617df501e8c9c250e6a001689f2c7

(1) afaeff0fc68439c4057b09ef1807aaf4e695294db57bd631ce0ddd2e8332eea7

(9) dcc51540372fa2cf808efd322c5e158ad5b0dbf330a809c79b540f553c6243d7

HD plånbok

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

Mnemonic: prov hund kommer år spray krypa lär allmän upptäcka silver gelé pilot

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

Lyssnar på lokal värd: 8545

Du ser en del aktiviteter här i det här fönstret när TestRPC körs när du distribuerar och interagerar med ditt smarta kontrakt via Truffle eller Web3.js. Ok, vi är redo för testdistribution. Du måste ändra filen /migrations/2_deploy_contracts.js att inkludera namnet på ditt smarta kontrakt, för tryffel att veta att kompilera och distribuera det. Vi gör detta kommando:

tryffelkompilering

Om allt går bra ser du ett meddelande som säger att det sparar artefakter och inga felmeddelanden. Jag kommer inte att ljuga, om ditt kontrakt har syntaxfel eller andra problem, kommer kompileringsfelmeddelandena som du ser sannolikt att vara mystiska och svåra att tolka! Om du får ett fel angående “stackstorleken” betyder det förmodligen att du har för många variabler som skickas in / ut från ett funktionsanrop, en bra regel att komma ihåg är 16 variabler in- eller utdata är max, i allmänhet. Kom också ihåg att Smartity-kontrakt med soliditet inte kan returnera anpassade strukturdatatyper, så du måste kringgå det också, vanligtvis returnerar jag bara matriser och pekare / adresser till andra strukturer i mina interna mappningar. Om du får körning felmeddelande om “stacken”, det kan innebära att du har en dålig villkor i din kod.

tryffel migrera

Detta kommando (ovan) gör faktiskt testdistributionen av ditt smarta kontrakt på din TestRPC-nod. Jag ser denna output returnera:

Kör migreringen: 1_initial_migration.js

Implementera migreringar…

Migrationer: 0xd06a1935230c5bae8c7ecf75fbf4f17a04564ed8

Sparar framgångsrik migrering till nätverket…

Spara artefakter…

Kör migreringen: 2_deploy_contracts.js

Implementerar Geekt…

Geekt: 0xe70ff0fa937a25d5dd4172318fa1593baba5a027

Sparar framgångsrik migrering till nätverket…

Spara artefakter..

Vårt smarta kontrakt (med namnet “Geekt”) får en adress på Ethereum blockchain när det distribueras framgångsrikt, du kan se ovan, adressen är 0xe70ff0fa937a25d5dd4172318fa1593baba5a027. På ett riktigt levande eternätverk betalar du gas för att distribuera ditt kontrakt och adressen ändras aldrig. Om du stänger av TestRPC kommer TestRPC att glömma allt, och när du startar TestRPC igen måste du distribuera ditt kontrakt igen och du får en annan adress för ditt smarta kontrakt. Adressen till ditt smarta kontrakt är där människor kan skicka transaktioner med meddelanden för att interagera med det, göra tillståndsförändrade transaktioner eller bara läsa data ur etherum blockchain. Smarta kontrakt kan också interagera direkt med varandra via dessa adresser med “meddelanden”. Smarta kontrakt som interagerar med andra smarta kontrakt för att lagra, ändra eller läsa data via dessa etherum blockchain “meddelanden” är kända som Decentraliserade autonoma organisationer, eller DAO.

Ok, nu kommer den roliga delen. Vi är redo att faktiskt göra några första tester och interagera med vårt smarta kontrakt. Vi startar Truffle-konsolen och gör några frågor mot vår TestRPC-lokalnod för att se till att allt fungerar och vi kan lägga till användare och bilder och hämta dem ordentligt.

tryffelkonsol

> Geekt = Geekt.deployed ()

> Geekt.then (funktion (instans) {returnera JSON.stringify (instans.abi);})

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

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

> Geekt.then (function (instans) {return instance.getUser (‘0x0ac21f1a6fe22241ccd3af85477e5358ac5847c2’);}) > Geekt.then (funktion (instans) {return instans.getUsers ();})

> Geekt.then (funktion (instans) {return instans.getImages ();})

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

Ett viktigt koncept här är ABI, som är ett javascript-formaterat objekt som beskriver funktionsnamn och ingångar / utgångar för att interagera med ditt smarta kontrakt, det är ungefär som API-beskrivningen (Application Programmer Interface) för ditt smarta kontrakt, som berättar för folk hur man skapar meddelanden för det. Min registerNewUser () -funktion fungerar! Jag ser detta som svar på registeranvändaren () -funktionsanropet, i konsolfönstret:

{tx: ‘0x1b9f55971871921ccd23a9aa7620620c6c958a893af334087283926d4c6d60b1’,

mottagande:

{transaktionHash: ‘0x1b9f55971871921ccd23a9aa7620620c6c958a893af334087283926d4c6d60b1’,

transactionIndex: 0,

blockHash: ‘0x2be4fab68daaf8db199e2a6adea101c0f1ed06f46aba21e8e4c06e752ca3325c’,

blockNumber: 5,

gas Används: 145215,

cumulativeGasUsed: 145215,

contractAddress: null,

loggar: []},

loggar: []}

AddImageToUser () -funktionen returnerar framgång på samma sätt, och när jag nu kan hämta enskilda användarposter eller notariserade bildposter från ethereum blockchain. Mitt getUser () -funktionssamtal returnerar:

[‘Tektrakt’,

‘0x44656e76657200000000000000000000000000000000000000000000000000000000’,

‘0x434f0000000000000000000000000000000000000000000000000000000000000000’,

‘0x55534100000000000000000000000000000000000000000000000000000000000000’,

[‘0x6c3e007e281f6948b37c511a11e43c8026d2a16a8a45fed4e83379b66b0ab927’]]

och jag kan ta den bilddata via den 32-byte SHA256Notary hashsträngen jag har associerat med den, min getImage () -funktion returnerar:

[‘www.myimageURL.com’,

{[Sträng: ‘1496256315’] s: 1, e: 9, c: [1496256315]}]

Allt detta ser bra ut. Allt fungerar, testat i TestRPC och Truffle, och vi är redo att faktiskt bygga ett coolt grafiskt användargränssnitt för vår Ðapp så att världen kan interagera med vår användarregistrering och bildnotarie i ethereum blockchain.

Grundläggande Ethereum ÐApp Design

Localhost Design & Testning

Vi är redo att börja, vårt soliditetsspråkiga smartkontrakt har framgångsrikt sammanställts och distribuerats till vår lokala testRPC-eter-nod. Nu kan vi snabbt bygga en enkel ÐApp som gör det möjligt för användare att interagera med smartkontraktet via sin webbläsare, med hjälp av grundläggande webbprogrammering och det speciella Web3.js javascript-modul, speciellt gjord för att interagera med Ethereum-noder och smarta kontrakt via webben.

jag har gjort denna demo (öppen källkod github repositories) som en referens för människor att använda när de bygger Ethereum ÐApps med web3.js, denna demo gjordes med ett lättanvänt verktyg som heter Skapa-reagera-app, den använder en Facebook-intern webbspråk React, men vi kommer inte att fokusera på någon React-kod, bara de web.js javascript-kommandon som behövs. Min kod finns i CommonJS, den är nästan exakt densamma som vanligt gammalt ES6-javascript.

Så i din webbapp installerar du nodmodulen web3 via ett kommando som “npm i -S web3” och det kommer att sparas i din package.json-fil, om du använder en. Så du skulle ha inuti en “” -tagg eller inuti en .js-fil, en sådan rad för att ladda själva web3-modulen:

importera Web3 från ‘web3’;

(eller i ES6-javascript)

var Web3 = kräver (‘web3’);

Vi måste berätta för Web3 om några detaljer om vår nod och vårt smarta kontrakt, så att det kan ansluta. Du ser rader så här:

# denna rad specificerar vår lokala värdnod IP: portinställningar

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

# vår adress för smarta kontrakt, ovanifrån

var GeektAddress = ‘0xe70ff0fa937a25d5dd4172318fa1593baba5a027’;

# vårt smarta kontrakt ABI, som rå javascript-objekt, inte citerad sträng!

var GeektABI = [{"konstant":Sann,"ingångar": [],"namn":"getUsers","utgångar": [{"namn":"", (…)

# detta laddar smartkontraktet i vårt web3-objekt

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

# detta hittar standardkontot som anges för nodanslutningen (konto 0 från TestRPC ovan)

defaultAccount = web3.eth.accounts [0];

Här är några rader som visar skrivskyddade funktioner som gränsar till vårt smarta kontrakt via web3:

# funktionen nedan aktiveras när sidan laddas, för att hämta "vita sidor" av alla kända användaradresser

GeektContract.getUsers (funktion (err, usersResult) {

# nedanstående funktion tar en bild efter behov och lagrar dem i webbläsarens minne…

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

Den här enkla demonstrationen ÐApp laddar bara alla kända användaradresser och tar tag i den faktiska informationen om användaren och bilden registrerar sig vid behov. Här är en skärmdump:

Hur man lär sig soliditet: Den ultimata Ethereum-kodningsguiden

Vid den här tiden (bilden ovan) har jag uppdaterat min TestRPC-klient och just gjort kommandot “truffle migrate” som distribuerar smartkontraktet mot min lokala värd TestRPC-nod. Du kan se att gränssnittet är klart för mig att klicka på knappen och “registrera” den första användaren. När jag klickar på den här knappen klickar jag på min registerNewUser () -funktion från mitt smarta kontrakt och lägger till dessa användardata till min (localhost-testning) ethereum blockchain-nod på den smarta kontraktsadressen vi noterade ovan. Att lägga till användardata till blockkedjans “lagring” kommer att kosta gas, och vi måste ta reda på hur mycket gas vi ska betala, istället för att bara ta en vetenskaplig vild-gissning (SWAG). Här är koden som faktiskt kallas när den här knappen “Signera gästbok” klickas:

GeektContract.registerNewUser.estimateGas (

outerThis.state.defaultHandle,

outerThis.state.defaultCity,

outerThis.state.defaultState,

outerThis.state.defaultCountry,

{from: defaultAccount},

funktion (fel, resultat) {

var myGasNum = resultat;

GeektContract.registerNewUser.sendTransaction (

outerThis.state.defaultHandle,

outerThis.state.defaultCity,

outerThis.state.defaultState,

outerThis.state.defaultCountry,

{from: defaultAccount, gas: myGasNum},

funktion (fel, resultat) {

Så du kan se, när vi gör en tillståndsförändrad transaktion som vi faktiskt måste betala för med etergas (äkta eller testnätgas), kommer vi att kalla detta registerNewUser.estimateGas () fungera före hand och använd sedan den uppskattade mängden gas när vi kallar den tillståndsförändrande funktionen på riktigt med hjälp av registerNewUser.sendTransaction () fungera.

När vi startade TestRPC och det spottar ut några testplånboksadresser för oss, är dessa konton besläktade med kontot du skulle ha om du körde en hel nod och gjorde ett getAccounts RPC-kommando mot det, som en plånbok med full nod. TestRPC ger dig gratis testnetmynt, 100 testnet Ether per konto när det startar.

När vi kallar dessa tillståndsförändrande funktioner som registerNewUser () eller addImageToUser (), i testfasen för lokal värd, mot vår TestRPC-nod, betalar TestRPC bara testnätgas för dig och returnerar resultatet av transaktionen direkt. På en fullständig lokalhostnod måste du “låsa upp” det kontot innan transaktionen lyckas på mainnet, och du måste vänta på mainnet till nästa block för att hämta din transaktion, förutsatt att vår gasuppskattning var tillräcklig! Men det finns alltid ett bättre sätt, mina vänner &# x1f642;

Ansluta din Ðapp till Mainnet

Jag har skapat och distribuerat smart-kontrakt på ethereum Mainnet och den här demo-appen på en av mina webbservrar på www.enledger.io/etherereum-demo-tools. Om du besöker den här webbplatsen och du inte har en TestRPC- eller full ethereum-nod som körs på localhost: 8545, och du besöker den här webbplatsen, kommer du troligen att se något liknande:

Såganslutning till nätverk: !

Såg standardkonto: (ingen web3.eth nodlänk)

Så betyder det att du behöver en fullständig eterumnod som körs, eller en virtuell privat server (VPS) full nod för att ansluta till, för att kunna interagera med ethereum Mainnet? Fram till nyligen var det sant, men nu har vi det här fantastiska krompluginet som heter Metamask (för Chrome-webbläsaren), vilket gör att du kan ansluta till ethereum Mainnet i din webbläsare, och Metamask-killarna ger i princip en anslutning till en fullständig nod för dig , precis där, gratis, så rekvisita till dem!

Du kan se i min kod jag upptäcker för det speciella “injicerade” web3-objektet från metamask-plugin som ställer in nodanslutningen till deras ethereum-fulla nod. Här är den relevanta koden som automatiskt byter till din vanliga klient (localhost) eller metamask web3-anslutning:

funktion loadWeb3 () {

låt web3Injected = window.web3;

if (typeof web3Injected! == ‘undefined’) {

console.log ("såginsprutad web3!");

web3 = ny Web3 (web3Injected.currentProvider);

} annat {

console.log ("såg inte web3 injiceras!");

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

}

}

I bilden nedan, notera Metamask Fox-logotypen i det övre högra hörnet, jag har installerat Metamask Plugin och anslutit till ethereum Mainnet i min webbläsare! Du kan se att jag har lagt till ett par användare i gästboken redan i vårt “Geekt” gästbok demo smart-kontrakt. ÐApp-gränssnittet låter dig välja användare och bläddra bland deras bilder, och du kommer att se sidan Gästbokssignal om du ansluter från en adress som ännu inte har registrerat en användare.

Jag lade till lite kod så att du bara kan klistra in webbadressen till en bild som du vill lägga till i ditt användarkonto, och det hämtar SHA256-noteringshashen för att du ska lägga till bilden, och det kommer också att kontrollera SHA256-notishashen av bilder när de laddas in på sidan och ger dig en liten grön bock eller ett rött ‘X’ baserat på huruvida bilden vid den URL: n och notishashen fortfarande matchar. Jag lägger till “BlockGeeks” -logotypen under mitt Ryan M.-användarkonto här och jag har klickat på knappen för att lägga till bilden för den här användaren.

Metamask-plugin-programmet har upptäckt att jag måste betala för denna web3-eterentransaktion med riktig Ethereum-gas, och det har dykt upp ett litet fönster för att fråga mig om jag kommer att acceptera den här transaktionen. Jag har skickat en liten riktig eter till den här Metamask-plånboken och det räcker för att rensa transaktionen, så jag klickar på “acceptera”.

Hur man lär sig soliditet: Den ultimata Ethereum-kodningsguiden

Slutliga tankar, djupa reflektioner

Det är det, det fungerar! Den här demoartikeln och kodförvaret bör hjälpa dig att bli en fantastisk Ethereum Solidity Language och ÐApp-utvecklare! Du kan installera Metamask Plugin, ansluta till Ethereum Mainnet och besöka www.enledger.io/etherereum-demo-tools och du kommer att se min gästbok / noteringsdemo-app och samma användare och bilder, och du kan till och med underteckna gästboken och notera bilder också om du vill &# x1f642;

Bara så att ni inte blir alltför out-of-control med den här saken, jag lade till en liten moderering förmåga till smart-kontraktet “ägare”, som jag har ställt internt till adressen till den som ursprungligen betalade för att distribuera smart- kontrakt till mainnet, det är jag. Jag vill visa dig väldigt snabbt hur den speciella administratörsfunktionen fungerar eftersom det är ganska vanligt att se den här typen av administratörskodmönster:

adress GeektAdmin;

funktion Geekt () betalas {// detta är KONSTRUKTÖREN (samma namn som kontraktet) den kallas EN GÅNG när kontrakten först distribueras

GeektAdmin = msg.sender; // ställ bara in admin så att de kan ta bort dåliga användare eller bilder om det behövs, men ingen annan kan

}

endast modifierareAdmin () {

if (msg.sender! = GeektAdmin)

kasta;

// Glöm inte "_;"! Den kommer att ersättas av den faktiska funktionskroppen när modifieraren används.

_;

}

funktionen removeUser (adress badUser) endastAdmin returnerar (bool framgång) {

ta bort användare [badUser];

återvänd sant;

}

funktionen removeImage (bytes32 badImage) endastAdmin returnerar (bool-framgång) {

ta bort notarizedImages [badImage];

återvänd sant;

}

Vi har en speciell konstruktörsfunktion, Geekt (), med samma namn som själva kontraktet, som bara kallas en gång när kontraktet först distribueras till blockchain. Den här funktionen ställer in administratörsanvändaren till adressen till msg.sändaren som betalade för att distribuera smartkontraktet. Vi har också en speciell endastAdmin () modifieringsfunktion som sedan tillämpas på våra removeUser () och removeImage () -funktioner, för att begränsa dessa funktioner så att de bara kan aktiveras om msg.sender-adressen är admin-användaradressen.

Nu har jag ett sätt att ta bort alla dåliga användare om det behövs &# x1f642; Låt mig inte göra det!

En annan sista punkt som jag vill nämna är att vi bara har repat upp ytan här. En typ av grundläggande funktion som jag inte täckte över är Soliditetshändelser, vilket är ett sätt för dig att trycka uppdateringar tillbaka till webbläsaren, som en “uttag” -anslutning som tittar på och aktiverar webbläsarhändelser när en ny registrerad användare eller bilden detekteras. De riktigt coolaste delarna av eter och fasthet kommer från smarta kontrakt som interagerar med Oracles, och smarta kontrakt som pratar och agerar mellan varandra med hjälp av “meddelanden” (DAO). Det finns också några

De riktigt coolaste delarna av eter och fasthet kommer från smarta kontrakt som interagerar med Oracles, och smarta kontrakt som pratar och agerar mellan varandra med hjälp av “meddelanden” (DAO). Det finns också några ganska seriöst säkerhetshänsyn du bör lära dig om, innan du försöker lagra äkta eter inom ditt smarta kontrakt och skicka ut det till människor baserat på funktionssamtal, en massa människor förlorade ungefär M dollar över den och det slutade med att dela upp eterennätverket i en omstridd hård gaffel. Det är något du verkligen borde se upp för, och jag borde förmodligen täcka det i en annan artikel, förstås &# x1f642; Den här artikeln borde vara bra för att komma igång och vara “farlig” som sagt, och jag uppmuntrar dig att lära dig det, till och med få ett trevligt företag att betala dig för att lära dig det om du kan, men det finns fortfarande mer på den här vägen.

En annan, den sista punkten jag vill prata om är själva strukturen i ethereum och den verkliga kostnaden för att använda smarta kontrakt just nu. ethereum är ett nätverk som körs på en stor, enda, offentlig blockchain, där alla kan betala för att komma åt och lagra data där inne. Men faktiskt håller på med det är något dyrt. Du kan se ovan i min bild, jag debiterades 0,004182 Ether, vilket idag motsvarar $ 0,96 i riktiga amerikanska dollar, för att lagra en bild-URL, SHA256-nothash och tidsstämpel, bestående av 196 byte, till Ethereum Mainnet. Detta räknas ut till en datalagringskostnad på 5 159,03 USD per MB!

Det är bokstavligen galet dyr. Den ursprungliga tanken för bensinkostnad som beskrivs i etherum Whitepaper säger att bensinkostnaden idealt sett ska förbli något konstant, men gaskostnaden är bunden till blocknummer, i den verkliga implementeringen, och blocknumret går inte upp nästan lika snabbt som det nuvarande marknadspriset på eter, så gas blir allt dyrare i reala termer. Hard-fork-situationen visar också att det här verkligen är en offentlig kedja, och om något riktigt omtvistat händer på det kan det gaffla och dina data kan teoretiskt sett vara föremål för återföring, eller den underliggande tillgångsklassen kan sjunka i priset brant. Den stora kostnaden för data och de stora oceanerna av data där ute som väntar på att lagras innebär att mängden data som kan lagras i vilken kedja som helst kan behöva begränsas eller kan vara självbegränsande.

ethereum kan vara bäst lämpad för saker som bara behöver en liten mängd offentligt tillgängligt datalagring för att vara on-chain, som kanske ett online-rykte-system eller ett data-notariat-projekt. Det är kanske inte meningsfullt att bygga ett blockchain-projekt för att lägga ut all data från den amerikanska widgetindustrin på ethereum-blockchain, till exempel eftersom du kanske inte vill ha all den informationen offentligt tillgänglig, och du måste få transaktionsavgifterna långt ner för din widget-branschspecifika användningsområden. Du kan överväga att en proof-of-stake blockchain-modell kan vara mer energieffektiv, även om det kan representera en teoretisk försvagning av konsensus-säkerhetsmodellen kontra Nakamoto proof-of-stake för ditt blockchain-projekt.

Jag föreslår att innan du börjar ett nytt blockchain-projekt, överväga noggrant plattformen du vill använda, titta på de senaste sakerna där ute och inte vara rädd att utforska, och överväga också noga nodincitament som kommer att locka människor att ladda ner din coola nodkod och köra den! Det bästa komplimang som en programmerare kan få är att människor som använder sin kod i den verkliga världen och är produktiva med den.

Secret Crazy Bonus-avsnitt

Distribuera mig upp till Mainnet, kapten

Jag är tillbaka, med mer fantastiska saker för dig och ethereum-communityn! Så jag hoppade över en viktig detalj ovan, kanske du har lagt märke till det. När du har skrivit ditt smarta kontrakt testar du att kompilera det tusen gånger tills det fungerar, distribution, localhost testar allt. Nu, hur Helvete får du den här saken på Mainnet !? Det är typ av

Det är ganska svårt och innebär vanligtvis att du måste köra din egen fullständiga eteromenod eller betala någon för att köra en åt dig och låta dig komma åt den (som via en VPS). Så det var verkligen obekvämt för mig, för jag är otålig och jag skriver den här artikeln under en deadline, folk! Jag har inte tid att vänta på att min nya ethereum-fulla nod ska synkroniseras, och jag känner inte för att spränga bort ett par hundra spelningar på hårddiskutrymme och en av mina lådor för att knäcka ethereum tx på heltid, och jag Jag är också för billig för att betala för en VPS för att göra det åt mig, lol.

Så jag använde en speciell javascript-webb-kung-fu och tänkte bara hur jag kan skapa en webbsida med en ruta och en knapp, där du bara kan klistra in ditt kontrakt, klicka på knappen och distribuera ett Solidity-smartkontrakt direkt till Mainnet, via Metamask Plugin. Främst gjorde jag det bara för att göra det, för att skriva den här artikeln, men det visade sig vara ett överraskande användbart verktyg, så jag lade upp det på webben för alla att använda. För första gången kan du göra alla dina tester och till och med fullständig distribution av smarta kontrakt till ethereum Mainnet utan att behöva en egen fullständig etere-nod! Låt mig presentera EthDeployer verktyg, det är gratisprogram för er eftersom gratis programvara ger oss frihet &# x1f642;

Här är en länk till EthDeployer Repo på Github, och du kan också helt enkelt komma åt min live-körning Tectract’s EthDeployer och distribuera dina kontrakt direkt därifrån, du behöver bara installera Metamask Plugin och ansluta till Ethereum Mainnet först, plus att du behöver en liten eter i din Metamask-plånbok för att betala Mainnet-smartavtalets distributionsavgift också, naturligtvis!

Detta verktyg använder Browser-Solc verktyget, som bara är ett webbläsarförminskat, laddat verktyg för att ladda upp javascriptversion av Solidity Compiler, direkt i webbläsaren på klientsidan, för att analysera / sammanställa ett smart-kontrakt direkt. Detta gör verktyget helt fristående och bärbart, vilket innebär att du inte behöver oroa dig för att installera Solc-kompilatorn på din dator, och jag behöver inte heller oroa mig för att installera det på min server, vilket är utmärkt för alla. Låt mig peka på koden som laddar den senaste tillgängliga solidity-kompilatorn:

Jag har den minifierade webbläsaren-solc.min.js javascript laddas via toppnivå index.html-sidan, vilket gör en window.BrowserSolc objekt tillgängligt för mina lägre nivån reagera skript. Detta är en annan mycket enkel skapa-reagera-app som kan installeras och distribueras på några minuter på din egen maskin, jag gav till och med en faktiskt användbar readme.md i github repo som visar hur du gör det.

setupCompiler () {

var yttre Detta = detta;

setTimeout (funktion () {

// console.debug (window.BrowserSolc);

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

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

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

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

kompilator = c;

outerThis.setState ({statusMessage:"redo!"},fungera(){

console.log ("Solc-version laddad: " + compilerVersion);

});

});

});

}, 1000);

}

SetupCompiler-funktionen väntar en sekund på att fönstret.BrowserSolc-objektet ska vara tillgängligt efter att sidan har laddats, då är det interna .getVersions () och .loadVersion () -funktioner, det finns verkligen inte mycket för det, och vi har en funktionell Solc-kompilator tillgängliga för oss direkt i en helt klientmiljö, trevligt! För fullständighet kommer jag att visa några relevanta rader som faktiskt hanterar kompilering och distribution av kontraktet från en javascript-funktion när “kompilera & distribuera! ” knappen trycks in:

compileAndDeploy () {

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

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}, funktion (err, gasEstimate) {

myContract.new ({från: web3.eth.accounts [0], data: bytecode, gas: inflatedGasCost}, funktion (err, newContract) {

thisTxHash: newContract.transactionHash,

thisAddress: newContract.address

Vi har alla våra välbekanta föremål från tidigare, ringer vi compiler.compile () på kontraktstexten och få ett sammanställt kontrakts “resultat” -objekt från vilket vi extraherar abi och bytecode och skickar det i en ny transaktion. Vi ser vår gamla välkända .estimateGas () -funktion kastas in här för gott mått också. Vi tar tag i transaktions-ID och den nya kontraktsadressen för att visa tillbaka för användaren när kontraktet har distribuerats. Bam, gjort! Låt oss se det i aktion:

“Åh ja, om du får ett felmeddelande om distributionen, se till att du faktiskt kontrollerar transaktions-ID-länken, kontraktet troligen har DID faktiskt distribuerats framgångsrikt, ibland misslyckas Metamask bara med att hämta transaktionstillståndet för distributionens framgång och den nya kontraktsadressen och returnera dessa till vår webbläsarmiljö framgångsrikt. “

Hur man lär sig soliditet: Den ultimata Ethereum-kodningsguiden

Det lever fortfarande. Detta gör mig så glad! Secret Crazy Extra Bonus upplåst! Så jag betalade 0,02268 eter i gas, vilket är ungefär $ 5,30 USD (1 juni 2017), för att distribuera detta kontrakt på eterum Mainnet. Kom ihåg att detta var tänkt att vara en super enkel demo-app, med bokstavligen bara två möjliga datastrukturer. Det var bara som $ 2 för några veckor sedan, det här är vildt! Men ändå överkomligt, du borde inte verkligen behöva distribuera ditt kontrakt till huvudkedjan som ofta, verkligen bara en gång borde göra det.

Det är allt jag har för dig den här gången, killar! Hoppas att du tyckte att den här handledningen var mycket användbar och att du kan använda EthDeployer-verktyget i dina äventyr där ute. Jag ser fram emot att höra frågor och kommentarer, tack!

Ryan Molecke

Ryan Molecke, Chief Technology Officer (CTO) för EnLedger Corp.., är en mycket tvärvetenskaplig forskare i beräkningsvetenskap, som övergick till en värld av finansteknik och handelssystem. Han har arbetat vid flera anmärkningsvärda och framgångsrika finanstekniska startups, hjälpt arkitekthandelssystem och mäklare / utbyten och fokuserar nu på tillåtna huvudböcker och blockchain-systemintegrationer, tokeniseringar och krediteringsprogram. Han har en B.S.E. i datateknik och doktorsexamen inom nanovetenskap och mikrosystemteknik, båda från UNM

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