UXVhbCDDqCBzdGF0YSBsYSBwcmltYSBjcmlwdG92YWx1dGE6IENyeXB0byBwcmltYSBkaSBCaXRjb2luPw==

<p><img src="https://gimg2.gateimg.com/blog/167583907498183482111.jpg" alt=""><br><strong>[TL; DR]</strong></p>
<p>DigiCash, HashCash, Bit Gold e Flooz.com sono esempi di valute digitali che esistevano prima delle criptovalute.</p>
<p>Non c’era alcun controllo governativo o intermediari con la maggior parte delle prime valute digitali.</p>
<p>Satoshi Nakamoto ha preso in prestito alcuni concetti da alcune delle prime valute digitali per sviluppare <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>.</p>
<p>La principale ragione per cui la maggior parte delle prime valute virtuali ha fallito è stata la mancanza di supporto dalle basi.</p>
<h2 id="h2-Introduzione851188"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Nel mondo delle criptovalute, molte persone credono che <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, introdotto nel 2009, è stato il primo asset digitale decentralizzato. Tuttavia, la verità è che <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> non è stato il primo progetto a sviluppare una valuta decentralizzata. Prima <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> c’erano diverse valute digitali che le persone usavano, ma per periodi brevi e su una scala più piccola rispetto a BTC. Oggi discutiamo alcune delle valute digitali centralizzate e decentralizzate che sono state inventate prima di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> come ad esempio <strong>Hashcash, B-Money, Bit Gold ed eCash.</strong></p>
<h2 id="h2-Denaro20virtuale20alla20stazione20di20servizio760833"><a name="Denaro virtuale alla stazione di servizio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Denaro virtuale alla stazione di servizio</h2><p>La moneta virtuale in una stazione di servizio è stato uno dei primi casi registrati di valute virtuali, sviluppato negli anni ‘80. Infatti, David Chaum, un crittografo americano ha ideato una valuta digitale nel 1983 che è stata brevemente utilizzata nelle stazioni di servizio nei Paesi Bassi.</p>
<p>Il principale motivo scatenante di questa mossa innovativa è stato affrontare i numerosi casi di furti che avvenivano nelle stazioni di servizio. I furti di contanti erano diffusi nelle stazioni di rifornimento che operavano durante la notte. Pertanto, per ridurre al minimo questi furti, un gruppo di sviluppatori ha collegato il denaro contante alle smart card. Di conseguenza, i camionisti hanno utilizzato le carte per pagare il carburante.</p>
<p>Col tempo, i clienti sono stati in grado di pagare beni utilizzando il punto vendita (PoS) collegato ai loro conti bancari. Il sistema di pagamento <a href="/price/ecash-xec" target="_blank" class="blog_inner_link">eCash</a> di Chaum è stato progettato per garantire la privacy nel sistema bancario. Curiosamente, Chaum ha pubblicato due documenti, simili ai whitepaper odierni, che dettagliavano il funzionamento del sistema di pagamento eCash.<br><img src="https://gimg2.gateimg.com/image/article/1675839251111.png" alt=""><br>David Chaum - Embnation</p>
<p>Chaum pubblicò il primo “documento” sul sistema di pagamento eCash nel 1981, intitolato “Posta elettronica non rintracciabile, Indirizzi di ritorno e Pseudonimi digitali. Un anno dopo, nel 1982, Chaum pubblicò un altro documento con il titolo “Firme cieche per pagamenti non rintracciabili.” È questo documento che ha gettato le basi per il sistema di transazioni anonime che usiamo oggi, coinvolgendo <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">criptovalute come](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> e ETH. e ETH. “)</p>
<p>Nel 1989, Chaum e il suo team di sviluppatori crearono un protocollo eCash. Tuttavia, Chaum e il team non riuscirono a stringere partnership con banche e commercianti per spingere maggiormente l’adozione del sistema di pagamento eCash. Pertanto, nel 1989 dichiarò bancarotta.</p>
<h2 id="h2-Digicash831290"><a name="Digicash" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Digicash</h2><p>Abbiamo accennato un po’ a Digicash sopra, ma parliamo di più su di esso. Chaum aveva l’obiettivo di rendere Digicash una moneta digitale anonima e molti imprenditori ne erano affascinati dalla privacy delle transazioni che avrebbe offerto ai suoi utenti. Anche Microsoft voleva integrare DigiCash nel suo Windows 95.</p>
<p>La principale differenza tra DigiCash e la maggior parte delle valute digitali come <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> è vero che DigiCash era una valuta virtuale privata mentre le criptovalute sono beni open source.</p>
<p>Ciò che i developer di criptovalute hanno principalmente guadagnato da DigiCash è l’uso delle firme cieche, che utilizzano una combinazione di chiavi private e pubbliche per nascondere il contenuto dei messaggi. I concetti di chiavi private e pubbliche sono aspetti critici della tecnologia delle criptovalute.</p>
<h2 id="h2-Bit20Oro984449"><a name="Bit Oro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bit Oro</h2><p>Nick Szabo, un membro prominente delle comunità extropian e cypherpunk, è stato fondamentale nello sviluppo delle criptovalute e del sistema blockchain. Con esperienza in informatica e crittografia legale, Szabo ha proposto l’uso di contratti intelligenti che dipendevano da codici specializzati anziché dal diritto giurisdizionale.</p>
<p>In seguito, Szabo propose l’uso di una valuta digitale nativa che fluirebbe nel contratto digitale e sarebbe trasferita elettronicamente da una persona all’altra. Si concentrò nel migliorare il concetto di Digicash per creare una valuta virtuale che fosse scarsa, costosa da produrre e non dipendesse da intermediari come le banche.</p>
<p>Di conseguenza, Szabo sviluppò Bit Gold che utilizzava il protocollo di proof-of-work, simile a quello di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. La produzione, la proprietà e la distribuzione di Bit Gold verrebbero registrate in un registro di titoli di proprietà distribuito, governato da un sistema di voto basato su un quorum.</p>
<p>Tuttavia, Bit Gold ha alcuni svantaggi. Non era fungibile, il che rendeva difficile usarlo quotidianamente. L’altra proposta di miglioramento di Szabo di avere una banca sicura, affidabile e verificabile era soggetta ad attacchi Sybil che potrebbero portare alla divisione della rete.</p>
<p>Anche se Szabo voleva continuare con lo sviluppo di una valuta Bit Gold funzionale, ha interrotto il progetto poco dopo il lancio di Satoshi Nakamoto <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. Questo perché credeva che <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> risolto il problema che ha impedito il lancio completo e l’adozione di Bit Gold.</p>
<p>Anche <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Il fondatore, Satoshi Nakamoto, ha riconosciuto il contributo <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">che il progetto Bit Gold ha contribuito allo sviluppo di successo](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 uno dei forum Bitcointalk, Nakamoto ha scritto: “ <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> è un’implementazione della proposta B-money di Wei Dai […] nel 1998 e della proposta Bitgold di Nick Szabo.</p>
<h2 id="h2-HashCash871082"><a name="HashCash" class="reference-link"></a><span class="header-link octicon octicon-link"></span>HashCash</h2><p>Un altro grande precursore di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> e altre criptovalute è HashCash, suggerito e sviluppato da Adam Beck, un rinomato criptografo. Ciò che ha innescato l’HashCash è stata una ricerca condotta dai ricercatori IBM Cynthia Dwork e Moni Naor nel 1992 che spiegava come prevenire attacchi Sybil, attacchi di negazione del servizio e messaggistica spam.</p>
<p>Hanno ideato una proposta per combattere questi problemi. In questo caso, il mittente di una email completava un puzzle come prova che non si trattava di un’email o messaggio non richiesto. Questa persona avrebbe poi allegato la copia della soluzione del puzzle all’email, che agiva come prova del lavoro, autenticando che il messaggio proveniva da lui/lei. Questo avrebbe potuto vietare l’invio di spam.</p>
<p>Di conseguenza, Adam Beck ha proposto un sistema simile per una valuta digitale. La valuta virtuale proposta da Beck, chiamata HashCash, si baserebbe sull’hashing invece che sulla risoluzione di puzzle complessi.<br><img src="https://gimg2.gateimg.com/image/article/1675839515222.png" alt=""><br>Adam Beck - Bitkub</p>
<p>L’hashing è il processo di utilizzare la potenza computazionale per trasformare dati specifici in stringhe casuali di caratteri. Pertanto, HashCash ha utilizzato la prova del lavoro per confermare le transazioni.</p>
<h2 id="h2-BMoney921591"><a name="B-Money" class="reference-link"></a><span class="header-link octicon octicon-link"></span>B-Money</h2><p>Wei Dai, un cypherpunk attivo, aveva pianificato di introdurre un tipo di sistema finanziario peer-to-peer, non regolato dal governo o da un’autorità centrale. Coinvolgerebbe l’uso di smart contract con un sistema per risolvere le controversie che potrebbero insorgere.</p>
<p>La valuta virtuale utilizzerebbe un sistema di registro condiviso che potrebbe connettere tutti i partecipanti. Inoltre, questo sistema utilizzerebbe l’algoritmo di consenso del proof-of-stake e avrebbe chiavi pubbliche, rappresentanti gli utenti. Va notato che c’era bisogno di un server per memorizzare i record delle transazioni per un uso futuro.</p>
<p>Anche se B-Money non è mai stato utilizzato, il suo sistema era simile a quello della maggior parte delle criptovalute, ovvero elettronico, sicuro, privato e anonimo. Ma soprattutto, <a href="https://www.gate.io/learn/articles/who-is-satoshi-nakamoto/286" target="_blank">Satoshi Nakamoto</a> ha fatto riferimento a B-Money nel <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> whitepaper. Il B-money era simile a contanti digitali basati su blockchain nel senso che non coinvolgerebbe intermediari.</p>
<h2 id="h2-Floozcom92445"><a name="Flooz.com" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Flooz.com</h2><p>Il Flooz eCash è un esempio di denaro digitale che esisteva prima delle criptovalute. Flooz ha introdotto l’eCash nel 1998 come parte della sua strategia promozionale e di marketing. In particolare, i clienti che acquistavano beni su Flooz.com ricevevano carte bonus per i clienti che potevano riscattare in qualsiasi momento.<br>Tuttavia, i clienti avrebbero anche acquistato il Flooz eCash dalla piattaforma per $1,00. Oltre ad utilizzare l’eCash per acquistare prodotti sulla piattaforma, i suoi detentori avrebbero anche acquistato beni da altri commercianti online affiliati a Flooz.com. Purtroppo, Flooz.com è stato chiuso a causa delle numerose attività criminali che avvenivano utilizzando quel sistema di pagamento.</p>
<h2 id="h2-Conclusione605645"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Fondamentalmente, diverse persone di spicco hanno cercato di sviluppare e utilizzare denaro elettronico molto prima del lancio di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. La storia delle criptovalute non può essere completa senza denaro virtuale come DigiCash, HashCash, Bit Gold, B-Money e Flooz.com. Successivamente, gli sviluppatori di criptovalute come Satoshi Nakamoto hanno preso spunti da queste precedenti valute digitali quando hanno sviluppato le proprie criptovalute.</p>
<h2 id="h2-FAQs20su20criptovalute20prima202020Bitcoin82269"><a name="FAQs su criptovalute prima   Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FAQs su criptovalute prima <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a></h2><h3 id="h3-Qual20era20la20prima20criptovaluta20prima20di202020Alessio20423771"><a name="Qual era la prima criptovaluta prima di   Alessio ?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual era la prima criptovaluta prima di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a>?</h3><p>La prima criptovaluta prima <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> eCash è stato creato dall’azienda DigiCash nel 1990. Il crittografo David Chaum ha creato Ecash. Altre valute virtuali che esistevano prima <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> sono state eCash, B-money, Bit Gold e Hashcash.</p>
<h3 id="h3-In20che20anno2020stato202020Bitcoin2020creato371794"><a name="In che anno è stato   Bitcoin  creato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In che anno è stato <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> creato?</h3><p><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, una valuta digitale peer-to-peer, è stata creata nel 2009. Infatti, Satoshi Nakamoto, il fondatore di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, pubblicato il <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> nel 2008 prima di lanciarlo nel 2009. Lo scopo principale di creare BTC era quello di renderlo un mezzo di pagamento decentralizzato per beni e servizi. Tuttavia, alcuni investitori lo utilizzano come riserva di valore e come asset di investimento.</p>
<h3 id="h3-Qual2020la20seconda20criptovaluta20pi20vecchia458725"><a name="Qual è la seconda criptovaluta più vecchia?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la seconda criptovaluta più vecchia?</h3><p><a href="https://www.gate.io/trade/LTC_USDT" target="_blank">Litecoin</a>, Creato dall’ex ingegnere di Google Charlie Lee e lanciato nel 2011, è la seconda criptovaluta più antica dopo <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. È stato creato per superare i problemi di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> come la lentezza delle transazioni e le alte commissioni di gas. Pertanto, <a href="https://www.gate.io/trade/LTC_USDT" target="_blank">Litecoin</a>, un fork di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, è stato progettato per essere veloce, a basso costo e sicuro.</p>
<h3 id="h3-Qual2020stata20la20prima20cosa20acquistata20con20la20criptovaluta316170"><a name="Qual è stata la prima cosa acquistata con la criptovaluta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è stata la prima cosa acquistata con la criptovaluta?</h3><p>Le prime cose registrate che la criptovaluta acquistò furono due grandi pizze Papa John’s. In realtà, Laszlo Hanyecz, un programmatore della Florida, comprò la pizza il 22 maggio 2010 usando <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, al costo di 10.000 BTC, equivalenti a $30 in quel momento. Questo è il motivo per cui i fan delle criptovalute festeggiano <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Giornata della pizza il 22 maggio, ogni anno.</p>
<h3 id="h3-Qual2020il20pi20antico20scambio20di20criptovalute622370"><a name="Qual è il più antico scambio di criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è il più antico scambio di criptovalute?</h3><p>Bitstamp, fondata in Slovenia nel 2011, è la più antica borsa di criptovalute ancora in esistenza. Tuttavia, la prima criptovaluta ad essere lanciata è <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Il mercato, fondato il 17 marzo 2010. Gli altri scambi precoci includono Mt. Gox, fondato nel 2010 e BitInstant lanciato nello stesso periodo.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il repostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>