Wat kost het ons om een blockchain te bouwen?

De hele geschiedenis van de mensheid is een voortdurende bevrijding van ketens en het creëren van nieuwe, nog sterkere. (Anonieme auteur)

Bij het analyseren van talloze blockchain-projecten (Bitshares, Hyperledger, Exonum, Ethereum, Bitcoin enz.), begrijp ik dat ze technisch gezien allemaal volgens dezelfde principes zijn gebouwd. Blockchains lijken op huizen, die, ondanks de diversiteit aan constructies, decoraties en doeleinden, een fundering, muren, een dak, ramen en deuren hebben, die op bepaalde manieren met elkaar verbonden zijn. En als je de basisprincipes van het ontwerpen van gebouwen begrijpt en weet welke materialen je gebruikt, kun je het doel van een specifiek huis bepalen. Op dit moment is er met blockchain een situatie ontstaan waarin iedereen ervan heeft gehoord, maar weinigen de architectuur en de werkwijze begrijpen. Daarom ontstaat er verwarring over waarvoor en hoe het zinvol is om blockchain-technologieën te gebruiken.

In dit artikel zullen we de gemeenschappelijke eigenschappen en principes van alle blockchains bespreken. Vervolgens kijken we naar de taken die met behulp van blockchain opgelost kunnen worden, en om het materiaal te verankeren, zullen we een kleine, maar echte blockchain op onze virtuele locatie bouwen!

Laten we dus herinneren welke problemen blockchain oorspronkelijk heeft opgelost.

Ik ben er zeker van dat velen zullen zeggen dat het een gedistribueerde, gedecentraliseerde, openbare en onveranderlijke database is. Maar waarom was dit allemaal nodig?

Ik geef de voorkeur om mijn studie van elke technologie te beginnen met het lezen van de standaarden, omdat daarop alle artikelen en boeken over het onderwerp zijn gebaseerd. Maar de standaarden voor blockchain ontbreken momenteel, in de ISO zijn alleen maar commissies voor hun ontwikkeling opgericht. Op dit moment heeft elk openbaar blockchain-project zijn eigen White paper, dat in wezen een technisch ontwerpdocument is. Het eerste bekende blockchain-project is het Bitcoin-netwerk. Laten we naar de officiële website van het netwerk gaan en kijken waar het allemaal begon.

De taak van blockchain

Dus de taak die blockchain oploste in het pioniersnetwerk Bitcoin is het veilig overdragen van eigendom van digitale activa in een wantrouwende omgeving zonder tussenpersonen. Bijvoorbeeld, in het Bitcoin-netwerk is het digitale actief digitale munten bitcoin. En alle technische oplossingen van Bitcoin en andere blockchains draaien om deze taak.

Problemen die blockchain oplost

Stel dat een financiële instelling beweert dat ze een netwerk over de hele wereld heeft opgebouwd waarmee je geld naar iemand kunt overmaken. Zou je haar geloven? Als deze organisatie Visa of MasterCard is, geloof je dat waarschijnlijk, maar als het hypothetisch gezien AnonymousWorldMoney is, denk ik van niet. Waarom? Omdat we goed weten hoe gedistribueerde systemen door particuliere bedrijven worden opgebouwd, met welke doelen en wat dit kan betekenen. Laten we de problemen van dergelijke systemen in detail bekijken en hoe deze opgelost kunnen worden met behulp van blockchain-technologie.

Laten we aannemen dat er servers met databases staan bij AnonymousWorldMoney, en het is goed als er meerdere zijn in verschillende datacenters. Wanneer de verzender geld overmaakt, wordt er een transactie geregistreerd die op alle servers wordt gerepliceerd, en het geld komt bij de ontvanger aan.

In een ideale wereld werkt dit schema perfect, maar in de onze ontstaan de volgende problemen:

1. Het probleem van de identificatie van deelnemers aan de ene kant en de noodzaak van anonimiteit van transacties aan de andere kant. Met andere woorden, je moet geld overmaken naar een specifieke ontvanger en dat zo doen dat niemand, behalve de deelnemers aan de transactie, hiervan op de hoogte is. Banken hebben rekeningnummers en bankkaarten die aan specifieke natuurlijke of rechtspersonen zijn gekoppeld, en het bankgeheim beschermt informatie over transacties. Maar wie garandeert dat de hypothetische AnonymousWorldMoney geen persoonlijke gegevens en informatie over transacties voor eigen doeleinden gebruikt?
2. Hoe kun je er zeker van zijn dat de ontvanger precies het bedrag heeft ontvangen dat naar hem is overgemaakt? Laten we zeggen dat de verzender $100 heeft overgemaakt, maar de ontvanger heeft $10 ontvangen. De verzender gaat naar het kantoor van AnonymousWorldMoney met zijn ontvangstbewijs, en de medewerker laat zijn versie zien waarin staat dat de verzender slechts $10 heeft overgemaakt.
3. Het probleem van een wantrouwige omgeving, bijvoorbeeld fraude die double-spending wordt genoemd. Een onbetrouwbare deelnemer kan zijn saldo meerdere keren uitgeven voordat de betaling op alle servers is gerepliceerd. De CAP-theorema, natuurlijk, is nog steeds van kracht, en consistentie zal uiteindelijk worden bereikt, maar iemand zal zijn geld voor geleverde diensten of goederen niet ontvangen. Daarom, als er geen volledig vertrouwen is in de betalingsorganisatie of de deelnemers aan de transacties, moet er een netwerk worden opgebouwd dat niet op vertrouwen gebaseerd is, maar op cryptografie.
4. De voorwaardelijke AnonymousWorldMoney heeft een eindig aantal servers die onbedoeld of opzettelijk onbeschikbaar kunnen worden.
5. AnonymousWorldMoney zal zijn merkbare commissie behouden.
6. Beheer mogelijkheden. Tijdens het gebruik van Bitcoin is gebleken dat mensen niet alleen munten naar elkaar willen overmaken, maar ook verschillende voorwaarden van transacties willen controleren, scenario's willen programmeren en automatisch acties willen uitvoeren op basis van voorwaarden, enzovoort.

Hoe blockchain deze problemen oplost

1. De identificatie van deelnemers gebeurt met behulp van een paar sleutels: een privésleutel en een openbare sleutel, en het algoritme voor digitale handtekening identificeert de afzender en de ontvanger eenduidig, terwijl hun identiteit anoniem blijft.
2. Transacties worden verzameld in blokken, de hash van een blok wordt berekend en in het volgende blok geschreven. Dit opeenvolgend opnemen van hashes in blokken heeft de naam technology blockchain gegeven, en het maakt ook onopgemerkt wijzigen/verwijderen van blokken of individuele transacties in blokken onmogelijk. Dus, als een transactie in de blockchain verschijnt, kan men er zeker van zijn dat de gegevens ervan ongewijzigd blijven.
3. Fraude bij double-spending wordt voorkomen door consensus in het netwerk te bereiken over welke gegevens als juist moeten worden beschouwd en welke moeten worden verworpen. In het Bitcoin-netwerk wordt consensus bereikt door middel van proof-of-work (PoW).
4. De betrouwbaarheid van het functioneren van het netwerk wordt bereikt doordat de blockchain openbaar is, waar elke deelnemer zijn eigen node kan draaien, een volledige kopie van de blockchain kan krijgen en bovendien zelf de transacties op juistheid kan controleren. Het is belangrijk op te merken dat moderne blockchains het mogelijk maken om niet alleen openbare (open) maar ook private (gesloten) blockchains te bouwen, en ook gecombineerde schema's te gebruiken.
5. Volledig ontsnappen aan commissies in de blockchain is niet mogelijk, aangezien men de mensen die het netwerk ondersteunen moet betalen, maar de noodzaak van commissies in de blockchain wordt zo overtuigend bewezen dat er geen twijfel meer over blijft.
6. Moderne blockchains hebben de mogelijkheid om bedrijfslogica te implementeren, die in de blockchain Smart Contracts wordt genoemd. De logica van smart contracts wordt geïmplementeerd in verschillende programmeertalen van hoge niveau.

Laten we deze oplossingen verder onderzoeken.

Architectuur van de blockchain

Onderdelen van de blockchain

Elke deelnemer kan zijn eigen node starten met een volledige kopie van de blockchain (full node). Volledige nodes die transacties kunnen opnemen in de blockchain worden genoemd consensus nodes (witness) of miners (miner). Volledige nodes die alleen de juistheid van transacties controleren worden genoemd audit nodes (audit). Lichte cliënten (light clients) bewaren geen volledige kopieën van de blockchain, maar communiceren met het netwerk via volledige nodes.
De meeste gebruikers maken voor transacties gebruik van lichte cliënten of webportemonnees. Alle nodes zijn met elkaar verbonden. Met deze opstelling wordt de netwerkinfrastructuur veerkrachtiger:

Levenscyclus van een transactie

Laten we de levenscyclus van een transactie bekijken en deze in onderdelen analyseren:

Blockchain-technologieën

Laten we dieper ingaan op technische oplossingen en hun onderlinge verbanden.

Identificatie

Elke blockchain-transactie moet worden ondertekend met een digitale handtekening. Daarom moet elke deelnemer een paar sleutels hebben: private / public. Soms wordt dit sleutelpaar een portemonnee (wallet) genoemd, omdat de sleutels een unieke digitale adres en saldo van de deelnemer duidelijk kunnen identificeren. In feite zijn sleutels en adressen gewoon reeksen cijfers in verschillende talstelsels. Voorbeelden van sleutels en een portemonnee-adres:

Private key: 0a78194a8a893b8baac7c09b6a4a4b4b161b2f80a126cbb79bde231a4567420f
Public key: 0579b478952214d7cddac32ac9dc522c821a4489bc10aac3a81b9d1cd7a92e57ba
Address: 0x3814JnJpGnt5tB2GD1qfKP709W3KbRdfb27V

Voor het creëren van een digitale handtekening in blockchains wordt een algoritme gebruikt dat is gebaseerd op elliptische krommen: Elliptic Curve Digital Signature Algorithm (ECDSA). Voor de werking ervan wordt de privé-sleutel (een 256-bits getal) meestal willekeurig gekozen. Het aantal mogelijke sleutels bedraagt 2 tot de macht 256, waardoor we kunnen spreken van de praktische onmogelijkheid van overeenstemming tussen waarden van privé-sleutels.

Vervolgens wordt de openbare sleutel verkregen uit de privé-sleutel door deze te vermenigvuldigen met de coördinaten van een punt dat zich op de elliptische kromme bevindt, met als resultaat de coördinaten van een nieuw punt op dezelfde kromme. Deze actie garandeert het verkrijgen van een sleutelpaar dat geschikt is voor digitale handtekeningen van transacties. Ten slotte wordt het portemonnee-adres eenduidig berekend uit de openbare sleutel.

Er zijn veel artikelen met details over de cryptografie die in blockchain wordt gebruikt, bijvoorbeeld: Bitcoin in een notendop — Cryptografie

De privésleutel moet strikt geheim blijven en veilig worden opgeslagen. De publieke sleutel is voor iedereen bekend. Bij verlies van de privésleutel is het onmogelijk om toegang tot het activum (munten) te herstellen, waardoor het geld voor altijd verloren gaat. Daarom is het cruciaal om privésleutels veilig op te slaan, aangezien dit geen bank is waar je altijd met een identiteitsbewijs naartoe kunt om je rekening te herstellen. Er bestaat een hele industrie die zogenaamde koude crypto-portemonnees produceert, die lijken op USB-sticks:

of je kunt betrouwbaardere methoden gebruiken, zoals het graveren van de privésleutel op tokens:

Transacties

Meer over de structuur van een transactie kun je vinden in het artikel Bitcoin in een notendop — Transactie. Het is belangrijk om te begrijpen dat elke transactie minstens de volgende gegevens bevat:

Van: 0x48C89c341C5960Ca2Bf3732D6D8a0F4f89Cc4368 - digitale adres van de afzender
Naar: 0x367adb7894334678b90aFe7882a5b06f7fbc783a - digitale adres van de ontvanger
Waarde: 0.0001 - bedrag van de transactie
Transactie Hash: 0x617ede331e8a99f46a363b32b239542bb4006e4fa9a2727a6636ffe3eb095cef - hash van de transactie

Vervolgens wordt de transactie ondertekend met de privésleutel en verzonden (zie details over het protocol Bitcoin in een notendop - Protocol) naar alle nodes in de blockchain, die de transacties op geldigheid controleren. Het algoritme voor het controleren van de transactie is niet triviaal en omvat tweeënhalve stap.

Transactieblokken

Nadat de nodes de geldigheid van de transacties hebben geverifieerd, vormen zij blokken. Naast transacties wordt de hash van het vorige blok in het blok vastgelegd, evenals een getal (Nonce-teller), en wordt de hash van het huidige blok berekend met behulp van het SHA-256-algoritme. De hash moet voldoen aan bepaalde moeilijkheidsvoorwaarden. Bijvoorbeeld, in het Bitcoin-netwerk verandert de hash-moeilijkheid automatisch elke 2 weken op basis van de netwerkkracht, zodat een blok ongeveer elke 10 minuten wordt gegenereerd. De moeilijkheid wordt bepaald door de voorwaarde dat de gevonden hash kleiner moet zijn dan een vooraf gedefinieerd getal. Als aan deze voorwaarde niet wordt voldaan, wordt 1 bij de Nonce opgeteld en wordt het proces van hashberekening herhaald. Voor het vinden van de hash wordt het Nonce-veld gebruikt, omdat dit de enige gegevens zijn in het blok die kunnen worden gewijzigd; de overige moeten ongewijzigd blijven. De juiste hash moet een bepaald aantal nullen aan het begin hebben, bijvoorbeeld, een van de werkelijke hashes:

000000000000000000000bf03212e7dd1176f52f816fa395fc9b93c44bc11f91

Het succesvol vinden van een hash is het bewijs van het uitgevoerde werk (Proof-of-Work, PoW) voor Bitcoin- of Ethereum-netwerken. Het proces van het vinden van hashes wordt mining genoemd, wat vergelijkbaar is met het delven van goud. De naam beschrijft het proces vrij nauwkeurig, aangezien het een eenvoudige brute-force zoektocht is, en als iemand de juiste hash vindt, is dat echt geluk. Het is alsof je een echt goudklompje vindt tussen tonnen waardeloos gesteente. De beloning voor een blok bedraagt momenteel 12,5 BTC en als je dat vermenigvuldigt met de huidige bitcoinprijs van $3900, krijg je meer dan een kilo puur goud. Er is dus wat te behalen!

Na het succesvol vinden van een hash worden het blok en de gevonden hash als de volgende blok in de blockchain opgenomen. Meer over de structuur van blokken is te vinden in het artikel Bitcoin in een notendop - Blockchain, en hieronder geef ik een vereenvoudigde schematische weergave:

Een blockchain begint met een blok dat nog geen hash van het vorige blok heeft. Dit blok is uniek in de blockchain en heeft de naam Genesis block. De overige blokken hebben een identieke structuur en verschillen slechts in het aantal transacties. Werkelijke transacties en blokken die momenteel in Bitcoin of Ethereum worden aangemaakt, kunnen worden bekeken in de Block Explorer.

De grootte van blokken in Bitcoin is beperkt tot 1 MB, en met een minimale informatiegrootte van ongeveer 200 bytes per transactie, kunnen er maximaal ongeveer 6000 transacties in een blok passen. Dit verklaart ook de prestaties van Bitcoin, waar iedereen om lacht: een blok wordt ongeveer elke 10 minuten * 60 seconden = 600 seconden gegenereerd, wat een formele prestatie van ongeveer 10 TPS oplevert. Hoewel dit in feite geen prestatie is, maar een bewust geïmplementeerd werkalgoritme. In Ethereum hebben ze simpelweg de blokgeneratietijd op 15 seconden ingesteld, waardoor de formele prestatie steeg. Daarom is het in blockchains die PoW als consensus gebruiken zinloos om de prestaties te vergelijken, aangezien deze rechtstreeks afhankelijk zijn van de moeilijkheidsgraad van de hash-berekeningen, die je kunt toewijzen als je wilt.

Forks

Wat gebeurt er als meerdere knooppunten bijvoorbeeld hashes vinden die voldoen aan de moeilijkheidsvoorwaarden, maar die verschillende waarden hebben (met andere woorden, als ze verschillende consensus bereiken) en blokken in de blockchain schrijven? Laten we kijken hoe de blockchain zichzelf tegen deze situatie beschermt. In dit geval vindt er een zogenaamde fork (‘vork’) plaats, en de blockchain heeft twee versies van de keten:

Wat gebeurt er daarna? Daarna begint een deel van het netwerk te werken aan blok N+2 van de ene keten, terwijl een ander deel dit voor de andere doet:

Een van deze blokken zal eerder worden gevonden en naar de blockchain worden gestuurd, en volgens de regels moet de blockchain overschakelen naar de langere keten en alle transacties uit het alternatieve blok annuleren:

Het kan voorkomen dat de transactie van een deelnemer zich alleen in een van de blokken van de fork bevond, die vervolgens werd geannuleerd. Daarom, om er zeker van te zijn dat de gewenste transactie in de blockchain is vastgelegd, is er een algemene aanbeveling — voordat je een transactie vertrouwt, moet je wachten tot er een paar extra blokken aan de blockchain zijn toegevoegd. De aanbevelingen voor het aantal te wachten blokken verschillen per blockchain. Voor het Bitcoin-netwerk is het minimum 2 blokken, en het maximum 6.

Hetzelfde beeld met forks van blokken zal zichtbaar zijn tijdens een zogenaamde 51%-aanval — wanneer een groep miners probeert een alternatieve blokketen te creëren en de originele keten met hun frauduleuze transacties probeert te annuleren. Hoewel het momenteel voordeliger is om je middelen te gebruiken voor eerlijke mining in plaats van fraude.

Consensus

Om een blok aan de blockchain toe te voegen, moet het netwerk tot consensus komen. Laten we de taak van het bereiken van consensus in computernetwerken herinneren. Het probleem wordt geformuleerd als de taak van Byzantijnse generaals BFT (Byzantine fault tolerance). Om het schilderachtige probleem van het Byzantijnse leger over te slaan, kan de taak als volgt worden geformuleerd: hoe kunnen de knooppunten van het netwerk tot een gemeenschappelijk resultaat komen, als een deel van de knooppunten opzettelijk vervormingen kan aanbrengen. Bestaande algoritmen voor het oplossen van het BFT-probleem tonen aan dat het netwerk correct kan functioneren als minder dan 1/3 fraudeurs aanwezig zijn. Waarom is er geen BFT-consensus in het Bitcoin-netwerk toegepast? Waarom was PoW nodig? Er zijn verschillende redenen:

• BFT werkt goed met een beperkte set knooppunten, terwijl in een publieke blockchain het aantal knooppunten onvoorspelbaar is en bovendien kunnen knooppunten willekeurig aan- en uitgeschakeld worden.
• Het is noodzakelijk om mensen te motiveren om blockchain knooppunten te starten. Hiervoor moeten mensen een beloning ontvangen. In BFT is er formeel niets waarvoor je een beloning kunt krijgen, terwijl het in PoW voor iedereen intuïtief duidelijk is: voor de elektriciteit die de processor verbruikt tijdens het vinden van de hash van een blok.

Naast PoW zijn er nog verschillende andere consensusmechanismen die worden gebruikt in moderne blockchains, bijvoorbeeld:

• PoS (Proof-of-Stake) — in de blockchain Hyperledger
• DPoS (Delegated Proof-of-Stake) — in de blockchain BitShares
• Modificaties van BFT: SBFT (Simplified BFT) en PBFT (Practical BFT), bijvoorbeeld in de blockchain Exonum

Laten we even stilstaan bij de PoS-consensus, omdat vooral PoS en zijn varianten de grootste verspreiding hebben gekregen in private blockchains. Waarom juist in private blockchains? Enerzijds zijn de kenmerken van PoS beter in vergelijking met PoW, omdat voor het bereiken van consensus minder rekenkracht nodig is, wat betekent dat de snelheid van gegevensopslag in de blockchain toeneemt. Maar anderzijds biedt PoS meer mogelijkheden voor fraude, daarom moeten alle deelnemers aan de blockchain bekend zijn om dit te neutraliseren.

De PoS-consensus is gebaseerd op de keuze van een knooppunt dat een blok met transacties in de blockchain kan opslaan, afhankelijk van het aantal middelen dat op de rekening staat, of beter gezegd, wat als onderpand is gesteld. Hoe meer middelen je als onderpand hebt, hoe groter de kans dat het netwerk jouw knooppunt kiest voor het opslaan van het blok. Het onderpand wordt niet teruggegeven als het blok ongeldig blijkt te zijn. Op deze manier is er bescherming tegen fraude gerealiseerd. Er zijn de volgende varianten van PoS:

• De Delegated PoS (DPoS) consensus verdeelt deelnemers in 'stemgerechtigden' en 'validatoren'. Munteigenaren (stemgerechtigde deelnemers) delegeren hun recht om transacties in de blockchain te verifiëren en op te slaan aan andere deelnemers. Op deze manier voeren de validators al het rekenwerk uit en ontvangen hiervoor een beloning, terwijl het bestaan van stemgerechtigde deelnemers de eerlijkheid van de validators garandeert, omdat ze op elk moment kunnen worden vervangen.
• Het LPoS-consensusmodel (Leased Proof-of-Stake) stelt je in staat om je middelen te verhuren aan andere knooppunten, zodat zij een grotere kans hebben om blokken te verifiëren. Zo kun je commissie verdienen op transacties zonder zelf betrokken te zijn bij het verifiëren van transacties en het minen van blokken.

Er zijn nog verschillende andere consensusmodellen die nog niet wijdverspreid zijn. Hiernoem ik ze gewoon ter informatie, en een overzicht van de consensusalgoritmen is te vinden in bijvoorbeeld het artikel: Consensusalgoritmen in Blockchain.

• PoET (Proof-of-Elapsed Time)
• PoC (Proof-of-Capacity)
• PoB (Proof-of-Burn)
• PoWeight (Proof-of-Weight)
• PoA (Proof-of-Activity) — PoW + PoS
• PoI (Proof-of-Importance)

Betrouwbaarheid en modellen van blockchains

Openbare blockchain

Veerkracht Publiek of een andere naam Permissionless blockchain wordt bereikt doordat iedereen zich kan aansluiten en informatie kan bekijken of zelfs hun eigen knooppunt kan aansluiten, en vertrouwen wordt opgebouwd op basis van de PoW-consensus.

Privé blockchain

Privé of Private Permissioned blockchain. In deze blockchains heeft slechts een bepaalde groep deelnemers (organisaties of mensen) toegang tot de informatie. Dergelijke blockchains worden opgebouwd door organisaties om de algehele winst of efficiëntie te verhogen. Hun betrouwbaarheid wordt gewaarborgd door de gezamenlijke doelen van de deelnemers en de PoS- en BFT-consensusalgoritmen.

Blockchain-consortium

Er bestaan Consortium of Public Permissioned blockchain. Dit zijn blockchains waar iedereen zich kan aansluiten om te bekijken, maar informatie toevoegen of een eigen knooppunt aansluiten kan alleen met toestemming van andere deelnemers. Dergelijke blockchains worden opgebouwd door organisaties met als doel het verhogen van het vertrouwen van klanten of consumenten van producten of de samenleving als geheel. Hier wordt betrouwbaarheid ook bereikt door de aanwezigheid van vertrouwen tussen deelnemers en dezelfde PoS- en BFT-consensusalgoritmen.

Smart Contracts

In blockchains die zijn ontwikkeld na Bitcoin is in zekere mate de mogelijkheid toegevoegd om smart contracts uit te voeren. In essentie is een smart contract een transactie waarin programmatuur is opgenomen voor uitvoering. Smart contracts in het Ethereum-netwerk worden uitgevoerd in de EVM (Ethereum Virtual Machine). Om de uitvoering van een smart contract te starten, moet dit expliciet worden geactiveerd door een andere transactie, of moeten aan bepaalde voorwaarden worden voldaan. De resultaten van de uitvoering van een smart contract worden ook in de blockchain vastgelegd. Toegang tot gegevens van buiten de blockchain is mogelijk, maar sterk beperkt.

Welke zakelijke logica kan worden geïmplementeerd met smart contracts? Eigenlijk niet zoveel, bijvoorbeeld het controleren van voorwaarden op basis van gegevens uit de blockchain, het wijzigen van de eigenaren van digitale activa afhankelijk van deze voorwaarden, het opslaan van gegevens in permanente opslag binnen de blockchain. De logica wordt geïmplementeerd in een speciale programmeertaal op hoog niveau, Solidity.

Een klassiek voorbeeld van de functionaliteit die wordt gerealiseerd met smart contracts is de uitgifte van tokens voor het uitvoeren van ICO's. Bijvoorbeeld, ik heb een smart contract geïmplementeerd voor de uitgifte van bescheiden 500.000.000 AlexToken. Volgens de link op Etherscan bevindt zich

de source code van het smart contract in de programmeertaal Solidity

pragma solidity ^0.4.23;

library SafeMath {
    /**
     * @dev Multiplies two numbers, throws on overflow.
     **/
    function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
        if (a == 0) {
            return 0;
        }
        c = a * b;
        assert(c / a == b);
        return c;
    }
    
    /**
     * @dev Integer division of two numbers, truncating the quotient.
     **/
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
        // uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return a / b;
    }
    
    /**
     * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
     **/
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
    }
    
    /**
     * @dev Adds two numbers, throws on overflow.
     **/
    function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
        c = a + b;
        assert(c >= a);
        return c;
    }
}

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 **/
 
contract Ownable {
    address public owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev The Ownable constructor sets the original `owner` of the contract to the sender account.
     **/
   constructor() public {
      owner = msg.sender;
    }
    
    /**
     * @dev Throws if called by any account other than the owner.
     **/
    modifier onlyOwner() {
      require(msg.sender == owner);
      _;
    }
    
    /**
     * @dev Allows the current owner to transfer control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     **/
    function transferOwnership(address newOwner) public onlyOwner {
      require(newOwner != address(0));
      emit OwnershipTransferred(owner, newOwner);
      owner = newOwner;
    }
}

/**
 * @title ERC20Basic interface
 * @dev Basic ERC20 interface
 **/
contract ERC20Basic {
    function totalSupply() public view returns (uint256);
    function balanceOf(address who) public view returns (uint256);
    function transfer(address to, uint256 value) public returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
}

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 **/
contract ERC20 is ERC20Basic {
    function allowance(address owner, address spender) public view returns (uint256);
    function transferFrom(address from, address to, uint256 value) public returns (bool);
    function approve(address spender, uint256 value) public returns (bool);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

/**
 * @title Basic token
 * @dev Basic version of StandardToken, with no allowances.
 **/
contract BasicToken is ERC20Basic {
    using SafeMath for uint256;
    mapping(address => uint256) balances;
    uint256 totalSupply_;
    
    /**
     * @dev total number of tokens in existence
     **/
    function totalSupply() public view returns (uint256) {
        return totalSupply_;
    }
    
    /**
     * @dev transfer token for a specified address
     * @param _to The address to transfer to.
     * @param _value The amount to be transferred.
     **/
    function transfer(address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[msg.sender]);
        
        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(_value);
        emit Transfer(msg.sender, _to, _value);
        return true;
    }
    
    /**
     * @dev Gets the balance of the specified address.
     * @param _owner The address to query the the balance of.
     * @return An uint256 representing the amount owned by the passed address.
     **/
    function balanceOf(address _owner) public view returns (uint256) {
        return balances[_owner];
    }
}

contract StandardToken is ERC20, BasicToken {
    mapping (address => mapping (address => uint256)) internal allowed;
    /**
     * @dev Transfer tokens from one address to another
     * @param _from address The address which you want to send tokens from
     * @param _to address The address which you want to transfer to
     * @param _value uint256 the amount of tokens to be transferred
     **/
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[_from]);
        require(_value <= allowed[_from][msg.sender]);
    
        balances[_from] = balances[_from].sub(_value);
        balances[_to] = balances[_to].add(_value);
        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
        
        emit Transfer(_from, _to, _value);
        return true;
    }
    
    /**
     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
     *
     * Beware that changing an allowance with this method brings the risk that someone may use both the old
     * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
     * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     * @param _spender The address which will spend the funds.
     * @param _value The amount of tokens to be spent.
     **/
    function approve(address _spender, uint256 _value) public returns (bool) {
        allowed[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }
    
    /**
     * @dev Function to check the amount of tokens that an owner allowed to a spender.
     * @param _owner address The address which owns the funds.
     * @param _spender address The address which will spend the funds.
     * @return A uint256 specifying the amount of tokens still available for the spender.
     **/
    function allowance(address _owner, address _spender) public view returns (uint256) {
        return allowed[_owner][_spender];
    }
    
    /**
     * @dev Increase the amount of tokens that an owner allowed to a spender.
     *
     * approve should be called when allowed[_spender] == 0. To increment
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * @param _spender The address which will spend the funds.
     * @param _addedValue The amount of tokens to increase the allowance by.
     **/
    function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
        allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
        return true;
    }
    
    /**
     * @dev Decrease the amount of tokens that an owner allowed to a spender.
     *
     * approve should be called when allowed[_spender] == 0. To decrement
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * @param _spender The address which will spend the funds.
     * @param _subtractedValue The amount of tokens to decrease the allowance by.
     **/
    function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
        uint oldValue = allowed[msg.sender][_spender];
        if (_subtractedValue > oldValue) {
            allowed[msg.sender][_spender] = 0;
        } else {
            allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
        }
        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
        return true;
    }
}

/**
 * @title Configurable
 * @dev Configurable varriables of the contract
 **/
contract Configurable {
    uint256 public constant cap = 1000000000*10**18;
    uint256 public constant basePrice = 100*10**18; // tokens per 1 ether
    uint256 public tokensSold = 0;
    
    uint256 public constant tokenReserve = 500000000*10**18;
    uint256 public remainingTokens = 0;
}

/**
 * @title CrowdsaleToken 
 * @dev Contract to preform crowd sale with token
 **/
contract CrowdsaleToken is StandardToken, Configurable, Ownable {
    /**
     * @dev enum of current crowd sale state
     **/
     enum Stages {
        none,
        icoStart, 
        icoEnd
    }
    
    Stages currentStage;
    /**
     * @dev constructor of CrowdsaleToken
     **/
    constructor() public {
        currentStage = Stages.none;
        balances[owner] = balances[owner].add(tokenReserve);
        totalSupply_ = totalSupply_.add(tokenReserve);
        remainingTokens = cap;
        emit Transfer(address(this), owner, tokenReserve);
    }
    
    /**
     * @dev fallback function to send ether to for Crowd sale
     **/
    function () public payable {
        require(currentStage == Stages.icoStart);
        require(msg.value > 0);
        require(remainingTokens > 0);
        
        uint256 weiAmount = msg.value; // Calculate tokens to sell
        uint256 tokens = weiAmount.mul(basePrice).div(1 ether);
        uint256 returnWei = 0;
        
        if(tokensSold.add(tokens) > cap){
            uint256 newTokens = cap.sub(tokensSold);
            uint256 newWei = newTokens.div(basePrice).mul(1 ether);
            returnWei = weiAmount.sub(newWei);
            weiAmount = newWei;
            tokens = newTokens;
        }
        
        tokensSold = tokensSold.add(tokens); // Increment raised amount
        remainingTokens = cap.sub(tokensSold);
        if(returnWei > 0){
            msg.sender.transfer(returnWei);
            emit Transfer(address(this), msg.sender, returnWei);
        }
        
        balances[msg.sender] = balances[msg.sender].add(tokens);
        emit Transfer(address(this), msg.sender, tokens);
        totalSupply_ = totalSupply_.add(tokens);
        owner.transfer(weiAmount);// Send money to owner
    }
    

    /**
     * @dev startIco starts the public ICO
     **/
    function startIco() public onlyOwner {
        require(currentStage != Stages.icoEnd);
        currentStage = Stages.icoStart;
    }
    

    /**
     * @dev endIco closes down the ICO 
     **/
    function endIco() internal {
        currentStage = Stages.icoEnd;
        // Transfer any remaining tokens
        if(remainingTokens > 0)
            balances[owner] = balances[owner].add(remainingTokens);
        // transfer any remaining ETH balance in the contract to the owner
        owner.transfer(address(this).balance); 
    }

    /**
     * @dev finalizeIco closes down the ICO and sets needed varriables
     **/
    function finalizeIco() public onlyOwner {
        require(currentStage != Stages.icoEnd);
        endIco();
    }
    
}
 
/**
 * @title LavevelToken 
 * @dev Contract to create the Lavevel Token
 **/
contract AlexToken is CrowdsaleToken {
    string public constant name = "AlexToken";
    string public constant symbol = "ALT";
    uint32 public constant decimals = 18;
}

en de binaire weergave, zoals deze wordt gezien door het netwerk

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

Meer details over smart contracts zijn te vinden in het artikel: Wat zijn smart contracts in Ethereum.

Conclusie

We hebben de technologieën opgesomd waarop moderne blockchains zijn gebaseerd en hoe ze met elkaar verbonden zijn. Laten we nu formuleren welke problemen we met blockchain kunnen oplossen en welke oplossingen in de beste gevallen ondoeltreffend zouden zijn. Het gebruik van blockchain is dus niet noodzakelijk als:

• Transacties plaatsvinden in een betrouwbare omgeving;
• De aanwezigheid van intermediaire vergoedingen de deelnemers niet bemoeilijkt;
• De deelnemers hebben geen eigendommen die als digitale activa kunnen worden gepresenteerd;
• Er is geen decentralisatie in digitale activa, d.w.z. dat de waarde alleen door één deelnemer wordt bezeten of geleverd.

Wat voor toekomst wacht de blockchain? Op dit moment kunnen we alleen speculeren over de mogelijke ontwikkelingspaden van blockchaintechnologieën:

• Blockchain zal een alledaagse database technologie worden, zoals bijvoorbeeld SQL of NoSQL, voor het oplossen van specifieke taken;
• Blockchain wordt een veelgebruikte protocol, net als HTTP voor het internet;
• Blockchain zal de basis vormen voor een nieuw financieel en politiek systeem van de planeet!

In het volgende deel zullen we bekijken welke blockchains momenteel bestaan en waarvoor ze in verschillende industrieën worden gebruikt.

Dit is nog maar het begin!

Bron: habr.com