QmluYW5jZSBvbmRlcmJyZWVrdCBzcG90IHRyYWRpbmcgZ2VkdXJlbmRlIHR3ZWUgdXVyIHZhbndlZ2UgZWVuIGJ1Zw==

2023-04-10, 01:39

<p><img src="https://gimg2.gateimg.com/image/article/1681090024RDZZ.jpeg" alt=""></p>
<h2 id="h2-TL20DR198925"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Binance crypto-platform heeft op 24 maart zijn spot-handelsservices gepauzeerd nadat het een bug had ontdekt die invloed had op de trailing stop loss.<br>De prijzen van BTC en ETH daalden met kleine percentages na de glitch op de Binance crypto-uitwisseling.</p>
<p>De meeste Binance-gebruikers waren blij met de manier waarop de beurs het probleem heeft opgelost.</p>
<p>Mensen kunnen verkopen en <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">koop Bitcoin</a> op de Gate.io beurs.</p>
<h2 id="h2-Introductie503946"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Cryptocurrency exchanges en DeFi-platforms worden vaak geconfronteerd met bugs of glitches die hun soepele werking verstoren. Soms kan zo’n verstoring leiden tot verliezen voor handelaren en andere korte termijn investeerders. Een glitch die paniek op de markt veroorzaakt, kan bijvoorbeeld leiden tot prijsdalingen van bepaalde cryptocurrencies, vooral de native token van het platform. Dit artikel bespreekt het effect van een bug op Binance die resulteerde in een <a href="https://www.gate.io/help/trade/trade/17244/about-spot-trading" target="_blank">pauze van spot-handel</a> voor twee uur.</p>
<h2 id="h2-Binance20pauzeert20spot20handel20wat20is20er20gebeurd771519"><a name="Binance pauzeert spot handel, wat is er gebeurd?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Binance pauzeert spot handel, wat is er gebeurd?</h2><p>Op 24 maart dwong een bug Binance crypto exchange om zijn spot trading service twee uur lang te pauzeren, wat paniek creëerde onder zijn gebruikers. Als zodanig zou niemand storten, handelen of zich terugtrekken uit de spot trading sectie.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1681090489BN spot.png" alt=""></p>
<p>De CEO van de crypto-uitwisseling, Changpeng Zhao (CZ), benadrukte echter voortdurend aan zijn gebruikers dat alles onder controle was en dat alle activa veilig waren. Hij informeerde de gebruikers zelfs dat de bug invloed had gehad op de trailing stop.</p>
<p>CZ heeft de gebruikers bijgewerkt op Twitter. Hij zei: ‘Uit initieel onderzoek blijkt dat de matchende engine een bug tegenkwam bij een trailing stop order. Stortingen &amp; opnames zijn gepauzeerd als een SOP (standaard bedrijfsprocedure).’ Hij verzekerde hen ook dat de handel binnen twee uur zou worden hervat.</p>
<p>Wat de hervatting van de handel vertraagde, was de lange tijd die nodig was om de aard van de storing op de beurs te identificeren. Volgens CZ werd de bug zelfs pas na 57 minuten geïdentificeerd. Hij verzekerde de gebruikers ook dat deze gebeurtenis waarschijnlijk geen invloed zou hebben op de prijs van cryptocurrencies.</p>
<p>Lees ook: <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>Hij zei: “Als de grootste beurs de handel stillegt, zullen de prijzen niet veel bewegen. Als het op kleinere beurzen beweegt en Binance terugkomt, zal ons diepere orderboek de prijs weer terugbrengen, waardoor die jongens geld verliezen. Handelaren weten dit.”</p>
<p>Volgens de verzekering van CZ werd de spot trading hervat na ongeveer twee uur nadat de beurs de bug aankondigde en de spot trading pauzeerde. Hoewel spot trading doorging om 2.00 UTC, pauzeerde de beurs trailing stop enkele uren.</p>
<h2 id="h2-Begrip20van20de20trailing20stoploss542159"><a name="Begrip van de trailing stop-loss" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Begrip van de trailing stop-loss</h2><p>Zoals hierboven vermeld, is een trailing stop loss een belangrijk aspect van risicobeheer bij spot trading. Een trailing stop loss is een type stop loss-order dat een vast aantal pips onder of boven een marktorder handhaaft, afhankelijk of het een short trade of long trade is. Bijvoorbeeld, bij een long trade verplaatst de stop loss zich omhoog wanneer de prijs stijgt.</p>
<p>Echter, wanneer de prijs tegen de marktbeweging ingaat, zal de trailing stop-loss vast blijven. Handelaren kunnen pips of percentages gebruiken bij het instellen van de stop loss, afhankelijk van wat het handelsplatform toelaat.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/247/difference-between-perpetual-futures-and-spot-trading" target="_blank">Verschil tussen eeuwigdurende futures en spot trading</a></p>
<h2 id="h2-Het20effect20van20het20pauzeren20van20spot20trading392646"><a name="Het effect van het pauzeren van spot trading" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het effect van het pauzeren van spot trading</h2><p>Veranderingen in de werking van een handelsplatform kunnen ernstige gevolgen hebben voor de prijzen van cryptocurrencies. Het belangrijkste effect was een plotselinge daling van de prijs van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> van $28.073 naar ongeveer $27.456. Maar tegen de tijd dat de handel werd hersteld, was de waarde van BTC terug op $28.068.</p>
<p>Net als BTC daalde de waarde van ETH met 3%, van $1.789,05 naar $1.730. Desalniettemin was de waarde tegen 2.00 UTC, toen de handel werd hervat, gestegen tot $1.765,50.</p>
<h2 id="h2-Marktreactie520467"><a name="Marktreactie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktreactie</h2><p>De algemene opmerkingen op Twitter tonen aan dat gebruikers tevreden waren over hoe Binance de zaak heeft afgehandeld. Bijvoorbeeld, een persoon met de Twitter-gebruikersnaam @ CryptoViv schreef: “@cz_binance komt letterlijk binnen enkele seconden met een verduidelijking! Ongelijke klantenservice eerlijk gezegd. Dit zou veel mensen moeten kalmeren. Trouwens, geen enkele bank zou dit doen!” Deze gebruiker voegde ook toe dat Binance de kwestie beter heeft afgehandeld dan banken.</p>
<h2 id="h2-Spot20trading20op20Gateio138811"><a name="Spot trading op Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Spot trading op Gate.io</h2><p>Veel crypto-beurzen, waaronder Gate.io, een van de veiligste <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> uitwisselingen, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">bieden spot handelsdiensten</a>. In feite is het een van de gemakkelijkste manieren om cryptocurrencies te verhandelen, omdat er niet veel complicaties zijn. Laten we illustreren hoe u cryptocurrencies kunt verhandelen op Gate.io.</p>
<p>De eerste stap om crypto te verhandelen bij Gate.io is om je portemonnee te financieren. Je kunt belangrijke cryptocurrencies zoals USDT, ETH en BTC kopen met een creditcard of bankoverschrijving. Vervolgens kun je de cryptocurrencies die je hebt overzetten naar je spot trading account.</p>
<p>Vervolgens voert u het paar in dat u wilt verhandelen in het marktgedeelte zoals aangegeven in de onderstaande afbeelding.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1681090520BN spot 2.png" alt=""></p>
<p>Als voorbeeld hebben we een USDT/BTC-paar geselecteerd. Zodra u op het paar klikt, wordt er een nieuw venster geopend waar u de hoeveelheid van de cryptocurrency aangeeft die u wilt kopen, zoals weergegeven in het volgende diagram. In dit g geven we aan hoe u BTC kunt kopen met behulp van USDT.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1681090645BN spot 3.png" alt=""></p>
<p>Daarom voert u eenvoudig het bedrag aan BTC in dat u wilt kopen. Zodra u dat hebt gedaan, klikt u op “ <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">koop btc</a> De volgende en laatste stap is om de transactie te bevestigen.</p>
<h2 id="h2-Conclusie993899"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Binance Exchange had op 24 maart een bug die leidde tot de opschorting van de spot handelsservice voor twee uur. Na het oplossen van het probleem herstelde de beurs de handelsservice om 2.00 UTC. Echter, de trailing stop loss was de volgende uren niet beschikbaar. De prijzen van BTC en ETH daalden gedurende een korte periode na de handelsonderbreking.</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 opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>