Wat moeten we een blockchain bouwen?

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

Bij het analyseren van talloze blockchain-projecten (Bitshares, Hyperledger, Exonum, Ethereum, Bitcoin, enz.) begrijp ik dat ze vanuit technisch oogpunt allemaal op dezelfde principes zijn gebouwd. Blockchains doen denken aan huizen, die ondanks alle verscheidenheid aan ontwerpen, inrichting en doeleinden een fundering, muren, dak, ramen, deuren hebben die op bepaalde manieren met elkaar verbonden zijn. En als u de basisprincipes van het bouwen van gebouwen begrijpt en de eigenschappen van de gebruikte materialen kent, kunt u het beoogde doel van een bepaald huis bepalen. Momenteel is er een situatie ontstaan ​​met blockchain waar iedereen van heeft gehoord, maar weinig mensen begrijpen de architectuur en werkingsprincipes. Daarom bestaat er een misverstand over waarom en hoe het zinvol is om blockchain-technologieën te gebruiken.

In dit artikel analyseren we de eigenschappen en principes die alle blockchains gemeen hebben. Laten we vervolgens kijken naar de problemen die kunnen worden opgelost met behulp van de blockchain en om het materiaal te versterken, laten we een kleine maar echte blockchain bouwen op onze virtuele site!

Laten we dus onthouden welke problemen blockchain aanvankelijk heeft opgelost.

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

Ik geef er de voorkeur aan om welke technologie dan ook te bestuderen door de normen te lezen, omdat alle artikelen en boeken over het onderzochte onderwerp daarop zijn gebaseerd. Maar er zijn momenteel geen blockchain-standaarden; ISO heeft alleen maar gecreëerd commissies voor hun ontwikkeling. Momenteel heeft elk openbaar blockchain-project zijn eigen Whitepaper-document, dat in wezen een technische specificatie is. Het eerste publiekelijk bekende blockchain-project is het Bitcoin-netwerk. Ga naar de officiële website van het netwerk en wij kijken waar het allemaal begon.

Blockchain-uitdaging

De taak die blockchain in het Bitcoin-pioniersnetwerk heeft opgelost, is dus het uitvoeren van een vertrouwde eigendomsoverdracht van digitale activa (activa) in een niet-vertrouwde omgeving zonder tussenpersonen. In het Bitcoin-netwerk zijn digitale activa bijvoorbeeld digitale bitcoin-munten. En alle technische oplossingen van Bitcoin en andere blockchains komen neer op het oplossen van dit probleem.

Problemen die blockchain oplost

Stel dat een bepaalde financiële organisatie zegt dat ze over de hele wereld een netwerk heeft opgebouwd met behulp waarvan het mogelijk is om geld naar iedereen over te maken. Zul je haar geloven? Als deze organisatie Visa of MasterCard is, zul je het hoogstwaarschijnlijk geloven, maar als je, relatief gezien, AnonymousWorldMoney bent, zul je dat waarschijnlijk niet doen. Waarom? Maar omdat we heel goed weten hoe gedistribueerde systemen door particuliere bedrijven worden gemaakt, voor welke doeleinden en waar dit toe kan leiden. Laten we de problemen van dergelijke systemen eens nader bekijken en hoe ze kunnen worden opgelost met behulp van blockchain-technologieën.

Laten we zeggen dat er in de voorwaardelijke AnonymousWorldMoney servers met databases zijn, en het is goed als er meerdere in verschillende datacenters zijn. Wanneer de afzender geld overmaakt, wordt er een transactie geregistreerd, die naar alle servers wordt gerepliceerd, en bereikt het geld de ontvanger.

In een ideale wereld werkt dit schema prima, maar in de onze doen zich de volgende problemen voor:

1. Het probleem van het identificeren van deelnemers aan de ene kant en de noodzaak van anonimiteit van transacties aan de andere kant. Die. u moet geld overmaken naar een specifieke ontvanger en op een zodanige manier dat niemand van deze transactie op de hoogte is, behalve de deelnemers aan de transactie. Banken hebben rekeningnummers en bankkaarten die zijn gekoppeld aan een specifiek individu of rechtspersoon, en het bankgeheim beschermt transactie-informatie. En wie garandeert dat de voorwaardelijke AnonymousWorldMoney persoonsgegevens en transactie-informatie niet voor eigen doeleinden gebruikt?
2. Hoe zorg je ervoor dat de ontvanger precies het bedrag ontvangt dat naar hem is overgemaakt? Relatief gesproken maakte de afzender €100 over en ontving de ontvanger €10. De afzender komt met zijn ontvangstbewijs naar het AnonymousWorldMoney-kantoor en de griffier laat zijn versie zien, waarin staat dat de afzender slechts $ 10 heeft overgemaakt.
3. Het probleem van een niet-vertrouwde omgeving, bijvoorbeeld een oplichterij die dubbele uitgaven wordt genoemd. Een gewetenloze deelnemer kan zijn saldo meerdere keren uitgeven totdat de betaling naar alle servers is gerepliceerd. CAP-stellingNatuurlijk heeft niemand afgezegd en zal er uiteindelijk overeenstemming worden bereikt, maar iemand krijgt geen geld voor geleverde diensten of goederen. Daarom, als er geen volledig vertrouwen is in de betalingsorganisatie of deelnemers aan transacties, is het noodzakelijk om een ​​netwerk op te bouwen dat niet gebaseerd is op vertrouwen, maar op cryptografie.
4. Voorwaardelijk AnonymousWorldMoney heeft een eindig aantal servers die onbedoeld of vanwege kwade bedoelingen niet beschikbaar kunnen zijn.
5. AnonymousWorldMoney zal zijn eigen tastbare commissie in ontvangst nemen.
6. Mogelijkheid tot controle. Tijdens de werking van Bitcoin bleek dat mensen niet alleen munten aan elkaar willen overdragen, maar ook verschillende voorwaarden voor de transactie willen controleren, werkscenario's willen programmeren, automatisch acties willen uitvoeren afhankelijk van de voorwaarden, enz.

Hoe blockchain deze problemen oplost

1. Identificatie van deelnemers wordt uitgevoerd met behulp van een paar sleutels: privé en openbaar, en het algoritme voor digitale handtekeningen identificeert op unieke wijze de afzender en de ontvanger, waardoor hun identiteit anoniem blijft.
2. Transacties worden in blokken verzameld, de hash van het blok wordt berekend en naar het volgende blok geschreven. Deze opeenvolging van het vastleggen van hashes in blokken geeft de blockchain-technologie zijn naam, en maakt het ook onmogelijk om blokken of individuele transacties uit blokken ongemerkt te wijzigen/verwijderen. Als een transactie dus in de blockchain is opgenomen, kunt u er zeker van zijn dat de gegevens ervan ongewijzigd blijven.
3. Fraude met dubbele uitgaven wordt voorkomen door een netwerkconsensus te bereiken over welke gegevens als geldig moeten worden beschouwd en welke moeten worden weggegooid. In het Bitcoin-netwerk wordt consensus bereikt door proof of work (PoW).
4. De betrouwbaarheid van het netwerk wordt bereikt doordat de blockchain openbaar is, waarbij elke deelnemer zijn eigen knooppunt kan runnen, een volledige kopie van de blockchain kan ontvangen en bovendien zelfstandig transacties kan gaan controleren op juistheid. Opgemerkt moet worden dat moderne blockchains het mogelijk maken om niet alleen publieke (open) maar ook private (gesloten) blockchains te bouwen, evenals het gebruik van gecombineerde schema’s.
5. De blockchain zal de commissies niet volledig wegnemen, omdat... je moet de mensen betalen die het netwerk ondersteunen, maar in de blockchain wordt de noodzaak van een commissie zo overtuigend bewezen dat er geen twijfel bestaat over de noodzaak ervan.
6. Moderne blockchains hebben het vermogen om bedrijfslogica te implementeren, wat in de blockchain Smart Contracts wordt genoemd. De logica van slimme contracten wordt geïmplementeerd in verschillende talen op hoog niveau.

Vervolgens zullen we deze oplossingen in meer detail bekijken.

Blockchain-architectuur

Blockchain-componenten

Elke deelnemer kan zijn eigen node lanceren met een volledige kopie van de blockchain (full node). Er worden volledige knooppunten aangeroepen die transacties op de blockchain kunnen vastleggen consensus knooppunten (getuige) of mijnwerkers (mijnwerker). Er worden volledige knooppunten aangeroepen die alleen de juistheid van transacties controleren auditknooppunten (controle). Lichte klanten (light clients) slaan geen volledige kopieën van de blockchain op, maar communiceren met het netwerk met behulp van volledige knooppunten.
De meeste gebruikers gebruiken lichte clients of webportefeuilles om transacties uit te voeren. Alle knooppunten zijn met elkaar verbonden. Met deze reeks elementen wordt de netwerkarchitectuur stabieler:

Levenscyclus van transacties

Laten we eens kijken naar de levenscyclus van een transactie en deze stukje bij beetje opsplitsen:

Blockchain-technologieën

Laten we dieper ingaan op technische oplossingen en hun verbindingen met elkaar.

identificatie

Elke blockchain-transactie moet digitaal worden ondertekend. Om een ​​transactie te voltooien, moet elke deelnemer daarom over een sleutelpaar beschikken: privé / openbaar. Soms wordt een paar sleutels een portemonnee genoemd, omdat de sleutels zijn op unieke wijze gekoppeld aan het unieke digitale adres en saldo van de deelnemer. In werkelijkheid zijn sleutels en adressen slechts reeksen getallen in verschillende nummersystemen. Voorbeelden van sleutels en portemonnee-adressen:

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

Om een ​​digitale handtekening in blockchains te creëren, wordt een algoritme gebruikt dat gebaseerd is op elliptische curven: Elliptic Curve Digital Signature Algorithm (ECDSA). Om dit te laten werken, wordt de privésleutel (256-bits nummer) meestal willekeurig genomen. Het aantal sleutelopties is 2 tot de macht 256, dus we kunnen praten over de praktische onmogelijkheid om de waarden van privésleutels te matchen.

Vervolgens wordt de publieke sleutel verkregen uit de private sleutel door de waarde ervan te vermenigvuldigen met de coördinaten van een punt op de elliptische curve, wat resulteert in de coördinaten van een nieuw punt op dezelfde curve. Deze actie zorgt ervoor dat u een sleutelpaar verkrijgt dat geschikt is voor het digitaal ondertekenen van transacties. Ten slotte wordt het portemonnee-adres op unieke wijze afgeleid van de publieke 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 vertrouwelijk zijn en veilig worden bewaard. De publieke sleutel is bij iedereen bekend. Als de privésleutel verloren gaat, kan de toegang tot het bezit (munten) niet worden hersteld en zal het geld voor altijd verloren gaan. Daarom is de taak van het veilig opslaan van privésleutels uiterst relevant, omdat Dit is geen bank waar u altijd met uw paspoort langs kunt komen en uw rekening kunt herstellen. Er is een hele industrie voor de productie van zogenaamde cold crypto-wallets, vergelijkbaar met flashdrives:

of u kunt betrouwbaardere methoden gebruiken, bijvoorbeeld door de waarde van de privésleutel op tokens te stempelen:

Transactie

Meer details over de transactiestructuur vindt u in het artikel Bitcoin in een notendop – Transactie. Het is belangrijk voor ons om te begrijpen dat elke transactie minimaal de volgende gegevens bevat:

From: 0x48C89c341C5960Ca2Bf3732D6D8a0F4f89Cc4368 - цифровой адрес отправителя
To: 0x367adb7894334678b90аfe7882a5b06f7fbc783a - цифровой адрес получателя
Value: 0.0001 - сумма транзакции
Transaction Hash: 0x617ede331e8a99f46a363b32b239542bb4006e4fa9a2727a6636ffe3eb095cef - хэш транзакции

Vervolgens wordt de transactie ondertekend met een privésleutel en verzonden (zie details over de werking van het protocol). Bitcoin in een notendop-protocol) naar alle knooppunten in de blockchain die transacties op geldigheid controleren. Het transactieverificatiealgoritme is niet triviaal en omvat: twee dozijn stappen.

Transactieblokken

Na het controleren van de geldigheid van transacties, vormen knooppunten er blokken van. Naast transacties worden de hash van het vorige blok en een getal (Nonce-teller) in het blok geschreven, en wordt de hash van het huidige blok berekend met behulp van het SHA-256-algoritme. De hash moet voorwaarden voor complexiteit hebben vastgesteld. In het Bitcoin-netwerk wordt de moeilijkheidsgraad van de hash bijvoorbeeld elke 2 weken automatisch gewijzigd, afhankelijk van de kracht van het netwerk, zodat er ongeveer elke 10 minuten een blok wordt gegenereerd. De complexiteit wordt bepaald door de volgende voorwaarde: de gevonden hash moet kleiner zijn dan een vooraf bepaald getal. Als niet aan deze voorwaarde wordt voldaan, wordt 1 toegevoegd aan de Nonce en wordt het werk van het berekenen van de hash herhaald. Om een ​​hash te selecteren wordt het veld Nonce gebruikt, omdat Dit zijn de enige gegevens in het blok die kunnen worden gewijzigd; de rest moet ongewijzigd blijven. Een geldige hash moet een bepaald aantal voorloopnullen hebben, zoals een van de echte hashes:

000000000000000000000bf03212e7dd1176f52f816fa395fc9b93c44bc11f91

Het succesvol vinden van een hash is een bewijs van verricht werk (Proof-of-Work, PoW) voor de Bitcoin- of Ethereum-netwerken. Het proces van het vinden van hasj wordt mining genoemd, vergelijkbaar met goudwinning. De naam definieert vrij nauwkeurig de essentie van het proces, omdat er is een eenvoudige zoektocht naar opties, en als iemand een geschikte hasj vindt, dan is dit echt geluk. Het is alsof je een echte goudklomp vindt in tonnen afvalgesteente. De blokbeloning bedraagt ​​nu 12.5 BTC en als je deze vermenigvuldigt met de huidige Bitcoin-koers van $3900, krijg je meer dan een kilogram puur goud. Er is iets om voor te vechten!

Na het succesvol vinden van een hash, worden het blok en de gevonden hash zelf als het volgende blok naar de blockchain geschreven. Meer details over de structuur van blokken zijn te vinden in het artikel Bitcoin in een notendop: Blockchain, en hieronder is een vereenvoudigd diagram:

De blockchain begint met een blok dat nog niet de hash van het vorige blok heeft. Er is slechts één zo’n blok in de blockchain en het heeft zijn eigen naam Genesis-blok. De overige blokken hebben dezelfde structuur en verschillen alleen in het aantal transacties. Echte transacties en blokken die momenteel in Bitcoin of Ethereum worden aangemaakt, kunnen worden bekeken Block Explorer.

De grootte van blokken in Bitcoin is beperkt tot 1MB en met een minimale hoeveelheid informatie in een transactie van ongeveer 200 bytes kan het maximale aantal transacties in een blok ongeveer 6000 zijn. Vanaf hier volgt overigens de prestatie van Bitcoin, waar iedereen om lacht: ongeveer eens in de 10 minuten * 60 seconden = 600 seconden wordt er een blok gegenereerd, wat een formele prestatie oplevert van ongeveer 10 TPS. Hoewel dit in feite geen productiviteit is, maar een opzettelijk geïmplementeerd werkalgoritme. In Ethereum hebben ze, voor de concurrentie, de blokgeneratietijd eenvoudigweg 15 seconden gemaakt. en de productiviteit steeg formeel. Daarom heeft het bij blockchains die PoW als consensus gebruiken helemaal geen zin om de prestaties te vergelijken, omdat het hangt rechtstreeks af van de complexiteit van de cacheberekening, die aan elke waarde kan worden toegewezen.

Vorken

Wat gebeurt er als verschillende knooppunten bijvoorbeeld hashes vinden die aan de complexiteitsvoorwaarden voldoen, maar een verschillende waarde hebben (met andere woorden, ze kwamen tot verschillende consensussen) en blokken naar de blockchain schrijven? Laten we eens kijken hoe blockchain tegen deze situatie beschermt. In dit geval vindt er een zogenaamde fork plaats en heeft de blockchain twee versies van de keten:

Wat gebeurt er nu? Vervolgens begint een deel van het netwerk te werken op blok N+2 van de ene keten, en een deel van een andere:

Eén van deze blokken zal eerder worden gevonden en naar de blockchain worden gestuurd, en dan zal de blockchain volgens de regels moeten overschakelen naar een langere keten en alle transacties uit het alternatieve blok moeten annuleren:

Tegelijkertijd kan er een situatie ontstaan ​​waarin de transactie van een deelnemer zich slechts in een van de forkblokken bevond, die werd geannuleerd. Om er zeker van te zijn dat de gewenste transactie in de blockchain wordt vastgelegd, is er daarom een ​​algemene aanbeveling: voordat u de transactie vertrouwt, moet u wachten tot de volgende paar blokken aan de blockchain zijn toegevoegd. Aanbevelingen voor het aantal blokken dat moet wachten op verschillende blockchains variëren. Voor het Bitcoin-netwerk is het minimum bijvoorbeeld 2 blokken, het maximum 6.

Hetzelfde beeld met blokvorken zal worden waargenomen tijdens de zogenaamde 51%-aanval - dit is wanneer een groep mijnwerkers een alternatieve blokketen probeert te laten groeien, in een poging de keten te annuleren met hun frauduleuze transacties. Hoewel het momenteel, in plaats van fraude, winstgevender is om uw macht te besteden aan eerlijke mijnbouw.

Overeenstemming

Om een ​​blok op de blockchain vast te leggen, moet het netwerk consensus bereiken. Laten we niet vergeten dat het de taak is om consensus te bereiken in computercommunicatienetwerken. Het probleem is geformuleerd als de taak van de Byzantijnse generaals BFT (Byzantijnse fouttolerantie). Als we de schilderachtige beschrijving van de problemen van het Byzantijnse leger achterwege laten, kan het probleem als volgt worden geformuleerd: hoe kunnen netwerkknooppunten tot een gemeenschappelijk resultaat komen als sommige netwerkknooppunten deze opzettelijk kunnen vervormen. Bestaande algoritmen voor het oplossen van het BFT-probleem laten zien dat het netwerk correct kan functioneren als er minder dan 1/3 van de fraudeurs is. Waarom is de BFT-consensus niet toegepast op het Bitcoin-netwerk? Waarom was het nodig om PoW te gebruiken? Er zijn verschillende redenen:

• BFT werkt goed met een kleine vaste set knooppunten, maar in een publieke blockchain is het aantal knooppunten onvoorspelbaar en bovendien kunnen knooppunten willekeurig worden in- en uitgeschakeld.
• Het is noodzakelijk om mensen te motiveren om blockchain-nodes te lanceren. Om dit te doen moeten mensen beloond worden. In BFT is er formeel niets om een ​​beloning voor te ontvangen, maar waar de beloning voor is in PoW is voor iedereen op intuïtief niveau duidelijk: voor de elektriciteit die de processor verbruikt tijdens het vinden van de blok-hash.

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

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

Laten we even stilstaan ​​bij de PoS-consensus, want... Het zijn PoS en zijn varianten die het meest verspreid zijn in private blockchains. Waarom privé? Aan de ene kant zijn de kenmerken van PoS beter vergeleken met PoW, omdat Om consensus te bereiken zijn minder computerbronnen nodig, wat betekent dat de snelheid waarmee gegevens naar de blockchain worden geschreven toeneemt. Maar aan de andere kant heeft PoS meer mogelijkheden voor fraude, dus om dit te neutraliseren moeten alle deelnemers aan de blockchain bekend zijn.

PoS-consensus is gebaseerd op de selectie van een knooppunt dat een blok met transacties naar de blockchain kan schrijven, afhankelijk van de hoeveelheid geld op de rekening, of beter gezegd, niet op de rekening, maar op het onderpand, d.w.z. Hoe meer geld u als onderpand heeft, hoe groter de kans dat het netwerk uw knooppunt kiest om een ​​blok te schrijven. De borg wordt niet geretourneerd als de blokkering ongeldig is. Dit biedt bescherming tegen fraude. Er zijn de volgende varianten van PoS:

• De Delegated PoS (DPoS)-consensus verdeelt de deelnemers in ‘kiezers’ en ‘validators’. Munthouders (stemgerechtigde deelnemers) delegeren hun macht om transacties op de blockchain te verifiëren en vast te leggen aan andere deelnemers. Validators doen dus al het rekenwerk en ontvangen er een beloning voor, en de aanwezigheid van stemgerechtigde deelnemers garandeert de eerlijkheid van validators, omdat ze kunnen op elk moment worden gewijzigd.
• Met LPoS-consensus (Leased Proof-of-Stake) kunt u uw geld aan andere knooppunten leasen, zodat zij een betere kans hebben om blokken te valideren. Dat. U kunt een commissie ontvangen voor transacties zonder deel te nemen aan de daadwerkelijke transactieverificatie en block mining.

Er zijn nog een aantal andere consensussen die nog niet veel worden gebruikt, ik zal ze hier ter informatie opsommen, en een overzicht van de consensusalgoritmen zelf kun je bijvoorbeeld vinden in het artikel: Consensusalgoritmen in Blockchain.

• PoET (bewijs van verstreken tijd)
• PoC (Proof-of-Capaciteit)
• PoB (Proof-of-Burn)
• PoWeight (bewijs van gewicht)
• PoA (Bewijs van activiteit) – PoW + PoS
• PoI (Proof-of-Importans)

Betrouwbaarheid en implementatiemodellen van blockchains

Openbare blockchain

stabiliteit Publieke of een andere naam Toestemmingloze blockchain Dit wordt bereikt doordat iedereen verbinding kan maken en informatie kan bekijken of zelfs zijn eigen knooppunt kan verbinden, en vertrouwen is gebaseerd op PoW-consensus.

Privé blockchain

Privé of Privé-geautoriseerde blockchain. Bij deze blockchains heeft slechts een bepaalde groep deelnemers (organisaties of personen) toegang tot informatie. Dergelijke blockchains worden door organisaties gebouwd met als doel het algehele voordeel of de efficiëntie te vergroten. Hun betrouwbaarheid wordt verzekerd door de gemeenschappelijke doelen van de deelnemers en de PoS- en BFT-consensusalgoritmen.

Blockchain-consortium

Er Consortium of Publiek goedgekeurde blockchain. Dit zijn blockchains waar iedereen verbinding mee kan maken om te bekijken, maar een deelnemer kan alleen informatie toevoegen of zijn knooppunt verbinden met toestemming van andere deelnemers. Dergelijke blockchains worden door organisaties gebouwd om het vertrouwen van klanten of consumenten van producten of van de samenleving als geheel te vergroten. Hier wordt betrouwbaarheid ook bereikt door de aanwezigheid van vertrouwen tussen deelnemers en dezelfde PoS- en BFT-consensusalgoritmen.

Slimme contracten

Blockchains die na Bitcoin zijn geïmplementeerd, hebben tot op zekere hoogte de mogelijkheid toegevoegd om slimme contracten uit te voeren. In wezen is een slim contract een transactie waarin programmacode wordt geplaatst voor uitvoering. Slimme contracten op het Ethereum-netwerk worden uitgevoerd in de EVM (Ethereum Virtual Machine). Om te beginnen met het uitvoeren van een slim contract, moet het expliciet worden gelanceerd door een andere transactie, of moet aan de voorwaarden voor uitvoering worden voldaan. De resultaten van de uitvoering van het slimme contract zullen ook in de blockchain worden vastgelegd. Het ontvangen van data van buiten de blockchain is mogelijk, maar uiterst beperkt.

Welke bedrijfslogica kan worden geïmplementeerd met behulp van een slim contract? In feite is er niet veel, bijvoorbeeld het controleren van omstandigheden met behulp van gegevens uit de blockchain, het veranderen van de eigenaren van digitale activa afhankelijk van deze omstandigheden, het vastleggen van gegevens in een permanente opslag binnen de blockchain. De logica is geïmplementeerd in een speciale taal op hoog niveau Solidity.

Een klassiek voorbeeld van functionaliteit die wordt geïmplementeerd met behulp van slimme contracten is de uitgifte van tokens voor ICO’s. Ik heb bijvoorbeeld een slim contract geïmplementeerd om een ​​bescheiden AlexToken van 500 uit te geven. Door link in Etherscan is

broncode van het slimme contract in de Solidity-taal

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 representatie zoals het netwerk deze ziet

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

Meer details over slimme contracten vindt u in het artikel: Wat zijn slimme contracten in Ethereum.

Conclusie

We hebben de technologieën op een rij gezet waarop moderne blockchains zijn gebouwd en hoe deze met elkaar zijn verbonden. Laten we nu formuleren welke problemen kunnen worden opgelost met behulp van blockchain, en welke oplossingen op zijn best ineffectief zullen zijn. Het gebruik van blockchain is dus niet nodig als:

• Transacties worden uitgevoerd in een vertrouwde omgeving;
• De aanwezigheid van een commissie van tussenpersonen verslechtert het leven van de deelnemers niet;
• Deelnemers beschikken niet over eigendommen die kunnen worden weergegeven als digitale activa;
• Er is geen distributie in digitale activa, d.w.z. de waarde is eigendom van of wordt geleverd door slechts één deelnemer.

Wat heeft de toekomst voor blockchain in petto? Nu kunnen we alleen maar speculeren over mogelijke manieren voor de ontwikkeling van blockchain-technologieën:

• Blockchain zal dezelfde algemene databasetechnologie worden als bijvoorbeeld SQL of NoSQL voor het oplossen van de specifieke reeks problemen;
• Blockchain zal een wijdverspreid protocol worden, zoals HTTP dat is voor internet;
• Blockchain zal de basis worden voor een nieuw financieel en politiek systeem op de planeet!

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

Dit is slechts het begin!

Bron: www.habr.com