QmluYW5jZSBTb3NwZW5kZSBpbCBUcmFkaW5nIFNwb3QgcGVyIER1ZSBPcmUgYSBDYXVzYSBkaSB1biBCdWc=

2023-04-10, 01:39

<p><img src="https://gimg2.gateimg.com/image/article/1681090024RDZZ.jpeg" alt=""></p>
<h2 id="h2-TL20DR973870"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La piattaforma crittografica di Binance ha interrotto i suoi servizi di trading spot il 24 marzo dopo aver rilevato un bug che ha colpito la sua stop loss trailing.<br>I prezzi di BTC e ETH sono diminuiti di piccoli percentuali a seguito del glitch sulla piattaforma di scambio crittografico di Binance.</p>
<p>La maggior parte degli utenti di Binance era felice del modo in cui lo scambio ha risolto il problema.</p>
<p>Le persone possono vendere e <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">acquistare Bitcoin</a> sull’exchange Gate.io.</p>
<h2 id="h2-Introduzione740641"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Gli scambi di criptovalute e le piattaforme DeFi spesso incontrano bug o problemi tecnici che ne compromettono il corretto funzionamento. A volte, tali interruzioni possono causare perdite ai trader e ad altri investitori a breve termine. Ad esempio, un errore che genera panico sul mercato può far diminuire i prezzi di alcune criptovalute, in particolare del token nativo della piattaforma. Questo articolo discute l’effetto di un bug su Binance che ha portato a <a href="https://www.gate.io/help/trade/trade/17244/about-spot-trading" target="_blank">pausa del trading spot</a> per due ore.</p>
<h2 id="h2-Binance20mette20in20pausa20il20trading20spot20cosa2020successo170628"><a name="Binance mette in pausa il trading spot, cosa è successo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Binance mette in pausa il trading spot, cosa è successo?</h2><p>Il 24 marzo, un bug ha costretto lo scambio di criptovalute Binance a interrompere il suo servizio di trading spot per due ore, creando il panico tra i suoi utenti. Di conseguenza, nessuno avrebbe depositato, scambiato o prelevato dalla sezione di trading spot.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1681090489BN spot.png" alt=""></p>
<p>Tuttavia, il CEO della piattaforma di scambio di criptovalute, Changpeng Zhao (CZ), ha costantemente ricordato agli utenti che tutto era sotto controllo e che tutti gli asset erano al sicuro. Ha persino informato gli utenti che il bug aveva influenzato lo stop di tracciamento.</p>
<p>CZ ha aggiornato gli utenti su Twitter. Ha detto: ‘L’analisi iniziale indica che il motore di corrispondenza ha riscontrato un bug su un ordine di stop trailing. I depositi e i prelievi sono in pausa come una SOP (procedura operativa standard)’. Ha anche rassicurato gli utenti che le negoziazioni riprenderanno entro due ore.</p>
<p>Ciò che ha ritardato la ripresa delle negoziazioni è stato il molto tempo impiegato prima di identificare la natura del difetto riscontrato dall’exchange. Infatti, secondo CZ, la piattaforma ha identificato il bug dopo 57 minuti. Ha inoltre assicurato agli utenti che l’accaduto è improbabile che influenzi il prezzo delle criptovalute.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/512/spot-trading-vs-leveraged-token-trading" target="_blank">Spot Trading VS Leveraged Token Trading</a></p>
<p>Ha detto: “Quando la più grande borsa sospende le negoziazioni, i prezzi non si muoveranno molto. Se si muove su borse più piccole, quando Binance torna, il nostro libro degli ordini più profondo riporterà il prezzo indietro, facendo perdere soldi a quei ragazzi. I trader lo sanno.”</p>
<p>Come assicurato da CZ, il trading spot è ripreso circa due ore dopo che l’exchange ha annunciato il bug e la pausa del trading spot. Sebbene il trading spot sia continuato alle 2.00 UTC, l’exchange ha interrotto lo stop trailing per alcune ore in più.</p>
<h2 id="h2-Comprensione20dello20stop20loss20trailing945145"><a name="Comprensione dello stop loss trailing" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprensione dello stop loss trailing</h2><p>Come accennato in precedenza, il trailing stop loss è un aspetto importante della gestione del rischio nel trading spot. Un trailing stop loss è un tipo di ordine di stop loss che mantiene un numero fisso di pips al di sotto o al di sopra di un ordine di mercato a seconda che si tratti di un trade corto o lungo. Ad esempio, con un trade lungo lo stop loss si sposta verso l’alto quando il prezzo sta salendo.</p>
<p>Tuttavia, quando il prezzo si muove contro il movimento di mercato, lo stop loss dinamico rimarrà fisso. I trader possono utilizzare pips o percentuali quando impostano lo stop loss, a seconda di ciò che permette la piattaforma di trading.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/247/difference-between-perpetual-futures-and-spot-trading" target="_blank">Differenza tra futures perpetui e trading spot</a></p>
<h2 id="h2-Leffetto20della20sospensione20del20trading20spot834466"><a name="L’effetto della sospensione del trading spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’effetto della sospensione del trading spot</h2><p>Le modifiche su come funziona una piattaforma di trading possono portare a seri effetti sui prezzi delle criptovalute. L’effetto principale è stato una diminuzione improvvisa del prezzo di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> da $28.073 a circa $27.456. Tuttavia, al momento della ripresa delle negoziazioni, il valore di BTC era tornato a $28.068.</p>
<p>Come BTC, il valore dell’ETH è sceso del 3%, da $1,789.05 a $1,730. Tuttavia, alle 2.00 UTC, quando è ripresa la negoziazione, il suo valore era salito a $1,765.50.</p>
<h2 id="h2-Reazione20di20mercato972123"><a name="Reazione di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reazione di mercato</h2><p>I commenti generali su Twitter mostrano che gli utenti erano contenti di come Binance ha gestito il caso. Ad esempio, un individuo con un nome utente Twitter @CryptoViv ha scritto: ‘@cz_binance fornisce una chiarificazione in letteralmente pochi secondi! Servizio clienti ineguagliabile onestamente. Questo dovrebbe tranquillizzare molte persone. A proposito, nessuna banca farebbe questo!’ Questo utente ha anche aggiunto che Binance ha gestito la questione meglio delle banche.</p>
<h2 id="h2-Trading20spot20su20Gateio865883"><a name="Trading spot su Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Trading spot su Gate.io</h2><p>Molti scambi di criptovalute, tra cui Gate.io, uno dei più sicuri <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> scambi, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">offre servizi di trading spot</a>. In realtà, è uno dei modi più semplici per il trading di criptovalute poiché non ci sono molte complicazioni. Illustreremo come puoi scambiare criptovalute su Gate.io.</p>
<p>Il primo passo per fare trading di criptovalute su Gate.io è finanziare il tuo portafoglio. Puoi acquistare le principali criptovalute come USDT, ETH e BTC utilizzando la carta di credito o il bonifico bancario. Successivamente, trasferisci le criptovalute che possiedi sul tuo account di trading spot.</p>
<p>Successivamente, inserisci la coppia che desideri scambiare nella sezione del mercato come indicato nell’immagine qui sotto.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1681090520BN spot 2.png" alt=""></p>
<p>Come esempio, abbiamo selezionato una coppia USDT/BTC. Una volta cliccato sulla coppia, si aprirà una nuova finestra in cui si indica la quantità di criptovaluta che si desidera acquistare, come mostrato nel diagramma successivo. In questo caso, indichiamo come è possibile acquistare BTC utilizzando USDT.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1681090645BN spot 3.png" alt=""></p>
<p>Quindi, inserisci semplicemente l’importo di BTC che desideri acquistare. Una volta fatto ciò, fai clic su “ <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">acquista btc</a>.” Il passaggio successivo e ultimo è confermare la transazione.</p>
<h2 id="h2-Conclusion168890"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Lo scambio Binance ha avuto un bug il 24 marzo che ha portato alla sospensione del servizio di trading spot per due ore. Dopo aver risolto il problema, lo scambio ha ripristinato il servizio di trading alle 2.00 UTC. Tuttavia, il trailing stop loss non era disponibile per le ore successive. I prezzi di BTC ed ETH sono diminuiti per un breve periodo dopo la sospensione del trading.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore 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 ripostare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>