TWV0IGRlIHRvZW5lbWVuZGUgcG9wdWxhcml0ZWl0IHZhbiBTdWksIHphbCBoZXQgZGV6ZSByb25kZSBkZSBTb2xhbmEgS2lsbGVyIHdvcmRlbj8=

2024-08-20, 11:49

<p><img src="https://gimg2.gateimg.com/image/article/17241536361690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR546702"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Onlangs zijn de prijzen van Sui gestegen en populair geworden op sociale media, waardoor ze de bijnaam ‘ <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Challenger.</p>
<p>De recente ondersteuning van Grayscale Trust voor het ‘grijze effect’ dat Sui met zich meebrengt en de prestatieverbetering die wordt geboden door de Mysticeti-upgrade, zijn belangrijke drijfveren achter de recente stijging van de Sui-muntprijzen.</p>
<p>Gedreven door technologische innovatie en marktvraag zal het Sui-ecosysteem blijven strijden om de positie van <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> als koning van de prestaties.</p>
<h2 id="h2-Kennismaking600556"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Met de voortdurende stijging van de Sui-prijs heeft Sui veel aandacht en discussie op sociale-mediaplatforms aangetrokken. De populariteit is enorm gestegen en sommige waarnemers noemen het zelfs een ‘Solana-uitdager’, wat suggereert dat het concurrentiedruk kan uitoefenen op Solana en vergelijkbare projecten.</p>
<p>We hebben vorig jaar ook een artikel geschreven waarin de ontwikkeling van openbare ketenseries zoals Sui en MOVE werd besproken. <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a>. Dit artikel blijft de constructie van het Sui-ecosysteem verkennen en de groeipotentie ervan analyseren.</p>
<h2 id="h2-Muntprijs20stijgt20met2014020in20een20week20Sui20trekt20marktaandacht596531"><a name="Muntprijs stijgt met 140% in een week, Sui trekt marktaandacht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Muntprijs stijgt met 140% in een week, Sui trekt marktaandacht</h2><p>Sui-prijzen zijn aanzienlijk hersteld, van een dieptepunt van $0.46 op 5 augustus tot een piek van $1.11 op 12 augustus, met een verbijsterende wekelijkse stijging van meer dan 140%, leidend tot mainstream publieke ketentokens.</p>
<p>Op de schrijfdatum zijn de Sui-prijzen licht gedaald en stabiliseren ze zich rond $0,91.<br><img src="https://gimg2.gateimg.com/image/article/17241540081.jpg" alt=""><br>Bron: Gate.io</p>
<p>Sommige analisten wezen er echter op dat deze opwaartse trend mogelijk een manifestatie is van een oververkochte opleving vanuit technisch analyse-oogpunt. Gebaseerd op zijn recente leidende positie als een stijgende valuta in de Layer1-sector, heeft het nu de onderdrukking van de dalende trendlijn doorbroken en wordt het ondersteund wanneer het terugvalt naar de buurt van het 60-daags voortschrijdend gemiddelde, wat vaak aangeeft dat het de volgende golf van bullish sentiment zal triggeren.</p>
<p>Vanuit een breder perspectief heeft Sui de afgelopen zes maanden een aanzienlijke daling doorgemaakt sinds het op 27 maart van dit jaar $2,18 bereikte. Het laagste punt bereikte $0,46, een daling van meer dan 78%.</p>
<p>Deze prijsontwikkeling doet mensen gemakkelijk denken aan vergelijkbare schommelingen van Solana (SOL) in de vroege fase van de laatste bullmarkt, toen SOL een duik van 80% maakte voordat het zich herstelde en een verbazingwekkende stijging van 2500% kende.<img src="https://gimg2.gateimg.com/image/article/17241540682.jpg" alt=""><br>Bron: openbare informatie</p>
<p>Uiteraard staat Sui momenteel op de 15e plaats op de Layer1 openbare keten met een marktkapitalisatie van $2,2B, en vertegenwoordigt het slechts 1⁄30van SOL’s marktaandeel. Het is voorbarig om te oordelen of het SOL’s marktpositie zal doen schudden. Echter, de TVL heeft $600M bereikt, wat neerkomt op1⁄8van het marktaandeel van SOL. Uit deze gegevens kunnen we zien dat Sui relatief ondergewaardeerd is en dat de waarde van het ecosysteem verder moet worden vrijgegeven.<img src="https://gimg2.gateimg.com/image/article/17241540923.jpg" alt=""><br>Bron: CoinGecko</p>
<h2 id="h2-Grayscaleondersteuning20en20Mysticetiupgrade20Driver20Sui20Price20Surge427560"><a name="Grayscale-ondersteuning en Mysticeti-upgrade Driver Sui Price Surge" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Grayscale-ondersteuning en Mysticeti-upgrade Driver Sui Price Surge</h2><p>Andrew Kang, medeoprichter van Mechanism Capital, wees op belangrijke redenen voor de recente waardering van Sui, zoals de steun van voormalig uitvoerend Goldman Sachs en macro-economisch expert Raoul Pal, de stijging van de vraag naar over-the-counter handel, het aanhoudende vertrouwen van houders na grootschalige ontgrendeling, en de gestage stijging van Sui-prijzen zonder enige tekenen van correctie. <img src="https://gimg2.gateimg.com/image/article/17241541164.jpg" alt=""><br>Bron: @Rewkang</p>
<p>Naar mijn mening lijken deze gebeurtenissen meer toe te schrijven aan de externe prestaties van de markt die worden veroorzaakt door de scherpe stijging van Sui, en de aanzienlijke opwaartse momentum is voornamelijk te wijten aan de verbetering van zijn fundamenten en financiering, namelijk het ‘grijze effect’ veroorzaakt door de recente ondersteuning van Grayscale Trust voor Sui en de prestatieverbetering die is veroorzaakt door de upgrade van Mysticeti.</p>
<p>Op 7 augustus kondigde Grayscale de introductie aan van twee <a href="/price/view/new-cryptocurrencies" rel="nofollow noopener noreferrer" target="_blank">nieuwe cryptografie</a> beleggingsproducten, gericht op trustfondsen voor Sui en TAO tokens.</p>
<p>Rayhaneh Sharif Askary, Director of Product and Research bij Grayscale, is verheugd om aan te kondigen in de officiële verklaring: “We zijn vereerd om Bittensor en Sui op te nemen in ons productaanbod. We zijn er stellig van overtuigd dat Bittensor een belangrijke kracht is die de ontwikkeling van gedecentraliseerde AI stimuleert, terwijl Sui een nieuwe ronde van transformatie leidt in het veld van smart contract blockchain.”</p>
<p>Dit positieve signaal fermenteerde snel op de markt, waardoor de prijs van Sui de volgende dag met 42% steeg en de grootste eendaagse stijging in de recente tijd bereikte.</p>
<p>Daarnaast kondigde CoinList afgelopen dinsdag de lancering van het Staking Fund aan, dat passieve rendementen op digitale activa biedt aan geaccrediteerde investeerders in de Verenigde Staten. Het ondersteunt vijf soorten activa: ETH, SOL, NEAR, Sui en MINA, waarbij Sui een geannualiseerd rendement van 3,35% oplevert.</p>
<p>Naast de ondersteuning van de secundaire handelsmarkt is Sui onlangs begonnen met het gefaseerd lanceren van een nieuwe consensus engine Mysticeti, die de netwerkprestaties aanzienlijk zal verbeteren en Sui mogelijk een van de snelst beschikbare blockchaintnetwerken zal maken.<img src="https://gimg2.gateimg.com/image/article/17241542235.jpg" alt=""><br>Bron: Sui.io/mysticeti</p>
<p>Mysticeti is een nieuw consensusalgoritme gebaseerd op DAG (Directed Acyclic Graph), gericht op het oplossen van de trade-off tussen latentie en doorvoer in traditionele consensusalgoritmen. In vergelijking met het oude algoritme Narwhal Bullshark is de prestatie met ongeveer 80% verbeterd.</p>
<p>Deze verbetering verkort niet alleen de tijd voor transactiebevestiging, maar optimaliseert ook de netwerkdoorvoer, waardoor het efficiënte verwerkingsmogelijkheden behoudt in g van node- en netwerkstoringen. Het maakt real-time interactie van games en virtuele realiteitservaringen op de blockchain mogelijk, waardoor ontwikkelaars meer kansen krijgen voor innovatie.</p>
<h2 id="h2-Hoe20ver20moet20Sui20nog20gaan20om20de20Solana20Killer20te20worden747059"><a name="Hoe ver moet Sui nog gaan om de Solana Killer te worden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe ver moet Sui nog gaan om de Solana Killer te worden?</h2><p>Naar mijn mening heeft Sui, als een high-performance Layer1 publieke keten, enkele kenmerken laten zien die superieur zijn aan vergelijkbare projecten. Ondanks dat het ver achterloopt op giganten zoals ETH en SOL, zijn de huidige positieve signalen van Sui bemoedigend.</p>
<p>Dankzij de aanzienlijke verbetering in transactiesnelheid die is bereikt door de upgrade van Mysticeti, is het doel van Sui ingesteld op 100.000 TPS, waardoor het op één na hoogste is na Solana in TPS. Vooral in mei van dit jaar, door gebruik te maken van de SPAM (spam) borstelmodus, overtrof Sui eens Solana om de openbare keten te worden met het hoogste aantal transacties.<img src="https://gimg2.gateimg.com/image/article/17241542856.jpg" alt=""><br>Bron: Artemis Terminal</p>
<p>In de toekomst zal Sui doorgaan met het optimaliseren van de onderliggende architectuur, vooral met de introductie van zero knowledge proofs en sharding technologie, wat het privacy- en schaalbaarheid van het netwerk aanzienlijk zal verbeteren.</p>
<p>Bovendien is Sui toegewijd aan het verkennen van interoperabiliteit tussen blockchains om een meer open en verbonden blockchain-ecosysteem op te bouwen.</p>
<p>Het Sui-ecosysteem zal blijven evolueren onder de dubbele stimulans van technologische innovatie en marktvraag. Sui zal de veiligheid, privacy en schaalbaarheid van zijn netwerk verder verbeteren terwijl het de interoperabiliteit tussen ketens onderzoekt. Dit zal ongekende openheid en interconnectiviteit brengen naar het Sui-ecosysteem en de diepe integratie van de blockchain-wereld bevorderen.</p>
<p>Over het algemeen heeft Sui bepaalde prestatievoordelen aangetoond in vergelijking met sommige andere Layer1, maar er is nog steeds aanzienlijke ruimte voor optimalisatie en verbetering, vooral in de opbouw van zijn ecosysteem en zijn unieke stijl, die verdere verbetering behoeft. Kortom, de ‘Solana Killer’ lijkt overdreven. We zullen blijven monitoren of het aan dergelijke hoge marktverwachtingen kan voldoen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel geeft alleen de visie van de onderzoeker weer en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>