U29sYW5hIFBhbmllaywgVm9sYXRpbGl0ZWl0IGVuIEVub3JtZSBQdXQgT3JkZXJz

2023-04-07, 01:27

<p><img src="https://gimg2.gateimg.com/image/article/1680830273SDFX.jpeg" alt=""></p>
<h2 id="h2-TL20DR866826"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De ineenstorting van FTX resulteerde in angst voor liquidatie van SOL, aangezien Alameda er veel in had geïnvesteerd.</p>
<p>Na de implosie van FTX daalde de waarde van SOL binnen een week met meer dan 25%.</p>
<p>Op dit moment schommelt SOL met een prijs van meer dan $21, een stijging van meer dan 100% ten opzichte van zijn waarde in november 2022.</p>
<p>SOL blijft een van de best gerangschikte cryptocurrencies die investeerders kunnen kopen van Gate.io.</p>
<h2 id="h2-Introductie640064"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, <a href="https://www.gate.io/blog_detail/357/essentials-for-crypto-newbie-what-is-layer-0-layer-1-and-layer-2" target="_blank">de blockchain van laag 1</a>, is een crypto-ecosysteem dat zwaar getroffen is door de ineenstorting van FTX. Dit komt doordat FTX gedurende lange tijd veel <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> crypto’s in bezit had. Alameda, het zusterbedrijf van FTX, had veel SOL-tokens in bezit. In deze post bespreken we <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana crypto</a> blootstelling aan FTX en Alameda. We kijken ook naar hoe de ineenstorting van FTX de prijs van <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> (SOL).</p>
<h2 id="h2-Blootstelling20van202020Solana20crypto2020naar20FTX20en20Alameda20Research829726"><a name="Blootstelling van   Solana crypto  naar FTX en Alameda Research" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Blootstelling van <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana crypto</a> naar FTX en Alameda Research</h2><p>De <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> blockchain, geprezen als de grootste rivaal van de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain, stond voor een zware test in november 2022, <a href="https://www.gate.io/blog_detail/2390" target="_blank">na de ineenstorting van FTX</a> crypto-beurs. Zowel de totale waarde opgesloten als de prijs daalden een week nadat FTX faillissement aanvroeg.</p>
<p>Bijvoorbeeld, tegen de tweede week van november 2022, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De totale waarde die vergrendeld was, was met 70% gedaald tot $303 miljoen. In dezelfde periode daalde de waarde van SOL met een kwart, een indicatie van nog zwaardere tijden. Laten we nu kort de relatie bespreken die bestond tussen <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en FTX vóór de implosie ervan.</p>
<p>Lees ook; <a href="https://www.gate.io/blog_detail/1806/FTX-s-collapse--Affected-a-Wide-Cross-section-of-the-Crypto-Eco-" target="_blank">De ineenstorting van FTX had invloed op een breed scala aan cryptovaluta</a></p>
<p>In feite investeren FTX en Alameda Research in <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> sinds december 2020. Bijvoorbeeld, FTX heeft 4 miljoen SOL gekocht van de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> In augustus 2020 is een verdere 12 miljoen toegevoegd in september en een extra 34,52 miljoen SOL in januari 2021.</p>
<p>De enorme overname van SOL door FTX en Alameda is bevestigd door de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Stichting en <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Labs. Ze zeiden dat de twee zusterbedrijven 58,08 miljoen SOL bezitten, ongeveer 11% van het totale aanbod. Helaas werd de FTX crypto exchange, die voorheen meer dan $10 miljard aan dagelijks handelsvolume verwerkte, insolvent in september 2022 en diende op 11 november 2022 een faillissementszaak in die werd onderzocht door het Amerikaanse ministerie van Justitie en andere federale en staatsinstanties.</p>
<h2 id="h2-Crypto20Paniek20als202020Solana2020Volatiliteit20werd20onvermijdelijk111790"><a name="Crypto Paniek als   Solana  Volatiliteit werd onvermijdelijk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Paniek als <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Volatiliteit werd onvermijdelijk</h2><p>De cryptomarkt raakte in paniek kort nadat FTX instortte in 2022, wat wijst op een mogelijke massale liquidatie van SOL. De ontwikkelingen rondom SOL in november toonden aan dat SOL te maken had met ernstige uitdagingen, aangezien er een mogelijkheid was van een stijging van het aanbod en een daling van de cryptovraag.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680830509SOL 1.png" alt=""></p>
<p>Binnen een week die zich uitstrekte tot 10 november steeg de impliciete volatiliteit van SOL tot een geannualiseerde 270%, ongeveer twee keer dat van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> die op dat moment 135% was. Op dezelfde manier steeg de geïmpliceerde volatiliteit van SOL op 30 dagen tot 90%, een cijfer dat als zeer hoog wordt beschouwd en markt turbulentie toonde. Aan de andere kant daalde de call-put skew van SOL tot een dieptepunt van -99%, wat aangeeft dat de markt een scherpe prijsdaling verwachtte.</p>
<p>In dit verband zei Gregoire Magadini, de directeur van derivaten bij Amberdata, ‘Er heerst paniek op de SOL-markt. Handelaren zijn nerveus over de waarde van SOL en de mogelijkheid van massale liquidaties.’</p>
<p>Hij wees duidelijk op de reden waarom SOL op dat moment geliquideerd kon worden. Hij voegde eraan toe: “SOL is een onderpandactivum; het is waarschijnlijk dat het wordt geliquideerd omdat FTX/Alameda geld moet ophalen.”</p>
<p>Volgens CoinDek daalde de prijs van SOL in vier dagen met 50% tot een dieptepunt van $10. Echter, de verkoopdruk bleef nog vele dagen aanhouden. Bijvoorbeeld, de validators beloofden $800 miljoen aan bezittingen binnen een dag te verkopen.</p>
<p>Ook op 10 november eindigde epoch 370, waarbij investeerders de kans kregen om hun SOL tegen een hogere koers uit te stellen. Vervolgens, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Stakers van epoch 370 tot 372 hebben in totaal 39 miljoen SOL ingetrokken, een teken van toenemende risicomijdendheid.</p>
<p>De mogelijkheid van een kortetermijnemissie van SOL heeft ook een grotere verkoopdruk dan ooit gecreëerd. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Blockchain bedoeld om 2.558.000 SOL’s te ontgrendelen tegen een snelheid van 68.493 SOL/dag. Tijdens deze turbulente marktdagen nam ook de angst toe dat de zusteronderneming van FTX, Alameda Research, haar SOL-posities zou kunnen liquideren, wat zou leiden tot een verdere vrije val van de token.</p>
<p>Lees ook: <a href="https://www.gate.io/ru/blog_detail/570/solana-or-ethereum-which-is-the-better-smart-contract-platform?lang=en" target="_blank">Solana of Ethereum: Welk platform voor slimme contracten is beter?</a></p>
<p>Het is niet verrassend dat bovenstaande ontwikkelingen negatieve sentimenten creëerden op SOL en de hele crypto-markt. Desalniettemin heeft SOL de verkoopdruk geabsorbeerd die zich binnen de laatste 2 maanden van 2022 opstapelde.</p>
<h2 id="h2-Huidige20waarde20en20marktpositie20van20SOL690723"><a name="Huidige waarde en marktpositie van SOL" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Huidige waarde en marktpositie van SOL</h2><p>Op het moment van schrijven presteert SOL goed op de markt, gezien de huidige prijs ($21), ongeveer 100% hoger dan de waarde in november 2022. Met een huidige marktkapitalisatie van $8,17 miljard, een handelsvolume van $194,90 miljard en een circulerend aanbod van 385,67 miljoen, is SOL sinds het begin van 2023 met 91,71% gestegen. De onderstaande grafiek geeft een volledig beeld van de prijsprestaties van SOL in de afgelopen drie maanden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680830556SOL 2.png" alt=""></p>
<p>Zoals je ziet vanaf <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a> De waarde van SOL was begin januari 2023 ongeveer $11. Echter, het is binnen drie maanden gestegen tot meer dan $21, waarbij alle angsten voor liquidatie zijn verdreven.</p>
<h2 id="h2-Solana2020Voorspelling20voor20202420en202030713125"><a name="Solana  Voorspelling voor 2024 en 2030" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Voorspelling voor 2024 en 2030</h2><p>De verwachte prijs voor SOL voor 2024 en 2030 zou je een duidelijk beeld moeten geven van hoe de markt het ziet en het groeipotentieel ervan. Voorspellingen van verschillende crypto-analysebedrijven tonen mogelijke prijsbereiken voor SOL. Over het algemeen zijn de verschillen in hun voorspellingen klein. Zo voorspellen zowel Bitnation als Changelly dat de prijs van SOL tegen het einde van 2023 rond de $30 zal liggen.</p>
<p>Voor 2024 voorspellen ze dat de waarde tussen de $33 en $60 zal liggen. Bovendien verwachten de twee platforms dat de prijs van SOL in 2030 waarschijnlijk tussen de $332 en $376.24 zal liggen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680830581SOL 3.png" alt=""></p>
<p>Zoals u ziet, voorspelt Bitnation dat de prijs van SOL rond de $29 zal liggen in 2023, $60 in 2024 en $180 tegen 2030. Aan de andere kant toont de volgende tabel Changelly’s <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">prijsvoorspelling</a> voor SOL voor 2023, 2024, 2025 en 2030.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680830601SOL 4.png" alt=""></p>
<p>Zoals je kunt zien, voorspelt Changelly dat de prijs van SOL aan het einde van 2023 $29,84 zal zijn, aan het einde van 2024 $42,99 zal zijn en in 2030 $376,24 zal bedragen. Als we kijken naar de huidige prijs van SOL, dan is deze prijsrange haalbaar.</p>
<h2 id="h2-hoe20sol20te20kopen2020op20Gateio772550"><a name="hoe sol te kopen  op Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/how-to-buy/solana-sol" rel="nofollow noopener noreferrer" target="_blank">hoe sol te kopen</a> op Gate.io</h2><p>Om te kunnen <a href="https://www.gate.io/how-to-buy/solana-sol" target="_blank">SOL kopen bij Gate.io</a> je moet een geverifieerd account hebben. Het verificatieproces is heel eenvoudig, omdat het alleen inhoudt dat je je nationale identiteitsgegevens indient via het Gate.io-webplatform.</p>
<p>De volgende stap is om uw portemonnee bij Gate.io te financieren. U kunt een van de andere belangrijke cryptocurrencies zoals ETH, USDT of storten. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>. Als alternatief kunt u een van deze cryptocurrencies kopen met een creditcard of bankoverschrijving.<br>Zodra u uw portemonnee hebt gefinancierd, gaat u naar de sectie Spot Trading en selecteert u het juiste paar zoals <a href="https://www.gate.io/trade/SOL_USDT" target="_blank">USDT/SOL</a> zoals weergegeven in de onderstaande afbeelding.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680830679SOL 5.png" alt=""></p>
<p>Wanneer u het paar (USDT/SOL) selecteert, wordt er een nieuw venster geopend waarmee u USDT naar SOL kunt converteren, zoals hieronder wordt weergegeven.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680830693SOL 6.png" alt=""></p>
<p>Zodra u de hoeveelheid SOL invoert die u wilt kopen, klikt u op “ <a href="/how-to-buy/solana-sol" rel="nofollow noopener noreferrer" target="_blank">koop sol</a>” voor de verwerking van uw transactie.</p>
<h2 id="h2-Conclusie528903"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana crypto</a> geconfronteerd met veel crypto-volatiliteit in november 2022, na de ineenstorting van FTX. Er was angst op de markt dat als het zusterbedrijf van FTX, Alameda Research, al zijn SOL-holdings zou liquideren, de crypto opnieuw een vrije val zou ervaren. Echter, SOL bleef standvastig voor de rest van 2022 en doet het goed in 2023.</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 visie van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel te herdrukken op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens copyrightinbreuk.<br></div><p></p><br></div></div></div>