Wat zijn slimme contracten? Een beginnershandleiding voor slimme contracten

De zin en het concept van 'slimme contracten' waren voorgesteld door Nick Szabo met de visie om de functionaliteit van elektronische transactiemethoden, zoals POS (point of sale), uit te breiden naar de digitale wereld. Slimme contracten helpen u eigendommen, aandelen of iets van waarde op een transparante, conflictvrije manier uit te wisselen terwijl u de diensten van een tussenpersoon vermijdt.

Hieronder volgen de onderwerpen die we gaan behandelen in deze Smart Contract-blog:

1. 1. Wat zijn slimme contracten?
   2. Slimme contracten door Nick Szabo
   3. Waarom hebben we slimme contracten nodig?
   4. Slimme contracten: complexiteit volgens gebruiksscenario's
   5. Gebruiksvoorbeeld voor slimme contracten: gezondheidszorg
   6. Voordelen van slimme contracten
   7. Blockchain-platforms voor het schrijven van slimme contracten
   8. Hulpmiddelen voor het schrijven en implementeren van slimme contracten
   9. Programmeertalen voor het schrijven van Ethereum
   10. Eigendomsoverdracht slim contract

   Wat zijn slimme contracten?

   Slimme contracten zijn een zelfwerkend computerprogramma dat automatisch wordt uitgevoerd wanneer aan specifieke voorwaarden wordt voldaan.

   Slimme contracten = betrouwbare contracten

   
   
   

   Met slimme contracten kunt u alles van waarde delen met vreemden op een conflictvrije transparante manier.

   Je kunt slimme contracten ook zien als een Blockchaingebaseerde automaat. Net zoals automaten zijn geconfigureerd om dollars in te nemen om uw itemkeuze uit te geven, gebruiken slimme contracten ether als brandstof om code uit te voeren op basis van vooraf geconfigureerde regels.

Wat zijn slimme contracten | Implementeer uw eerste Ethereum Smart Contract | Edureka

1. Slimme contracten door Nick Szabo
   

   In zijn paper stelde Szabo de uitvoering voor van een contract voor synthetische activa, zoals derivaten en obligaties. “Deze nieuwe effecten worden gevormd door effecten (zoals obligaties) en derivaten (opties en futures) op verschillende manieren te combineren. Zeer complexe termstructuren voor betalingen kunnen nu worden ingebouwd in gestandaardiseerde contracten en worden verhandeld met lage transactiekosten, dankzij geautomatiseerdeanalyse van deze complexe termstructuren ”, schreef hij.

   
   
   

1. Waarom hebben we slimme contracten nodig?

   We kunnen veel oplossingen automatiseren door een contract op een Blockchain te schrijven om dingen eenvoudig en efficiënt te maken. laten we vergelijken en evalueren hoe slimme contracten beter zijn dan traditionele contracten.

   Slimme contracten: complexiteit volgens gebruiksscenario's

   De complexiteit van contracten is afhankelijk van de use-cases waarvan u droomt om op de blockchain te coderen. De onderstaande afbeelding geeft u meer duidelijkheid over de complexiteit van de slimme contracten.

   Met gecontextualiseerde slimme contracten worden niet alleen de bedrijven geautomatiseerd, maar kan ook een gedecentraliseerde autonome overheid worden gevormd.

   
   Laten we eens kijken hoe slimme contracten werken met behulp van een use case.

   Gebruiksvoorbeeld voor slimme contracten: gezondheidszorg

   Beheer van patiëntgegevens: Als het gaat om het beheer van patiëntgegevens, zijn er twee hoofdzaken in de zorgsector:

   • Eerste , elke patiënt is uniek, daarom is toegang tot volledige medische dossiers essentieel om de behandeling aan te passen en gepersonaliseerde zorg te bieden
   • Tweede is het delen van informatie tussen de medische gemeenschap een grote uitdaging

   Nu kunnen de bovengenoemde problemen worden opgelost met behulp van slimme contractenfunctionaliteit op blockchains.

   Slimme contractvoordelen

   Dit is wat slimme contracten u bieden:

   Blockchain-platforms voor het schrijven van slimme contracten

   Terwijl Ethereum is het meest populaire platform voor het schrijven van contracten, het is niet het enige. Hieronder volgen enkele van de andere platforms die worden gebruikt voor het schrijven van slimme contracten:

   Bitcoins: Bitcoin gebruikt Script dat beperkte mogelijkheden heeft bij het verwerken van documenten. De scripts zijn specifiek ontworpen om Bitcoin-transacties te verwerken.

   Hyperledger-stof : In Fabric is Chaincode programmatische code die op het netwerk wordt geïmplementeerd, waar het wordt uitgevoerd en gevalideerd door kettingvalidators samen tijdens het consensusproces.

   NXT: Het is een openbaar blockchain-platform dat een beperkte selectie sjablonen voor slimme contracten bevat. Je moet gebruiken wat wordt gegeven, je kunt niet je eigen code schrijven.

   Zijketens: Zijketens verbeteren de prestaties en privacybescherming van Blockchains. Ze voegen ook mogelijkheden toeLeuk vindenslimme contracten, veilige handvatten,en real-world eigendomsregister.

   Hulpmiddelen voor het schrijven en implementeren van slimme contracten

   1. Mist Browser - Het is een hulpmiddel om dApps te bladeren en te gebruiken. Het is een aparte browser die kan worden gebruikt om door dApps te bladeren en ermee te communiceren.
   2. Truffel Framework - Truffel is een populair ontwikkelingsraamwerk voor Ethereum. Het heeft een ingebouwde slimme contractcompilatie, koppeling, implementatie en binair beheer.
   3. Metamask - MetaMask is een brug waarmee men vandaag het gedistribueerde web van morgen in zijn browser kan bezoeken. Hiermee kunnen gebruikers Ethereum dApps rechtstreeks in hun browser uitvoeren zonder een volledig Ethereum-knooppunt uit te voeren.
   4. Remix - Remix is ​​een op een webbrowser gebaseerde IDE waarmee gebruikers slimme Solidity-contracten kunnen schrijven en vervolgens het slimme contract kunnen implementeren en uitvoeren.

   Programmeertalen voor het schrijven van slimme Ethereum-contracten

   Stevigheid & Slang zijn twee primaire talen voor het schrijven van Ethereum Smart Contracts.

   : Het is een contractgeoriënteerde taal op hoog niveau met een syntaxis vergelijkbaar met die van JavaScript en is ontworpen om zich te richten op de Ethereum Virtual Machine (EVM).

   Slang: Serpent is een taal op hoog niveau die is ontworpen voor het schrijven van Ethereum-contracten. Het lijkt erg op Python, maar vanaf september 2017 is Solidity de voorkeurstaal voor ontwikkeling voor Ethereum-ontwikkelaars.

   Hoewel Solidity momenteel de meest populaire taal is voor slimme contracten, zijn er enkele opkomende slimme contracttalen die in de toekomst belangrijk kunnen worden.

   Aankomende programmeertalen

   1. Adder: Viper heeft een Python-achtig inspringingsschema. Het richt zich op beveiliging en taal en de eenvoud van de compiler.
   2. Lisk: Lisk gebruikt javascript als een slimme contracttaal die het voor een ontwikkelaar gemakkelijker maakt om applicaties te coderen.
   3. Keten: Chain biedt blockchain-infrastructuur op ondernemingsniveau met SDK's in populaire talen zoals Ruby, Java en NodeJS.

   Nu Solidity de meest gebruikte programmeertaal is voor het schrijven van Ethereum Smart Contracts, wil ik je door een contract leiden dat in Solidity is geschreven.

   Eigendomsoverdracht slim contract

   Probleem: Momenteel maken we gebruik van de centrale autoriteit om het eigendomsrecht over te dragen. Dit maakt het tijdrovend en brengt ook veel extra kosten met zich mee met een extra last van documentbeheer. Omdat het systeem gecentraliseerd is, is er ook altijd een mogelijkheid tot fraude.

   Oplossing: Het plan is om de technologie te gebruiken om de details van vastgoedtransacties zichtbaar te maken voor alle partijen: banken, makelaars, overheidsfunctionarissen, kopers en verkopers.

   Oké, laat me een slim contract voor je schrijven:

   pragma soliditeit ^ 0.4.11 // We maken deze use-case om de eigendomsoverdracht in de echte wereld na te bootsen // Voorwaarde voor deze use-case is dat: // er een digitale identiteit aanwezig is // Overheid stemt ermee in om de landrecords op de openbare blockchain // Elke ontwikkelingsautoriteit (DA) wordt de feitelijke eigenaar van het onroerend goed dat bestaat onder hun kiesdistrict / wetgevend orgaan // Wanneer aan alle bovenstaande voorwaarden is voldaan, kan DA (eigenaar) gemakkelijk het respectieve eigendom koppelen aan hun rechtmatige eigenaar na grondige verificatie. // we zullen de functie rond deze set aanname formuleren. // we gaan ervan uit dat elke DA zijn eigen slimme contract zal inzetten volgens hun regel en regelgeving. Dit hele slimme contract is geschreven door DA te beschouwen als de eigenaar, die eigendommen kan toewijzen. // Een regering kan een laag worden bovenop deze DA. en de regering kan beslissen, welke DA (adres) de eigenaar wordt van welke contituency. // We kunnen dit eenvoudig uitbreiden. Maar nadat u dit slimme contract hebt doorlopen, zult u erachter kunnen komen hoe de dingen zouden kunnen werken. contract PropertyTransfer {adres openbaar DA // DA zal de eigenaar zijn, we zullen de waarde van deze variabele initialiseren door het adres van de gebruiker die het gaat implementeren. bijv. laten we zeggen DA zelf. uint256 public totalNoOfProperty // totaal aantal eigenschappen onder een DA op enig moment. ze moeten na verificatie toenemen volgens de toewijzing aan hun respectieve eigenaar. // Hieronder staat de constructor waarvan de code alleen wordt uitgevoerd wanneer het contract is gemaakt. function PropertyTransfer () {DA = msg.sender // de eigenaar van het contract instellen als DA. } // modifier om te controleren of de tx afkomstig is van de DA (eigenaar) of niet de modifier onlyOwner () {vereist (msg.sender == DA) _} // Deze structuur wordt zo gehouden voor het opslaan van veel meer informatie dan alleen de naam struct Eigenschap {stringnaam // houdt de kaart van de eigenschap voor elk adres. we zullen de eigenschap een naam geven bool isSold // we houden ook de telling bij voor elk adres} mapping (adres => mapping (uint256 => Property)) openbare eigenschappen Eigenaar // we zullen de eigenschappen tegen elk adres laten toewijzen door zijn naam en zijn individuele telling. mapping (adres => uint256) individualCountOfPropertyPerOwner // hoeveel eigenschap heeft een bepaalde persoon de gebeurtenis PropertyAlloted (adres geïndexeerd _verifiedOwner, uint256 geïndexeerd _totalNoOfPropertyCurrently, string _nameOfProperty, string _msg) event PropertyTransferred, string addressed _ferty _msg) // dit zal ons het exacte aantal eigenschappen geven dat elk adres op elk moment bezit functie getPropertyCountOfAnyAddress (adres _ownerAddress) constante retourneert (uint256) {uint count = 0 voor (uint i = 0 i 
   U heeft dus zojuist een manier geprogrammeerd om eigendommen over een gedecentraliseerd netwerk over te dragen. Hoe cool is dat!!
     U kunt zien dat het potentieel voor [slimme contracten] om aspecten van de samenleving te veranderen van aanzienlijke omvang is.  
   hadoop admin rollen en verantwoordelijkheden
   Daarmee concludeer ik dit Slim contract blog. Ik hoop dat je deze blog met plezier gelezen en informatief vond.
    Heeft u een vraag voor ons? Vermeld het in het opmerkingengedeelte en we nemen zo snel mogelijk contact met u opst. 
    ikAls je Smart Contracts wilt leren, een carrière wilt opbouwen in het domein van Blockchain en expertise wilt opdoen in Ethereum-programmering, schrijf je dan in voor live-online    hier, dat wordt geleverd met 24 * 7 ondersteuning om u tijdens uw leerperiode te begeleiden.