🥇Vad ska vi bygga en blockchain?

Hela mänsklighetens historia är en kontinuerlig process för att bli av med kedjor och skapa nya, ännu starkare. (Anonym författare)

Genom att analysera många blockchain-projekt (Bitshares, Hyperledger, Exonum, Ethereum, Bitcoin, etc.), förstår jag att ur teknisk synvinkel är de alla byggda på samma principer. Blockkedjor påminner om hus, som trots all mångfald av design, inredning och syften har en grund, väggar, tak, fönster, dörrar som är kopplade till varandra på vissa sätt. Och om du förstår de grundläggande principerna för byggnadsdesign och känner till egenskaperna hos de använda materialen, kan du bestämma det avsedda syftet med ett visst hus. För närvarande har en situation uppstått med blockchain som alla har hört talas om, men få människor förstår arkitekturen och principerna för driften. Därför finns det en missuppfattning om varför och hur det är vettigt att använda blockchain-teknologier.

I den här artikeln kommer vi att analysera egenskaperna och principerna som är gemensamma för alla blockkedjor. Låt oss sedan titta på problemen som kan lösas med blockkedjan och för att förstärka materialet, låt oss bygga en liten men riktig blockkedja på vår virtuella sida!

Så låt oss komma ihåg vilka problem blockchain ursprungligen löste.

Jag är säker på att många kommer att säga om en distribuerad, decentraliserad, offentlig och oföränderlig databas. Men varför var allt detta nödvändigt?

Jag föredrar att börja studera vilken teknik som helst genom att läsa standarderna, eftersom alla artiklar och böcker om ämnet som studeras är baserade på dem. Men det finns för närvarande inga blockchain-standarder; ISO har bara skapat Kommittéer för deras utveckling. För närvarande har varje offentligt blockchain-projekt sitt eget vitbokdokument, som i huvudsak är en teknisk specifikation. Det första allmänt kända blockkedjeprojektet är Bitcoin-nätverket. Gå till den officiella webbplatsen för nätverket och vi kollar där allt började.

Blockchain utmaning

Så uppgiften som blockchain löste i Bitcoins pionjärnätverk är att utföra en pålitlig överföring av äganderätten till digitala tillgångar (tillgångar) i en icke-pålitlig miljö utan mellanhänder. Till exempel i Bitcoin-nätverket är en digital tillgång bitcoin digitala mynt. Och alla tekniska lösningar av Bitcoin och andra blockkedjor handlar om att lösa detta problem.

Problem som blockchain löser

Anta att en viss finansiell organisation säger att den har byggt upp ett nätverk runt om i världen med hjälp av vilket det är möjligt att överföra pengar till vilken person som helst. Kommer du att tro henne? Om den här organisationen är Visa eller MasterCard kommer du troligen att tro det, men om, relativt sett, AnonymousWorldMoney kommer du förmodligen inte att göra det. Varför? Men för att vi mycket väl vet hur distribuerade system tillverkas av privata företag, i vilka syften och vad det kan leda till. Låt oss ta en närmare titt på problemen med sådana system och hur de kan lösas med hjälp av blockchain-teknik.

Låt oss säga att i de villkorliga AnonymousWorldMoney finns det servrar med databaser, och det är bra om det finns flera av dem i olika datacenter. När avsändaren överför pengar registreras en transaktion som replikeras till alla servrar och pengarna når mottagaren.

I en idealisk värld fungerar detta schema utmärkt, men i vår uppstår följande problem:

Problemet med att identifiera deltagare å ena sidan och behovet av anonymitet för transaktioner å andra sidan. De där. du behöver föra över pengar till en specifik mottagare och på ett sådant sätt att ingen känner till denna transaktion förutom deltagarna i transaktionen. Banker har kontonummer och bankkort kopplade till en specifik individ eller juridisk person och banksekretessen skyddar transaktionsinformation. Och vem garanterar att de villkorade AnonymousWorldMoney inte använder personuppgifter och transaktionsinformation för sina egna syften?
Hur försäkrar man sig om att mottagaren fick exakt det belopp som överfördes till honom? Relativt sett överförde avsändaren 100 USD och mottagaren fick 10 USD. Avsändaren kommer till AnonymousWorldMoney-kontoret med sitt kvitto, och expediten visar sin version, där det står skrivet att avsändaren endast överförde 10 dollar.
Problemet med en opålitlig miljö, till exempel en bedrägeri som kallas dubbla utgifter. En skrupellös deltagare kan spendera sitt saldo flera gånger tills betalningen replikeras till alla servrar. CAP-sats, naturligtvis, ingen avbokade, och avtal kommer i slutändan att uppnås, men någon kommer inte att få pengar för tjänster eller varor som tillhandahålls. Därför, om det inte finns något fullständigt förtroende för betalningsorganisationen eller deltagare i transaktioner, är det nödvändigt att bygga ett nätverk baserat inte på förtroende, utan på kryptografi.
Villkorliga AnonymousWorldMoney har ett begränsat antal servrar som kan bli otillgängliga oavsiktligt eller på grund av uppsåt.
AnonymousWorldMoney kommer att ta sin egen konkreta provision.
Möjlighet till kontroll. Under driften av Bitcoin visade det sig att människor inte bara vill överföra mynt till varandra, utan också kontrollera olika villkor för transaktionen, programmera arbetsscenarier, automatiskt utföra åtgärder beroende på förhållandena, etc.

Hur blockchain löser dessa problem

Identifiering av deltagare utförs med hjälp av ett par nycklar: privata och offentliga, och den digitala signaturalgoritmen identifierar avsändaren och mottagaren unikt och lämnar deras identitet anonym.
Transaktioner samlas in i block, blockets hash beräknas och skrivs in i nästa block. Denna sekvens av inspelning av hash i block ger blockkedjeteknologin dess namn, och den gör det också omöjligt att omärkligt ändra / ta bort block eller enskilda transaktioner från block. Således, om en transaktion ingår i blockkedjan, kan du vara säker på att dess data förblir oförändrad.
Bedrägerier med dubbla utgifter förhindras genom att man når ett nätverkskonsensus om vilken data som ska anses vara giltig och vilken som ska kasseras. I Bitcoin-nätverket uppnås konsensus genom bevis på arbete (PoW).
Nätverkets tillförlitlighet uppnås genom att blockkedjan är offentlig, där varje deltagare kan köra sin egen nod, få en komplett kopia av blockkedjan och dessutom självständigt börja kontrollera transaktioner för korrekthet. Det bör noteras att moderna blockkedjor gör det möjligt att bygga inte bara offentliga (öppna) utan även privata (stängda) blockkedjor, såväl som användningen av kombinerade system.
Blockkedjan kommer inte helt att bli av med provisioner, eftersom... du måste betala de personer som stödjer nätverket, men i blockkedjan bevisas behovet av en provision så övertygande att det inte råder någon tvekan om dess nödvändighet.
Moderna blockkedjor har förmågan att implementera affärslogik, som i blockkedjan kallas för Smarta kontrakt. Logiken i smarta kontrakt är implementerad på olika högnivåspråk.

Därefter kommer vi att överväga dessa lösningar mer i detalj.

Blockchain-arkitektur

Blockchain-komponenter

Varje deltagare kan starta sin egen nod med en fullständig kopia av blockkedjan (full nod). Fulla noder som kan registrera transaktioner på blockkedjan kallas konsensusnoder (vittne) eller gruvarbetare (gruvarbetare). Fulla noder som endast kontrollerar transaktionernas korrekthet anropas revisionsnoder (granska). Lätta kunder (lätta klienter) lagrar inte fullständiga kopior av blockkedjan, utan interagerar med nätverket med hjälp av fullständiga noder.
De flesta användare använder lätta klienter eller webbplånböcker för att göra transaktioner. Alla noder är kopplade till varandra. Med denna uppsättning element blir nätverksarkitekturen mer stabil:

Transaktionens livscykel

Låt oss titta på transaktionens livscykel och dela upp den bit för bit:

Blockchain-teknologier

Låt oss uppehålla oss mer i detalj vid tekniska lösningar och deras kopplingar till varandra.

identifiering

Varje blockchain-transaktion måste signeras digitalt. Därför, för att slutföra en transaktion, måste varje deltagare ha ett nyckelpar: privat / offentligt. Ibland kallas ett par nycklar en plånbok, eftersom nycklarna är unikt förknippade med deltagarens unika digitala adress och saldo. I verkligheten är nycklar och adresser bara strängar av nummer i olika nummersystem. Exempel på nycklar och plånboksadresser:

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

För att skapa en digital signatur i blockkedjor används en algoritm baserad på elliptiska kurvor: Elliptic Curve Digital Signature Algorithm (ECDSA). För att det ska fungera tas den privata nyckeln (256-bitars nummer) vanligtvis slumpmässigt. Antalet nyckelalternativ är 2 upp till 256, så vi kan prata om den praktiska omöjligheten att matcha värdena för privata nycklar.

Därefter erhålls den publika nyckeln från den privata genom att multiplicera dess värde med koordinaterna för en punkt belägen på den elliptiska kurvan, vilket resulterar i koordinaterna för en ny punkt på samma kurva. Denna åtgärd säkerställer att du får ett nyckelpar som är lämpligt för digital signering av transaktioner. Slutligen är plånboksadressen unikt härledd från den publika nyckeln.

Det finns många artiklar med detaljer om kryptografi som används i blockchain, till exempel: Bitcoin i ett nötskal – Kryptografi

Den privata nyckeln måste vara strikt konfidentiell och förvaras säkert. Den offentliga nyckeln är känd för alla. Om den privata nyckeln försvinner kan tillgången (mynten) inte återställas och pengarna kommer att gå förlorade för alltid. Därför är uppgiften att säkert lagra privata nycklar extremt relevant, eftersom Det här är inte en bank dit du alltid kan komma med ditt pass och återställa ditt konto. Det finns en hel industri för produktion av så kallade kalla kryptoplånböcker, liknande flash-enheter:

eller så kan du använda mer pålitliga metoder, till exempel att stämpla värdet av den privata nyckeln på tokens:

Transaktioner

Mer information om transaktionsstrukturen finns i artikeln Bitcoin i ett nötskal – Transaktion. Det är viktigt för oss att förstå att varje transaktion har åtminstone följande data:

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

Därefter signeras transaktionen med en privat nyckel och skickas ut (se detaljer om hur protokollet fungerar Bitcoin i ett nötskal-protokoll) till alla noder i blockkedjan som kontrollerar transaktioners giltighet. Algoritmen för transaktionsverifiering är icke-trivial och inkluderar två dussin steg.

Transaktionsblock

Efter att ha kontrollerat transaktionernas giltighet bildar noder block från dem. Förutom transaktioner skrivs hashen för det föregående blocket och ett nummer (icke-räknare) in i blocket, och hashen för det aktuella blocket beräknas med SHA-256-algoritmen. Hashen måste ha etablerade komplexitetsvillkor. Till exempel i Bitcoin-nätverket ändras hashens svårighetsgrad automatiskt varannan vecka beroende på nätverkets kraft så att ett block genereras ungefär en gång var 2:e minut. Komplexiteten bestäms av följande villkor: hashen som hittas måste vara mindre än ett förutbestämt antal. Om detta villkor inte är uppfyllt läggs 10 till i nonce, och arbetet med att beräkna hash upprepas. För att välja en hash används fältet Nonce, eftersom Detta är den enda data i blocket som kan ändras, resten måste förbli oförändrade. En giltig hash måste ha ett visst antal inledande nollor, till exempel en av de riktiga hasharna:

000000000000000000000bf03212e7dd1176f52f816fa395fc9b93c44bc11f91

Att lyckas hitta en hash är ett bevis på utfört arbete (Proof-of-Work, PoW) för Bitcoin- eller Ethereum-nätverken. Processen att hitta hash kallas gruvdrift, liknande guldbrytning. Namnet definierar ganska exakt kärnan i processen, eftersom det finns en enkel sökning av alternativ, och om någon hittar en lämplig hash, då är detta verkligen tur. Det är som att hitta en riktig guldklimp i massor av gråberg. Blockbelöningen är nu 12.5 BTC och om du multiplicerar den med den nuvarande Bitcoin-kursen på $3900 får du mer än ett kilo rent guld. Det finns något att kämpa för!

Efter att ha lyckats hitta en hash skrivs blocket och den hittade hashen till blockkedjan som nästa block. Mer information om strukturen av block finns i artikeln Bitcoin i ett nötskal - Blockchain, och nedan är ett förenklat diagram:

Blockkedjan börjar med ett block som ännu inte har hash från föregående block. Det finns bara ett sådant block i blockkedjan och har sitt eget namn Genesis block. De återstående blocken har samma struktur och skiljer sig endast i antalet transaktioner. Verkliga transaktioner och block som för närvarande skapas i Bitcoin eller Ethereum kan ses i Blockera Explorer.

Storleken på block i Bitcoin är begränsad till 1MB och med en minsta mängd information i en transaktion på cirka 200 byte kan det maximala antalet transaktioner i ett block vara cirka 6000. Härifrån följer förresten Bitcoins prestanda, som alla skrattar åt: ett block genereras ungefär en gång var 10:e minut * 60 sekunder = 600 sekunder, vilket ger en formell prestation på cirka 10 TPS. Även om det i själva verket inte är produktivitet, utan en medvetet implementerad arbetsalgoritm. I Ethereum, för konkurrens, gjorde de helt enkelt blockgenereringstiden 15 sekunder. och produktiviteten steg formellt. Därför, i blockkedjor som använder PoW som konsensus, är det ingen mening att jämföra prestanda alls, eftersom det beror direkt på komplexiteten i cacheberäkningen, som kan tilldelas vilket värde som helst.

Gafflar

Vad händer om till exempel flera noder hittat hash som uppfyller komplexitetsvillkoren, men har olika värde (med andra ord, de kom till olika konsensus) och skrev block till blockkedjan? Låt oss se hur blockchain skyddar mot denna situation. I det här fallet uppstår en så kallad gaffel, och blockkedjan har två versioner av kedjan:

Vad händer sen? Därefter börjar en del av nätverket att arbeta på block N+2 från en kedja och en del från en annan:

Ett av dessa block kommer att hittas tidigare och skickas till blockkedjan, och sedan, enligt reglerna, måste blockkedjan byta till en längre kedja och avbryta alla transaktioner från det alternativa blocket:

Samtidigt kan en situation uppstå när en deltagares transaktion endast var i ett av gaffelblocken, som avbröts. Därför, för att vara säker på att den önskade transaktionen registreras i blockkedjan, finns det en allmän rekommendation - innan du litar på transaktionen bör du vänta tills de kommande blocken läggs till blockkedjan. Rekommendationer för hur många block som ska vänta på olika blockkedjor varierar. Till exempel, för Bitcoin-nätverket är minimum 2 block, max är 6.

Samma bild med blockgafflar kommer att observeras under den så kallade 51%-attacken - det är när en grupp gruvarbetare försöker växa en alternativ blockkedja och försöker avbryta kedjan med sina bedrägliga transaktioner. Även om det för närvarande, istället för bedrägeri, är mer lönsamt att spendera din kraft på ärlig gruvdrift.

Konsensus

För att spela in ett block på blockkedjan måste nätverket nå konsensus. Låt oss komma ihåg uppgiften att uppnå konsensus i datorkommunikationsnätverk. Problemet är formulerat som uppgiften för de bysantinska generalerna BFT (Bysantinsk feltolerans). Om man utelämnar den pittoreska beskrivningen av den bysantinska arméns problem, kan problemet formuleras på följande sätt: hur kan nätverksnoder komma till ett gemensamt resultat om vissa nätverksnoder medvetet kan förvränga dem. Befintliga algoritmer för att lösa BFT-problemet visar att nätverket kan fungera korrekt om det finns mindre än 1/3 bedragare. Varför har inte BFT-konsensus tillämpats på Bitcoin-nätverket? Varför var det nödvändigt att använda PoW? Det finns flera anledningar:

BFT fungerar bra med en liten fast uppsättning noder, men i en offentlig blockkedja är antalet noder oförutsägbart och dessutom kan noder slås på och av slumpmässigt.
Det är nödvändigt att motivera människor att lansera blockkedjenoder. För att göra detta måste människor belönas. I BFT finns det formellt inget att få en belöning för, men vad belöningen är för i PoW är tydligt för alla på en intuitiv nivå: för den elektricitet som förbrukas av processorn i processen att hitta blockhash.

Förutom PoW finns det flera andra konsensus som används i moderna blockkedjor, till exempel:

PoS (Proof-of-Stake) - på blockkedjan Hyperledger
DPoS (Delegated Proof-of-Stake) - på blockkedjan BitShares
Modifieringar av BFT: SBFT (Simplified BFT) och PBFT (Practical BFT), till exempel i blockchain Exonum

Låt oss uppehålla oss lite vid PoS-konsensus, eftersom... Det är PoS och dess varianter som är mest utbredda i privata blockkedjor. Varför privat? Å ena sidan är egenskaperna hos PoS bättre jämfört med PoW, eftersom För att uppnå konsensus behövs mindre datorresurser, vilket innebär att hastigheten för att skriva data till blockkedjan ökar. Men å andra sidan har PoS fler möjligheter till bedrägerier, så för att neutralisera detta måste alla deltagare i blockkedjan vara kända.

PoS-konsensus baseras på valet av en nod som kan skriva ett block med transaktioner till blockkedjan beroende på mängden medel på kontot, eller snarare, inte på kontot, utan i säkerheten, d.v.s. Ju mer pengar du har som säkerhet, desto mer sannolikt kommer nätverket att välja din nod för att skriva ett block. Depositionen återbetalas inte om spärren är ogiltig. Detta ger skydd mot bedrägerier. Det finns följande varianter av PoS:

Den delegerade PoS (DPoS) konsensus delar upp deltagarna i "väljare" och "validerare". Myntinnehavare (deltagare med rösträtt) delegerar sin makt att verifiera och registrera transaktioner på blockchain till andra deltagare. Validatorer gör alltså allt beräkningsarbete och får en belöning för det, och närvaron av röstande deltagare garanterar validatorernas ärlighet, eftersom de kan ändras när som helst.
LPoS (Leased Proof-of-Stake) konsensus gör att du kan leasa dina pengar till andra noder så att de har en bättre chans att validera block. Den där. Du kan få provision för transaktioner utan att delta i själva transaktionsverifieringen och blockbrytningen.

Det finns ett antal andra konsensus som ännu inte används i stor utsträckning, jag listar dem bara här för information, och en översikt över själva konsensusalgoritmerna finns till exempel i artikeln: Konsensusalgoritmer i 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-Importans)

Tillförlitlighet och distributionsmodeller av blockkedjor

Offentlig blockkedja

stabilitet offentliga eller annat namn Tillståndslös blockchain Detta uppnås genom att låta vem som helst ansluta och se information eller till och med ansluta sin egen nod, och förtroende bygger på PoW-konsensus.

Privat blockchain

Privat eller Privat tillåten blockchain. I dessa blockkedjor har bara en viss grupp av deltagare (organisationer eller personer) tillgång till information. Sådana blockkedjor byggs av organisationer med målet att öka den totala nyttan eller effektiviteten. Deras tillförlitlighet säkerställs av deltagarnas gemensamma mål och PoS- och BFT-konsensusalgoritmerna.

Blockchain konsortium

Det Consortium eller Public Permissioned blockchain. Dessa är blockkedjor som vem som helst kan ansluta till för att se, men en deltagare kan lägga till information eller ansluta sin nod endast med tillstånd från andra deltagare. Sådana blockkedjor byggs av organisationer för att öka förtroendet hos kunder eller konsumenter av produkter eller samhället som helhet. Här uppnås också tillförlitlighet genom närvaron av förtroende mellan deltagare och samma PoS- och BFT-konsensusalgoritmer.

Smarta kontrakt

Blockkedjor implementerade efter Bitcoin har i en eller annan grad lagt till möjligheten att utföra smarta kontrakt. I huvudsak är ett smart kontrakt en transaktion där programkoden placeras för exekvering. Smarta kontrakt på Ethereum-nätverket exekveras i EVM (Ethereum Virtual Machine). För att börja utföra ett smart kontrakt måste det explicit lanseras av en annan transaktion, eller så måste förutsättningarna för utförande vara uppfyllda. Resultaten av utförandet av det smarta kontraktet kommer också att registreras i blockkedjan. Att ta emot data utanför blockkedjan är möjligt, men extremt begränsat.

Vilken affärslogik kan implementeras med ett smart kontrakt? Det finns faktiskt inte mycket, till exempel att kontrollera förhållanden med hjälp av data från blockkedjan, byta ägare av digitala tillgångar beroende på dessa förhållanden, registrera data i en permanent lagring inom blockkedjan. Logiken är implementerad i ett speciellt högnivåspråk Solidity.

Ett klassiskt exempel på funktionalitet som implementeras med hjälp av smarta kontrakt är utfärdandet av tokens för ICO:er. Till exempel implementerade jag ett smart kontrakt för att utfärda blygsamma 500 000 000 AlexToken. Förbi länk i Etherscan är

källkoden för det smarta kontraktet på Solidity-språket

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;
}

och den binära representationen som nätverket ser den

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

Mer information om smarta kontrakt finns i artikeln: Vad är smarta kontrakt i Ethereum.

Slutsats

Vi har listat de teknologier som moderna blockkedjor bygger på och hur de är kopplade till varandra. Låt oss nu formulera vilka problem som kan lösas med blockchain, och vilka lösningar som i bästa fall kommer att vara ineffektiva. Så att använda blockchain är inte nödvändigt om:

Transaktioner utförs i en pålitlig miljö;
Närvaron av en kommission av mellanhänder förvärrar inte deltagarnas liv;
Deltagarna har ingen egendom som kan representeras som digitala tillgångar;
Det finns ingen distribution i digitala tillgångar, d.v.s. värdet ägs eller tillhandahålls av endast en deltagare.

Hur ser framtiden ut för blockchain? Nu kan vi bara spekulera om möjliga sätt för utveckling av blockchain-teknologier:

Blockchain kommer att bli samma vanliga databasteknologi som till exempel SQL eller NoSQL för att lösa dess specifika problemområde;
Blockchain kommer att bli ett utbrett protokoll, som HTTP är för Internet;
Blockchain kommer att bli grunden för ett nytt finansiellt och politiskt system på planeten!

I nästa del ska vi titta på vilka blockkedjor som finns för närvarande och varför de används i olika branscher.

Detta är bara början!

Källa: will.com

Vad ska vi bygga en blockchain?