T3Agd2Vsa2UgcHJvamVjdGVuIG1vZXQgaGV0IFNvbGFuYS1lY29zeXN0ZWVtIHppY2ggcmljaHRlbiBhbHMgU09MIG1lZXIgZGFuICQxNDUgYmVyZWlrdD8=

2024-03-08, 09:32

<p><img src="https://gimg2.gateimg.com/image/article/1709890159rdzz.jpeg" alt=""><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, als een langverwachte Layer1-token op de cryptomarkt, brak vanochtend vroeg door het belangrijke prijspunt van $145, wat veel aandacht in de markt trok. Deze doorbraak markeert niet alleen een nieuwe hoogte in SOL-prijzen sinds 2022, maar geeft ook aan dat het Solana-ecosysteem mogelijk een significante opwaartse trend zal ervaren.<br><img src="https://gimg2.gateimg.com/image/article/170989014311.png" alt=""><br>Volgens Bloomberg is Pantera Capital, een bekend crypto-investeringsbedrijf, bezig met het werven van fondsen om SOL-tokens ter waarde van maximaal $250 miljoen van de FTX-beurs te kopen. De verspreiding van dit nieuws kan een van de redenen zijn waarom SOL-prijzen belangrijke prijsniveaus hebben doorbroken.</p>
<p>Bovendien hebben sommige projecten in het Solana-ecosysteem ook een sterke opwaartse momentum getoond, zoals Jupiter (JUP), waardoor de prijs van SOL-tokens verder omhoog is gegaan. Tegelijkertijd hebben andere tokens in het Solana-ecosysteem, zoals RAY en MYRO, ook een significante opwaartse trend laten zien, wat de welvaart en vitaliteit van het Solana-ecosysteem aantoont.</p>
<p>De auteur heeft een lijst samengesteld van populaire projecten in het Solana-ecosysteem waar alle Gate.io-gebruikers naar kunnen verwijzen.</p>
<h2 id="h2-DEX481528"><a name="DEX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DEX</h2><h3 id="h3-Jupiter723231"><a name="Jupiter" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Jupiter</h3><p>Samengevat is Jupiter momenteel het grootste handelsaggregatieplatform op de Solana-keten, met als doel efficiënte, veilige en goedkope handelsdiensten voor digitale activa te bieden.</p>
<p>De kenmerken en voordelen van Jupiter zijn onder andere:<br>Hoge prestaties en lage latentie: Op basis van de <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> blockchain heeft Jupiter Exchange de kenmerken van hoge doorvoer en lage latentie, in staat om duizenden transacties per seconde te verwerken, waardoor gebruikers een soepele en efficiënte handelservaring krijgen.</p>
<p>Decentrale handel: Jupiter Exchange neemt een gedecentraliseerde architectuur aan, waardoor gebruikers transacties rechtstreeks op het platform kunnen uitvoeren via slimme contracten zonder dat ze vertrouwen hoeven te hebben in tussenpersonen van derden, waardoor veiligere en transparantere transacties worden bereikt.</p>
<p>Rijke handelsparen: Jupiter Exchange ondersteunt handelsparen voor alle digitale activa op het Solana-netwerk, met inbegrip van mainstream cryptocurrencies, stablecoins en Meme coins, en biedt gebruikers diverse handelsopties.</p>
<p>Onlangs kondigde Jupiter de lancering van Genesis-voting aan, waarbij JUP kan worden gestaked om beloningen voor Launchpad-kosten te ontvangen, wat resulteerde in een aanzienlijke stijging van JUP. JUP naar Solana kan worden vergeleken met UNI naar <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<h3 id="h3-Raydium340521"><a name="Raydium" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Raydium</h3><p>Raydium is een geautomatiseerde marktproducent (AMM) en gedecentraliseerde beurs (DEX) gebaseerd op Solana. Raydium-gebruikers kunnen uitwisselen in de liquiditeitspool, orderboeken gebruiken voor transacties, deelnemen aan liquiditeitswinning, of gecollateraliseerde RAY gebruiken om deel te nemen aan IDO via de Raydium AcceleRaytor-launchpad. In tegenstelling tot andere AMM DEX, gebruikt Raydium zijn liquiditeitspool om orders te plaatsen op het centrale prijslimietorderboek van Serum DEX in plaats van liquiditeit te isoleren van verschillende platforms.</p>
<h2 id="h2-Meme588952"><a name="Meme" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Meme</h2><h3 id="h3-BONK147367"><a name="BONK" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BONK</h3><p>Sinds de lancering eind december 2022 is BONK voortdurend gestegen te midden van vragen. Op het moment van schrijven van dit artikel, volgens Gate.io-gegevens, is de prijs in de afgelopen 24 uur bijna 10% gestegen en wordt nu genoteerd op 0,000032 USDT. Sinds de lancering is BONK meer dan 500 keer gestegen, met een maximumprijs van 0,000048 USDT en een minimumprijs van 0,000000086142 USDT.<br><img src="https://gimg2.gateimg.com/image/article/170989021612.png" alt=""><br>Volgens het officiële Twitter-account van Bonk begon de planning van het Bonk-project op 9 december 2022 en riep het op tot interactie met andere projecten in het Solana-ecosysteem. Op 25 december, toen Kerstmis naderde, lanceerde Bonk officieel een grootschalige luchtdropping gericht op het Solana-ecosysteem.</p>
<p>Volgens officiële rapporten heeft Bonk in totaal 100 biljoen BONK-tokens uitgegeven, waarvan 50% is airdropped naar de Solana-gemeenschap, inclusief ontwikkelaars van LamportDAO (het middelpunt van Solana-ontwikkelaars), houders van NFT-projecten zoals de Famous Fox Federation, en zelfs DeGods die eerder aankondigde te migreren naar andere chains.</p>
<p>Als we alleen naar Bonk kijken, zijn sommige gemeenschappen van mening dat, of het nu gaat om de mate of timing van Solana’s ecosysteeminteractie, het erg lijkt op een lang geplande “omheining en zelfopkomst” van Solana’s ecosysteem en ook een van de oplossingen kan zijn die door Solana’s ecosysteemontwikkelaars worden gebruikt om zichzelf nieuw leven in te blazen.</p>
<h3 id="h3-WIF651857"><a name="WIF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WIF</h3><p>WIF kan worden gezegd een “zelfgemaakt” project te zijn, en als het gaat om wat voor soort verhaal WIF is, kan men alleen denken aan de geweven wollen muts op het hoofd van de Shiba-hond. Eind december 2019 werden diverse logo’s en afbeeldingen die aan wollen mutsen waren toegevoegd populair op Twitter als persoonlijke profielafbeeldingen bij esportorganisaties en beroemdheden.</p>
<p>Het vond plaats tegen de achtergrond van geen andere verhalen dat WIF een tienduizendvoudige toename behaalde in minder dan vier maanden.<br><img src="https://gimg2.gateimg.com/image/article/170989024313.png" alt=""><br>Het WIF-muntuitgifteproces verloopt in stilte, en volgens marktgegevens opende WIF al op 20 november 2023 op $0,00016. Maar de eerste tweet die werd uitgebracht door het officiële Twitter-account was op 29 december. Volgens Gate.io-gegevens heeft de huidige WIF-prijs de $2 overschreden, met een stijging van bijna 20% in 24 uur. Sinds de lancering heeft WIF een toename van meer dan 10000 keer opgebouwd.</p>
<h3 id="h3-WEN369416"><a name="WEN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WEN</h3><p>Op 25 januari kondigde mede-oprichter Meow van Jupiter op het X-platform aan dat het de uitgifte van Meme-token WEN zal testen op basis van het nieuwste LFG Launchpad-platform dat door het project is gelanceerd. WEN, dat 70% van de totale voorraad uitmaakt, zal worden uitgedeeld aan miljoenen Solana wallet-adressen, en de airdrop-aanvraag zal doorgaan tot 29 januari.</p>
<p>Het meme-attribuut van WEN komt voort uit de wens en verwachting van de gemeenschap voor potentiële airdrops. Meow zei dat hij in de afgelopen maand bijna elke dag talloze Wen-tokens, Wen-airdrops en andere vragen heeft ontvangen. Hij schreef zelfs als grap een gedicht als reactie.<br><img src="https://gimg2.gateimg.com/image/article/170989027314.png" alt=""><br>Volgens Gate.io-gegevens heeft WEN de afgelopen 24 uur niet veel gefluctueerd en wordt momenteel aangeboden voor $0.000328. Toen WEN werd airdropped, werd het geciteerd op $0.000068 op Jupiter, maar nadat het live was gegaan, daalde het tot slechts $0.000041. Sinds het bereiken van het dieptepunt is WEN bijna 10 keer gestegen, waardoor het de valuta is met de kleinste stijging in populaire Meme-valuta op de Solana-keten.</p>
<h3 id="h3-MYRO395846"><a name="MYRO" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MYRO</h3><p>Het Twitter-profiel van MYRO is ‘Solana Founder’s Dog’, wat een gevoel voor memecultuur met zich meebrengt. MYRO is vernoemd naar het huisdier van de oprichter van Solana. Het MYRO-team verklaarde dat ze meer aandacht willen trekken voor Solana via Memes, om de on-chain handelsvolumes van DEX, NFT en tokens te verhogen. Ze hebben ook $5.000 gedoneerd aan de non-profitorganisatie Dogs for Better Lives.<br><img src="https://gimg2.gateimg.com/image/article/170989029715.png" alt=""><br>Veel mensen geloven dat MYRO de op één na grootste Meme-munt is op de Solana-keten, en beweren dat als ‘BONK is als DOGE, dan is MYRO SHIB.’ De stijgende prijs van BONK heeft ook geleid tot een aanzienlijke stijging van de prijs van MYRO. Volgens Gate.io-gegevens is MYRO in de afgelopen 24 uur met 11,6% gestegen en wordt nu aangehaald op 0,37 USDT. Sinds de lancering heeft MYRO een maximale stijging van meer dan 400 keer gezien.</p>
<h2 id="h2-Oracle20Machine293925"><a name="Oracle Machine" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Oracle Machine</h2><h3 id="h3-PYTH86170"><a name="PYTH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>PYTH</h3><p>Het Python-netwerk is het toonaangevende oracle-protocol op de Solana-keten, waarmee gebruikers toegang hebben tot prijzen van cryptocurrencies, aandelen in de echte wereld en hen helpt de laatste prijzen van verschillende activa, zoals cryptocurrencies en aandelen, te begrijpen. Dit platform biedt een speciale prijsindicatiedienst, die niet alleen de huidige prijs van een bepaald investeringsproject vertelt, maar ook een zogenaamd “betrouwbaarheidsinterval” biedt, dat is een waarschijnlijkheidsbereik voor prijsnauwkeurigheid.<br><img src="https://gimg2.gateimg.com/image/article/170989031816.png" alt=""><br>De inheemse token van Python is PYTH, die zal worden gebruikt om te betalen voor het bijwerken van de orakelmachine. De prijsbron op Python blijft ongewijzigd totdat iemand betaalt voor deze vergoeding update. De totale releaseperiode van PYTH is ongeveer 42 maanden. Het moet ook worden opgemerkt dat in mei 2024, wanneer <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> wordt gehalveerd, zal PYTH een aanzienlijk deel van zijn tokens vrijgeven. Bovendien zullen behalve voor de community en startups alle beloningen tegen dezelfde snelheid en tijd worden vrijgegeven.</p>
<p>PYTH’s investeerders omvatten onder andere Jump Crypto en CMT Digital, met een luxueuze beleggingsportefeuille. PYTH naar Solana kan worden vergeleken met <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> naar Ethereum.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Ijsing</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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 bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>