V2llIGlzIFNhdG9zaGkgTmFrYW1vdG8gZW4gd2Fhcm9tIGhlZWZ0IGhpaiBCaXRjb2luIGFub25pZW0gZ2VjcmXDq2VyZD8=

2023-02-23, 08:47

<p><img src="https://gimg2.gateimg.com/image/article/1677141794industry analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR327314"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>In 2009 introduceerde Satoshi Nakamoto de gedecentraliseerde digitale valuta Bitcoin.</p>
<p>Op dit moment weet niemand precies wie de oprichter van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> is, of Satoshi Nakamoto een man, een vrouw of een groep mensen is.</p>
<p>Veel cryptografie-experts en analisten verdenken dat Satoshi Nakamoto een van de volgende personen zou kunnen zijn: Craig Wright, Nick Szabo, Dorian Nakamoto of Hal Finney.</p>
<h2 id="h2-Inleiding258264"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Bij het bespreken van Bitcoin lijkt de geschiedenis van blockchain en cryptocurrency onvolledig zonder te praten over de maker van Bitcoin, Satoshi Nakamoto. Helaas weet niemand op dit moment precies wie deze geweldige uitvinder is. Cryptografie-analisten en ervaren cryptocurrency-liefhebbers zijn echter nieuwsgierig waarom Satoshi Nakamoto zijn identiteit niet openbaar heeft gemaakt. Dit artikel zal ingaan op de verdachte personen die mogelijk Satoshi Nakamoto zijn.</p>
<h2 id="h2-Wie20is20Satoshi20Nakamoto818879"><a name="Wie is Satoshi Nakamoto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie is Satoshi Nakamoto?</h2><p>Satoshi Nakamoto is het pseudoniem van de maker van Bitcoin. Hij communiceerde ooit met de buitenwereld via e-mail, forumberichten en andere documenten zoals whitepapers. Tot op heden is de exacte identiteit van deze persoon of groep mensen echter onbekend.</p>
<p>Hoewel Satoshi Nakamoto een Japanse naam is, zijn sommige analisten van mening dat deze persoon mogelijk in een ander land woont, zoals het Verenigd Koninkrijk of de Verenigde Staten, omdat hij/zij tijdens de ontwikkeling van Bitcoin zeer vloeiend Engels sprak. Bovendien heeft Satoshi Nakamoto tijdens zijn werkuren in Europa met anderen gecommuniceerd, wat ook de reden is waarom anderen denken dat hij/zij in een Europees land woont in plaats van in Japan.</p>
<p>Bovendien is het nog niet duidelijk of Satoshi Nakamoto een vrouw, een man of een groep mensen is. Sommigen geloven echter dat Satoshi Nakamoto waarschijnlijk een man is, omdat ‘Satoshi Nakamoto’ een veel voorkomende naam is voor mannen in Japan. Bovendien beweerde Satoshi Nakamoto in 2011 dat hij een man was die op 5 april 1975 was geboren.</p>
<p>Echter, sommigen geloven dat Satoshi Nakamoto mogelijk een naam is voor een groep ontwikkelaars die samen aan Bitcoin werken. Sommige software-ingenieurs en programmeurs geloven dat vanwege de complexiteit van de Bitcoin-code, Satoshi Nakamoto een groepsnaam zou kunnen zijn. Ze geloven dat zo’n complexe codeklus niet door slechts één persoon voltooid zou moeten zijn.</p>
<p>Het is vermeldenswaard dat Satoshi Nakamoto niet de uitvinder van blockchain is, maar de eerste persoon die gedecentraliseerd geld heeft gecreëerd. Tegelijkertijd publiceerde Satoshi Nakamoto in 2008 het Bitcoin whitepaper voordat Bitcoin in 2009 werd gelanceerd. Echter, in 2011 stopte hij/zij met wezenlijke communicatie met de buitenwereld, hoewel hij in 2014 nog een bericht publiceerde, wat zijn laatste openbare communicatie was.</p>
<p>Sinds Satoshi Nakamoto jaren geleden verdween uit het publieke oog, hebben sommige experts een lijst samengesteld van wie zij denken dat de maker van Bitcoin, Satoshi Nakamoto, is. Dit omvat Craig Wright, Nick Szabo, Dorian Nakamoto en Hal Finney.</p>
<h3 id="h3-Dorian20Nakamoto662919"><a name="Dorian Nakamoto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dorian Nakamoto</h3><p>Dorian Nakamoto wordt verdacht van mogelijk Satoshi Nakamoto te zijn. Dit komt omdat hij verschillende overeenkomsten heeft met de maker van Bitcoin. Ten eerste is Dorian een Japans-Amerikaan die in de Verenigde Staten woont en vloeiend Engels spreekt. Bovendien is zijn geboortedatum ook vergelijkbaar met die van Satoshi Nakamoto, dus het is zeer waarschijnlijk dat hij de uitvinder van Bitcoin is.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16771419479901677141882_.pic.jpg" alt=""><br>Dorian Nakamoto-BSCnieuws</p>
<p>Hoewel Dorian betrokken is geweest bij militaire projecten, heeft hij ook als computeringenieur gewerkt in de informatie-technologie (IT) en financiële sector. In 2014 bevestigde een artikel in het tijdschrift ‘Newsweek’ deze mogelijkheid, waarin Dorian werd geciteerd met uitspraken die sterk leken op die van Satoshi Nakamoto.</p>
<p>De laatste woorden van Satoshi Nakamoto voordat hij stopte met communiceren met de buitenwereld waren: “Ik ben niet langer betrokken bij het Bitcoin-project, ik kan er ook niet over praten. Het Bitcoin-project is overgedragen aan anderen. Ze zijn nu verantwoordelijk. Ik neem geen contact meer op.”</p>
<p>Dorian Nakamoto ontkent echter dat hij Satoshi Nakamoto is. Satoshi Nakamoto zelf heeft dit ook bevestigd en schreef: “Ik ben geen Satoshi Nakamoto.” Bovendien bevestigde Dorian tijdens een ander interview dat er sprake was van een misverstand in de vraag die aan hem werd gesteld door journalist Leah McGrath Goodwin van Newsweek, wat later tot verwarring heeft geleid.</p>
<h3 id="h3-Craig20Wright909616"><a name="Craig Wright" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Craig Wright</h3><p>Computerwetenschapper en zakenman Craig Wright beweert openlijk dat hij een van de mensen achter Satoshi Nakamoto is. Deze bewering is ontstaan uit artikelen gepubliceerd in de tijdschriften Wired en Gizmodo, waarin wordt gesteld dat Craig Wright Satoshi Nakamoto is. Wired biedt bijvoorbeeld enig bewijs, zoals e-mails, blogposts en andere aanwijzingen, die suggereren dat Wright de oprichter van Bitcoin is.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16771419779911677141894_.pic.jpg" alt=""><br>Craig Wright- Coindesk</p>
<p>Later vroeg Wright het auteursrecht aan voor de Amerikaanse versie van het Bitcoin-witboek en kreeg het in 2019. Desalniettemin zijn commentatoren en analisten van mening dat iedereen kan beweren de auteur van het Bitcoin-witboek te zijn en mogelijk deze rechtszaak kan winnen. Het feit dat de overheid dit auteursrecht heeft toegekend, bewijst echter niet dat Wright Satoshi Nakamoto is.</p>
<p>Desalniettemin zijn sommige experts van mening dat Wright, die in 1970 is geboren, niet de auteur van het Bitcoin whitepaper is en ook niet de maker van Bitcoin. Hun argument is dat Satoshi Nakamoto om redenen die niemand kent, volledig anoniem wilde blijven. Dus de bewering van Wright is misschien alleen maar om erkenning te krijgen, omdat hij geen nieuwe technologie heeft ontwikkeld of gecreëerd.</p>
<h3 id="h3-Hal20Finney589664"><a name="Hal Finney" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hal Finney</h3><p>Sommige analisten vermoeden dat Hal Finney Satoshi Nakamoto is, omdat hij de tweede persoon was die de Bitcoin-software gebruikte na Satoshi Nakamoto. feit is dat Finney de eerste persoon was die in 2009 bitcoins van Satoshi Nakamoto ontving. Daarom concluderen sommige analisten dat Finney mogelijk Satoshi Nakamoto is, die bitcoins van zijn ene portemonnee naar de andere heeft verzonden.</p>
<p>Als Finney mogelijk bewijs is voor Satoshi Nakamoto, heeft voormalig Forbes-journalist Andy Greenberg Finney’s handschrift vergeleken met dat van Nakamoto. Bovendien was Finney de eerste persoon die de Bitcoin-software downloadde kort nadat Nakamoto de <a href="/price/link-ln" target="_blank" class="blog_inner_link">link</a> had gepubliceerd.</p>
<p>Gezien de interactie tussen Satoshi Nakamoto en Finney waren ze nauw met elkaar verbonden sinds het begin van het Bitcoin-project. Ze stuurden elkaar verschillende e-mails, wat deed vermoeden dat Finney misschien dezelfde persoon was als Satoshi Nakamoto. Finney ontkende echter dat hij Satoshi Nakamoto was en overleed op 58-jarige leeftijd aan de ziekte van Lou Gehrig in 2014.</p>
<h3 id="h3-Nick20Szabo80569"><a name="Nick Szabo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nick Szabo</h3><p>Een andere persoon die door velen als Satoshi Nakamoto wordt beschouwd, is Nick Szabo, een computerprogrammeur en cryptograaf. Szabo plande in de jaren 90 de ontwikkeling van een gedecentraliseerde valuta genaamd Bit Gold, die enkele overeenkomsten vertoont met Bitcoin. Helaas is Bit Gold niet succesvol gelanceerd.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16771420089921677141907_.pic_hd.jpg" alt=""><br>Nick Szabo- Brickken</p>
<p>Szabo publiceerde destijds een gedetailleerd artikel over Bitcoin, wat deed vermoeden dat hij misschien Satoshi Nakamoto was. Szabo heeft echter altijd krachtig ontkend dat hij Satoshi Nakamoto is.</p>
<h2 id="h2-Conclusie538446"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Over het algemeen wordt gedacht dat Satoshi Nakamoto, de maker van Bitcoin, het in 2009 heeft ontwikkeld en geïntroduceerd. De exacte identiteit van Nakamoto blijft echter een mysterie. Niemand weet precies wie hij is of dat Nakamoto een vrouw, man of een groep mensen is. Analisten vermoeden echter dat de oprichter van Bitcoin een van de volgende personen zou kunnen zijn: Craig Wright, Nick Szabo, Dorian Nakamoto of Hal Finney.</p>
<h2 id="h2-Veelgestelde20vragen20over20Satoshi20Nakamoto592746"><a name="Veelgestelde vragen over Satoshi Nakamoto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Satoshi Nakamoto</h2><h3 id="h3-Wie20heeft20Bitcoin20gemaakt760121"><a name="Wie heeft Bitcoin gemaakt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie heeft Bitcoin gemaakt?</h3><p>Satoshi Nakamoto heeft Bitcoin gecreëerd en gelanceerd in 2009. Hij/Zij/Hun publiceerde het Bitcoin whitepaper in 2008 en bleef tot 2011 in contact met andere ontwikkelaars. De laatste communicatie met de Bitcoin-gemeenschap was in 2014.</p>
<h3 id="h3-Wie20is20Satoshi20Nakamoto696425"><a name="Wie is Satoshi Nakamoto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie is Satoshi Nakamoto?</h3><p>De identiteit van Satoshi Nakamoto is nog onduidelijk omdat het niet duidelijk is of hij een vrouw, man of een groep gelijkgestemde mensen is. Het is echter zeer waarschijnlijk dat Satoshi Nakamoto een man is omdat het in Japan een veelvoorkomende mannelijke naam is. Over het algemeen denken veel analisten dat Satoshi Nakamoto mogelijk een van de volgende personen is: Craig Wright, Nick Szabo, Dorian Nakamoto of Hal Finney.</p>
<h3 id="h3-Hoeveel20Bitcoin20bezit20Satoshi20Nakamoto20eigenlijk798465"><a name="Hoeveel Bitcoin bezit Satoshi Nakamoto eigenlijk?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel Bitcoin bezit Satoshi Nakamoto eigenlijk?</h3><p>Niemand weet de exacte hoeveelheid bitcoin die Satoshi Nakamoto momenteel bezit. Veel mensen geloven echter dat hij meer dan 1 miljoen bitcoins bezit, waarmee hij een van de grootste bitcoin-walvissen ooit is. Met de huidige prijs van bitcoin die op 22 januari 2023 rond de 20.000 dollar ligt, bedraagt het nettovermogen van Satoshi Nakamoto meer dan 20 miljard dollar.</p>
<h3 id="h3-Waarom20verschijnt20Satoshi20Nakamoto20niet20in20het20openbaar844184"><a name="Waarom verschijnt Satoshi Nakamoto niet in het openbaar?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom verschijnt Satoshi Nakamoto niet in het openbaar?</h3><p>Het is nog onbekend waarom Satoshi Nakamoto niet naar buiten wil treden. Maar het is zeker dat de oprichter van Bitcoin anoniem wil blijven. Tot slot speculeren sommigen dat Satoshi Nakamoto anoniem wil blijven omdat hij een grote hoeveelheid Bitcoin bezit. Als sommige overheidsinstanties zijn ware identiteit zouden kennen, zou zijn persoonlijke veiligheid misschien worden bedreigd.</p>
<h3 id="h3-Kan20Satoshi20Nakamoto20Bitcoin20sluiten841794"><a name="Kan Satoshi Nakamoto Bitcoin sluiten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kan Satoshi Nakamoto Bitcoin sluiten?</h3><p>Het is zeer onwaarschijnlijk dat Satoshi Nakamoto Bitcoin, dat al meer dan 12 jaar actief is, zou kunnen sluiten. Alleen als de meerderheid van de Bitcoin-houders instemt met veranderingen, kan een aanval op Bitcoin succesvol zijn. Satoshi Nakamoto bezit ongeveer 5% van de totale Bitcoin-voorraad, wat het moeilijk maakt om Bitcoin te sluiten.</p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Mashell C.</strong>, Gate.io researcher<div>Vertaler: Joy Z.<div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de auteur en vormt geen enkel handelsadvies.</em><div><em></em> This article is original, and the copyright belongs to Gate.io. If you need to repost, please indicate the author and source, otherwise legal liability will be pursued.<br></div><p></p></div></div></div></div>