Hoe soliditeit te leren: de ultieme zelfstudie over Ethereum-codering

Deze gids zal u stap voor stap helpen bij het leren van Soliditeit. Bekijk onze blockchain-cursussen voor een diepgaande verkenning van soliditeit.

De Ethereum Foundation heeft de wereld van blockchain wakker geschud sinds de begindagen van het project, rond eind 2013 en begin 2014. Ethereum heeft echt een kickstart gegeven aan de “Bitcoin 2.0” en wat wij beschouwen als de “blockchain” -beweging, na de eerste grote Bitcoin “bubble” omhoog boven $ 1000 USD op de markten trok de aandacht van iedereen. Ethereum is een blockchain-project met een cryptocurrency, Ether, vergelijkbaar met Bitcoin, maar Ethereum heeft de toegevoegde functie van een (bijna) Turing-complete virtuele machinetaal en verwerkingscapaciteit ingebed in de node-implementatie.

Met de Ethereum Virtual Machine (EVM) kunnen Ethereum-knooppunten daadwerkelijk gegevens opslaan en verwerken in ruil voor betaling, reageren op gebeurtenissen uit de echte wereld en veel nieuwe mogelijkheden bieden om on-chain applicaties te ondersteunen die nooit eerder beschikbaar waren voor ontwikkelaars en real- wereldgebruikers. Ik had het geluk begin 2014 daadwerkelijk in Zwitserland te zijn en een Ethereum “holon” te bezoeken en rond te hangen met een aantal van de Ethereum-oprichters vóór de Ether-token-uitverkoop, toen ze nog “uit eigen middelen gefinancierd” waren..

Ik vroeg Mihai Alisie wat een ethereum smart contract is, en hij legde uit:

“Slimme contracten zijn een manier voor mensen over de hele wereld om zaken met elkaar te doen, zelfs als ze niet dezelfde taal spreken of niet dezelfde valuta gebruiken.”

Dus dat is echt het perspectief waarmee ik begin, het idee dat we programmatisch de regels van een zakelijk contract kunnen definiëren, in een eenvoudige machinetaal, om mensen samen te brengen en hen in staat te stellen zaken te doen op een betrouwbare, veilige en geautomatiseerde manier..

Solidity Language zelf is een tool die we gebruiken om code op machineniveau te genereren die kan worden uitgevoerd op de EVM, het is een taal met een compiler die onze door mensen leesbare code van hoog niveau neemt en deze opsplitst in eenvoudige instructies zoals “zet gegevens in een register”, “voeg gegevens toe uit twee registers”, “spring terug naar instructie op geheugenpunt xxxxx”, die de basis vormen van elk uitvoerbaar programma van een microprocessor.

Dus de Solidity-taal is slechts een van de vele talen die kunnen worden gecompileerd in EVM-bytecode, een andere taal die hetzelfde doet, heet Serpent. Elke taal kan verschillende compilertools hebben, maar ze doen allemaal hetzelfde, namelijk het genereren van EVM-bytecode op machineniveau die tegen betaling wordt uitgevoerd op de ethereum-knooppunten.

Hoe soliditeit te leren

Solidity zelf is een vrij eenvoudige taal, wat programmeertalen betreft.

In feite is het een doelbewust afgeslankt, los getypte taal met een syntaxis die erg lijkt op ECMAScript (Javascript). Er zijn enkele belangrijke punten die u moet onthouden uit het Ethereum Design Rationale document, namelijk dat we werken binnen een stack-and-memory-model met een 32-byte instructiewoordgrootte, de EVM geeft ons toegang tot het programma “Stapel” dat is als een registerruimte waar we ook geheugenadressen kunnen plakken om de Program Counter te laten lus / springen (voor sequentiële programmabesturing), een uitbreidbare tijdelijke “geheugen” en een meer permanent “Opslag” die feitelijk in de permanente blockchain is geschreven, en het belangrijkste is dat de EVM totaal vereist determinisme binnen de slimme contracten.

Deze vereiste voor determinisme is de reden waarom je de functie “random ()” niet in Solidity-taal zult zien. Wanneer een ethereum-blok wordt “gedolven”, worden de smart-contractimplementaties en functieaanroepen binnen dat blok (wat betekent dat die in de rij staan ​​om te gebeuren binnen de duur van het laatste blok) uitgevoerd op het knooppunt dat het blok mineert, en de nieuwe status verandert opslagruimten of transacties binnen dat smart-contract vinden daadwerkelijk plaats op dat minerknooppunt. Vervolgens wordt het nieuwe blok verspreid naar alle andere knooppunten en probeert elk knooppunt het blok onafhankelijk te verifiëren, wat inhoudt dat dezelfde statuswijzigingen ook worden aangebracht in hun lokale kopie van de blockchain. Hier is waar het zal mislukken als het slimme contract niet-deterministisch werkt. Als de andere knooppunten geen consensus kunnen bereiken over de staat van blockchain nadat het nieuwe blok en de bijbehorende contracten zijn uitgevoerd, kan het netwerk letterlijk stoppen.

Dit is de reden waarom ethereum smart-contracts (en smart-contracts in het algemeen in elk blockchain-systeem) deterministisch moeten zijn: zodat het netwerk van knooppunten altijd kan valideren en consensus kan behouden over de nieuwe blokken die binnenkomen, om te kunnen blijven draaien.

Een andere beperking die u aantreft in slimme EVM-contracten, is het onvermogen om toegang te krijgen tot gegevens buiten het “geheugen” en “opslag” (we willen niet dat het slimme contract de harde schijven van de knooppunten waarop het draait), en het onvermogen om externe bronnen op te vragen zoals met een JQuery. We hebben niet echt toegang tot veel bibliotheekfuncties, zoals het ontleden van JSON-structuren of het doen van drijvende-kommaberekeningen, en het is eigenlijk te duur om die subroutines uit te voeren of veel gegevens op te slaan in de ethereum-blockchain zelf.

Wanneer u een smart-contract belt dat een statusveranderend werk of berekeningen uitvoert (elke andere actie dan alleen lezen uit de opslag), loopt u een gas “kosten” voor het werk dat door het slimme contract wordt gedaan, en deze gaskosten zijn gerelateerd aan de hoeveelheid rekenwerk die nodig is om uw functie uit te voeren. Het is een soort ‘microbetaling voor microcomputers’-systeem, waarbij je kunt verwachten dat je voor altijd een bepaalde hoeveelheid gas betaalt voor een bepaalde hoeveelheid berekeningen..

De prijs van gas zelf is bedoeld om over het algemeen constant te blijven, wat betekent dat wanneer Ether op de wereldmarkten stijgt, de prijs van gas tegen Ether zou moeten dalen. Dus wanneer u een functieaanroep naar een smart-contract uitvoert, kunt u vooraf een schatting krijgen van de hoeveelheid gas die u moet betalen, maar u moet ook de prijs (in ether per gas) die u bereid bent te betalen, en de mining-nodes kunnen beslissen of dat voldoende is om uw smart-contract-functieaanroep in hun volgende blok op te nemen.

Smart-contracts hebben hun eigen adres, van waaruit ze Ether kunnen ontvangen en verzenden. Slimme contracten kunnen de “beller” van de functie op een verifieerbare manier volgen, zodat het kan bepalen of een van zijn functies wordt aangeroepen door een geprivilegieerde “eigenaar” of “admin” -account, en dienovereenkomstig handelen voor administratieve functies. Ze hebben de mogelijkheid om gegevens uit de ethereum-blockchain te lezen en toegang te krijgen tot informatie over transacties in oudere blokken. Maar zijn slimme contracten ‘opgesloten’ in hun eigen kleine deterministische wereld, alleen in staat om op de hoogte te zijn van gegevens die zijn opgeslagen in de etherische blockchain zelf?

Helemaal niet! Dat is waar “Orakels” binnenkomen. We kunnen een orakel bellen dat ons op een betrouwbare manier iets over de buitenwereld vertelt, en handelen op basis van die gegevens binnen het slimme contract. Het belangrijkste punt hier is dat, hoewel real-world gebeurtenissen zelf niet deterministisch zijn, het orakel kan worden vertrouwd om altijd op een deterministische manier te antwoorden op de verzoeken van elk knooppunt over wat er is gebeurd, zodat alle knooppunten toch tot een consensus kunnen komen. Dus dit is hoe het vertrouwde Oracle in theorie werkt: een ‘orakel’ neemt wat gegevens, bijvoorbeeld een ticker prijsfeed over een echte aandelenkoers, en registreert die gegevens in ‘opslag’ in een eenvoudig Oracle smart-contract, iets zoals dit

(zie ook de uitleg hier

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

alleen Oracle

retourneert (bool succes)

# bewaar ticker-gegevens in de keten

tickerData [symbol] [block.number] = [open, hoog, laag, dicht]

# tickerData is een kaart met kaarten, string => uint => array [uint, uint, uint, uint]

terugkeer waar;

Er zijn bedrijven die gespecialiseerd zijn in het zijn van het vertrouwde orakel en het ontwerpen van systemen om te voorkomen dat ze vertrouwd hoeven te worden met de datafeed. Als we kijken naar de Oraclize-documentatie we zien dit interessante citaat:

Het doel is met name niet om slimme contractontwikkelaars te dwingen Oraclize de gegevens te geven die ze nodig hebben. Zonder enige ondersteuning van authenticiteit zou Oraclize gemakkelijk met de gegevens kunnen knoeien. Dit is de reden waarom Oraclize, om deze complexe taak te voltooien, de gevraagde gegevens retourneert, samen met een bewijs van de authenticiteit: dat wil zeggen dat de gegevens afkomstig zijn van de gegevensprovider die expliciet is geëist door het slimme contract.

Dus je zou dat documentgedeelte over ‘authenticiteitsbewijzen’ moeten bekijken voor meer details, maar het idee is dat zelfs wanneer nieuwe ethereum-nerds, op een bepaald moment in de toekomst, hun ethereum-knooppunten opstarten en hun blockchains beginnen te synchroniseren met het netwerk , alle gegevens die ze nodig hebben om al die ‘orakelafhankelijke’ slimme contracten uit te voeren, zijn veilig aan de ketting om voor altijd te downloaden. De kwestie van wie het ‘gas’ betaalt voor het orakel om al dat schrijven over real-world gebeurtenissen te doen (blockchain-opslag ‘state-changing’ kost gas) is een ander onderwerp, maar in feite wordt het vooruitbetaald door de data-aanvrager in een van de vele manieren. Het leuke hier is dat, ook al kunnen we geen smart-contract schrijven dat ‘dobbelstenen gooit’ in de zin van feitelijke willekeur, het is eigenlijk mogelijk om een ​​smart-contract te schrijven dat reageert op de worp van een dobbelsteen, zoals voorgeschreven door een orakel.

Solidity Basics-zelfstudie

Basiscode achtergrond en instellingen

Laten we dus aan de slag gaan met een eenvoudig ethereum smart-contract, geschreven in Solidity-taal. De beste manier om te leren is door te doen! We kunnen aan het kleine codefragment hierboven zien dat we een vrij eenvoudige syntaxis voor functie-declaratie hebben, en wat basis gegevenstypen zoals ‘uint’ (geheel getal zonder teken) en ‘string’, en we zien in de documenten dat we ook variabeletypen hebben zoals ‘address’, die de methoden ‘.balance’ en ‘.transfer’ bevatten, die voorspelbaar de balans retourneren bij een Ethereum adres, en laat het smart-contract daadwerkelijk Ether naar dat adres sturen, met eenheden uitgedrukt in Wei.

We hebben uw basisarrays, enums, operators, hash-datastructuren genaamd ‘mappings’, en enkele speciale vooraf gedefinieerde eenheden en globale variabelen waaronder zaken als blokhoogte, tijdstempel van het laatste blok en enkele handige SHA-hash- en adres- / toetsmanipulatiefuncties. Een belangrijke gril over Solidity bij het werken met multidimensionale arrays: indexering is in ‘omgekeerde’ volgorde van de meeste talen alleen tijdens aangifte, zoals vermeld in de documenten:

Een array met vaste grootte k en elementtype T wordt geschreven als T [k], een array met dynamische grootte als T []. Als voorbeeld: een array van 5 dynamische arrays van uint is uint [] [5] (merk op dat de notatie omgekeerd is in vergelijking met sommige andere talen). Om toegang te krijgen tot de tweede uint in de derde dynamische array, gebruik je x [2] [1] (indices zijn op nul gebaseerd en toegang werkt op de tegenovergestelde manier van de declaratie …)

Oké, we hebben hier genoeg basishulpmiddelen om gevaarlijk te zijn, laten we beginnen. Laten we een soort eenvoudige sociale app maken waar mensen wat afbeeldingen en wat basisinformatie over zichzelf in de blockchain kunnen plaatsen. Elke gebruiker heeft een ethereum-adres en een “handle” of gebruikersnaam die aan zijn account is gekoppeld. We hebben een aantal demografische basisgegevens die mensen wel of niet invoeren, en dan hebben we een eenvoudige zoekpagina waar je gebruikers in een basisdirectory kunt opzoeken en de afbeeldingen kunt bekijken die ze aan hun gebruiker hebben toegevoegd / notarieel zijn verklaard profiel.

Hier is een afbeelding van hoe ons laatste ethereum Solidity smart-contract Decentralized App (Ðapp) gebruikersinterfaceproduct eruit zal zien, met gebruikers en notariële afbeeldingen toegevoegd:

Hoe soliditeit te leren: de ultieme Ethereum-coderingsgids

Ik heb een mooie foto van mezelf gemaakt voor jullie, en een afbeelding van een Galium Arsenide Crystal-structuur uit mijn schooltijd voor jullie. U kunt de SH256-notaris-hashes en tijdstempels voor elke afbeelding zien en een klein vinkje dat aangeeft dat de notariële afbeeldingsgegevens nog steeds overeenkomen met de notaris-hash die is gemaakt op het aangegeven tijdstempel. Dus ik ga je laten zien hoe ik deze app heb gebouwd, waarbij ik de interessante weetjes voor je aanwijst, met alle links en codevoorbeelden die je nodig hebt voor toekomstig gebruik. Klinkt goed? Laten we gaan!

Het eerste dat ik ga doen, is een Truffel “Testbed” waarmee ik gemakkelijk kan testen tijdens het samenstellen van mijn slimme contract. Het compileren en implementeren van slimme contracten omvat het genereren van lang ondertekende transacties, maar Truffle stelt me ​​in staat om mijn slimme contract te compileren / implementeren en testen met behulp van eenvoudige opdrachten. Er zijn een heleboel tools die dit kunnen doen, maar ik vind het toevallig leuk deze videozelfstudie over Solidity smart-contract die de Truffel gereedschap. ik heb een demo github-project map die ik speciaal voor deze tutorial heb gemaakt, zodat iedereen deze kan volgen. Ik begin met enkele eenvoudige installatieopdrachten (in een Linux-omgeving van Debian):

tectract @ blockgeeks / ethereum-demo-tools> npm i -g truffel

# als u een toestemmingsfout tegenkomt bij het installeren van knooppuntmodules, kijk dan hier

tectract @ blockgeeks / ethereum-demo-tools> mkdir Geekt # Ik ga mijn sociale applicatie bellen "Geekt"

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

tectract @ blockgeeks / ethereum-demo-tools / Geekt> truffle init # dit creëert een paar mappen en setup-bestanden, binnen de Geekt / map

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

contracten migraties test truffle.js # we hebben drie mappen gemaakt en een nieuw bestand genaamd truffle.js

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

ConvertLib.sol MetaCoin.sol Migrations.sol # we hebben enkele basissjablooncontracten gegenereerd door Truffle

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

1_initial_migration.js 2_deploy_contracts.js # een paar bestanden voor compilatie / migratie-instellingen met Truffle

Een eenvoudig voorbeeld van een solide smart contract

Oké, ik ga een contract maken met de naam Geekt.sol, in de map / Geekt / contracts die werd gegenereerd toen ik ‘truffle init’ aanriep. Je kan de … zien volledige contractcode hier, en ik zal hier de meest interessante stukjes noemen. Aan de bovenkant van het bestand staat een regel die de compilerversie specificeert en enkele basiscontractdefinitiesyntaxis en variabeledefinities.

pragma stevigheid ^ 0.4.4;

contract Geekt {

adres GeektAdmin;

toewijzing (bytes32 => notarizedImage) notarizedImages; // dit maakt het mogelijk om notariële afbeeldingen op te zoeken met hun SHA256notaryHash

bytes32 [] imagesByNotaryHash; // dit is als een witpagina van alle afbeeldingen, door SHA256notaryHash

mapping (adres => Gebruiker) Gebruikers; // hiermee kunnen gebruikers worden opgezocht op basis van hun etheradres

adres [] usersByAddress; // dit is als een whitepage van alle gebruikers, op ethereumadres

Wanneer je een toestandveranderende functie in de echte wereld aanroept, zal je moeten specificeren hoeveel ether je daarvoor moet betalen, maar gelukkig kun je een schatting opvragen van de kosten in termen van gaskosten en gasprijs ( in gas / ether) vooraf, en het is meestal zeer nauwkeurig. De ethereum-miners zullen beslissen of je genoeg hebt betaald en je statusveranderende transactie opnemen in het volgende blok, dus je moet eigenlijk wachten tot die functies terugkeren wanneer het volgende blok wordt gevonden. Het uitlezen van gegevens uit deze “opslag” -structuren is gratis en u hoeft ook niet te wachten op het volgende blok, nodes lezen de gegevens gewoon en sturen deze meteen naar u terug.

Dus de Gebruikers mapping is ons belangrijkste opslagobject waarmee we gebruikersobjecten kunnen maken en deze op adres kunnen opzoeken. Toewijzingen zijn superefficiënt om gegevens op te slaan en snel op te halen, maar er is geen gemakkelijke manier om een ​​kaart te herhalen, dus u kunt zien dat ik ook een usersByAddress adresarray die elk bekend adres van een gebruiker in ons systeem bevat, zoals een witte pagina van alle gebruikers. Ik heb het

Ik heb het notariële afbeeldingen mapping om ons in staat te stellen “beeld” -objecten in opslag te maken en ze op te zoeken met een bijbehorende SHA256-hash van de afbeeldingsgegevens, en die notaryHash-indexen zijn 32 bytes lang.

We hebben ook een ImagesByNotaryHash bytes32-array die een lijst is van alle notaryHashes, zoals een witte pagina waarmee we alle afbeeldingen kunnen herhalen die zijn gelegaliseerd.

struct notarizedImage {

tekenreeks imageURL;

uint timeStamp;

struct gebruiker {

string handvat;

bytes32 stad;

bytes32 staat;

bytes32 land;

bytes32 [] myImages;

Deze (hierboven) zijn zeer eenvoudige structuren, en ze vertegenwoordigen ook ‘opslag’-objecten, dus ze kosten echte ether om te’ creëren ‘en de gegevens erin worden feitelijk opgeslagen in de ethereum-blockchain, en het kost echte ether om de’ status ‘te veranderen ”Van hun interne variabelen. We hebben eigenlijk alleen de buitenste mappings en arrays gebruikt om bij te houden waar in het blockchain-geheugen deze afbeeldings- / gebruikersstructuren zich bevinden. Onze notarizedImage struct slaat eenvoudigweg een URL naar een afbeelding op, vermoedelijk ergens op het web, en een tijdstempel die aangeeft wanneer de afbeelding is gelegaliseerd. Onze Gebruiker struct slaat een aantal basisgebruikers op: handle, stad, staat, land, en het slaat ook een reeks op van alle afbeeldingen die deze gebruiker notarieel heeft vastgelegd en ‘toegevoegd’ aan zijn gebruikersaccount, zoals een mini-gebruiker-per-gebruiker-versie van de globale imagesByNotaryHash witte pagina’s-object.

functie registerNewUser (string handle, bytes32 city, bytes32 state, bytes32 country) geeft (bool success) {

adres thisNewAddress = msg.sender;

// overschrijf bestaande vermeldingen niet en zorg ervoor dat handle niet null is

if (bytes (gebruikers [msg.sender] .handle) .length == 0 && bytes (handle) .length! = 0) {

Gebruikers [thisNewAddress] .handle = handle;

Gebruikers [thisNewAddress] .city = city;

Gebruikers [thisNewAddress] .state = state;

Gebruikers [thisNewAddress] .country = country;

usersByAddress.push (thisNewAddress); // voegt een vermelding voor deze gebruiker toe aan de ‘whitepages’ van de gebruiker

terugkeer waar;

} anders {

teruggeven false; // een van beide handle was null, of er bestond al een gebruiker met deze handle

Hier is onze registerNewUser functie. Het neemt handle, stad, staat, land als invoervariabelen en retourneert waar of onwaar om succes of mislukking aan te geven. Waarom zou het mislukken? We willen niet dat gebruikers elkaars handle overschrijven, dus dit wordt een soort eerste claimsysteem voor handvatten. Als er al een gebruiker met deze handle bestaat, retourneren we null, dus ik heb daar een conditianal “if” -regel geplaatst om dat te controleren. We staan ​​ook het aanmaken van een gebruikersnaam zonder handvat niet toe. Een ding dat we opmerken is de thisNewAddress dat is de beller van de functie, je kunt zien dat we de special gebruiken msg.sender functie om die gegevens op te halen, dit is het adres waarvandaan de “doe deze functie” -transactie werd verzonden wanneer iemand (iemand) onze slimme contractfunctie aanroept, en ze betalen echte ether om het te doen. Dus een “mapping” -object is standaard null, en wanneer we aanroepen:

Gebruikers [thisNewAddress] .handle = handle;

Dit maakt een nieuw gebruikersobject aan in onze gebruikersmapping en stelt de handle in. Hetzelfde geldt voor stad, staat, land. Merk op dat we ook het adres van de nieuwe gebruiker naar het ‘white-pages’-object van onze usersByAddress global Users pushen voordat we daar true retourneren.

functie addImageToUser (string imageURL, bytes32 SHA256notaryHash) retourneert (bool success) {

adres thisNewAddress = msg.sender;

if (bytes (Users [thisNewAddress] .handle) .length! = 0) {// zorg ervoor dat deze gebruiker eerst een account heeft aangemaakt

if (bytes (imageURL) .length! = 0) {//) {// kon bytes32 null check niet laten werken, nou ja!

// voorkom dat gebruikers vechten om sha->afbeeldingen in de whitepages, maar laat ze toch een persoonlijke referentie toevoegen aan elke sha

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

imagesByNotaryHash.push (SHA256notaryHash); // voegt een vermelding voor deze afbeelding toe aan onze afbeeldingswitpagina’s

notarizedImages [SHA256notaryHash] .imageURL = imageURL;

notarizedImages [SHA256notaryHash] .timeStamp = block.timestamp; // merk op dat het bijwerken van een afbeelding ook het tijdstempel bijwerkt

Gebruikers [thisNewAddress] .myImages.push (SHA256notaryHash); // voeg de afbeeldingshash toe aan de .myImages-array van deze gebruiker

terugkeer waar;

} anders {

teruggeven false; // ofwel imageURL of SHA256notaryHash was null, kon afbeelding niet opslaan

terugkeer waar;

} anders {

teruggeven false; // gebruiker had nog geen account, kon afbeelding niet opslaan

Onze addImageToUser naar gebruikersfunctie is vrij gelijkaardig aan de registerNewUser functie. Het zoekt u op via uw verzendadres via de special msg.sender object en controleert of er een geregistreerde gebruiker (via handle) is voor dat adres voordat deze probeert een afbeelding toe te voegen voor uw gebruikersinvoer. We staan ​​gebruikers toe om hun notaryHash alleen toe te voegen aan de wereldwijde witte pagina’s met afbeeldingen als deze niet bestaat, om te voorkomen dat gebruikers vechten om vermeldingen in de algemene witte pagina’s, maar we staan ​​hen toe om notaryHash-gegevens toe te voegen / bij te werken binnen hun eigen mini-whitepages van hun eigen afbeeldingen. Niets aan de hand!

functie getUsers () constante retourneert (adres []) {return usersByAddress;​

functie getUser (adres gebruikerAddress) constante retourneert (string, bytes32, bytes32, bytes32, bytes32 []) {

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

functie getAllImages () constante retourneert (bytes32 []) {return imagesByNotaryHash;​

functie getUserImages (adres userAddress) constante retourneert (bytes32 []) {return Users [userAddress] .myImages;​

functie getImage (bytes32 SHA256notaryHash) constante retourneert (string, uint) {

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

Ten slotte stellen de (bovenstaande) accessorfuncties ons in staat om eenvoudig elke gebruiker of afbeelding voor te lezen, of de volledige lijst met witte pagina’s van alle gebruikers of alle afbeeldingen te krijgen. Merk op dat deze functies terugkeren constante gegevens, wat in feite betekent dat ze alleen-lezen zijn, niet “statusveranderend” en ze zijn vrij om te bellen en ze sturen de gegevens meteen terug, je hoeft niet te wachten tot het volgende blok. We bellen in feite gewoon onze globale mappings / arrays in en retourneren de relevante gegevens: gebruikers op adres of afbeeldingen door notaryHash.

Compileren & Een slim contract testen

Nu willen we ons smart-contract daadwerkelijk lokaal testen, in een testomgeving. Het is heel gemakkelijk om eenvoudige Truffel-commando’s te gebruiken, maar eerst hebben we eigenlijk een lokaal ethereum-knooppunt om tegen te testen. Dat is waar Ethereum TestRPC komt binnen. TestRPC is eigenlijk een nepknooppunt, een slank programma dat zich gewoon voordoet als een knooppunt en reageert zoals een knooppunt zou reageren op je localhost-machine. TestRPC draait op poort 8545 als een normaal ethereum-knooppunt, en het heeft de mogelijkheid om Solidity smart-contracts in EVM-code te compileren en die code ook uit te voeren, plus je krijgt directe reacties om te testen, in plaats van te moeten wachten op het echte ethereum-netwerk om vind het volgende blok. Nu zou je Truffle-test compileer / implementatie-opdrachten kunnen uitvoeren tegen een echt ethereumknooppunt, maar dat zou echte Ether kosten, plus het kost tijd en geheugen om je eigen knooppunt te draaien als dat niet nodig is. Dus we doen een paar snelle installatieopdrachten:

npm i -g ethereum-testrpc

testrpc -m “monster hond kom jaar spray crawl leren algemeen detecteren zilvergelei piloot”

Dit start TestRPC met een gespecificeerde “seed” -zin, en je zou zoiets als dit moeten zien als de uitvoer:

EthereumJS TestRPC v3.0.5

Beschikbare accounts

(0) 0x0ac21f1a6fe22241ccd3af85477e5358ac5847c2

(1) 0xb0a36610de0912f2ee794d7f326acc4b3d4bc7bc

(9) 0x4c1cc45ef231158947639c1eabec5c5cb187401c

Privésleutels

(0) 91e639bd434790e1d4dc4dca95311375007617df501e8c9c250e6a001689f2c7

(1) afaeff0fc68439c4057b09ef1807aaf4e695294db57bd631ce0ddd2e8332eea7

(9) dcc51540372fa2cf808efd322c5e158ad5b0dbf330a809c79b540f553c6243d7

HD-portemonnee

Ezelsbruggetje: monster hond kom jaar sproeien kruipen leren algemeen detecteren zilveren gelei piloot

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

Luisteren op localhost: 8545

U ziet hier wat activiteit in dit venster terwijl TestRPC wordt uitgevoerd, terwijl u uw smartcontract implementeert en ermee communiceert via Truffle of Web3.js. Oké, we zijn klaar voor testimplementatie. U moet het bestand aanpassen /migrations/2_deploy_contracts.js om de naam van uw smart-contract op te nemen, zodat truffel het kan compileren en implementeren. We doen dit commando:

truffel compileren

Als alles goed gaat, ziet u een bericht dat het “artefacten opslaat” en geen foutmeldingen. Ik ga niet liegen, als uw contract syntaxisfouten of andere problemen bevat, zullen de compileerfoutmeldingen die u ziet waarschijnlijk mysterieus en moeilijk te interpreteren zijn! Als u een foutmelding krijgt over de “stackgrootte”, betekent dit waarschijnlijk dat er te veel variabelen in / uit een functieaanroep worden doorgegeven. Een goede regel om te onthouden is dat 16 variabelen invoer of uitvoer in het algemeen het maximum is. Onthoud ook dat Solidity smart-contracts geen aangepaste struct-gegevenstypen kunnen retourneren, dus u zult daar ook omheen moeten werken, meestal retourneer ik alleen arrays en pointer / adressen van andere structs in mijn interne toewijzingen. Als je krijgt looptijd foutmelding over de “stapel”, dat kan betekenen dat je een slechte voorwaardelijke code in je code hebt.

truffel migreren

Deze opdracht (hierboven) doet eigenlijk de testimplementatie van uw smart-contract op uw TestRPC-knooppunt. Ik zie deze output terugkomen:

Migratie uitvoeren: 1_initial_migration.js

Migraties implementeren…

Migraties: 0xd06a1935230c5bae8c7ecf75fbf4f17a04564ed8

Succesvolle migratie naar netwerk opslaan…

Artefacten opslaan…

Migratie uitvoeren: 2_deploy_contracts.js

Geekt…

Geekt: 0xe70ff0fa937a25d5dd4172318fa1593baba5a027

Succesvolle migratie naar netwerk opslaan…

Artefacten opslaan..

Ons smart-contract (genaamd “Geekt”) krijgt een adres op de Ethereum-blockchain wanneer het succesvol wordt geïmplementeerd, u kunt hierboven zien, het adres is 0xe70ff0fa937a25d5dd4172318fa1593baba5a027. Op een echt, live ethereumnetwerk betaal je gas om je contract in te zetten en verandert het adres nooit. Als u TestRPC op TestRPC afsluit, zal het alles vergeten, en zodra u TestRPC weer opstart, moet u uw contract opnieuw implementeren en krijgt u een ander adres voor uw smart-contract. Het adres van uw smart-contract is waar mensen transacties met berichten kunnen verzenden om ermee te communiceren, statusveranderende transacties uit te voeren of gewoon gegevens uit de etherische blockchain te lezen. Slimme contracten kunnen ook communiceren direct met elkaar via deze adressen, met behulp van “berichten”. Slimme contracten die communiceren met andere slimme contracten om gegevens op te slaan, te wijzigen of te lezen via deze etherische blockchain-berichten staan ​​bekend als Gedecentraliseerde autonome organisaties, of DAO’s.

Ok, nu komt het leuke gedeelte. We zijn klaar om daadwerkelijk een eerste test uit te voeren en te communiceren met ons slimme contract. We starten de Truffle “console” en doen wat vragen tegen onze TestRPC localhost node, om er zeker van te zijn dat alles werkt en dat we gebruikers en afbeeldingen kunnen toevoegen en ze correct kunnen ophalen.

truffel console

> Geekt = Geekt.deployed ()

> Geekt.then (function (instance) {return JSON.stringify (instance.abi);})

> Geekt.then (function (instance) {return instance.registerNewUser ("Tectract","Denver","CO","VS"​

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

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

> Geekt.then (function (instance) {return instance.getImages ();})

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

Een belangrijk concept hier is de ABI, een object in javascript-indeling dat de functienamen en invoer / uitvoer beschrijft voor interactie met uw smart-contract, het is een beetje zoals de Application Programmer Interface (API) -beschrijving voor uw smart-contract, dat mensen vertelt hoe ze er berichten voor kunnen maken. Mijn registerNewUser () functie werkt! Ik zie dit in reactie op de functieaanroep registerNewUser (), in het consolevenster:

{tx: ‘0x1b9f55971871921ccd23a9aa7620620c6c958a893af334087283926d4c6d60b1’,

bon:

{transactionHash: ‘0x1b9f55971871921ccd23a9aa7620620c6c958a893af334087283926d4c6d60b1’,

transactionIndex: 0,

blockHash: ‘0x2be4fab68daaf8db199e2a6adea101c0f1ed06f46aba21e8e4c06e752ca3325c’,

blockNumber: 5,

gas Gebruikt: 145215,

cumulativeGasUsed: 145215,

contractAddress: null,

logboeken: []},

logboeken: []}

De functie AddImageToUser () retourneert het succes op dezelfde manier, en wanneer ik nu individuele gebruikersrecords of notariële afbeeldingsrecords kan ophalen uit de ethereum blockchain. Mijn functieaanroep getUser () retourneert:

[‘Tectract’,

‘0x44656e766572000000000000000000000000000000000000000000000000000000’,

‘0x434f00000000000000000000000000000000000000000000000000000000000000’,

‘0x555341000000000000000000000000000000000000000000000000000000000000’,

[‘0x6c3e007e281f6948b37c511a11e43c8026d2a16a8a45fed4e83379b66b0ab927’]]

en ik kan die afbeeldingsgegevens pakken via de 32-byte SHA256Notary hash-string die ik eraan heb gekoppeld, mijn functie getImage () retourneert:

[‘www.myimageURL.com’,

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

Dit ziet er allemaal geweldig uit. Alles werkt, getest in TestRPC en Truffle, en we zijn klaar om daadwerkelijk een coole grafische gebruikersinterface voor onze Ðapp te bouwen, zodat de wereld kan communiceren met onze gebruikersregistratie en beeldnotaris op de ethereum blockchain.

Basis Ethereum ÐApp-ontwerp

Localhost-ontwerp & Testen

We zijn er klaar voor, ons Solidity-taal smart-contract is met succes samengesteld en geïmplementeerd op onze lokale testRPC-ethereum-node. Nu kunnen we snel een eenvoudige ÐApp bouwen waarmee gebruikers via hun webbrowser kunnen communiceren met het smart-contract, met behulp van wat basiswebprogrammering en de speciale Web3.js Javascript-module, speciaal gemaakt om te communiceren met Ethereum-knooppunten en slimme contracten via internet.

ik heb gemaakt deze demo (open-source github-repositories) als referentie voor mensen om te gebruiken tijdens het bouwen van Ethereum ÐApps met web3.js, Deze demo is gemaakt met een eenvoudig te gebruiken tool genaamd Create-React-App, het maakt gebruik van de Facebook-interne webtaal React, maar we zullen ons niet concentreren op enige React-code, alleen de web.js javascript-opdrachten die nodig zijn. Mijn code is in CommonJS, het is bijna precies hetzelfde als het oude ES6-javascript.

Dus installeer je in je webapp de node-module web3 via een commando als “npm i -S web3” en het zal in uw package.json-bestand opslaan, als u er een gebruikt. Dus je zou, in een “” tag of in een .js-bestand, een regel als deze hebben om de web3-module zelf te laden:

importeer Web3 van ‘web3’;

(of, in ES6 javascript)

var Web3 = vereisen (‘web3’);

We moeten Web3 wat details over ons knooppunt en ons smart-contract vertellen, zodat het verbinding kan maken. U ziet regels als deze:

# deze regel specificeert onze localhost node IP: poortinstellingen

var web3 = nieuwe Web3 (nieuwe Web3.providers.HttpProvider ("http: // localhost: 8545"​

# ons slimme contractadres, van bovenaf

var GeektAddress = ‘0xe70ff0fa937a25d5dd4172318fa1593baba5a027’;

# onze smart-contract ABI, als onbewerkt javascript-object, niet geciteerde tekenreeks!

var GeektABI = [{"constante": waar,"ingangen"​,"naam"​"getUsers","uitgangen"​"naam"​"", ​

# dit laadt het smart-contract in ons web3-object

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

# hiermee wordt het standaardaccount gevonden dat wordt vermeld voor de knooppuntverbinding (account 0 van TestRPC hierboven)

defaultAccount = web3.eth.accounts [0];

Hier zijn enkele regels die alleen-lezen functies demonstreren die samenwerken met ons smart-contract, via web3:

# de onderstaande functie wordt geactiveerd wanneer de pagina wordt geladen, om het "witte pagina’s" van alle bekende gebruikersadressen

GeektContract.getUsers (functie (err, usersResult) {

# de onderstaande functie pakt indien nodig een afbeelding op en slaat deze op in het browsergeheugen…

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

Deze eenvoudige demo ÐApp laadt gewoon alle bekende gebruikersadressen en pakt de daadwerkelijke details van de gebruikersafbeelding en de afbeelding legt zichzelf vast als dat nodig is. Hier is een screenshot:

Hoe soliditeit te leren: de ultieme Ethereum-coderingsgids

Op dit punt (afbeelding hierboven) heb ik mijn TestRPC-client vernieuwd en zojuist de opdracht “truffel migreren” uitgevoerd, die het smart-contract implementeert tegen mijn localhost TestRPC-knooppunt. U kunt zien dat de interface klaar is om op de knop te klikken en de eerste gebruiker te “registreren”. Wanneer ik op deze knop klik, wordt mijn registerNewUser () -functie van mijn smart-contract aangeroepen, waarbij deze gebruikersgegevens worden toegevoegd aan mijn (localhost testing) ethereum blockchain-knooppunt op het smart-contract-adres dat we hierboven hebben genoteerd. Het toevoegen van gebruikersgegevens aan de blockchain “opslag” kost gas, en we moeten uitzoeken hoeveel gas we moeten betalen, in plaats van alleen een wetenschappelijke gok (SWAG) te doen. Hier is de code die daadwerkelijk wordt aangeroepen wanneer op deze knop ‘Gastenboek ondertekenen’ wordt geklikt:

GeektContract.registerNewUser.estimateGas (

outerThis.state.defaultHandle,

outerThis.state.defaultCity,

outerThis.state.defaultState,

outerThis.state.defaultCountry,

{from: defaultAccount},

functie (err, resultaat) {

var myGasNum = resultaat;

GeektContract.registerNewUser.sendTransaction (

outerThis.state.defaultHandle,

outerThis.state.defaultCity,

outerThis.state.defaultState,

outerThis.state.defaultCountry,

{from: defaultAccount, gas: myGasNum},

functie (err, resultaat) {

U kunt dus zien dat wanneer we een toestandveranderende transactie uitvoeren waarvoor we daadwerkelijk moeten betalen met ethergas (echt of testnetgas), we dit zullen noemen registerNewUser.estimateGas () functie vooraf, en gebruik dan die geschatte hoeveelheid gas wanneer we de statusveranderende functie echt aanroepen, met behulp van de registerNewUser.sendTransaction () functie.

Toen we TestRPC startten en het enkele testportefeuilleadressen voor ons uitspuugt, lijken deze accounts op het account dat u zou hebben als u een volledig knooppunt zou draaien en er een getAccounts RPC-opdracht voor zou uitvoeren, zoals een portemonnee met een volledig knooppunt. TestRPC geeft u enkele gratis testnet-munten, 100 testnet Ether per account bij het opstarten.

Wanneer we deze toestandsveranderende functies zoals noemen registerNewUser () of addImageToUser (), in de localhost-testfase, tegen onze TestRPC-node, betaalt TestRPC alleen het testnetgas voor u en retourneert het resultaat van de transactie meteen. Op een volledig localhost-knooppunt zou u dat account moeten “ontgrendelen” voordat de transactie zou slagen op het mainnet, en u zou op het mainnet moeten wachten op het volgende blok om uw transactie op te halen, ervan uitgaande dat onze schatting van het gas voldoende was! Maar er is altijd een betere manier, mijn homies &# x1f642;

Uw Ðapp aansluiten op het hoofdnet

Ik heb smart-contract opgezet en geïmplementeerd op het etherische Mainnet, en deze demo-app op een van mijn webservers, op www.enledger.io/etherereum-demo-tools. Als u deze site bezoekt en geen TestRPC of volledig ethereum-knooppunt draait op localhost: 8545, en u deze site bezoekt, ziet u waarschijnlijk zoiets als dit:

Zag verbinding met netwerk: !

Saw default account: (geen web3.eth node link)

Dus, betekent dit dat je een volledig ethereum-knooppunt nodig hebt, of een Virtual Private Server (VPS) volledig knooppunt om verbinding mee te maken, om te kunnen communiceren met het etherische Mainnet? Tot voor kort was dat waar, maar nu hebben we deze geweldige Chrome-plug-in genaamd Metamask (voor Chrome-browser), waarmee je verbinding kunt maken met het etherische Mainnet in je browser, en de Metamask-jongens bieden in feite een verbinding met een volledig knooppunt voor je , daar gratis, dus rekwisieten voor hen!

Je kunt in mijn code zien die ik detecteer voor het speciale “geïnjecteerde” web3-object van de metamask-plug-in die de knooppuntverbinding met hun etherische volledige knooppunt opzet. Hier is de relevante code die automatisch overschakelt naar uw gewone client (localhost) of metamask web3-verbinding:

functie loadWeb3 () {

laat web3Injected = window.web3;

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

console.log ("zag geïnjecteerd web3!"​

web3 = nieuwe Web3 (web3Injected.currentProvider);

} anders {

console.log ("zag web3 niet geïnjecteerd!"​

web3 = nieuwe Web3 (nieuwe Web3.providers.HttpProvider ("http: // localhost: 8545"​

Let in de onderstaande afbeelding op het Metamask Fox-logo in de rechterbovenhoek, ik heb de Metamask-plug-in geïnstalleerd en verbonden met het etherische Mainnet in mijn browser! Je kunt zien dat ik al een paar gebruikers aan het gastenboek heb toegevoegd in ons “Geekt” Gastenboek demo smart-contract. Met de ÐApp-interface kun je gebruikers selecteren en door hun afbeeldingen bladeren, en je zult de pagina Sign Guestbook zien als je verbinding maakt vanaf een adres dat nog geen gebruiker heeft geregistreerd.

Ik heb wat code toegevoegd, zodat je gewoon de URL kunt plakken van een afbeelding die je aan je gebruikersaccount wilt toevoegen, en het zal de SHA256 notaris hash ophalen die je aan de afbeelding kunt toevoegen, en het zal ook de SHA256 notaris hashes van afbeeldingen terwijl ze op de pagina worden geladen en u een klein groen vinkje of een rode ‘X’ geven, afhankelijk van of de afbeelding op die URL en de notaris-hash nog steeds overeenkomen. Ik voeg hier de afbeelding van het “BlockGeeks” -logo toe aan mijn Ryan M.-gebruikersaccount en ik heb op de knop geklikt om de afbeelding voor deze gebruiker toe te voegen.

De Metamask-plug-in heeft gedetecteerd dat ik voor deze web3 ethereum-transactie moet betalen met echt Ethereum-gas, en er is een klein venster verschenen om me te vragen of ik deze transactie accepteer. Ik heb een beetje echte Ether naar deze Metamask-portemonnee gestuurd en er is genoeg om de transactie te wissen, dus ik klik op ‘accepteren’.

Hoe soliditeit te leren: de ultieme Ethereum-coderingsgids

Laatste gedachten, diepe reflecties

Dat is het, het werkt! Dit demo-artikel en deze coderepository zouden je enorm moeten helpen om een ​​geweldige Ethereum Solidity Language en ÐApp-ontwikkelaar te worden! U kunt de Metamask-plug-in installeren, verbinding maken met Ethereum Mainnet en bezoeken www.enledger.io/etherereum-demo-tools en je ziet mijn gastenboek / notaris demo-app en dezelfde gebruikers en afbeeldingen, en je kunt zelfs het gastenboek ondertekenen en ook notariële afbeeldingen maken, als je wilt &# x1f642;

Om ervoor te zorgen dat jullie niet al te uit de hand lopen met dit ding, heb ik een kleine moderatiemogelijkheid toegevoegd aan de ‘eigenaar’ van het slimme contract, die ik intern heb ingesteld op het adres van degene die in eerste instantie heeft betaald om de slimme- contract met het mainnet, dat ben ik. Ik wil je heel snel laten zien hoe die speciale admin-mogelijkheid werkt, omdat het vrij normaal is om dit soort admin-gebruikerscodepatroon te zien:

adres GeektAdmin;

function Geekt () payable {// dit is de CONSTRUCTOR (dezelfde naam als contract) het wordt EENMAAL alleen genoemd wanneer het contract voor het eerst wordt geïmplementeerd

GeektAdmin = msg.sender; // stel gewoon de admin in, zodat ze indien nodig slechte gebruikers of afbeeldingen kunnen verwijderen, maar niemand anders kan

modifier onlyAdmin () {

if (msg.sender! = GeektAdmin)

werpen;

// Vergeet de "​"! Het wordt vervangen door de daadwerkelijke functie van de functie wanneer de modificator wordt gebruikt.

functie removeUser (adres badUser) onlyAdmin retourneert (bool success) {

gebruikers verwijderen [badUser];

terugkeer waar;

functie removeImage (bytes32 badImage) onlyAdmin retourneert (bool success) {

notarizedImages [badImage] verwijderen;

terugkeer waar;

We hebben een speciale constructorfunctie, Geekt (), met dezelfde naam als het contract zelf, die maar één keer wordt gebeld, wanneer het contract voor het eerst wordt geïmplementeerd op de blockchain. Deze functie stelt de admin-gebruiker in op het adres van de msg.sender die heeft betaald om het smart-contract te implementeren. We hebben ook een speciale onlyAdmin () modifier-functie die vervolgens wordt toegepast op onze removeUser () en removeImage () functies, om die functies te beperken zodat ze alleen kunnen worden geactiveerd als het msg.sender-adres het admin-gebruikersadres is.

Nu heb ik een manier om alle badUsers te verwijderen, indien nodig &# x1f642; Laat me het niet doen!

Een ander laatste punt dat ik wil noemen, is dat we hier pas echt de oppervlakte hebben bekrast. Een soort basisfunctie die ik niet heb behandeld, is Solidity ‘events’, wat een manier is om updates terug naar de browser te pushen, een soort van een ‘socket’ -verbinding die browsergebeurtenissen bekijkt en activeert wanneer nieuwe geregistreerde gebruikers of afbeelding is gedetecteerd. De echt coolste delen van ethereum en Solidity komen van slimme contracten die communiceren met Oracles, en slimme contracten die met elkaar praten en handelen met behulp van ‘berichten’ (DAO’s). Er zijn er ook enkele

De echt coolste delen van ethereum en Solidity komen van slimme contracten die communiceren met Oracles, en slimme contracten die met elkaar praten en handelen met behulp van ‘berichten’ (DAO’s). Er zijn er ook enkele vrij serieus beveiligingsoverwegingen die u moet leren kennen, voordat u gaat proberen om echt ethereum op te slaan in uw smart-contract en het naar mensen te sturen op basis van functieaanroepen, een aantal mensen zijn ongeveer M dollar kwijtgeraakt over dat ene en het heeft uiteindelijk het ethereum-netwerk opgesplitst in een omstreden harde vork. Dat is iets waar je echt op moet letten, en dat zou ik natuurlijk in een ander artikel moeten behandelen &# x1f642; Dit artikel zou goed moeten zijn om je op weg te helpen en “gevaarlijk” te zijn, zoals ik al zei, en ik moedig je aan om het te leren, zelfs als je kunt een leuk gezelschap te vragen om het te leren, maar er is nog meer op dit pad.

Een ander, het laatste punt waar ik het over wil hebben, is de structuur van ethereum en de werkelijke kosten van het gebruik van slimme contracten, op dit moment. ethereum is een netwerk dat draait op een grote, enkele, openbare blockchain, waar iedereen kan betalen om toegang te krijgen tot gegevens en deze daarin op te slaan. Maar eigenlijk aan het doen dat is ietwat duur. Je kunt hierboven in mijn afbeelding zien dat er 0,004182 Ether in rekening werd gebracht, wat vandaag gelijk is aan $ 0,96 in echte Amerikaanse dollars, om een ​​afbeeldings-URL, SHA256 notaris-hash en tijdstempel, bestaande uit 196 bytes, op te slaan op het Ethereum Mainnet. Dit komt neer op een kosten voor gegevensopslag van $ 5.159,03 per MB!

Dat is letterlijk gek duur. Het oorspronkelijke idee voor gaskosten dat wordt beschreven in de ethereum Whitepaper zegt dat de gaskosten idealiter enigszins constant moeten blijven, maar de gaskosten zijn in de echte implementatie gekoppeld aan het bloknummer en het bloknummer gaat lang niet zo snel omhoog als het huidige marktprijs van ethereum, dus gas wordt in reële termen veel duurder. De hard-fork-situatie laat ook zien dat dit echt een openbare keten is, en als er iets echt omstreden op gebeurt, kan het worden geforkt en kunnen uw gegevens theoretisch worden teruggedraaid, of kan de onderliggende activaklasse sterk in prijs dalen. De enorme kosten van gegevens, en de enorme hoeveelheid gegevens die wachten om te worden opgeslagen, betekent dat de hoeveelheid gegevens die in elke keten kan worden opgeslagen, mogelijk moet worden beperkt of zelfbeperkend kan zijn.

ethereum is misschien het meest geschikt voor zaken die slechts een kleine hoeveelheid openbaar beschikbare gegevensopslag nodig hebben om on-chain te zijn, zoals misschien een online reputatiesysteem of een gegevensnotarisproject. Het is misschien niet logisch om een ​​blockchain-project te bouwen om alle Amerikaanse widget-industrie-gegevens op de ethereum-blockchain te plaatsen, bijvoorbeeld omdat u misschien niet al die informatie openbaar wilt maken, en u die transactiekosten voor uw widget-branchespecifieke toepassingen. Je zou kunnen bedenken dat een proof-of-stake blockchain-model energiezuiniger kan zijn, zelfs als dat een theoretische verzwakking kan betekenen van het consensusbeveiligingsmodel versus Nakamoto proof-of-stake voor je blockchain-project..

Ik stel voor dat u, voordat u aan een nieuw blockchain-project begint, zorgvuldig nadenkt over het platform dat u wilt gebruiken, naar de nieuwste dingen kijkt en niet bang bent om te verkennen, en ook zorgvuldig de knooppunt incentive dat zal mensen aantrekken om je coole knooppuntcode te downloaden en uit te voeren! Het beste compliment dat een programmeur kan krijgen, is dat mensen hun code in de echte wereld gebruiken en er productief mee zijn.

Geheime gekke bonussectie

Zet me op het hoofdnet, kapitein

Ik ben terug, met nog meer geweldige dingen voor jou en de ethereum-gemeenschap! Dus ik heb hierboven een belangrijk detail overgeslagen, misschien is het je opgevallen. Nadat u uw smart-contract hebt geschreven, test u het duizend keer compileren totdat het werkt, implementatie, localhost-test werkt allemaal. Nu, hoe de hel krijg je dit ding op het Mainnet !? Het is een soort van

Het is een beetje moeilijk en houdt meestal in dat je je eigen volledige ethereum-knooppunt moet runnen, of iemand moet betalen om er een voor je uit te voeren en je toegang te geven (zoals via een VPS). Dus dat was echt vervelend voor mij, want ik ben ongeduldig en ik schrijf dit artikel onder een deadline, mensen! Ik heb geen tijd om te wachten tot mijn nieuwe ethereum full-node is gesynchroniseerd, en ik heb geen zin om een ​​paar honderd optredens van harde schijfruimte en een van mijn boxen weg te blazen om ethereum tx fulltime te kraken, en ik ben ook te goedkoop om voor een VPS te betalen om het voor mij te doen, hihi.

Dus ik heb wat speciale javascript web kung-fu gebruikt en ben erachter gekomen hoe ik een webpagina kan maken met een kader en een knop, waar je gewoon je contract kunt plakken, op de knop kunt klikken en een Solidity smart-contract rechtstreeks naar het Mainnet, via Metamask Plugin. Ik deed dit voornamelijk voor het gemak, om dit artikel te schrijven, maar het bleek een verrassend handig hulpmiddel te zijn, dus heb ik het op internet gezet zodat iedereen het kan gebruiken. Voor de eerste keer kunt u al uw tests en zelfs volledige smart-contractimplementatie uitvoeren op het etherische hoofdnet, zonder dat u zelf een volledig eigen ethereumknooppunt nodig hebt! Laat me de EthDeployer tool, het is freeware voor jullie omdat gratis software ons vrijheid geeft &# x1f642;

Hier is een link naar de EthDeployer Repo op Github, en je hebt ook gewoon toegang tot mijn live hardlopen EthDeployer van Tectract en implementeer uw contracten rechtstreeks vanaf daar, u hoeft alleen de Metamask-plug-in te installeren en eerst verbinding te maken met het Ethereum Mainnet, en u heeft natuurlijk ook een beetje Ether in uw Metamask-portemonnee nodig om de Mainnet smart-contract-implementatiekosten te betalen!

Deze tool maakt gebruik van de Browser-Solc tool, wat slechts een browser-verkleinde, verkleinde lader-tool is om de javascript-versie van Solidity Compiler rechtstreeks in de client-side browser te laden, voor het on-the-fly parseren / compileren van een smart-contract. Dit maakt de tool volledig stand-alone en draagbaar, wat betekent dat je je geen zorgen hoeft te maken over het installeren van de Solc-compiler op je computer, en ik hoef me ook geen zorgen te maken over het installeren op mijn server, wat uitstekend is voor iedereen. Laat me wijzen op de code die de nieuwste beschikbare solidity-compiler laadt:

Ik heb het verkleinde browser-solc.min.js javascript laden via de index.html-pagina op het hoogste niveau, wat een window.BrowserSolc object beschikbaar voor mijn reactiescripts op een lager niveau. Dit is weer een heel eenvoudige create-react-app die binnen enkele minuten op je eigen computer kan worden geïnstalleerd en geïmplementeerd, ik heb zelfs een echt nuttige readme.md in de github-repo gegeven die je laat zien hoe je dat moet doen.

setupCompiler () {

var outerThis = this;

setTimeout (functie () {

// console.debug (window.BrowserSolc);

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

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

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

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

compiler = c;

outerThis.setState ({statusMessage:"klaar!"},functie(){

console.log ("Solc-versie geladen: " + compilerVersion);

}, 1000);

De setupCompiler-functie wacht een seconde op het window.BrowserSolc-object om beschikbaar te zijn nadat de pagina is geladen, en doet vervolgens zijn interne .getVersions () en .loadVersion () -functies, er is echt niet veel aan de hand, en we hebben een functionele Solc-compiler direct voor ons beschikbaar in een volledig client-side omgeving, leuk! Voor de volledigheid zal ik enkele relevante regels laten zien die daadwerkelijk omgaan met het compileren en implementeren van het contract vanuit een javascript-functie, wanneer de ‘compile & inzetten!” knop is ingedrukt:

compileAndDeploy () {

var resultaat = compiler.compile (this.state.contractText, optimaliseren);

var abi = JSON.parse (resultaat.contracten [_. sleutels (resultaat.contracten) [0]]. interface);

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

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

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

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

thisTxHash: newContract.transactionHash,

thisAddress: newContract.address

We hebben al onze vertrouwde objecten van vroeger, noemen we compiler.compile () op de contracttekst, en krijg een gecompileerd contract “resultaat” -object waaruit we de abi en bytecode extraheren en verzenden in een nieuwe transactie. We zien onze oude vertrouwde .estimateGas () -functie hier ook voor de goede orde. We pakken de transactie-ID en het nieuwe contractadres om aan de gebruiker weer te geven wanneer het contract met succes is geïmplementeerd. Bam, klaar! Laten we het in actie zien:

“Oh ja, als je een foutmelding krijgt bij de implementatie, zorg er dan voor dat je de transactie-ID-link controleert, het contract is hoogstwaarschijnlijk succesvol geïmplementeerd, soms slaagt Metamask er gewoon niet in om de status van de implementatiesuccestransactie en het nieuwe contractadres op te halen en terug te sturen die succesvol in onze browseromgeving.​

Hoe soliditeit te leren: de ultieme Ethereum-coderingsgids

Het leeft nog. Dit maakt mij zo blij! Geheime gekke extra bonus ontgrendeld! Dus ik betaalde 0,02268 Ether in gas, wat ongeveer $ 5,30 USD is (1 juni 2017), om dit contract op het ethernetnet te implementeren. Onthoud dat dit een supereenvoudige demo-app moest zijn, met letterlijk slechts twee mogelijke gegevensstructuren. Het was slechts $ 2 een paar weken geleden, dit is wild! Maar nog steeds betaalbaar, u zou uw contract niet echt in de hoofdketen moeten inzetten, dat zou het vaak, eigenlijk maar één keer moeten doen.

Dat is alles wat ik deze keer voor jullie heb, jongens! Ik hoop dat je deze tutorial super handig vond, en dat je goed gebruik kunt maken van de EthDeployer-tool tijdens je dev-avonturen die er zijn. Ik kijk uit naar vragen en opmerkingen, bedankt!

Ryan Molecke

Ryan Molecke, Chief Technology Officer (CTO) van EnLedger Corp., is een zeer multidisciplinaire academische computational science-onderzoeker, die de overstap maakte naar de wereld van financiële technologie en handelssystemen. Hij heeft bij verschillende opmerkelijke en succesvolle startups op het gebied van financiële technologie gewerkt, hielp bij het ontwerpen van handelssystemen en makelaardij / uitwisselingen, en is nu gefocust op geautoriseerde grootboeken en blockchain-systeemintegraties, tokenisaties en kredietprogramma’s. Hij heeft een B.S.E. in Computer Engineering en een Ph.D. in Nanoscience and Microsystems Engineering, beide van de UNM

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me
Like this post? Please share to your friends:
map