UXVhbCDDqCBpbCBzaWduaWZpY2F0byBkZWxsJ2ludHJvZHV6aW9uZSBkaSBhdWRpdCBkaSB0ZXJ6ZSBwYXJ0aSBuZWxsbyBzY2FtYmlvPyBDYXBpcmUgY29zJ8OoIGxhIHByb3ZhIGRlbCBtYXJnaW5l

2022-11-02, 09:44

<p><img src="https://gimg2.gateimg.com/image/article/1667384337166738187230712451620221102-173459.jpeg" alt=""></p>
<p>Dall’inizio di quest’anno, il mercato è stato in continuo declino e le richieste di supervisione sono aumentate una dopo l’altra, portando più incertezza e turbolenza nel campo delle criptovalute. Nel trading di asset digitali, la gestione degli asset è sempre stata la cosa più importante per gli utenti. Se lo scambio può gestire veramente in modo equo, trasparente e sicuro gli asset degli utenti è il primo fattore che tutti gli utenti devono considerare prima di effettuare il trading di asset digitali.</p>
<p>Nella finanza tradizionale, la solvibilità è uno degli aspetti chiave per i clienti per valutare un’istituzione finanziaria. Pertanto, gli utenti spesso si affidano a qualche istituzione di audit terza e autorevole per riferimento. Questa situazione si applica anche al campo delle criptovalute, specialmente nel campo degli scambi centralizzati di asset digitali che le persone sono generalmente abituate.</p>
<p>Il motivo per cui gli scambi centralizzati sono stati riconosciuti e accolti dalle persone è che hanno diversi vantaggi rispetto al sistema non custodiale, come una minore latenza, una maggiore capacità e caratteristiche eccezionali come il mantenimento della fiducia e della privacy prima dell’esecuzione.</p>
<p>In generale, il meccanismo Proof of Reserve (PoR) può verificare la sua reale performance di solvibilità nel campo degli exchange centralizzati.</p>
<p>Pertanto, il PoR è uno dei principali indicatori di riferimento per far sì che le persone si fidino di un exchange di valuta digitale centralizzato.</p>
<p>Attualmente, gli asset di riserva di Gate.io sono stati certificati da Armanino e possono fornire un margine del 100% per gli utenti. Gli utenti possono <a href="https://proof-of-reserves.trustexplorer.io/clients/gate.io" target="_blank">visualizza i risultati sul sito ufficiale di Armanino.</a></p>
<h2 id="h2-Cos20la20Prova20di20Margine60510"><a name="Cos’è la Prova di Margine?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è la Prova di Margine?</h2><p>La Proof of Margin consente agli utenti di verificare se i loro asset digitali sono completamente conservati nell’exchange in modo criptato. Nel frattempo, gli utenti possono scegliere un exchange che sia più in linea con alcune delle attuali esigenze regolamentari internazionali in base al fatto che l’exchange abbia la Proof of Margin come una delle opzioni prioritarie.</p>
<p>La Proof of Margin sarà verificata da una società indipendente di terze parti. Lo scopo principale dell’audit è confermare se gli asset totali gestiti dall’exchange sono consistenti con il saldo contabile dell’utente. In generale, se l’importo totale di token detenuti e controllati in modo efficace dall’exchange sulla blockchain è maggiore o uguale all’importo totale di token detenuti da tutti gli utenti della piattaforma, la piattaforma fornirà una garanzia del 100% per i token.</p>
<p>Gate.io archivia il valore hash degli asset del conto di ogni utente mediante un Albero di Merkle all’interno del nodo foglia dell’Albero di Merkle, fornendo il certificato degli asset totali posseduti dall’utente della piattaforma e il margine valido dell’utente. Un’istituzione di revisione finanziaria di terze parti controlla l’importo totale degli asset dell’utente archiviati nel nodo foglia dell’Albero di Merkle e verifica e confronta il numero di margini validi detenuti dalla piattaforma per determinare se gli asset dell’utente sono supportati da margini completi.<img src="https://gimg2.gateimg.com/image/article/16673845532751667384384_.jpg" alt=""><br>Dettagli della Proof of Margin di Gate.io al 2 novembre 2022</p>
<p>TrustExplorer è una suite di tecnologie proprietarie di sicurezza blockchain di Armanino, progettata per aumentare la fiducia dei partecipanti nell’industria degli asset digitali. Proof of Reserves (PoR) è una delle soluzioni principali di TrustExplorer ed è una soluzione di reporting e verifica dei dati autorevole, che consente alla piattaforma di asset digitali di provare e rappresentare gli asset detenuti dai clienti.</p>
<p>Il modello di verifica dell’attivo è stato brevettato da Gate.io nel 2020. L’audit PoR condotto dall’Exchange in questa modalità è diventato uno dei passaggi standard per l’industria per verificare la sicurezza degli asset. La strategia di Gate.io fornisce anche all’industria un nuovo standard per la verifica della sicurezza degli asset.</p>
<h2 id="h2-Cosa20significa20la20prova20di20margine20per20gli20utenti469462"><a name="Cosa significa la prova di margine per gli utenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa significa la prova di margine per gli utenti?</h2><h3 id="h3-Sicuro20e20regolare700470"><a name="Sicuro e regolare" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sicuro e regolare</h3><p>Gli asset dell’utente sulla piattaforma Gate.io sono garantiti superare il 100% del margine e vengono regolarmente contabilizzati da una piattaforma di audit di terze parti.</p>
<h3 id="h3-Transazione20fluida2024x7736128"><a name="Transazione fluida 24x7" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Transazione fluida 24x7</h3><p>Le esigenze di capitale degli utenti possono essere soddisfatte rapidamente in qualsiasi momento, basandosi su una garanzia di liquidità 24x7 senza intoppi.</p>
<h3 id="h3-Trasparente20e20conveniente635682"><a name="Trasparente e conveniente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Trasparente e conveniente</h3><p>Gli utenti possono verificare se i loro asset sono inclusi nell’audit sulla pagina ufficiale di Armanino, o scaricarli e <a href="https://proof-of-reserves.trustexplorer.io/clients/gate.io" target="_blank">visualizzare il rapporto di revisione del margine</a>.</p>
<p>Di seguito è riportato il metodo per verificare se gli asset dell’utente sono inclusi nell’audit:</p>
<ol>
<li><p>Vai alla piattaforma di audit di terze parti Armanino e scorri verso il basso della pagina finché non vedi la figura qui sotto.</p>
</li><li><p>Nella casella sulla sinistra della pagina, compila le informazioni come richiesto per verificare se il tuo account è stato incluso nell’audit.</p>
</li></ol>
<h2 id="h2-La20sicurezza20prima20di20tutto20la20priorit20dellutente872378"><a name="La sicurezza prima di tutto, la priorità dell’utente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La sicurezza prima di tutto, la priorità dell’utente</h2><p>   Gate.io è sempre stato orientato verso una maggiore trasparenza e sicurezza, migliorando la sicurezza degli asset degli utenti e aumentando la fiducia del mercato. La collaborazione con una revisione di terze parti affidabile è solo una piccola parte del processo di sviluppo di una maggiore trasparenza e sicurezza, Gate.io continuerà a mantenere un ambiente di trading sicuro, equo e trasparente e contribuirà alla crescita sana e stabile del mercato degli asset digitali.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Team del Blog Gate.io</strong><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 per violazione del copyright.<br></div><p></p><br></div></div></div>