Wil je Corda-expert worden? De volgende corda-tutorial behandelt alles wat je moet weten over het ontwikkelen van een Corda-applicatie.

Blockchain heeft een lange weg afgelegd. Het idee van gedistribueerde grootboektechnologie heeft veel pijnpunten opgelost die de huidige organisaties doormaken. Het belangrijkste doel is om efficiënter, veiliger en schaalbaarder te worden zonder miljoenen dollars te investeren.

Corda is een open-source blockchain-platform dat een wereldwijd blockchain-ecosysteem biedt. Het biedt strikte privacy met het gebruik van slimme contracten. Het helpt het bedrijf ook om rechtstreeks transacties uit te voeren en biedt een kosteneffectieve benadering om de bedrijfsactiviteiten te stroomlijnen.

Het belangrijkste verschil is hoe Corda de transacties afhandelt. Het is een DLT die de haalbaarheid, snelheid en schaalbaarheid van blockchain wil verbeteren door niet bij elke peer een volledig grootboek te hebben. Als een transactie tussen twee peers kan worden afgerond zonder het hele netwerk te informeren, dan zal Corda die aanpak gebruiken. Het is ook ontworpen om andere partijen op te nemen die het gemakkelijk maken om de transactie te volgen en de geldigheid ervan te zien. Het is een gedistribueerde grootboektechnologie voor het bedrijf.

Laten we nu aan de slag gaan met onze Corda blockchain-zelfstudie!

Binnenkort beschikbaar: Beginnersgids voor Corda Development Course

Hoe de Corda Development Tutorial is gestructureerd?

We zullen Corda in detail bespreken. In de meeste secties zullen we proberen de belangrijke Corda-concepten te behandelen.

De belangrijkste concepten die we zullen behandelen, zijn onder meer de volgende.

  • Staat
  • Contract
  • Flow secties

Onze tutorial zal een IOU-applicatie maken. IOU staat voor “I Owe yoU.” Dit is een eenvoudige voorstelling van het feit dat de ene persoon geld bezit van een andere persoon. We zullen later meer in detail op het concept ingaan.

Om het eenvoudiger te maken, zullen we de programmeertaal Kotlin gebruiken. Als leerling zou het geweldig zijn als je Kotlin kent, maar het is niet een noodzakelijke vaardigheid om de tutorial te volgen.

Gereedschap

Voordat we aan de slag gaan met de Corda-tutorial voor beginners, hebben we de volgende tools nodig. Er zijn ook blockchain-tools die ontwikkelaars heel graag vaak gebruiken. We gaan ze vandaag echter niet behandelen.

  • Kotlin
  • Grijpen
  • Git
  • IntelliJ
  • Opdrachtregel

Vanaf de geïntegreerde ontwikkelomgeving gaan we de IntelliJ gebruiken. Het zal onze ontwikkeling vereenvoudigen.


Corda-zelfstudie

Wat is Corda?

Corda blockchain kan het best worden gedefinieerd als een open-source die zakelijke problemen oplost door een interoperabel blockchain-netwerk te bieden. De belangrijkste kenmerken zijn onder meer strikte privacy, efficiëntie en directe transacties met behulp van slimme contracttechnologie.

De slimme contracten die in Corda worden gebruikt, kunnen worden geschreven met JVM-talen of Java. De dApps binnen het Corda-platform staan ​​bekend als CorDapps. Ze bieden ook een peer-to-peer-knooppuntnetwerk met de mogelijkheid om notarisinfrastructuur te gebruiken. De infrastructuur wordt gebruikt om transacties te valideren en te rangschikken zonder dat de transactiegegevens naar elke peer op het netwerk hoeven te worden verzonden.

Een ander belangrijk onderdeel dat door de blockchain wordt gebruikt, is het Flow-raamwerk, dat de onderhandeling en communicatie tussen deelnemers beheert.

Inzicht in de Corda Ledger

Corda Ledger is niet vergelijkbaar met het grootboeksysteem dat wordt gebruikt door traditionele blockchain-technologieën. Daarom moeten we een duidelijk beeld hebben van hoe het werkt en het begrijpen vanuit zowel het functionele oogpunt als het gegevensperspectief..

Het Corda-grootboek werkt als een grafiek. Alle knooppunten in een grafiek zijn met elkaar verbonden, hetzij rechtstreeks, hetzij via enkele andere knooppunten. Alle knooppunten kunnen met elkaar communiceren als ze dat willen. Door het gebruik van de grafiek is het niet nodig om de transactie wereldwijd uit te zenden.

Knooppunten ontdekken

Dus, hoe ontdekken de knooppunten elkaar? Ze gebruiken een netwerkkaart om elkaar te vinden. U kunt het zien, vergelijkbaar met een telefoonboek. De netwerkkaart bevat de metagegevens om elk van deze services te lokaliseren en biedt daarom een ​​goede manier om kaarten te ontdekken.

Hoe werkt het?

De grootste uitdaging in een niet-wereldwijd blockchain-netwerk voor uitzendingen is consensus. Dus, hoe weten de knooppunten van elkaar en verifiëren ze die informatie?

Het antwoord is hier gedeelde feiten. Elk knooppunt overlapt elk ander knooppunt op de een of andere manier. De gedeelde feiten worden opgeslagen in het Corda-grootboek, dat vervolgens kan worden gebruikt om de informatie te verifiëren. Het Corda-grootboek bevat een set van deze sets. Aangezien er geen centraal knooppunt is, fungeren deze knooppunten als proxy wanneer er zaken moeten worden geverifieerd. Om die informatie op te slaan, heeft elk knooppunt een kluis die het feit bevat dat niet kan worden gewijzigd. Dit is hoe ontwikkelaars blockchain implementeren.

Staten

Staten in de Corda-blockchain zijn onveranderlijk. Ze worden gebruikt om gedeelde feiten over een transactie, overeenkomst of contract op een bepaald tijdstip op te slaan.

Klinkt technisch? Laten we proberen het in eenvoudiger woorden op te splitsen.

Gedeelde feiten

Laten we twee mensen nemen die het Corda-grootboek gebruiken. Laten we ze Alpha en Bravo noemen.

Beiden hebben een gedeeld feit. Het gedeelde feit is een IOU (I Own You). IOU wordt gebruikt wanneer een geldschieter geld heeft te danken aan de kredietverstrekker. Om het feit gedeeld te maken, hebben ze allebei dezelfde gedeelde informatie vertegenwoordigd in de IOU.

Vertegenwoordig alles

Staten kunnen worden gebruikt om alles te vertegenwoordigen. Dit betekent dat het elke vorm van informatie kan opslaan voor verschillende corda-gebruikssituaties. Als ontwikkelaar kunt u staten gebruiken om KYC-informatie, financiële instrumenten, gesyndiceerde leningen, enzovoort op te slaan.

Statussen kunnen ook worden gebruikt om meerdere attributen op te slaan. Maar er is een beperking voor staten. De beperking is dat als een staat eenmaal een type heeft gekregen, het type niet kan worden gewijzigd. Als u een IOU-status creëert, zal deze de IOU-status voor de rest van zijn leven moeten aangeven.

Onveranderlijk en evoluerend

Staten zijn gemaakt om onveranderlijk te zijn. Hun onveranderlijkheid heeft echter betrekking op de tijd. Een toestand wordt op een bepaald moment gepresenteerd.

Dit betekent dat er naast de oorspronkelijke staat een nieuwe staat kan worden aangemaakt. Het wordt gedaan wanneer er een nieuwe wijziging is aangebracht in de staat die moet worden opgeslagen. De oude staat wordt dan historisch genoemd.

Als Alpha bijvoorbeeld zijn schuld aan Bravo afbetaalt, zal er een nieuwe staat worden gecreëerd, met vermelding van het feit dat Alpha de schuld heeft vereffend. Als de status is voltooid, vervalt de IOU. In eenvoudige bewoordingen is de levenscyclus van de staat in dit geval als volgt.

  1. Er wordt een eerste staat gecreëerd om aan te tonen dat Alpha een schuld heeft bij Bravo. Deze staten delen ook meer informatie over de IoU, inclusief de datum, tijd, rentetarief, het geleende bedrag en andere nuttige informatie die nodig is voor de IoU.
  2. Nu, wanneer Alpha de schuld oplost, wordt een nieuwe staat gecreëerd die de nieuwe informatie bijwerkt. De oude staat wordt op geen enkele manier aangeraakt, aangezien deze onveranderlijk is.
  3. De nieuwe status wordt nu bijgewerkt in de gedeelde feiten tussen de twee gebruikers.
  4. Nu wordt de oude staat historisch genoemd. Er kunnen meerdere historische statussen zijn in één enkele transactie. Dit kan leiden tot het creëren van een opeenvolging van toestanden.
  5. Er wordt een sequentiekop gemaakt, die verwijst naar de laatste status. Ook worden de nieuwste staten ook als niet-geconsumeerd genoemd.

Lees verder: Hyperledger versus Corda versus Ethereum-vergelijkingsgids

De ontwikkelomgeving gereed maken

Nu, volgens de dApp-ontwikkelhandleiding, zou de omgeving klaar moeten zijn voor de Corda-ontwikkelhandleiding. U heeft de volgende tools nodig om aan de slag te gaan.

  • Oracle JDK 8 JVM – v8u171 of hoger.
  • Git
  • IntelliJ IDEE

Git-opslagplaats klonen

De beste manier om onze reis te beginnen, is door een voorbeeld van CorDapp in onze ontwikkelomgeving te gebruiken. Het goede nieuws is dat Corda een voorbeeld CorDapp biedt die u kunt downloaden en lokaal kunt uitvoeren.

Je kunt de repository lokaal klonen met behulp van het git clone-commando zoals hieronder.

git kloon http://github.com/roger3cev/corda-training-template.git

Voor de tutorial gaan we IntelliJ gebruiken om de git-repository te importeren. Open de IntelliJ. Als u klaar bent, ziet u de optie om uit te checken bij Versiebeheer. Klik erop en kloon vervolgens de repository op uw computer.

U kunt ervoor kiezen om het project op te slaan; u vindt de projectrepository zoals hieronder.

Rechtsonder vindt u de melding, importeer Gradle Project zoals hieronder. Het is belangrijk dat onze Corda Tutorial werkt.

Klik op het ‘Gradle-project importeren’.

U moet ook de Project SDK instellen. Ga naar de projectinstellingen en selecteer vervolgens de nieuwste versie van Java. In mijn geval was het ingesteld op Java 11.0.5.

Als u een fout vindt om uit te voeren, moet u uw Gradle upgraden en deze de benodigde opslagplaatsen laten importeren om het te laten werken. Het zal even duren om dit te doen. Dus ga op de achterbank zitten en wacht tot het voltooid is.

Voor mij duurde het ongeveer 20 minuten om alle updates voor Gradle-afhankelijkheden te voltooien.

Laten we snel de structuur van ons Corda-zelfstudieproject doornemen. Onze belangrijkste opslagplaats is het src-bestand. Aangezien we Kotlin gebruiken, zullen we de map Kotlin-source gebruiken; je zult de src-map eronder vinden. Verwar het alstublieft niet met de java-source-map.

Hier vindt u alle benodigde bestanden in de trainingsmap. Er is ook een map “test” die de testeenheden voor de applicatie bevat.

Een ander belangrijk bestand dat we moeten kennen, is de IOUState.kt. Het bevindt zich in de training > staat.

Tests van staatseenheden laten werken

De IOUState-klasse ziet er erg basic uit. Het is nog niet voltooid. We gaan een testgestuurde ontwikkelingsmethodologie gebruiken om de klas te ontwikkelen en klaar te maken voor gebruik.

Testgestuurde ontwikkeling is een geweldige benadering als het gaat om moderne ontwikkelingspraktijken. Het helpt vanaf het begin om bugs of andere problemen op te lossen.

Daarom bevat de sjabloon die u heeft gedownload al overeenkomstige tests voor elk van de klassen, inclusief contract, stroom en staat.

Om te beginnen, moeten we naar de tests gaan > Kotlin> netto- > Corda > opleiding > staat > IOUStateTests

Daar vindt u reeds geschreven tests. Het wordt ook geleverd met tonnen documentatie. Het R3 Corda-team heeft de tijd genomen om de sjabloon te maken.

U moet de sectie verwijderen, zoals hieronder weergegeven, om een ​​enkele test uit te voeren.

Selecteer de code en druk op Ctrl + / om commentaar te verwijderen. Als u MAC gebruikt, gebruikt u CMD + / om commentaar te verwijderen.

Nu is het tijd voor ons om de unit-test uit te voeren.

Omdat onze IOUState-klasse bijna leeg is, zullen de tests mislukken en krijgt u de volgende testfout.

Zoals je kunt zien, zegt het dat de Kotlin-source: test is mislukt vanwege de NoSuchFieldException. Dit betekent dat de test de variabele hoeveelheid verwacht als deze er geen heeft gevonden.

Om het probleem op te lossen, moeten we teruggaan naar ons IOUState.kt-bestand en het bewerken. Als u weet hoe je een blockchain-app bouwt, dan zal het een gemakkelijke taak voor je zijn.

Voordat we verder gaan, moeten we Kotlin beter begrijpen. Om de code die we gaan bewerken te begrijpen, is het beter om een ​​inleiding te krijgen. Kotlin is een compacte programmeertaal. Kotlin gaat ook converteren naar een virtuele JVM-machine, dus het zou goed moeten zijn met het gebruik ervan in onze tutorial.

  • dataklasse IOUState → Dit trefwoord betekent dat we een dataklasse definiëren met de naam “IOUState”.
  • val data → variabele declaratie. De naam van het veld is data
  • String = “data” → dit definieert de standaardwaarde van de datavariabele als er niets is gedefinieerd.
  • ContractState → Interface

Als u volgens de test alle wijzigingen in het IOUState.kt-bestand hebt aangebracht, ziet de IOUState-klasse er als volgt uit.

dataklasse IOUState (val bedrag: Bedrag,

                   val geldschieter: Party,

                   val lener: Party,

                   val betaald: Bedrag = Bedrag (0, amount.token),

                   opheffen val linearId: UniqueIdentifier = UniqueIdentifier ()): LinearState {

   ​

    * Deze eigenschap bevat een lijst van de knooppunten die deze status kunnen “gebruiken” in een geldige transactie. In dit geval is het

    * Geldschieter of de lener.

    ​

   opheffen val deelnemers: lijst krijgen() = listOf (geldschieter, lener)

   ​

    * Helper-methoden voor het opbouwen van transacties voor het verrekenen en overboeken van IOU’s.

    ​ [betalen] voegt een bedrag toe aan de betaalde woning. Het heeft geen validatie.

    ​ [withNewLender] maakt een kopie van de huidige staat met een nieuw gespecificeerde kredietverstrekker. Voor gebruik bij het overzetten.

    ​

   pret pay (amountToPay: Amount) = kopie (betaald = betaald.plus (amountToPay))

   pret withNewLender (newLender: Party) = copy (lender = newLender)

Nu zou u hulpmethoden moeten kunnen toevoegen volgens de bovenstaande opmerkingen.

Corda-expert worden? Hier is een gids tot R3 Corda-certificering die u door uw certificeringsproces leidt.

Corda Contacten

We hebben geleerd dat de staten kunnen evolueren naar nieuwe staten. Ontwikkelaars kunnen de evolutie van de on-ledger state controleren met behulp van contracten. In deze sectie zullen we in detail over contracten leren.

Omdat R3 Corda niet afhankelijk is van het uitzenden van berichten naar het hele netwerk, gebruikt het een gemeenschappelijke transactieverificatiedefinitie voor elk staatstype. Op deze manier verifieert het Corda-netwerk de transactie en bereikt het consensus. Het lijkt veel op hoe andere blockchain-transacties transacties vastleggen.

Corda-contracten worden geïmplementeerd via functies. U kunt staten beschouwen als gegevensopslageenheden en contracten is een manier om de gegevens en hun statuswijzigingen te verifiëren. Deze verificatiefuncties zijn specifiek voor het staatstype.

Om ervoor te zorgen dat staten kunnen worden geverifieerd en bruikbaar zijn, moet naar elke staat worden verwezen met een contract.

Elk contract bevat twee items, waaronder contractcode en juridisch proza.

Laten we de volgende afbeelding eens bekijken om het te begrijpen.

Zoals u kunt zien, bevat het contract twee items en in de staat is er een IOU-contractreferentie voor die code.

Juridisch Proza: Juridisch Proza wordt gebruikt als een verwijzing naar een juridisch contract voor de overeenkomst. Het wordt gebruikt om ervoor te zorgen dat het bestaande juridische kader en gerechtelijk systeem kunnen worden gebruikt als zich een geschil voordoet.

Andere belangrijke kenmerken van Corda Contracts zijn de volgende

  • Meerdere contracten kunnen verwijzen naar een contract. Een contract kan ook meerdere staatstypen bevatten
  • Corda gebruikt een verificatiefunctie om een ​​voorgestelde transactie te verifiëren
  • De handtekening van de verificatiemethode is zoals hieronder
  • leuk verifiëren (tx: Transaction): Unit
  • De verificatiemethode verifieert de transactie door alle beperkingen uit te voeren. Als de beperking mislukt, wordt er een uitzondering gegenereerd; anders wordt de transactie als geldig beschouwd.
  • De verificatiefunctie is deterministisch.

De blockchain-sjablonen bevatten ook de code voor de Corda-contracten. Je moet ook de Corda-contracten benaderen, vergelijkbaar met de staten. Het zou helpen als je naar de Corda-testunits gaat en vervolgens de vereiste code toevoegt aan de contractklasse.

Corda-transacties

Onze volgende stop is Corda Transactions. Het zijn transacties die toestandsveranderingen mogelijk maken.

Dus, wat is een transactie? Het kan het beste worden gedefinieerd als een container die referenties voor invoerstatus bevat (0 of meer). Ze produceren ook staten (0 of meer).

Transacties zorgen ervoor dat het netwerk optimaal presteert doordat meerdere peers real-time met elkaar kunnen communiceren. Het maakt het voor twee partijen mogelijk om een ​​atomaire swap te doen zonder andere peer-activiteiten te hinderen. Transacties zijn ook atomair van aard. Dit betekent dat een transactie nooit kan worden verminderd of verdeeld.

Er zijn ook drie soorten transacties: verzekeringen, updates en exits. Ieder heeft zijn eigen agenda. Laten we ze hieronder opsommen.

  • Verzekering → Creëert nieuwe staten
  • Updates → Status-eigenschappen wijzigen
  • Exits → Staten verwijderen uit het grootboek

Corda stroomt

Corda Flows zijn de stappen die nodig zijn voor peers om een ​​succesvolle transactie uit te voeren (uit te voeren).

De stroom bepaalt de CorDapp core business logica. Het is ervoor verantwoordelijk dat de transacties in de juiste volgorde en met de juiste parameters worden uitgevoerd. Omdat transacties complex van aard zijn, zijn stromen nodig om ervoor te zorgen dat alles werkt zoals bedoeld.

Flow control zorgt ervoor dat er moet worden gecommuniceerd, wat er moet worden gecommuniceerd en met wie.

Dit is het tegenovergestelde van andere gedistribueerde grootboektechnologieën die zich richten op het uitzenden van transactiegegevens naar het hele netwerk. Corda gedijt op point-to-point-transacties waarbij de transacties twee belangrijke parameters moeten hebben, afzender en ontvanger.

Belangrijkste dingen die u over stromen moet weten

  • Stromen kunnen binnen enkele seconden worden voltooid of het kan meerdere dagen duren om te voltooien
  • Ze zijn volledig autonoom
  • De Flows slapen voordat ze wachten op een reactie
  • Flows volgen Flow Framework, dat een mechanisme biedt voor ontwikkelaars om te zorgen voor de juiste ontwikkeling van state-machines.
  • Stromen kunnen zowel gepaard als eenzijdig zijn
  • Ontwikkelaars kunnen ook substromen coderen om code eenvoudiger te maken

Wil je een tandje bijsteken en een expert worden? Hier is een gids voor het bouwen van een blockchain in Python.

Consensus

Van alle opwindende dingen die we tot nu toe hebben besproken, is het bijzondere van Corda hoe er consensus wordt bereikt. Corda heeft een unieke aanpak en maakt het daarom haalbaar voor bedrijven die er zijn.

Allereerst gebruikt Corda twee consensusalgoritmen. Het bevat het volgende

  • Uniciteitsconsensus → Deze consensusmethode zorgt ervoor dat er nooit conflicten plaatsvinden in het grootboek
  • Verificatieconsensus → De verificatieconsensus behandelt de transacties en zorgt ervoor dat er geen conflicten plaatsvinden volgens de contractcode. Het vergemakkelijkt de evolutie van een gedeelde staat binnen het netwerk.

Belangrijkste dingen die u moet doen over Corda Consensus:

  • Unieke consensus zorgt ervoor dat de grootboekupdates altijd uniek zijn. Het zorgt er ook voor dat het grootboek geldig is wanneer de update wordt uitgevoerd.
  • De verificatieconsensus zorgt ervoor dat de update geldig is.

Corda-knooppunt

Het laatste gedeelte van Corda dat we hier gaan bespreken, is de Corda Node. Corda Node is een weergave op hoog niveau van de Corda.

Dus, wat is precies het Corda-knooppunt?

Een Corda-knooppunt is een entiteit die wordt uitgevoerd in Java Virtual Machine. Het omvat het volgende

  • Het biedt opslagdiensten en kluizen
  • SQL DB ondersteunt de kluizen en opslagservices
  • Er worden speciale mappen gebruikt om bijlagen op te slaan
  • Biedt aangepaste functionaliteit en ingebouwde extensies die bekend staan ​​als CorDapps
  • Biedt een RPC-clientraamwerk

Dit is hoe het Corda-knooppunt eruitziet.

Zoals u kunt zien, bevat het alle noodzakelijke aspecten om het Corda-netwerk te laten draaien. Ze werken samen met flow en bieden aangepaste CorDapp-functionaliteit.

Gevolgtrekking

Dit leidt ons naar het einde van onze Corda-tutorial. Hier keken we naar de Corda en probeerden we een IoU CorDapp te zien. We hebben de verschillende secties besproken met behulp van de sjabloontraining die beschikbaar is in de Corda GitHub-repository.

Onze focus is om met Corda aan de slag te gaan zonder alles uit te leggen wat Corda te bieden heeft. Daarvoor kunt u altijd de Corda-documentatie gebruiken. We hebben ook een aanstaande cursus over Corda-ontwikkelhandleiding. Je moet het zeker eens bekijken als je een complete ontwikkelingsgids nodig hebt.

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