WmFsIEJOQiBDaGFpbiBMaW5rIGRlIFNPTCBDaGFpbiBrb3BwZWxlbiBvbSBoZXQgb24tY2hhaW4gZWNvc3lzdGVlbSBuaWV1dyBsZXZlbiBpbiB0ZSBibGF6ZW4/

2025-04-25, 04:36

<p><img src="https://gimg2.gateimg.com/image/article/1745555440INDUSTRYANALYSIS.png" alt=""></p>
<h2 id="h2-TLDR255510"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Gedreven door de orders van CZ en het mememunt ondersteuningsplan, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> De eco van Chain heeft zich actief ontwikkeld en de TVL is gestegen naar $7 miljard, op één na alleen voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>.</p>
<p>BROCCOLI(f3b) is een meme-munt geïnspireerd door de huisdierhond van <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain-oprichter CZ. De prijs is onlangs gestegen naar een nieuw hoogtepunt en valt op tussen een aantal van dergelijke conceptmunten.</p>
<p>De echte uitdaging voor de BNB-keten is niet om SOL te overtreffen, maar hoe verkeersvoordelen om te zetten in technologische accumulatie.</p>
<h2 id="h2-Kennismaking839812"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>De <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> in april heeft altijd dramatische wendingen. Net zoals BTC aan het begin van de maand daalde en nu weer is gestegen, is het aantal maandelijkse transacties in de <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a>-ecosysteem met 20% gedaald tot 1,5 miljard, terwijl het aantal transacties op de BNB-keten met 17% is gestegen tot 140 miljoen. Deze trend van de ene stijging en de andere daling laat waarnemers zich afvragen: voltooit de BNB-keten, die ooit werd bekritiseerd vanwege zijn overmatige klemmen, de transformatie van verkeersoogst naar ecosedimentatie?</p>
<h2 id="h2-Eco20Data20Soars20Making20BNB20Chain20Great20Again168403"><a name="Eco Data Soars, Making BNB Chain Great Again" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Eco Data Soars, Making <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain Great Again</h2><p>In april, toen de on-chain gegevens saai waren, beleefde BNB Chain een kleine climax van eco welvaart. Volgens DeFiLlama-gegevens is de totale waarde vergrendeld (TVL) van BNB Chain gestegen naar $7 miljard, en nadert daarmee het hoogtepunt in april 2024. Ondertussen bereikte de TVL van opBNB $25,21 miljoen, wat zijn potentie als een high-performance side chain aantoont. Hoewel er nog steeds een kloof is in vergelijking met <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en SOL Chain, is de groeisnelheid van BNB Chain ongetwijfeld opmerkelijk.<br><img src="https://gimg2.gateimg.com/image/article/17455556491.jpeg" alt=""><br>Bron: Defillma</p>
<p>Stablecoin actieve adressen zijn een belangrijke indicator voor het beoordelen van de activiteit van het ecosysteem. Volgens gegevens van CryptoRank van vorige week, bereikte het totale aantal actieve USDT-adressen in de hele keten 31,1 miljoen in de afgelopen 30 dagen. BNB-keten stond op de eerste plaats met bijna 12 miljoen actieve USDT-adressen, gevolgd door <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a>(11.2 miljoen) en <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> (2.6 miljoen).</p>
<p>Het aantal actieve adressen is een andere belangrijke indicator voor het meten van de activiteit van de eco. Zoals hieronder te zien is, volgens de statistieken van verschillende ketens door Nansen, bereikte het aantal maandelijkse actieve adressen van BNB Chain 16 miljoen, waarmee het <a href="/price/tron-trx" target="_blank" class="blog_inner_link">Tron</a> en Base overtrof en op de tweede plaats kwam. Echter, hoewel het aantal actieve adressen van de BNB-keten slechts 15% is van die van de SOL-keten, vertegenwoordigen de transactiekosten 65% van laatstgenoemde, wat de sterke kapitaalschaal en hype van de keten aantoont.<img src="https://gimg2.gateimg.com/image/article/17455556662.jpeg" alt=""><br>Bron: nansen</p>
<p>Het herstel van de BNB-keten is niet tolig, maar het gezamenlijke resultaat van technologische innovatie, gemeenschapsdrang en marktstrategie. Het is met name vermeldenswaardig dat de BNB-keten het ‘Meme Coin Liquiditeitssteunplan’ lanceerde op basis van de markttrend van ‘nieuw verkeer omarmen’. Volgens de officiële aankondiging van de BNB-keten trok het plan een groot aantal nieuwe gebruikers en ontwikkelaars aan door initiële liquiditeitssteun te bieden voor het meme-coinproject.<br><img src="https://gimg2.gateimg.com/image/article/17455556883.jpeg" alt=""><br>Bron: BNB CHAIN DappBay</p>
<p>Vanaf april 2025 hebben tientallen meme-coinprojecten geprofiteerd van het programma, waaronder stertokens zoals BROCCOLI en $BANAAN. Deze stap verbetert niet alleen de concurrentiepositie van BNB Chain op het gebied van meme-coins, maar verbetert ook aanzienlijk de activiteit en markt aantrekkingskracht van zijn ecosysteem.</p>
<h2 id="h2-Nieuwe20munten20met20verhaal20en20populariteit20Broccoli20BANANA20FHE20SKYAI20enz799229"><a name="Nieuwe munten met verhaal en populariteit: Broccoli, $BANANA, FHE, SKYAI, enz." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nieuwe munten met verhaal en populariteit: Broccoli, $BANANA, FHE, SKYAI, enz.</h2><p>In deze sectie zullen we vier populaire tokens grondig analyseren: BROCCOLI, BANANA (Banana For Scale), FHE (Mind Network) en SKYAI (SkyAI). Het is vermeldenswaard dat deze populaire tokens zijn genoteerd op Gate.io.</p>
<h2 id="h2-BROCCOLI20de20Dogecoin20van20CZ20een20door20de20community20gedreven20ster187589"><a name="BROCCOLI: de Dogecoin van CZ, een door de community gedreven ster" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BROCCOLI: de <a href="/price/dogecoin-doge" target="_blank" class="blog_inner_link">Dogecoin</a> van CZ, een door de community gedreven ster</h2><p>BROCCOLI(f3b) is een meme-munt geïnspireerd door de huisdierhond van BNB Chain oprichter CZ. Het werd gelanceerd op BNB Chain via het four.meme-platform in februari 2025.<br><img src="https://gimg2.gateimg.com/image/article/17455557164.jpeg" alt=""><br>Bron: firstbroccoli</p>
<p>Als de eerste CZ-hondenthema-token op BNB Chain, viel deze meme-munt met het tokencontractadres dat eindigt op f3b al snel op tussen vele CZ-huisdierhondconceptmunten. Het is ook de enige populaire munt die recentelijk een nieuw hoogtepunt in prijs heeft bereikt.</p>
<h2 id="h2-BANANA20Banana20For20Scale20Een20SpaceXaangedreven20memerage372120"><a name="$BANANA (Banana For Scale): Een SpaceX-aangedreven meme-rage" class="reference-link"></a><span class="header-link octicon octicon-link"></span>$BANANA (Banana For Scale): Een SpaceX-aangedreven meme-rage</h2><p>$BANANA (officieel bekend als Banana For Scale, met het tokensymbool ook BANANAS31) is gebaseerd op de veelvuldig verspreide ‘banaan als universele eenheid van maat’ meme op Reddit en werd gelanceerd op BNB Chain in het begin van 2025.<br><img src="https://gimg2.gateimg.com/image/article/17455557385.jpeg" alt=""><br>Bron: bananabsc.com</p>
<p>Nog opvallender is dat Elon Musk hetzelfde “Banaan voor Schaal” patroon heeft afgedrukt op SpaceX’s S31 Starship, waardoor het de “eerste banaan is die de ruimte in is gelanceerd.”</p>
<h2 id="h2-FHE20Mind20Netwerk20Pionier20in20Homomorfe20Versleuteling81780"><a name="FHE (Mind Netwerk): Pionier in Homomorfe Versleuteling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FHE (Mind Netwerk): Pionier in Homomorfe Versleuteling</h2><p>FHE (Mind Network) is een token uitgegeven door het Mind Network-project, dat zich richt op homomorfe versleuteling, een geavanceerde technologie die berekeningen mogelijk maakt zonder gegevens te decoderen. In april 2025 organiseerde Mind Network een airdrop-evenement voor FHE-tokens, dat aanzienlijke aandacht trok van ontwikkelaars en investeerders.<br><img src="https://gimg2.gateimg.com/image/article/17455557566.jpeg" alt=""><br>Bron: mindnetwork.xyz</p>
<p>Als een token gerelateerd aan AI en privacy computing, positioneert het technische verhaal van FHE het uniek binnen het DeFi en AI-ecosysteem van BNB Chain. Naar mijn mening weerspiegelt de opkomst van FHE niet alleen het potentieel van BNB Chain voor technologische innovatie, maar ook de groeiende vraag van de markt naar privacybescherming en gegevensbeveiliging.</p>
<p>Evenzo is de prijs van deze nieuwe munt na de lancering relatief sterk gebleven en heeft onlangs ook een nieuw hoogtepunt bereikt.</p>
<h2 id="h2-SKYAISkyAI20Door20de20community20gedreven20AIMCP20protocol945201"><a name="SKYAI(SkyAI): Door de community gedreven AI+MCP protocol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SKYAI(SkyAI): Door de community gedreven AI+MCP protocol</h2><p>SKYAI is een protocol dat grote taalmodel (LLM) toepassingsscenario’s bedient door MCP (Model Context Protocol) uit te breiden om blockchaingegevens te verbinden.<img src="https://gimg2.gateimg.com/image/article/17455557757.jpeg" alt=""><br>Bron: @SKYAIpro</p>
<p>Als het eerste IDO-project op het Four.meme-platform trok de pre-sale van SKYAI meer dan 110.000 adressen aan om deel te nemen, en haalde in totaal 83.848 BNB op (ongeveer $50 miljoen). Na de officiële TGE van SKYAI afgelopen zondag steeg de marktwaarde ervan tot ongeveer $76 miljoen, en de IDO had een significant effect op het creëren van rijkdom.</p>
<h2 id="h2-Samenvattend705394"><a name="Samenvattend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvattend</h2><p>BNB Chain activeerde het lang slapende on-chain ecosysteem in april 2025. De opkomst van trending tokens zoals BROCCOLI en BANANAS31, de groei van TVL en handelsvolume, en de bloei van door de gemeenschap gedreven projecten tonen de vitaliteit van BNB Chain aan. Echter, in vergelijking met het ecosysteem van SOL Chain, moet BNB Chain nog steeds bijbenen op het gebied van diversiteit en gebruikersbinding.</p>
<p>Echter is naar mijn mening de echte uitdaging van de BNB-keten niet om SOL te overtreffen, maar hoe de verkeersvoordelen om te zetten in technologische accumulatie. Van BSC’s ‘transactie als dienst’ naar opBNB’s ‘rekenen als dienst’, van Mind Network’s privacy-rekenen tot Four.meme’s community-aandrijving, dit ecosysteem bewijst dat de competitie van publieke ketens uiteindelijk terug zal keren naar het essentiële vraagstuk van ‘de drempel van innovatie verlagen’. Uiteindelijk is in het huidige tijdperk van meme en technologie de veerkracht van het ecosysteem altijd iets om naar uit te kijken in plaats van de tijdelijke populariteit.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Charle Y.</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 beleggingsadvies. Alle investeringen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>