Innholdsfortegnelse[Gjemme seg][Forestilling]
Hvis vi ser på trendene de siste årene, har vi hørt om blockchain hele tiden, men ikke mye om detaljene.
Vi er alle klar over at kryptovalutaer som Bitcoin, Ethereum, Dogecoin, Matic og andre er avhengige av blockchain-teknologi. Blockchain ledet de viktige hendelsene som revolusjonerte en rekke bransjer i 2021 og banet vei for nye prestasjoner.
Blockchain er et middel for å lagre data på en måte som er vanskelig eller umulig å redigere, hacke eller svindle. Det er en digital hovedbok over transaksjoner som dupliseres og spres over hele blokkjedens nettverk av datasystemer.
Det er den banebrytende databaseteknologien som driver praktisk talt alle kryptovalutaer. Blockchain gjør det utrolig vanskelig å hacke eller jukse systemet ved å spre identiske kopier av en database over et helt nettverk.
Mens Bitcoin nå er den mest fremtredende bruken av blokkjede, kan teknologien tjene et veldig bredt utvalg av applikasjoner.
Kryptovalutaer og blokkjeder har blitt stadig mer populære de siste årene, og denne trenden forventes å fortsette.
Vi lager en enkel blokkjede med JavaScript i denne opplæringen. Det vil gi deg en grunnleggende forståelse av hvordan en blokkjede fungerer.
La oss kalle det MelodyCoin og gå rett inn i handlingen!
Opprette en blokk
Til å begynne med oppretter vi en ny JavaScript-fil der vi legger all koden vår.
La oss kalle det main.js og starte med en beskrivelse av hvordan en blokkjede og blokker skal se ut.
Lag en blokkklasse og gi den en funksjon Object() { [native code] } til å begynne med.
Du må oppgi en dato og hashen til forrige blokk når du oppretter en ny blokk:
Her er definisjonene for hver eiendom:
- Tidsstemplet indikerer når blokkeringen ble laget. Du kan bruke hvilket format du velger (i dette tilfellet et UNIX-tidsstempel).
- Enhver form for data som du ønsker å koble til denne blokken kan inkluderes i dataparameteren. Hvis du ønsker å opprette en kryptovaluta, kan du beholde transaksjonsdata som avsender/mottaker og pengebeløpet som er flyttet hit.
- The previousHash er en streng som inneholder den forrige blokkens hash. Det er dette som vil generere kjeden av blokker, som vil være avgjørende for å gi integriteten til blokkjeden vår senere.
Opprette hashes
Hver blokk lenker til den foregående blokken (dermed egenskapen previousHash). Det vil si at hver blokk krever en hash. En hash ligner på et fingeravtrykk. Det er forskjellig for hver blokk.
En blokks hash kan beregnes ved å sende alt innholdet gjennom en hash-funksjon.
Så la oss begynne med å implementere en funksjon som beregner hashen til gjeldende blokk.
Så under Block-klassen definerer vi calculateHash-funksjonen:
SHA256-hashen støttes imidlertid ikke av JavaScript og må hentes fra et eksternt bibliotek.
Crypto-js er en fantastisk pakke som inkluderer sikre implementeringer av flere hash-algoritmer.
Deretter kan vi importere den til main.js-koden vår.
Nå som vi har vår calculateHash()-funksjon, la oss bruke den i blokkens funksjon:
Etter å ha beskrevet hvordan en blokk ser ut, kan vi definere hvordan en blokkjede skal se ut. Så la oss lage en ny klasse.
I dette scenariet er blokkjeden et veldig enkelt objekt som har en eiendomskjede. Dette er en matrise som inneholder alle blokkene på kjeden.
Før vi kan legge til blokker, må vi først lage det som er kjent som en «genese-blokk». Dette er den første blokken i kjeden, og den er unik ved at den ikke kan peke til en tidligere blokk (det er den første!).
Så, for å bygge genesis-blokken, legger jeg til en funksjon i klassen vår kalt createGenesisBlock (). Tilbake i funksjonen Object() { [native code] } i Blockchain-klassen vår.
Vi kan nå inkludere genesis-blokken når som helst vi bygger en ny Blockchain-forekomst:
Blokkjedemetoder
La oss nå legge til metoder i Blockchain-klassen vår som lar oss gjøre ting som å legge til nye blokker og hente den nyeste blokken.
GetLatestBlock-funksjonen er den mest grunnleggende. Den returnerer ganske enkelt det siste medlemmet av kjedearrayen:
AddBlock-teknikken er litt mer involvert.
Før vi kan legge til en ny blokk i kjeden vår, må vi først angi blokkens forrige Hash-felt på riktig måte.
Den må settes til hashen til den sist lagt til blokken i kjeden vår. Vi må også beregne hashen til den nye blokken:
Testing
La oss se hvordan vår MelodyCoin har kommet ut.
Lag en blokkjedeforekomst for å oppnå dette. La oss legge til et par blokker til:
Vi har laget to nye blokker der. La oss ta en titt på hvordan blokkjeden vår ser ut for øyeblikket.
MelodyCoin vil bli strengt og formatert med fire mellomrom:
Bekreft Blockchains integritet
Blokkjeder er fantastiske fordi når en blokk først er lagt til, kan den ikke endres uten å ugyldiggjøre resten av kjeden.
Det er imidlertid ingen metode for meg å sjekke integriteten til blokkjeden vår med denne implementeringen.
La oss introdusere en isChainValid-funksjon til blokkjeden vår. Hvis kjeden er legitim, vil den returnere sann; ellers vil den returnere false:
Testing av integritet
Vi kan nå sette blokkjedens integritet på prøve. Hvis vi utfører det nå, vil det bekrefte at kjeden vår er ekte.
La oss nå prøve å tukle med blokkjeden vår. La oss endre blokk 2 og overskrive innholdet (la oss anta at vi overførte 100 mynter i stedet for fire).
Når vi utfører dette, kan vi se at programvaren gjenkjenner vår innsats for å tukle med kjeden.
Du kan imidlertid tro at det finnes en annen metode for meg å blande meg inn i dette. Jeg endret innholdet i blokken, men beregnet ikke hashen på nytt. Så du kan prøve å være smart og beregne hashen på den samme blokken på nytt.
Det var alt som var til vårt lille blockchain-oppsett! Det gjør det mulig for oss å legge til nye blokker og oppdage tukling med data i kjeden.
Det er to problemer med vår lille blokkjede som vi må løse:
- Moderne datamaskiner er ekstremt raske og kan legge til tusenvis av blokker til kjeden vår på sekunder. Vi vil åpenbart ikke at noen skal spamme blokkjeden vår.
- Blockchain vår er fortsatt sårbar for tukling. Du kan oppdatere innholdet i en blokk og deretter ganske enkelt beregne hashen (og tidligere hashes) på nytt for alle påfølgende blokker. Selv om du roter med det, vil du ende opp med en legitim kjede.
For å løse disse bekymringene bruker blokkjeder en teknikk kjent som "bevis på arbeid." Du må demonstrere at du brukte en betydelig mengde beregningsressurser for å lage en blokk ved hjelp av denne tilnærmingen. Dette kalles også gruvedrift.
Proof-of-work krever at en blokks hash begynner med en bestemt mengde nuller. Men hvordan kan du vite om hasjen din passer til denne regelen?
Innholdet i en blokk bestemmer hashen. Så vi får alltid den samme hasjen, forutsatt at vi ikke endrer innholdet.
Hver blokk bør ha en nonce-verdi som en løsning. Dette er i hovedsak noen tilfeldige data som vi kan oppdatere til hashen til blokken vår begynner med nok nuller. Fordi du ikke kan endre utgangen til en hash-funksjon, må du teste mange forskjellige kombinasjoner og håpe på det beste.
Introduser Mining til Blockchain
La oss begynne med å inkludere en nonce i blokkklassen vår. Nonce er enkeltverdien i blokken vår som vi kan endre for å påvirke blokkens hash.
Vi kan ikke endre tidsstemplet eller dataene.
La oss deretter skrive en mineBlock()-funksjon som vil gjøre selve miningen av en blokk. Denne funksjonen vil bli sendt med den nødvendige vanskelighetsgraden som en parameter og vil fortsette å kjøre til hashen til blokken vår begynner med nok nuller.
Jeg har nettopp laget en grunnleggende while-løkke som ville kjøre til hashen vår begynner med nok nuller. Vi bruker vanskelighetsgraden til å finne ut hvor mange nuller som trengs. Med en vanskelighetsgrad på 5 må hasjen vår begynne med 5 nuller.
Når hashen vår ikke inneholder nok nuller, hever vi nonsen med én og beregner hashen på nytt. Og hvis vi finner en hash som tilsvarer vanskelighetsgraden, logger vi den på konsollen.
Det er en ting til vi må gjøre. Vi tar egentlig ikke hensyn til nonce-variabelen i calculateHash-metoden vår, så her er den:
Blockchain klasse
La oss sette denne nye tilnærmingen på prøve i blokkjedeklassen vår og se hvordan det går.
Til å begynne med vil jeg definere vanskelighetsgraden til blokkjeden vår i funksjonen Object(). Vi definerer det her siden vi kan bruke det et sted senere.
AddBlock-funksjonen må da endres slik at den miner blokken før den legges til i kjeden vår.
Bruk Blockchain
La oss nå ta vår nye blokkjede i bruk med bevis-på-arbeid-algoritmen. Her legger du til et par console.log-setninger.
Når vi utfører denne koden, kan vi observere at gruveprosessen ikke lenger er spesielt rask.
Det tar litt tid for algoritmen å generere blokker med hashes som begynner med tre nuller (som konfigurert av vanskelighetsgrad).
Så det var slutten på vårt grunnleggende blockchain-oppsett.
Vi kan regulere hvor raskt nye blokker legges til blokkjeden vår takket være proof-of-work-mekanismen.
Det er den viktigste sikkerhetsfunksjonen på blokkjeder. Og nå som du forstår hvordan det fungerer, fortsett å lage din egen!
Legg igjen en kommentar