U3BhcmsgUHJvdG9jb2wgQ29pbiBTUEsgMjAyNSBQcmlqc3Zvb3JzcGVsbGluZw==

2025-06-23, 10:21

<p><img src="https://gimg2.gateimg.com/image/spkkk202506231809415400823854.png" alt="">
</p><p>Op 17 juni 2025 werd de governance-token SPK van het Spark Protocol, ontwikkeld door het kernteam van MakerDAO, officieel gelanceerd op het Gate Alpha handelsgebied. Als een nieuwe kracht in DeFi, gepositioneerd als een “on-chain kapitaalallocatie platform”, beheert Spark een kapitaalschaal van tot $3,95 miljard, die drie belangrijke gebieden dekt: DeFi, CeFi en RWA (real-world assets). Het kernmechanisme ligt in het algoritmisch aanpassen van de activa-allocatie in real-time, wat de kapitaal efficiëntie verhoogt terwijl de risico’s worden beheerst. Echter, slechts enkele uren na de lancering, ondervond de prijs van SPK een klifachtige daling, die daalde van zijn historische hoogtepunt van $0,1774 naar $0,03968, een daling van meer dan 70%, wat brede aandacht van de markt trok.</p>
<h2 id="h2-SPK20Lancering20Prestatie20Hoge20Opening20Lage20Sluiting20Airdrop20Verkoopdruk20als20Hoofdoorzaak607307"><a name="SPK Lancering Prestatie: Hoge Opening, Lage Sluiting, Airdrop Verkoopdruk als Hoofdoorzaak" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SPK Lancering Prestatie: Hoge Opening, Lage Sluiting, Airdrop Verkoopdruk als Hoofdoorzaak</h2><p>De debuut van SPK kan worden omschreven als “een co-existentie van hoogte- en dieptepunten”:</p>
<ul>
<li>Initiële Prestatie: Op 17 juni was de openingsbenchmarkprijs ongeveer $0,073, steeg kort naar $0,075 en stond op een gegeven moment op de tweede plaats op de trendinglijst van CoinGecko.</li><li>Snelle Inzakking: Binnen enkele uren daarna kelderde de prijs met meer dan 60%, en bereikte een dieptepunt van $0,03968 (gegevens van 21 juni). Op 23 juni schommelde de prijs rond $0,0467, met een marktkapitalisatie van $456 miljoen, en een daling van 67,69% in 7 dagen.</li></ul>
<p>De belangrijkste reden voor de daling wijst op geconcentreerde verkopen vanuit airdrops:</p>
<ul>
<li>De initiële circulatie was slechts 1,7 miljard (totaal aanbod van 10 miljard), maar ongeveer 300 miljoen SPK stroomde kort na de beursnotering de markt binnen om te worden verzilverd;</li><li>Platforms zoals Binance hebben 200 miljoen tokens (goed voor 2% van het totale aanbod) uitgedeeld aan stakers, waarbij de meeste ontvangers ervoor kozen om winst te nemen;</li><li>Onvoldoende marktdiepte, vooral met nieuwe beurzen zoals Bybit die zwakke orderboeken hebben, verergert de prijsvolatiliteit.</li></ul>
<p>Dit fenomeen onthult het langdurige structurele dilemma op de cryptocurrency-markt: airdrop-incentives trekken gemakkelijk kortetermijnarbitraire aan in plaats van echte gebruikers van het protocol, wat leidt tot een herhaalde cyclus van “farming en dumping.”</p>
<h2 id="h2-202520Prijsvoorspelling20Een20Mix20van20Herstel20en20Voorzichtig20Optimisme758060"><a name="2025 Prijsvoorspelling: Een Mix van Herstel en Voorzichtig Optimisme" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2025 Prijsvoorspelling: Een Mix van Herstel en Voorzichtig Optimisme</h2><p>Ondanks een moeizame start hebben verschillende instellingen, die de gegevens van de Gate-lancering en de fundamenten van het protocol combineren, een vooruitzicht gegeven voor de trend van SPK in 2025 dat zowel divergentie als consensus laat zien.</p>
<table>
<thead>
<tr>
<th>Bron</th>
<th>Minimale prijs (USD)</th>
<th>Gemiddelde prijs (USD)</th>
<th>Hoogste prijs (USD)</th>
</tr>
</thead>
<tbody>
<tr>
<td>Algoritmisch Dynamisch Model Voorspelling</td>
<td>0.073</td>
<td>0,0733 (na 30 dagen)</td>
<td>0,0733 (+0,41%)</td>
</tr>
<tr>
<td>Technische Analyse Voorspelling</td>
<td>0.079186</td>
<td>0,082434</td>
<td>0,099084</td>
</tr>
<tr>
<td>Marktsentimentmodel</td>
<td>0,06</td>
<td>0.073</td>
<td>0.085</td>
</tr>
</tbody>
</table>
<ul>
<li><p>Korte termijn (juni - juli): Gate voorspelt dat als de Launchpool liquiditeitsprikkels van kracht worden, de prijs mogelijk iets kan herstellen naar $0.073299 na 30 dagen (een stijging van 0,41% ten opzichte van de opening). Echter, voorzichtigheid is geboden met betrekking tot de voortdurende verkoopdruk door airdrops en het algehele volatiliteitsrisico op de cryptocurrency-markt.</p>
</li><li><p>Tweede helft herstelmarkt: Als de TVL (Totaal Waarde Vastgezet) van het protocol toeneemt en de opzet van RWA (Echte Wereld Activa) versnelt, wordt verwacht dat de prijs zal terugveren naar het bereik van 0,06 - 0,085 USD. Belangrijke katalysatoren zijn:</p>
<ul>
<li>Kan het stablecoin yield product sUSDS een hoge APY (momenteel gerapporteerd als 7-daags geannualiseerd op 64%) handhaven;</li><li>Vooruitgang van cross-chain uitbreiding, vooral de integratievoortgang van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L2-netwerken;</li><li>De synergie met het MakerDAO-ecosysteem verdiept zich, zoals exclusieve kortingen voor DAI-leningen.</li></ul>
</li></ul>
<h2 id="h2-Belangrijke20variabelen20die20de20SPKprijs20benvloeden20kansen20en20uitdagingen82928"><a name="Belangrijke variabelen die de SPK-prijs beïnvloeden: kansen en uitdagingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijke variabelen die de SPK-prijs beïnvloeden: kansen en uitdagingen</h2><p>Voor investeerders moet de SPK-operatie in 2025 een tweefasensstrategie hanteren:</p>
<ol>
<li>Halverwege het jaar observatieperiode: Let op de voortgang van de vertering van de airdrop verkopen en het $0,05 ondersteuningsniveau, in combinatie met activiteiten op platforms zoals Gate (zoals handelen om 720.000 SPK airdrop te delen);</li><li>Tweede helft lay-outperiode: Als de protocolinkomsten (momenteel geannualiseerd op 172 miljoen USD) en de deelname aan governance toenemen, kan dit worden toegewezen tijdens dips, met een doelrange van 0,08 - 0,09 USD.</li></ol>
<h3 id="h3-Positieve20ondersteunende20factoren549631"><a name="Positieve ondersteunende factoren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Positieve ondersteunende factoren</h3><ul>
<li>Goedkeuring van Ecologische Kracht: Gebaseerd op het volwassen liquidatiemodel van MakerDAO en $3,95 miljard aan ervaring in asset management, is de technische veiligheid door de markt erkend;</li><li>Sterke ondersteuning van beurzen: Het Gate-platform omvat SPK in meerdere productlijnen zoals Earn, Margin en Futures, waardoor de liquiditeit en de gebruikersbasis worden versterkt;</li><li>Macro-economische Omgevingshulp: De verwachting voor een crypto bullmarkt in 2025 is sterk, met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> projected op $125.000 en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> op $5.000. Als deze trend aanhoudt, zal het de waardeontdekking van opkomende Tokens zoals SPK stimuleren.</li></ul>
<h3 id="h3-Risicos20en20Uitdagingen26237"><a name="Risico’s en Uitdagingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risico’s en Uitdagingen</h3><ul>
<li>Voortdurende Verkoopdruk van Airdrops: Het vroege inflatoire tokenomics-ontwerp kan leiden tot voortdurende verkopen, vooral met 8,3 miljard tokens die nog moeten worden vrijgegeven;</li><li>Moeilijkheden om door de Competitieve Rode Zee heen te Breken: DeFi leningen zijn <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> Om voorop te lopen, moet Spark een gedifferentieerd voordeel creëren in de integratie van RWA-activa en modellen voor renteoptimalisatie.</li></ul>
<h2 id="h2-Conclusie20Waardereconstructie20te20midden20van20volatiliteit20langetermijn20ecologische20implementatie49366"><a name="Conclusie: Waardereconstructie te midden van volatiliteit, langetermijn ecologische implementatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie: Waardereconstructie te midden van volatiliteit, langetermijn ecologische implementatie</h2><p>De turbulente start van SPK bevestigt het klassieke dilemma waarmee opkomende DeFi-tokens worden geconfronteerd: de kloof tussen technologische visie en markt-speculatie. Herstel van de prijs op korte termijn is afhankelijk van echte groeisignalen van het protocol—zoals TVL die naar het miljardenniveau stijgt, implementatie van cross-chain routing, of integratie van RWA-activa op institutioneel niveau.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="4">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>