V2F0IHdhcyBkZSBlZXJzdGUgY3J5cHRvY3VycmVuY3k6IENyeXB0byB2w7PDs3IgQml0Y29pbj8=

2023-02-08, 07:01

<p><img src="https://gimg2.gateimg.com/blog/167583907498183482111.jpg" alt=""><br><strong>[TL; DR]</strong></p>
<p>DigiCash, HashCash, Bit Gold en Flooz.com zijn voorbeelden van digitale valuta die bestonden vóór cryptocurrency.</p>
<p>Er was geen overheidscontrole of tussenpersonen bij de meeste vroege digitale valuta.</p>
<p>Satoshi Nakamoto heeft enkele concepten geleend van enkele van de vroege digitale valuta’s om te ontwikkelen <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>.</p>
<p>De belangrijkste reden waarom de meeste vroege virtuele valuta’s faalden, was het gebrek aan grassroots-ondersteuning.</p>
<h2 id="h2-Introductie717666"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>In de cryptowereld geloven veel mensen dat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> geïntroduceerd in 2009 was de eerste gedecentraliseerde digitale activa. Echter, de waarheid is dat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a> was niet het eerste project om een gedecentraliseerde valuta te ontwikkelen. Voor <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> er waren verschillende digitale valuta’s die mensen gebruikten, maar voor korte perioden en op kleinere schaal dan BTC. Vandaag bespreken we enkele van de gecentraliseerde en gedecentraliseerde digitale valuta’s die eerder zijn uitgevonden <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> zoals Hashcash, B-Money, Bit Gold en eCash.</p>
<h2 id="h2-Virtueel20geld20op20het20benzinestation321816"><a name="Virtueel geld op het benzinestation" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Virtueel geld op het benzinestation</h2><p>Het virtuele geld op een benzinestation was een van de eerste geregistreerde glen van virtuele valuta, ontwikkeld in de jaren 80. In feite bedacht David Chaum, een Amerikaanse cryptograaf, in 1983 een digitale valuta die kortstondig werd gebruikt bij tankstations in Nederland.</p>
<p>De belangrijkste trigger voor deze innovatieve stap was om om te gaan met hoge glen van diefstal die vroeger plaatsvonden bij benzinestations. Diefstallen van contant geld waren wijdverspreid bij tankstations die ‘s nachts open waren. Daarom hebben een groep ontwikkelaars fiatgeld verbonden met slimme kaarten om deze diefstallen tot een minimum te beperken. Als gevolg daarvan gebruikten vrachtwagenchauffeurs de kaarten om te betalen voor brandstof.</p>
<p>Met de tijd konden shoppers goederen betalen met behulp van point of sales (PoS) gekoppeld aan hun bankrekeningen. Chaum’s eCash-betalingssysteem was ontworpen om privacy in het banksysteem te brengen. Interessant is dat Chaum twee documenten heeft gepubliceerd, vergelijkbaar met de witboeken van vandaag, waarin werd uitgelegd hoe het eCash-betalingssysteem zou werken.<br><img src="https://gimg2.gateimg.com/image/article/1675839251111.png" alt=""><br>David Chaum - Embnation</p>
<p>Chaum publiceerde het eerste ‘paper’ over het eCash-betalingssysteem in 1981, getiteld ‘Onopspoorbare elektronische post, retouradressen en digitale pseudoniemen’. Een jaar later, in 1982, publiceerde Chaum een ander artikel met de titel ‘Blind signatures voor onopspoorbare betalingen’. Het is dit artikel dat een stevig fundament legde voor het anonieme transactiesysteem dat we vandaag de dag gebruiken, met betrekking tot <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">cryptocurrencies zoals](https://www.gate.io/learn/articles/what-is-cryptocurrency/367 “cryptocurrencies like [Bitcoin</a> <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> en ETH. en ETH. “)</p>
<p>In 1989 creëerde Chaum en zijn team van ontwikkelaars een <a href="/price/ecash-xec" target="_blank" class="blog_inner_link">eCash</a> Protocol. Echter, Chaum en het team slaagden er niet in om samenwerkingen met banken en handelaren tot stand te brengen om de grotere adoptie van het eCash-betalingssysteem te bevorderen. Daarom verklaarde hij in 1989 faillissement.</p>
<h2 id="h2-Digicash409241"><a name="Digicash" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Digicash</h2><p>We hebben hierboven al een beetje over Digicash gesproken, maar laten we er meer over bespreken. Chaum streefde ernaar om Digicash anoniem digitaal geld te maken en veel zakenmensen waren gecharmeerd van de transactieprivacy die het aan zijn gebruikers zou bieden. Zelfs Microsoft wilde DigiCash integreren in zijn Windows 95.</p>
<p>Het belangrijkste verschil tussen DigiCash en de meeste digitale valuta’s zoals <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> is dat DigiCash een privé virtuele valuta was terwijl cryptocurrencies open-source activa zijn.</p>
<p>Wat crypto-ontwikkelaars voornamelijk hebben geleerd van DigiCash is het gebruik van Blind handtekeningen, die een combinatie van privé- en openbare sleutels gebruiken om de inhoud van de berichten te verbergen. De concepten van privé- en openbare sleutels zijn kritieke aspecten van de technologie van cryptocurrency.</p>
<h2 id="h2-Bit20Goud982409"><a name="Bit Goud" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bit Goud</h2><p>Nick Szabo, een prominente lid van de extropian en cypherpunk gemeenschappen, was instrumenteel in de ontwikkeling van cryptocurrencies en het blockchain systeem. Met ervaring in computerwetenschappen en cryptografie tot aan wetgeving, stelde Szabo het gebruik van slimme contracten voor die afhankelijk waren van gespecialiseerde codes in plaats van jurisdictie.</p>
<p>Later stelde Szabo voor om een inheemse digitale valuta te gebruiken die zou stromen in het digitale contract en elektronisch van de ene persoon naar de andere zou worden overgedragen. Hij richtte zich op het verbeteren van het concept van Digicash om een virtuele valuta te creëren die schaars was, duur om te produceren en niet zou vertrouwen op tussenpersonen zoals banken.</p>
<p>Als gevolg hiervan ontwikkelde Szabo Bit Gold, dat het proof-of-work protocol gebruikte, vergelijkbaar met dat van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. De productie, eigendom en distributie van Bit Gold zouden worden geregistreerd in een gedistribueerd eigendomsregister, beheerd door een quorum-gebaseerd stemsysteem.</p>
<p>Desalniettemin heeft Bit Gold enkele tekortkomingen. Het was niet fungibel, wat het moeilijk maakte om op dagelijkse basis te gebruiken. Szabo’s andere verbeteringsvoorstel om een veilige, vertrouwde, controleerbare bank te hebben, was vatbaar voor Sybil-aanvallen die tot de splitsing van het netwerk zouden kunnen leiden.</p>
<p>Hoewel Szabo zijn ontwikkeling van een functionele Bit Gold-valuta wilde voortzetten, stopte hij het project kort nadat Satoshi Nakamoto het lanceerde. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. Dit komt doordat hij geloofde dat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> loste het probleem op dat de volledige lancering en adoptie van Bit Gold heeft voorkomen.</p>
<p>Zelfs de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> oprichter, Satoshi Nakamoto erkende de bijdrage <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">die het Bit Gold-project heeft bijgedragen aan de succesvolle ontwikkeling van](https://www.gate.io/blog_detail/626/who-is-satoshi-nakamoto-here-are-the-best-guesses “which the Bit Gold project made to the successful development of [Bitcoin</a> <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>”). In een van de Bitcointalk-forums schreef Nakamoto: “ <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> is een implementatie van Wei Dai’s B-money voorstel […] in 1998 en Nick Szabo’s Bitgold voorstel.</p>
<h2 id="h2-HashCash251376"><a name="HashCash" class="reference-link"></a><span class="header-link octicon octicon-link"></span>HashCash</h2><p>Nog een geweldige voorloper van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> en andere cryptocurrencies is HashCash, voorgesteld en ontwikkeld door Adam Beck, een bekende cryptograaf. Wat HashCash heeft veroorzaakt, was een onderzoek uitgevoerd door IBM-onderzoekers Cynthia Dwork en Moni Naor in 1992, waarin werd uitgelegd hoe Sybil-aanvallen, denial-of-service-aanvallen en spam-messaging te voorkomen.</p>
<p>Ze bedachten een voorstel om deze problemen aan te pakken. In dit g zou de afzender van een e-mail een puzzel oplossen als bewijs dat het geen ongevraagde e-mail of bericht is. Deze persoon zou vervolgens een kopie van de oplossing aan de e-mail toevoegen, wat fungeerde als een proof-of-work en bevestigde dat het bericht van hem/haar afkomstig was. Dit zou het verzenden van spamberichten kunnen verbieden.</p>
<p>Als gevolg hiervan stelde Adam Beck een vergelijkbaar systeem voor een digitale valuta voor. De door Beck voorgestelde virtuele valuta genaamd HashCash zou vertrouwen op hashing in plaats van het oplossen van complexe puzzels.<br><img src="https://gimg2.gateimg.com/image/article/1675839515222.png" alt=""><br>Adam Beck - Bitkub</p>
<p>Hashing is het proces van het gebruik van rekenkracht om specifieke gegevens om te zetten in willekeurige reeksen karakters. Daarom gebruikte HashCash bewijs-van-werk om transacties te bevestigen.</p>
<h2 id="h2-BGeld900383"><a name="B-Geld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>B-Geld</h2><p>Wei Dai, een actieve cypherpunk, was van plan om een soort peer-to-peer financieel systeem te introduceren, dat niet gereguleerd zou worden door de overheid of enige centrale autoriteit. Het zou het gebruik van slimme contracten omvatten met een systeem om geschillen op te lossen die zouden kunnen ontstaan.</p>
<p>De virtuele valuta zou gebruik maken van een gedeeld grootboeksysteem dat alle deelnemers zou kunnen verbinden. Bovendien zou dit systeem het proof-of-stake consensusalgoritme gebruiken en openbare sleutels hebben die de gebruikers vertegenwoordigen. Opmerkelijk was dat er een behoefte was aan een server om de transactierecords voor toekomstig gebruik op te slaan.</p>
<p>Hoewel B-Money nooit werd gebruikt, was het systeem vergelijkbaar met dat van de meeste cryptocurrencies, namelijk elektronisch, veilig, privé en anoniem. Belangrijker nog, <a href="https://www.gate.io/learn/articles/who-is-satoshi-nakamoto/286" target="_blank">Satoshi Nakamoto</a> verwees naar B-Money in de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> whitepaper. De B-money leek op blockchain-gebaseerd digitaal geld in die zin dat er geen tussenpersonen bij betrokken zouden zijn.</p>
<h2 id="h2-Floozcom955338"><a name="Flooz.com" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Flooz.com</h2><p>De Flooz eCash is een voorbeeld van digitaal geld dat al bestond vóór cryptocurrencies. Flooz introduceerde eCash in 1998 als onderdeel van zijn promotie- en marketingstrategie. Met name klanten die goederen kochten op Flooz.com kregen klantenbonuskaarten die ze op elk moment konden inwisselen.<br>De klanten konden echter ook de Flooz eCash van het platform kopen voor $1,00. Naast het gebruik van de eCash om producten op het platform te kopen, konden houders van eCash ook goederen kopen bij andere online handelaren die verbonden waren met Flooz.com. Helaas is Flooz.com gesloten omdat er veel criminele activiteiten plaatsvonden met behulp van dat betalingssysteem.</p>
<h2 id="h2-Conclusie887487"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>In feite hebben verschillende vooraanstaande personen geprobeerd elektronisch geld te ontwikkelen en te gebruiken, ruim voor de lancering van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> De geschiedenis van cryptocurrency kan niet compleet zijn zonder virtueel geld zoals DigiCash, HashCash, Bit Gold, B-Money en Flooz.com. Vervolgens kregen de ontwikkelaars van cryptocurrencies zoals Satoshi Nakamoto aanwijzingen van deze eerdere digitale valuta’s toen ze hun eigen cryptocurrencies ontwikkelden.</p>
<h2 id="h2-Veelgestelde20vragen20over20cryptocurrency20vr202020Bitcoin106629"><a name="Veelgestelde vragen over cryptocurrency vóór   Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over cryptocurrency vóór <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a></h2><h3 id="h3-Wat20was20de20allereerste20cryptocurrency20voor202020Bitcoin20672780"><a name="Wat was de allereerste cryptocurrency voor   Bitcoin ?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat was de allereerste cryptocurrency voor <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>?</h3><p>De eerste cryptocurrency eerder <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> eCash werd gecreëerd door het bedrijf DigiCash in 1990. De cryptograaf David Chaum creëerde Ecash. Andere virtuele valuta die eerder bestonden dan <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> waren eCash, B-geld, Bit Gold en Hashcash.</p>
<h3 id="h3-In20welk20jaar20was202020Bitcoin2020gemaakt846478"><a name="In welk jaar was   Bitcoin  gemaakt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In welk jaar was <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> gemaakt?</h3><p><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, een peer-to-peer digitale valuta, werd gecreëerd in 2009. Satoshi Nakamoto, de oprichter van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> gepubliceerd op <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> <a href="https://www.gate.io/blog_detail/1812/what-is-a-crypto-whitepaper-light-paper" target="_blank">whitepaper</a> in 2008 voordat het in 2009 werd gelanceerd. Het belangrijkste doel van het creëren van BTC was om er een gedecentraliseerd betaalmiddel van te maken voor goederen en diensten. Sommige beleggers gebruiken het echter als een waardeopslag en een beleggingsmiddel.</p>
<h3 id="h3-Wat20is20de20op20een20na20oudste20cryptocurrency558720"><a name="Wat is de op een na oudste cryptocurrency?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de op een na oudste cryptocurrency?</h3><p><a href="https://www.gate.io/trade/LTC_USDT" target="_blank">Litecoin</a>, Gemaakt door voormalig Google-ingenieur Charlie Lee en gelanceerd in 2011, is de op één na oudste cryptocurrency na <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. Het is in het leven geroepen om de problemen van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> zoals trage transactiesnelheid en hoge gaskosten. Daarom <a href="https://www.gate.io/trade/LTC_USDT" target="_blank">Litecoin</a>, een fork van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, is ontworpen om snel, kostenefficiënt en veilig te zijn.</p>
<h3 id="h3-Wat20was20het20eerste20dat20met20crypto20gekocht20werd29631"><a name="Wat was het eerste dat met crypto gekocht werd?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat was het eerste dat met crypto gekocht werd?</h3><p>De eerste geregistreerde dingen die met cryptocurrency werden gekocht, waren twee grote Papa John’s pizza’s. Feitelijk kocht Laszlo Hanyecz, een programmeur uit Florida, op 22 mei 2010 de pizza met <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a>, tegen een kostprijs van 10.000 BTC, ter waarde van $30 destijds. Dit is de reden waarom cryptofans feestvieren <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Pizzadag op 22 mei, elk jaar.</p>
<h3 id="h3-Wat20is20de20oudste20cryptocurrency20exchange398295"><a name="Wat is de oudste cryptocurrency exchange?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de oudste cryptocurrency exchange?</h3><p>Bitstamp, opgericht in Slovenië in 2011, is de oudste cryptocurrency exchange die nog steeds bestaat. Echter, de eerste crypto exchange die werd gelanceerd was <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a> Markt, opgericht op 17 maart 2010. Andere vroege beurzen zijn onder meer Mt. Gox, opgericht in 2010, en BitInstant gelanceerd rond dezelfde periode.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Mashell C. </strong>, Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen in g van schending van het auteursrecht.<br></div><p></p><br></div></div></div>