RmFjdG9yZW4gZGllIGRlIFNPTC1wcmlqc3JhbGx5IGFhbnN0dXJlbg==

2023-11-29, 02:29

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR448184"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Het netwerk is een blockchain van keuze onder crypto-investeerders vanwege de schaalbaarheid, snelheid en lage transactiekosten.</p>
<p>Onlangs prees Cathie Wood, CEO van ARK Invest, <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> om zijn efficiëntie.</p>
<p>De Solana-rally die halverwege oktober begon, heeft geholpen om de waarde van Grayscale’s Solana Trust (GSOL) te verhogen.</p>
<h2 id="h2-Introductie409541"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De inheemse cryptocurrency van het Solana-blockchain, SOL, is sinds medio oktober aan het stijgen. Er zijn momenten waarop de vraag naar SOL erg hoog wordt, aangezien het blockchain-platform, dat op de zesde plaats staat qua marktkapitalisatie, het op een na grootste netwerk is dat wordt geassocieerd met gedecentraliseerde applicaties (dApps).</p>
<p>By the way, Solana is de grootste concurrent voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Vandaag bespreken we de factoren die de prijsstijging van SOL aansturen, evenals de toekomstperspectieven.</p>
<h2 id="h2-Solana20Crypto20raakte20in20november20kortstondig20de206020grens322250"><a name="Solana Crypto raakte in november kortstondig de $60 grens." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Solana Crypto raakte in november kortstondig de $60 grens.</h2><p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana crypto</a> heeft het goed gedaan sinds het begin van het jaar. Tot nu toe is de waarde met meer dan 550% gestegen. Het steeg het meest in oktober toen het met ongeveer 200% steeg. Hoewel de bullish momentum in november afnam, verwacht de markt dat het verder zal stijgen naarmate het einde van het jaar nadert.</p>
<p>Terwijl Solana dit jaar met meer dan 550% is gestegen, hebben de andere belangrijke cryptocurrencies zijn momentum niet geëvenaard. De prijs van Ether (ETH) steeg in dezelfde periode met ongeveer 70%. Op dezelfde manier, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> gestegen met ongeveer 127%.</p>
<p>Tijdens de recente prijsstijging steeg de waarde van SOL kortstondig boven de $60. De huidige bullish druk begon op 24 oktober toen de meeste cryptocurrencies opleefden. Daarentegen, rond deze tijd in 2022 de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana prijs</a> schommelde rond de $10 na de ineenstorting van FTX.</p>
<p>Feitelijk is de waarde van Solana met meer dan 500% gestegen sinds de Amerikaanse Securities and Exchange Commission het als een effect heeft aangewezen naast. <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a>, Matic, Algo en MANA File coin (FIL), onder andere. In feite begon de Solana run op 10 juli, de datum waarop de SEC het als een crypto security bestempelde.</p>
<h2 id="h2-Solana20doet20het20echt20goed2020ARK20Invest20CEO20Cuthie20Wood638309"><a name="“Solana doet het echt goed” - ARK Invest CEO, Cuthie Wood" class="reference-link"></a><span class="header-link octicon octicon-link"></span>“Solana doet het echt goed” - ARK Invest CEO, Cuthie Wood</h2><p>Onlangs was er een unieke factor die de prijs van Solana omhoog dreef, zij het voor een korte periode. Het was de opmerking van Cathie Wood, CEO van ARK Invest, over de efficiëntie van de blockchain en lage transactiekosten.</p>
<p>In feite, op 15 november, <a href="https://www.youtube.com/watch?v=kj95_DAc-Ao" rel="nofollow noopener noreferrer" target="_blank">in een interview met CNBC</a>, Wood preesde het Solana blockchain om zijn unieke infrastructuur die resulteert in schaalbaarheid, transactiesnelheid, hoge beveiliging en efficiëntie, onder andere. Volgens Wood is het blockchain een belangrijke speler in de crypto sector.</p>
<p>Tijdens het interview zei ze: ‘Solana doet het echt goed. Ether was sneller en goedkoper dan <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> [terug] in die tijd - zo kregen we ether. Solana is zelfs nog sneller en [meer] kostenefficiënt dan ether.’</p>
<p>Ze voegde zelfs toe dat ze ‘echt van Solana houdt.’ Wood wees er echter ook op een van de grootste zwaktes van Solana, namelijk de constante downtime tijdens onderhoud en storingen.</p>
<p>Ze gelooft dat de downtime van Solana groter is dan die van het <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> blockchain. Volgens haar weerhoudt dat investeerders er echter niet van om het netwerk te gebruiken.</p>
<p>Ze voegde eraan toe: “Mensen zijn bereid om dat te accepteren omdat de transactieformaten misschien niet zo groot zijn of om de een of andere reden niet zo belangrijk zijn, ze willen gewoon snelheid en kosten als hun topprioriteit. Elk van [de netwerken] zal een plaats hebben.”</p>
<h2 id="h2-Factoren20die20bijdragen20aan20de20opwaartse20prijsbeweging20van20SOL424851"><a name="Factoren die bijdragen aan de opwaartse prijsbeweging van SOL" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Factoren die bijdragen aan de opwaartse prijsbeweging van SOL</h2><p>Er zijn andere belangrijke factoren die hebben bijgedragen aan de opwaartse prijsbeweging van Solana. Dit komt doordat investeerders niet alleen <a href="/how-to-buy/solana-sol" rel="nofollow noopener noreferrer" target="_blank">koop Solana</a> zonder sterke redenen.</p>
<p>Bijvoorbeeld heeft Solana een toename van nieuwe gebruikers gezien, iets dat vertrouwen heeft gecreëerd in de cryptocurrency. Dat heeft ook traditionele financiële instellingen zoals Grayscale aangetrokken om te investeren in SOL.</p>
<p>Natuurlijk is er een toename geweest in het aantal gedecentraliseerde applicaties die op de blockchain werken, wat heeft geleid tot een stijging van de vraag naar SOL en uiteindelijk de prijs ervan. De volgende diagram toont de recente piek in de Solana prijs.<br><img src="https://gimg2.gateimg.com/image/article/170122489115561701224598_.pic.jpg" alt=""><br>Solana’s Year-to-Date Prijs - TradingView</p>
<p>Zoals u kunt zien aan het diagram, steeg de prijs van Solana aanzienlijk vanaf medio oktober. Die bullish momentum trok veel investeerders aan om grote hoeveelheden SOL te kopen, wat resulteerde in een nog rooskleurigere toekomst voor Solana dan ooit tevoren.</p>
<p>Decentrale beurzen die bestaan op het Solana blockchain beïnvloeden SOL’s bullish momentum. In totaal heeft het handelsvolume van deze beurzen binnen 12 dagen, rond half november, de $2 miljard overschreden.</p>
<p>Veel crypto-handelaren handelen graag in Solana vanwege de kosteneffectiviteit en transactiesnelheid. Als gevolg van de hoge vraag houden investeerders ook Solana vast, wat heeft geleid tot een hogere totale waarde die vergrendeld is (TVL). Momenteel overtreft de TVL van Solana $500 miljoen en zal naar verwachting toenemen naarmate meer investeerders SOL kopen en vasthouden.</p>
<p>Deze factoren hadden een positief effect op de waarde van de Grayscale’s Solana Trust (GSOL) waarvan de aandelen worden verhandeld met een premie die 800% overstijgt. Bijvoorbeeld, op 10 november bereikten de secundaire SOL-aandelen een waarde van $202 zoals de volgende afbeelding laat zien.<br><img src="https://gimg2.gateimg.com/image/article/170122491915571701224612_.pic.jpg" alt=""><br>Grayscale’s Solana Trust - Grayscale</p>
<p>De stijging van de waarde van Grayscale Solana Trust-aandelen heeft de interesse van investeerders in het actief vergroot. Ter context, Grayscale Solana Trust (GSOL) is een alternatief digitaal activa beursgenoteerd fonds (ETF).</p>
<h2 id="h2-Conclusie582434"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Solana heeft sinds medio oktober een sterke rally doorgemaakt door op een bepaald moment de $60 te overschrijden. Veel handelaren geven de voorkeur aan Solana boven het Ethereum-netwerk vanwege zijn kosteneffectieve karakter, snelle transactie-finaliteit en efficiëntie. De positieve prijsbeweging van SOL heeft geleid tot een stijging van de waarde van Grayscale Solana Trust.</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 mening van de onderzoeker en vormt geen enkele beleggingsadviezen.<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 zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>