Tweede stappen

    In deze sectie gaan we enkele krachtige tools introduceren om uw ontwikkelervaring zo gemakkelijk mogelijk te maken. We zullen een ontwikkelomgeving genaamd Truffle installeren, Solidity verkennen, de basisprincipes van een smart contract behandelen (we zullen zelfs onze eigen maken!), En onze eigen node starten op onze lokale computer. Zodra we met succes lokaal zijn geïmplementeerd, zullen we Remix gebruiken om te communiceren met ons contract en dieper in het ontwikkelingsproces te duiken!

    Vertrouwd raken met truffel

    Truffel

    Truffle is een uitstekende ontwikkelomgeving waarmee u zowel verbinding kunt maken met als testen met behulp van de Ethereum Virtual Machine. Truffle is gemaakt om de ontwikkeling gemakkelijker te maken, en met lokale interacties helpt dit de stress van implementatie op zowel een testnet (zoals Ropsten of Rinkeby) als mainnet te verminderen..

    Kijk voor meer documentatie over truffel hier

    Screen Shot 2020 08 26 om 5 49 43 uur


    Om Truffle in uw terminal te installeren, gaat u door en voert u het volgende uit:

    npm truffel installeren -g

    Opmerking: aanbevelingen voor Windows

    Als u Truffle op Windows gebruikt, kunt u enkele naamconflicten tegenkomen die ertoe kunnen leiden dat Truffle niet correct wordt uitgevoerd. Alsjeblieft zie het gedeelte over het oplossen van naamconflicten voor oplossingen.

    Ganache 

    Laten we, terwijl we bezig zijn, doorgaan en de CLI voor ganache installeren

    Een kort overzicht van ganache is dat het een persoonlijke blockchain is die u lokaal kunt gebruiken om snel de functionaliteit van projecten op te starten en te testen. Ganache is een tool die u gedurende de gehele ontwikkelingscyclus kunt gebruiken. U kunt niet alleen uw dApps ontwikkelen, maar ook implementeren en testen. Dit alles gebeurt lokaal op uw machine, dus dit is de omgeving met de minste wrijving / risico om aan uw projecten te werken!

    Npm gebruiken:

    npm install -g ganache-cli

    Oké, terug naar truffel!

    Enkele van de aanbiedingen die Truffle biedt:

    • Ingebouwde slimme contractcompilatie, koppeling, implementatie en binair beheer.
    • Geautomatiseerde contracttesten voor snelle ontwikkeling.
    • Scriptbare, uitbreidbare implementatie & migratiekader.
    • Netwerkbeheer voor implementatie voor een willekeurig aantal publiek & particuliere netwerken.
    • Pakketbeheer met EthPM & NPM, gebruikmakend van de ERC190-standaard.
    • Interactieve console voor directe contractcommunicatie.
    • Configureerbare build-pijplijn met ondersteuning voor nauwe integratie.
    • Externe scriptrunner die scripts uitvoert binnen een Truffle-omgeving.

    Voor onze tutorial gaan we iets vanaf de grond opbouwen, maar je wordt absoluut aangemoedigd om enkele van de ketelprojecten te bekijken die Truffle al heeft gemaakt, genaamd Truffle Boxes (gevonden hier​.

    Nu we truffel en ganache hebben geïnstalleerd, gaan we het hebben over degelijkheid!

    Stevigheid 

    Solidity is een ongelooflijk populaire objectgeoriënteerde taal op hoog niveau voor het implementeren van slimme contracten die worden uitgevoerd op de Ethereum Virtual Machine (EVM). Slimme contracten zijn programma’s die het gedrag van accounts binnen de staat Ethereum bepalen. Als je nog nooit eerder naar een regel Solidity hebt gekeken, maar bekend bent met C ++ en / of JavaScript, zul je meer dan een paar overeenkomsten opmerken. 

    Solidity is een statisch getypeerde taal die onder meer overerving, bibliotheken en complexe door de gebruiker gedefinieerde typen ondersteunt. Met Solidity kunt u contracten maken voor gebruik zoals stemmen, crowdfunding, zelfs blinde veilingen om maar een paar gevallen te noemen.. 

    Solidity is gecompileerd in bytecode die uitvoerbaar is op de EVM. Met Solidity kunnen ontwikkelaars applicaties schrijven die zelfhandhavende bedrijfslogica implementeren, belichaamd in slimme contracten, waardoor een onweerlegbaar record van transacties overblijft. Slimme contracten stellen gebruikers in staat om de code te vertrouwen, wat helpt bij het creëren van een vertrouwde omgeving waarin potentiële menselijke corruptie aanzienlijk wordt verwijderd. 

    Houd er rekening mee dat u bij het implementeren van contracten altijd moet letten op de versie die u gebruikt. Er worden regelmatig belangrijke wijzigingen, nieuwe functies en bugfixes geïntroduceerd (onthoud dit als u merkt dat u online tutorials volgt, dat er fouten kunnen optreden, dus houd de documentatie bij u in de buurt​. 

    Een truffelproject starten 

    Met dat gezegd, laten we ons project beginnen en het “eth-hallo-world” noemen

    Spring in uw terminal en laten we een nieuwe lege map maken 

    mkdir eth-hallo-wereld

    Zodra we onze lege map hebben, ga je gang en spring je naar de map en voer je de opdracht uit

    truffel init

    Zodra het proces is voltooid, zouden we enkele bestanden moeten kunnen bekijken die voor ons zijn gemaakt:

    Screen Shot 2020 08 26 om 7 21 53 uur

    We hebben nu contacten, migraties, een testmap en een truffelconfiguratiebestand. Laten we deze bestanden eens bekijken en op een hoger niveau bespreken wat ze zijn.

    Contracten

    Deze map bevat al uw slimme contracten (die we in dit voorbeeld zullen maken met Solidity). Als je nog nooit van slimme contacten hebt gehoord, is een manier om erover na te denken; stukjes code die op de blockchain draaien (dit kan lokaal, test of mainnet zijn) die gegarandeerd dezelfde resultaten opleveren voor iedereen die ze uitvoert. Smart Contracts worden gebruikt binnen dApps (gedecentraliseerde applicaties) en kennen een enorm aantal use cases. Stemmen, gamen, toeleveringsketen, valuta’s, financiële gegevens, en dat zijn er maar een paar!

    Om dit nog verder op te splitsen geeft Nick Szabo het voorbeeld van de automaat. Als u het juiste aantal munten in de machine stopt, kunt u (en iedereen voor / na u) exact hetzelfde resultaat verwachten in ruil. Hetzelfde geldt voor slimme contacten die op Ethereum zijn gebouwd, ze bevatten een waarde en totdat aan hun voorwaarden is voldaan (d.w.z. het juiste aantal munten in ons voorbeeld), wordt de informatie die u probeert op te halen ontgrendeld en vrijgegeven..

    We zullen later terugkomen op het bespreken van Soliditeit en slimme contracten, laten we verder gaan met migraties!

    Migraties

    Migraties zijn Javascript-bestanden waarmee u uw contracten kunt implementeren op het Ethereum-netwerk. Wat echt interessant is, is dat er een onderliggende aanname is dat uw werk zal evolueren en dat uw implementatie in de loop van de tijd zal veranderen. Terwijl u updates aanbrengt, maakt u nieuwe migratiescripts tijdens de ontwikkeling van uw project. Een manier om na te denken over migratiebestanden is dat ze voornamelijk verantwoordelijk zijn voor de staging en implementatie van uw taken. Een eenvoudige manier om erover na te denken, is dat migraties een set beheerde implementatiescripts zijn. Terwijl u uw werk bijwerkt, wordt een logboek van uw eerder uitgevoerde migraties in de keten vastgelegd via een ingebouwd migratiecontract.

    Kijk zelf maar, u heeft al een migratiecontract! Ga naar je contractdirectory en open het, je ziet een Migrations.sol-bestand dat een contract bevat dat er ongeveer zo uit zou moeten zien:

    Screen Shot 2020 08 27 om 4 49 03 uur

    Dit is een standaardcontract dat voor ons wordt aangemaakt wanneer we truffel init uitvoeren. Truffel vereist van nature dat je een migratiecontract hebt om de migratiefunctie te gebruiken, dus verwijder dit niet!

    Opmerking: u moet dit contract tijdens uw eerste migratie implementeren om te profiteren van de migratiefunctie.

    Nu we de kans hebben gehad om ons migratiecontract te bekijken, kunnen we naar de migratiedirectory gaan en zien we een bestand met de naam 1_inital_migrations.js

    Opmerking: bekijk de naamgevingsconventie van dit bestand, het wordt voorafgegaan door een nummer en wordt gevolgd door een beschrijving. Het genummerde voorvoegsel is vereist om vast te leggen of de migratie is geslaagd. Het achtervoegsel is puur bedoeld voor menselijke leesbaarheid

    Screen Shot 2020 08 27 om 05 09 25 uur

    Als u contracten maakt, moet u ervoor zorgen dat u een migratie.js-bestand naast de contracten hebt. Zonder al te diep in artifacts.require (), deployer.deploy, enz. Te duiken hier is een uitstekende documentatie van het truffelteam om het gebruik van deze methoden verder uit te leggen.

    Om een ​​Truffle-project te compileren, ga je naar de root van de directory waar het project zich bevindt en typ je het volgende in een terminal:

    truffel compileren

    Om uw migraties in uw terminal uit te voeren, voert u uiteindelijk (wacht even, we hoeven dit nog niet te doen!

    truffel migreren

    Hiermee worden alle migraties uitgevoerd die zich in de migratiedirectory van uw project bevinden.

    Wat interessant is om op te merken, is dat deze opdracht alleen nieuw gemaakte migraties uitvoert. Dus als uw vorige migratie succesvol is verlopen, zal deze deze niet opnieuw uitvoeren. En als er geen nieuwe migraties zijn om uit te voeren, wordt deze gewoon niet uitgevoerd. Indien nodig kunt u de –reset-optie gebruiken om al uw migraties vanaf het begin uit te voeren.

    Andere commando-opties zijn gedocumenteerd hier.

    Opmerking: we hebben het eerder geïnstalleerd, maar voor lokale tests moet u ervoor zorgen dat u een testblokkering hebt, zoals Ganache geïnstalleerd en actief voordat de migratie wordt uitgevoerd.

    Testen

    Als het gaat om het schrijven van tests, wordt truffel geleverd met een aantal uitstekende tools om dit intuïtief te maken. Vooral als u van plan bent uw contracten in te zetten bij mainnet (maar het is een goede gewoonte, zelfs op testnet), is het erg belangrijk om tests uit te voeren en uw contracten zo goed mogelijk te controleren. Truffle heeft het eenvoudig en beheersbaar gemaakt om uw ontwikkeling te beoordelen / testen.

    Truffel gebruikt de Mokka testkader en Chai voor beweringen om u een solide raamwerk te bieden van waaruit u uw JavaScript-tests kunt schrijven. 

    Opmerking: als u niet bekend bent met het schrijven van eenheidstests in Mocha, raadpleegt u Mocha’s documentatie voordat u verder gaat.

    Kanttekening: een uitstekend hulpmiddel om te gebruiken om uw contracten grondig te herzien is Mythx, de belangrijkste beveiligingsanalysedienst in het veld met diepgaande beoordelingen voor slimme contracten. Hun missie is om er niet alleen voor te zorgen dat u kostbare fouten vermijdt, maar om Ethereum in het algemeen een veiliger en betrouwbaarder platform te maken.

    Alle testbestanden zouden in de./test directory moeten staan. Truffle voert alleen testbestanden uit met de volgende bestandsextensies: .js, .ts, .es, .es6, .jsx en.sol. Alle andere bestanden worden genegeerd.

    Om alle tests uit te voeren, voert u gewoon het volgende uit:

    truffeltest

    Nu we hebben besproken wat truffel init creëert en de steigers van ons project, laten we nu doorgaan en ons slimme contract aan ons project toevoegen!

    Een slim contract schrijven

    Laten we naar de contractdirectory gaan en ons eerste contract schrijven dat we willen implementeren in onze lokale testomgeving (ganache)!

    We beginnen met het maken van ons.sol-bestand, dat we HelloWorld.sol zullen noemen

    Vervolgens kunnen we ons basiscontract toevoegen dat er ongeveer zo uitziet

    pragma stevigheid >= 0,5,8 <0.7.0; contract HelloWorld {string openbaar bericht; constructor (string geheugen initMessage) openbaar {message = initMessage; } functie-update (string geheugen newMessage) openbaar {message = newMessage;​

    Als we ons contract wat nader bekijken, kunnen we een paar elementen opsplitsen

    Onthoud dat een contract een verzameling functies en gegevens is (de staat).

    Het pragma-sleutelwoord kan worden gebruikt om bepaalde compileerfuncties of controles in te schakelen. Een pragma-richtlijn is altijd lokaal voor een bronbestand, dus u moet de pragma aan al uw bestanden toevoegen als u deze in uw project wilt inschakelen. Zonder een pragmatische verklaring aan het begin van ons (of enig) soliditeitsdossier, zal ons contract niet weten hoe het moet worden samengesteld.

    hier is een link naar de soliditeitsdocumenten om de ins en outs van soliditeitsnuances te leren)

    Uiteindelijk is een contract een verzameling functies en gegevens (de staat) die zich op een specifiek adres op de Ethereum-blockchain bevindt..

    Als we naar de functionaliteit van ons contract kijken, kunnen we zien dat we ons bericht instellen als een zichtbare openbare tekenreeks. 

    Het trefwoord ‘openbaar’ maakt variabelen toegankelijk van buiten een contract en creëert een functie die andere contracten of SDK’s kunnen aanroepen om toegang te krijgen tot het openbare bericht met de waardestring.

    contract HelloWorld {string openbaar bericht;

    Hier is een functie die alleen wordt uitgevoerd tijdens het maken van het contract 

    constructor (string geheugen initMessage) openbaar {message = initMessage;​

    Het neemt een tekenreekswaarde en slaat de waarde op in het geheugengegevensopslaggebied, waarbij het bericht wordt ingesteld op dat waardebericht, d.w.z. initMessage.

    We kunnen dan een bericht initialiseren dat als parameter wordt doorgegeven en kan worden gewijzigd / bijgewerkt met de updatefunctie.

    Dit is een openbaar toegankelijke functie die een string als parameter neemt en het `bericht` bijwerkt (zie hieronder).

    functie-update (string geheugen newMessage) openbaar {message = newMessage;​

    Daar heb je het, een eenvoudig maar verteerbaar HelloWorld-contract!

    Nu we ons contract hebben toegevoegd, kunnen we ervoor zorgen dat het compileerbaar is!

    Ga naar de migratiemap in ons project en we zullen nu een.js-bestand maken dat speciaal is bedoeld voor ons HelloWorld-contract.

    We zullen een nieuw bestand maken en de naam is 2_deploy_contracts.js

    Onthoud de opmerking over naamgevingsconventies van eerder!

    const HelloWorld = artifacts.require ("Hallo Wereld"​module.exports = functie (implementator) {deployer.deploy (HelloWorld, "draad"​​

    Goed werk! We zijn bijna klaar om ons contract te implementeren, maar eerst moeten we ervoor zorgen dat onze truffel-configuratiebestanden weten met wie we moeten praten. Zoals eerder vermeld gaan we ons in deze sectie concentreren op onze lokale omgeving, maar in sectie 3 (spolier) creëren en implementeren we niet alleen lokaal, we brengen deze ook naar een testnetwerk!

    Scroll naar beneden in je truffle-config.js-bestand totdat je de sectie ziet die betrekking heeft op netwerken

    uncomment / voeg het volgende toe 

    netwerken: {ontwikkeling: {host: "127.0.0.1", poort: 8545, netwerk_id: "​", ​,

    Nu zou je bestand er ongeveer zo uit moeten zien:

     

    Screen Shot 2020 08 31 om 6 14 45 uur

    Wat hier gebeurt, is dat we ons configuratiebestand specifieke aanwijzingen vertellen waarmee we verbinding moeten maken. In dit geval zullen we, zoals je binnenkort zult zien, verbinding maken met onze ganache-cli-tool.

    Start Ganache

    Met dat gezegd, laten we doorgaan en onze ganache opstarten 

    in je terminal ga je gang en rennen 

    ganache-cli

    Screen Shot 2020 08 31 om 6 20 12 uur

    Bekijken! U draait nu uw eigen TestRPC daar in uw terminal! 

    (meer hierover hier)

    Opmerking: houd dit tabblad in uw terminal open, maar ga door en open een nieuw tabblad om uit te werken.

    Snel overzicht 

    Laten we teruggaan naar ons project en snel bekijken wat we hebben gedaan. 

    • We hebben een nieuw project gemaakt
    • Geïnitialiseerde truffel
    • Een korte rondleiding door de steiger gemaakt
    • Ons HelloWorld-contract gemaakt
    • Logica toegevoegd aan onze migratiemap voor ons contract
    • Ging naar ons configuratiebestand en paste onze netwerkinformatie aan 

    Tijd om ons contract op gang te krijgen! 

    In ons nieuwe terminalvenster (aangezien we ganache in het andere hebben) 

    laten we doorgaan en rennen 

    truffel compileren

    U zou dit nu als resultaat in uw terminal moeten zien:

    Screen Shot 2020 08 31 om 07 07 17 uur

    Als je nu naar je project gaat, zie je dat je nu een build / contracts-map hebt boven je contract-map met twee.json-bestanden. Je zou moeten zien: 

    • HelloWorld.json
    • Migrations.json 

    Het.json-bestand op hoog niveau beschrijft het geïmplementeerde contract en zijn functies. Het stelt ons in staat om het contract in een context te plaatsen en de functies ervan op te roepen.

    Als we naar binnen kijken, kunnen we een heleboel informatie zien:

     

    Screen Shot 2020 08 31 om 8 01 28 uur

    We gaan dieper in op deze informatie in stap drie, maar iets belangrijks om naar te kijken is de ABI.

    De Application Binary Interface is een gegevenscoderingsschema dat in Ethereum wordt gebruikt voor het werken met slimme contracten.

    Bekijk de informatie die relatief intuïtief te begrijpen is. De ABI definieert ook hoe de gebruiker de functies kan aanroepen, dat wil zeggen, de locatie van de functie in relatie tot het slimme contractadres. Een samenvatting op hoog niveau is de ABI is de beschrijving van de contractinterface. Het bevat geen code en kan niet op zichzelf worden uitgevoerd. Dan heb je de bytecode, wat de uitvoerbare EVM-code is, maar op zichzelf geen context heeft.

    Tijd om te migreren

    OK! 

    Dus nu onze ganache-cli draait en we ons slimme contract hebben samengesteld, is het tijd om onze contracten te migreren! 

    in je terminal ga je gang en rennen 

    truffel migreren

    JA! Je hebt het gedaan!

    Screen Shot 2020 08 31 om 8 37 37 uur

    We kunnen zien dat we ons slimme contract met succes hebben geïmplementeerd. U kunt zien dat er echt nuttige informatie is gegenereerd en als u naar uw andere tabblad gaat terwijl ganachi-cli wordt uitgevoerd, zou u een TransactionReceipt moeten zien (kijk zelf maar).

    Test ETH 

    Voordat we naar Remix gaan, moeten we wat test-ETH bemachtigen, zodat we de gaskosten op Remix kunnen betalen (maak je geen zorgen, dit kost je eigenlijk geen geld). 

    Ga naar deze kraan en pak wat Rinkeby. We duiken in welke test ETH is in stap 3, maar in deze stap weten we dat we Rinkeby zullen gebruiken, een Proof of Authority-netwerk, in tegenstelling tot laten we zeggen Ropsten, een Proof of Work-testnet (dat meer lijkt op het openbare hoofdnetwerk). netto). Na het voltooien van stap 2 en 3 heb je een aantal van beide in je MetaMask-portemonnee om mee te experimenteren!

    Remixen

    Ok, nu we wat test-EHT hebben, is het tijd om naar Remix te gaan en ons contract buiten onze lokale omgeving te implementeren en zelfs de mogelijkheid te hebben om ermee te communiceren!

    “Wat is in godsnaam Remix?” 

    Blij dat je het vraagt! 

    Remix is ​​een krachtige, open source-tool waarmee u rechtstreeks vanuit de browser Solidity-contracten kunt schrijven. Een echt verbazingwekkend element in het bijzonder over Remix is ​​dat het zowel gebruik in de browser als lokaal ondersteunt! Remix ondersteunt testen, debuggen en contractimplementatie om een ​​paar belangrijke functies te noemen. Remix moet worden beschouwd als een nietje-tool voor een ontwikkelaar in hun bouwproces. Beginnen met lokale implementatie (zoals we eerder deden) met ganache is een uitstekende basis, na lokale implementatie kunnen we experimenteren en communiceren met ons contract op Remix.

    Door de juiste overtuigingen te nemen en (keer op keer) uw ontwikkeling te testen voordat een mogelijke lancering naar het belangrijkste ethereum-netwerk wordt uitgevoerd, kunt u misschien meer dan hoofdpijn besparen!

    Laten we nu hetzelfde contract nemen en het buiten onze lokale omgeving implementeren met Remix 

    Koppeling hier 

    Ons contract 

    Klik op een nieuw bestand en noem het HelloWorld.sol

    (hier is het contract dat we opnieuw zullen gebruiken) 

    pragma stevigheid >= 0,5,8 <0.7.0; contract HelloWorld {string openbaar bericht; constructor (string geheugen initMessage) openbaar {message = initMessage; } functie-update (string geheugen newMessage) openbaar {message = newMessage;​

    We kunnen nu doorgaan en ons contract in het veld toevoegen. (Bekijk het hieronder) 

    Screen Shot 2020 08 31 om 9 47 48 uur

    Laten we nu eens kijken naar het linkermenu waarin wordt gevraagd naar de door u geselecteerde compilerversie.

    Compiler

    Houd er rekening mee dat we binnen ons contract ons compilergamma hebben verklaard.

    Onthoud dat het trefwoord pragma wordt gebruikt om bepaalde compileerfuncties of controles in te schakelen. 

    Dus we kunnen onze compiler instellen op 0.6.0, wat tussen ons opgegeven bereik valt (zie blaas) 

    Screen Shot 2020 09 08 om 8 44 41 uur

    Ons contract zou automatisch moeten worden samengesteld, zo niet doorgaan en klikken op HelloWorld.sol compileren

    Vervolgens zullen we onze omgeving opzetten om ons contract in te zetten! 

    Implementeer en voer transacties uit

    Milieu 

    U zult een paar verschillende opties opmerken bij het selecteren van uw omgeving:

    JavaScript-VM: Alle transacties worden uitgevoerd in een sandbox-blockchain in de browser. Dit betekent dat er niets wordt vastgehouden wanneer u de pagina opnieuw laadt. De JsVM is zijn eigen blockchain en bij elke herlaadbeurt start hij een nieuwe blockchain, de oude wordt niet opgeslagen.

    Geïnjecteerde provider: Remix maakt verbinding met een geïnjecteerde web3-provider. Metamask is een voorbeeld van een provider die web3.

    Web3-aanbieder: Remix maakt verbinding met een extern knooppunt. U moet de URL van de geselecteerde provider opgeven: geth, parity of een Ethereum-client.

    In dit voorbeeld gaan we gebruiken: Injected Web3

    We zullen onze MetaMask-portemonnee gebruiken en ervoor zorgen dat we verbonden zijn met ons Rinkeby-testnetwerk 

    We kunnen aan de linkerkant zien dat we verbonden zijn met Rinkeby en ook ons ​​gekoppelde accountadres zien! 

    Screen Shot 2020 09 08 om 8 30 29 uur

    Zodra we alles hebben geregeld, gaan we door met het implementeren van ons contract!

    Screen Shot 2020 09 08 om 8 57 35 uur

    &# 127881; We hebben het gedaan! &# 127881; 

    Bekijk de meegeleverde terminal en je kunt de bevestiging zien

    Screen Shot 2020 09 08 om 8 58 11 uur

    Nu we de mogelijkheid hebben om ons ingezette contract te bekijken, kunnen we ons bericht bijwerken (we moeten hiervoor zowel de gasvergoeding ondertekenen als betalen, aangezien we de staat bijwerken)

    Zodra we een bevestiging hebben, kunnen we zien dat ons bericht is bijgewerkt!

    Screen Shot 2020 09 08 om 9 18 54 uur

    &# 129395; Goed gedaan! &# 129395; 

    We hebben het contract aangenomen waarmee we in eerste instantie lokaal begonnen zijn en hebben dat contract op Remix geïmplementeerd om een ​​visuele weergave van contractinteractie te hebben. Dit is een gezonde stroom voor ontwikkelaars als ze in deze ruimte beginnen te bouwen. Remix is ​​een ongelooflijke tool die vaak moet worden gebruikt. In stap 3 gaan we een stap verder en bundelen we alle informatie die we in stap 1 hebben geleerd & 2 en bind Truffle + Infura + React samen! 

      Onboarding van ontwikkelaars: stap 1Stap 1 van de introductie van ontwikkelaars

      Onboarding van ontwikkelaars: stap 1

      Onboarding van ontwikkelaars: stap 3Onboarding voor ontwikkelaars Stap 3

      Onboarding van ontwikkelaars: stap 3

      10 minuten Ethereum-oriëntatie10 minuten Ethereum-oriëntatie

      10 minuten Ethereum-oriëntatie

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