UXVhbCDDqCBsYSB0cmFzcGFyZW56YSBkZWxsZSBjcmlwdG92YWx1dGU=

2023-02-20, 09:09
<p><img src="https://gimg2.gateimg.com/image/article/16768836371.18.jpeg" alt=""></p>
<h2 id="h2-TL20DR126194"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>🔹 Dopo il crollo degli scambi di criptovalute e dei token, il tema della mancanza di trasparenza delle criptovalute ha suscitato nuovamente una profonda riflessione e una richiesta.</p>
<p>🔹 La trasparenza delle criptovalute rende impossibile per l’infrastruttura finanziaria tradizionale monitorare come viene utilizzato il valore conservato delle criptovalute.</p>
<p>🔹 La trasparenza è essenziale nelle transazioni di criptovaluta perché elimina lo spazio per sospetti o inganni.</p>
<h2 id="h2-Introduzione787609"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Man mano che sempre più investitori al dettaglio e istituzioni iniziano ad essere interessati alle emergenti <a href="https://www.gate.io/blog_detail/1785/The-Digital-Asset-Market-has-Plunged.-What-is-the-Status-Quo-of-Cryptocurrency-Exchanges-" target="_blank">investimento in asset digitali</a> al fine di coprirsi dall’inflazione e dall’attuale situazione economica instabile, il mercato ha visto la criptovaluta sostituire l’oro come un nuovo potenziale investimento. Combinato con una serie di fattori, la criptovaluta è diventata sempre più popolare.</p>
<p>Tuttavia, il più grande vantaggio delle criptovalute o, più precisamente, della tecnologia blockchain è che crea un sistema di trading completamente trasparente, ovvero fornisce trasparenza blockchain. Tuttavia, a causa del <a href="https://www.gate.io/blog_detail/1876/after-ftx-investors-are-choosing-an-exchange-with-a-long-track-record-of-best-practices-in-liquidity-and-risk-management" target="_blank">fallimento dello scambio di criptovalute FTX</a> nel 2022 e una serie di crolli crittografici, il settore ha chiesto di migliorare la trasparenza della blockchain.</p>
<h2 id="h2-Qual2020la20trasparenza20delle20criptovalute485839"><a name="Qual è la trasparenza delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la trasparenza delle criptovalute?</h2><p>La trasparenza delle criptovalute si riferisce alla rete dei nodi che registra e condivide i dettagli di ciascuna transazione. Consente a tutti di visualizzare la cronologia delle transazioni o il registro, fornendo agli utenti informazioni completamente trasparenti.</p>
<p>La trasparenza è essenziale nelle transazioni di criptovalute perché elimina lo spazio per sospetti o inganni. Diversa dalla modalità di funzionamento finanziario tradizionale, la natura di un <a href="https://www.gate.io/blog_detail/1434/Letter-from-the-CEO---Transparency-in-the-age-of-Blockchain" target="_blank">sistema altamente trasparente</a> significa che ogni transazione verrà immediatamente verificata e autorizzata da ogni membro della rete. Pertanto, può cambiare in modo più efficace la modalità operativa di aziende o istituzioni e migliorare la sicurezza e la visibilità delle transazioni di criptovalute. Ecco perché l’attuale infrastruttura finanziaria tradizionale non può monitorare come viene utilizzato il valore conservato delle criptovalute.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16768838209451676883757_.pic_hd.jpg" alt=""><br>Fonte: techug.com</p>
<h2 id="h2-La20trasparenza2020un20principio20fondamentale20della20tecnologia20blockchain769746"><a name="La trasparenza è un principio fondamentale della tecnologia blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La trasparenza è un principio fondamentale della tecnologia blockchain</h2><p>Il termine blockchain è solitamente usato in modo intercambiabile con DLT o “ <a href="https://www.gate.io/blog_detail/1334/Fed-Survey-says-over-56--of-bank-officials-consider-distributed-ledger-technology---crypto--not-a-priority" target="_blank">tecnologia dei registri distribuiti</a>”, che è il sistema sottostante che rende possibile la blockchain. La trasparenza è la logica sottostante e una delle più grandi caratteristiche della tecnologia blockchain. Tutti i nodi (come partecipanti) possono accedere alla storia condivisa delle transazioni o dei conti nella blockchain.</p>
<p>La trasparenza della tecnologia blockchain è favorevole alla vita quotidiana in molti aspetti. Il suo campo di applicazione non è limitato alla finanza o al trasferimento di denaro, ma include anche lo storage dei file, la proprietà immobiliare, le transazioni di beni e persino la verifica del processo di produzione dei farmaci, nonché i certificati di nascita e le cartelle cliniche, raramente conosciuti. La possibilità del suo utilizzo è effettivamente limitata allo spettro dell’intelligenza umana. Nessuno può modificare i dati a meno che i partecipanti raggiungano un accordo.</p>
<p>I vantaggi della tecnologia blockchain e della trasparenza sono la chiave della rapida crescita delle criptovalute e anche il motore del loro futuro sviluppo. Migliorare l’efficienza attraverso registrazioni trasparenti da una singola fonte, migliorare l’integrità dei dati, migliorare l’esperienza del cliente attraverso un’elaborazione più veloce, aiutare a ridurre le perdite e fornire la possibilità di una maggiore disponibilità di capitale e costi operativi inferiori.</p>
<h2 id="h2-Come20garantiscono20le20tecnologie20blockchain20la20trasparenza709027"><a name="Come garantiscono le tecnologie blockchain la trasparenza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come garantiscono le tecnologie blockchain la trasparenza</h2><p>Tuttavia, dopo che nel 2022 si sono verificati più di un evento tonante riguardo agli scambi di criptovalute e ai token, il tema della mancanza di trasparenza delle criptovalute ha nuovamente scatenato il pensiero profondo e l’appello delle persone. Come garantire la trasparenza della tecnologia blockchain è principalmente attraverso i seguenti punti.</p>
<h3 id="h3-Tracciabilit20completa431145"><a name="Tracciabilità completa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tracciabilità completa</h3><p>La trasparenza, una delle migliori caratteristiche della blockchain, significa anche che è completamente rintracciabile e più facile da mantenere. Il metodo è un database decentralizzato e registra l’input e l’output di ciascuna transazione sulla catena in modo che i cambiamenti nel numero di attività e attività di transazione possano essere facilmente tracciati.</p>
<h3 id="h3-Libro20delle20transazioni20completamente20verificabile20e20accurato886316"><a name="Libro delle transazioni completamente verificabile e accurato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Libro delle transazioni completamente verificabile e accurato</h3><p>La funzione significa che tutte le transazioni sul sito web non possono essere eliminate, il che significa che nessuno può tentare di manipolare, modificare o eliminare qualsiasi dato memorizzato dopo la verifica della rete. Se qualcuno cerca di cambiare una transazione sulla rete, tutti gli altri blocchi nel sistema devono essere cambiati.</p>
<p>La trasparenza della blockchain rende anche impossibile manipolare le transazioni. Sebbene siano avvenuti crolli delle criptovalute, le informazioni sulle transazioni illegali possono essere trovate sulla catena.</p>
<h3 id="h3-Massima20sicurezza20e20garanzia197851"><a name="Massima sicurezza e garanzia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Massima sicurezza e garanzia</h3><p>La sicurezza dei dati più avanzata è un’altra caratteristica notevole della tecnologia blockchain che gode di una reputazione globale. La blockchain utilizza blocchi estremamente sicuri per proteggere i dati. Ciascuna copia dei blocchi è memorizzata in ordine cronologico e collegata ai documenti di tutti i blocchi precedenti.</p>
<p>Anche se tutte le transazioni possono essere tracciate, memorizzate e visualizzate sulla rete, le informazioni fornite dalla blockchain sono anonime e la sua sicurezza è una delle principali ragioni per cui è così popolare.</p>
<h3 id="h3-Rete20decentralizzata290824"><a name="Rete decentralizzata" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rete decentralizzata</h3><p>La tecnologia blockchain è relativamente nuova e non regolamentata poiché è una creazione di rete peer-to-peer decentralizzata, il che significa che nessun individuo o gruppo può influenzare o manipolare la rete in alcun modo. Gli utenti ordinari o i “minatori” provenienti da tutto il mondo sono responsabili della verifica di ogni transazione.</p>
<p>Non esiste un istituto o server centrale, quindi la tecnologia blockchain è relativamente più sicura rispetto ad altre opzioni di archiviazione.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16768839129461676883777_.pic.jpg" alt=""><br>Origine: transitnet.io</p>
<h2 id="h2-Come20le20aziende20di20criptovaluta20forniscono20la20prova20delle20riserve723354"><a name="Come le aziende di criptovaluta forniscono la prova delle riserve" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come le aziende di criptovaluta forniscono la prova delle riserve</h2><p>Sebbene la blockchain, la tecnologia sottostante delle criptovalute, affermi di essere una delle tecnologie più aperte e trasparenti, le sue transazioni sono ancora concentrate in un exchange centralizzato e condotte sotto forma di un database interno. L’architettura del sistema di trading è più o meno simile a quella del tradizionale trading di titoli finanziari. Pertanto, è ancora più necessario che le aziende di criptovalute forniscono <a href="https://www.gate.io/blog_detail/1817/as-industry-calls-for-more-transparency-gate.io-highlights-its-3-year-proof-of-reserves-journey" target="_blank">Proof of Reserves</a> per garantire agli utenti la sicurezza dei loro fondi.</p>
<p>Proof of Reserves è un metodo per verificare se la piattaforma ha abbastanza asset per garantire che i suoi utenti possano depositare e prelevare denaro. Se gli utenti desiderano prelevare i loro asset, la piattaforma dovrebbe verificare che possano prelevarli.</p>
<p>Tuttavia, nella piattaforma di trading centralizzata, gli asset di ciascun utente sono registrati tramite il libro mastro nel database. Come dimostrare in modo sicuro che la piattaforma mantenga integri gli asset di tutti gli utenti è un problema che la piattaforma deve dimostrare di risolvere.</p>
<h2 id="h2-Scambio20di20criptovalute20Gateio460289"><a name="Scambio di criptovalute Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Scambio di criptovalute Gate.io</h2><p>Essendo una delle piattaforme di trading più antiche con la più lunga storia e il maggiore volume di trading al mondo, Gate.io opera stabilmente da nove anni. Sapendo quanto sia importante la sicurezza degli asset blockchain, Gate.io è sempre stato il protettore della sicurezza degli asset degli utenti.</p>
<p>Per consentire agli utenti di verificare che il 100% dei loro asset sia effettivamente conservato in Gate, Gate.io ha proposto lo schema di <a href="https://www.gate.io/blog_detail/1795/What-is-a-Merkle-Tree-" target="_blank">utilizzando l’albero di Merkle</a> + una terza parte di revisione e ha assunto Armanino LLP, una nota società di revisione americana indipendente specializzata nella revisione contabile delle valute virtuali, per aiutare nella revisione.</p>
<p>Armanino LLP è una delle principali società di revisione contabile negli Stati Uniti e un leader globale nelle soluzioni per asset digitali. Gate.io, in qualità di prima piattaforma di trading al mondo che promette di fornire il 100% di margine, ha già iniziato a collaborare strettamente con la società di revisione Armanino LLP nel 2020 per fornire agli utenti di Gate.io servizi professionali e affidabili di verifica degli asset sotto forma di open source, apertura, trasparenza, firma blockchain e albero di Merkle.</p>
<p>Per ulteriori dettagli sulle riserve, si prega di fare riferimento a: <a href="https://www.gate.io/blog_detail/1731" target="_blank">Qual è l’importanza di introdurre audit di terze parti nell’Exchange? Capire cos’è la prova di margine</a></p>
<h2 id="h2-Domande20frequenti122189"><a name="Domande frequenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti</h2><h3 id="h3-Come2020trasparente20la20criptovaluta169015"><a name="Come è trasparente la criptovaluta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come è trasparente la criptovaluta?</h3><p>Attraverso la logica tecnica sottostante alla blockchain, tutte le transazioni sulla catena possono essere visualizzate in modo anonimo e non possono essere eliminate o modificate. L’indirizzo del portafoglio dell’utente è trasparente mentre il proprietario del portafoglio non lo è.</p>
<h3 id="h3-Perch20la20trasparenza2020importante20nelle20criptovalute31564"><a name="Perché la trasparenza è importante nelle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché la trasparenza è importante nelle criptovalute?</h3><p>Significa che nessuno può tentare di manipolare, modificare o eliminare dati memorizzati dopo l’autenticazione di rete, garantendo la sicurezza dei beni personali degli utenti.</p>
<h3 id="h3-20una20transazione20di20criptovaluta20trasparente146364"><a name="È una transazione di criptovaluta trasparente?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>È una transazione di criptovaluta trasparente?</h3><p>Le transazioni di criptovaluta si basano sulla tecnologia blockchain e hanno anche trasparenza.</p>
<h3 id="h3-Cosa20significa20trasparenza20nel20blockchain389354"><a name="Cosa significa trasparenza nel blockchain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa significa trasparenza nel blockchain?</h3><p>Ciò significa che alcuni dettagli delle transazioni sulla catena possono essere visualizzati da tutti, inclusi ricevuta, pagamento e importo. Tuttavia, a causa della privacy, le informazioni personali del partecipante sono anonime.</p>
<h3 id="h3-Qual2020il20principio20dietro20alle20criptovalute967185"><a name="Qual è il principio dietro alle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è il principio dietro alle criptovalute?</h3><p>La criptovaluta si riferisce a una valuta digitale basata su principi crittografici, che utilizza la tecnologia blockchain e un meccanismo di consenso distribuito per garantire token emergenti decentralizzati. Rispetto al sistema bancario e finanziario che si basa su un sistema normativo centralizzato, la criptovaluta non può fare affidamento sulla valuta di riferimento e sugli intermediari di terze parti, ma determina la proprietà della valuta tramite crittografia e completa direttamente le transazioni peer-to-peer.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Rena W.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<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 ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<p></p><br></div></div></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards