RGUgbWFya3RzaXR1YXRpZSBpcyBidWxsaXNoLCBrb210IGhldCBhbHRjb2luLXNlaXpvZW4gb3BuaWV1dz8=

2024-11-26, 06:33

<p><img src="https://gimg2.gateimg.com/image/article/1732602393deepanalysis.png" alt=""></p>
<h2 id="h2-TLDR196744"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> nadert de $100.000, en de crypto Fear &amp; Greed Index is gestegen naar een piek van 94. Echter, de prestaties van de Altcoin-markt zijn inconsistent en zijn nog niet volledig gestegen. Sommige goed gevestigde Altcoins zijn zelfs in stilte glen.</p>
<p>In voorgaande bullmarkten heeft er een significant fenomeen van aanvulling en rotatie plaatsgevonden in de Altcoin sector. Met de opkomst van mainstream munten zoals <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, verschillende Altcoin-tracks zullen op verschillende momenten een explosieve groei doormaken. Echter, het huidige probleem van onvoldoende liquiditeit en gebrek aan nieuwe fondsen op de Altcoin-markt wordt steeds prominenter.</p>
<p>In de toekomst, met de geleidelijke vrijgave van liquiditeit en de toenemende aandacht van investeerders voor opkomende markten, kan het algemene stijgingsseizoen van de hele Altcoin-markt weer komen.</p>
<h2 id="h2-Inleiding930798"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Met Bitcoin die vorige week voor het eerst een historisch hoogtepunt van $99.550 bereikte en de $100.000 grens nadert, is de marktenthousiasme opnieuw toegenomen en zijn veel instellingen over het algemeen optimistisch over de toekomstige prestaties ervan. Echter, in deze context is het een veelbesproken onderwerp of Altcoins nog steeds een vorige ‘Altcoin seizoen’ kunnen verwelkomen, aangezien deze stierenmarkt zelden een algehele stijging heeft gezien, en zelfs sommige goed gevestigde Altcoins zijn marginaal geworden en in stilte glen. Dit artikel zal ingaan op waarom het steeds moeilijker wordt voor het Altcoin seizoen en vooruitkijken naar mogelijke kansen in de toekomst.</p>
<h2 id="h2-Bitcoin20nadert2010000020GameFi20en20andere20Relay20Meme20stijgen15236"><a name="Bitcoin nadert $100.000, GameFi en andere Relay Meme stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin nadert $100.000, GameFi en andere Relay Meme stijgen</h2><p>Onlangs is het vertrouwen van investeerders aanzienlijk toegenomen, mede dankzij gunstige beleidsmaatregelen zoals de aanstaande inauguratie van Trump. <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> heeft een nieuwe opwaartse trend ingezet. Dit komt overeen met onze vooruitziende optimistische kijk in ons blogartikel “ <a href="https://www.gate.io/blog/4689/trump-won-the-us-election-will-crypto-market-embrace-bull-market-frenzy-again" target="_blank">Trump heeft de Amerikaanse verkiezingen gewonnen, zal de cryptomarkt opniezen in een stierenmarktgekte?</a>”</p>
<p>Op de schrijfdatum, het <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> is blijven stijgen en heeft een piek bereikt van $99.550, nog maar één stap verwijderd van de $100.000 markering. Ondertussen is het investeerderssentiment extreem hebzuchtig, met de crypto angst en hebzucht index die stijgt naar een hoogtepunt van 94, wat een driejarig hoogtepunt bereikt.<img src="https://gimg2.gateimg.com/image/article/17326026251.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Historische gegevens tonen aan dat Bitcoin sterke explosieve kracht heeft laten zien tijdens vergelijkbare situaties, zoals de prijsstijging na Thanksgiving in 2017.</p>
<p>Verschillende analisten voorspellen dat tijdens het weekend, wanneer institutionele beleggers gesloten zijn, het ‘paniekaankoop’-sentiment van particuliere beleggers mogelijk de prijs van Bitcoin verder zal opdrijven, mogelijk zelfs meer dan $100.000 of zelfs hoger. Ze wezen erop dat in de context van wereldwijde vermogensgroei, de waarde van het Bitcoin-netwerkeffect blijft toenemen en er nog enorme groeimogelijkheden zijn.</p>
<p>Ondertussen heeft de Altcoin-markt een pulserende opwaartse trend laten zien en is de momentum van de algemene stijging van de vorige bullmarkt niet gereproduceerd.</p>
<p>Volgens de observatie van de auteur is de meest populaire Meme-sector recentelijk tijdelijk gestagneerd, terwijl tokens in de metaverse, gaming en AI-sectoren achtereenvolgens zijn gestegen. Dit benadrukt de structurele bullmarkt situatie waarin de liquiditeit nog niet volledig gediversifieerd is en de marktspeculatie van Panasonic is geroteerd.<img src="https://gimg2.gateimg.com/image/article/17326026492.jpeg" alt=""><br>Bron: SoSoValue</p>
<h2 id="h2-Het20stimuleren20van20ritme20van20Altcoin20Sectors20in20het20verleden20Bull20Markets125055"><a name="Het stimuleren van ritme van Altcoin Sectors in het verleden Bull Markets" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het stimuleren van ritme van Altcoin Sectors in het verleden Bull Markets</h2><p>In feite zijn de aanvulling en rotatie van Altcoin-sectoren in de afgelopen bullmarkt bijzonder significant geweest, wat overvloedige kansen voor beleggers heeft gebracht.</p>
<p>Als voorbeeld nemen we de periode van eind 2020 tot de eerste helft van 2021. Bitcoin was de eerste die de markt optrok en een nieuw historisch hoogtepunt bereikte, terwijl <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> in het midden en later de pace bijhield en een sterkere hoofdopwaartse trend startte.</p>
<p>Tijdens deze periode werden ook verschillende Altcoin-tracks gelanceerd, zoals GT, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, en andere utility munten, evenals Doge en SHIB op de Meme track, die allemaal explosieve groei hebben doorgemaakt in specifieke fasen. Publieke keten tracks zoals SOL, AVAX, FTM, etc. zijn ook naar voren gekomen in de tweede golf van de markt, gevolgd door gaming, metaverse tracks, en enkele DeFi projecten, die allemaal hun belangrijkste opwaartse trend zijn begonnen.<br><img src="https://gimg2.gateimg.com/image/article/17326026743.jpeg" alt=""><br>Bron: Gate.io</p>
<p>In de tweede helft van 2021, met de secundaire stijging van BTC en ETH, verscheen de algemene opwaartse trend van de Altcoin-sector opnieuw. De SHIB en andere projecten in de Meme-track blijven zich inspannen, en de openbare kettingbaan behoudt ook een sterk momentum, terwijl de gaming-, metaverse- en NFT-tracks ook niet mogen worden overtroffen en de een na de ander nieuwe hoogten doorbreken.</p>
<p>Opmerkelijk genoeg begon het DeFi-traject, dat de stierenmarkt heeft gekatalyseerd, op dit punt te mislukken, en gedecentraliseerde opslagplatforms zoals FIL en XCH. ‘Doomsday Tank’ platformen, zoals <a href="/price/eos-eos" rel="nofollow noopener noreferrer" target="_blank">EOS</a>, ETC en BSV konden hun winsten in de eerste helft van het jaar niet voortzetten.<br><img src="https://gimg2.gateimg.com/image/article/17326026894.jpeg" alt=""><br>Bron: BLOCKCHAINCENTER.NET</p>
<p>Bij het betreden van de bullmarktcyclus van het vierde kwartaal van 2023 tot het eerste kwartaal van 2024 is het fenomeen van aanvullende prijsbewegingen in de Altcoin-sector nog steeds duidelijk zichtbaar. Met de synchrone stijging van BTC en ETH zijn er nieuwe trending tracks zoals AI, Ethereum’s L2-laag en modulaire blockchain één voor één opgekomen, die veel lof ontvangen en de prijzen stimuleren. In deze fase zijn er steeds nieuwe verhalen opgedoken in de publieke blockchain, RWA en Meme-tracks met inies die voornamelijk gebaseerd zijn op Ordi en gedecentraliseerde muntuitgifte die voornamelijk gebaseerd is op BOME. De prestaties van DeFi, metaverse, gaming, DAO en andere tracks zijn echter niet opvallend.</p>
<p>Het is niet moeilijk om te zien dat het fenomeen van de rotatie van het Altcoin-segment bij eerdere stierenmarkten een zekere regelmaat heeft. Onder leiding van mainstream munten zoals Bitcoin en Ethereum zal elke Altcoin-track explosieve groei doormaken in verschillende fasen, afhankelijk van zijn eigen ontwikkelingssituatie en marktpopulariteit. Sinds 2023 is het Altcoin-segment echter gestopt met het reproduceren van het grote tafereel van een algehele stijging.</p>
<h2 id="h2-Zal20het20Altseizoen20nog20steeds20komen771348"><a name="Zal het Alt-seizoen nog steeds komen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zal het Alt-seizoen nog steeds komen?</h2><p>Ondanks de voortdurend veranderende geschiedenis, is de komst van het Altcoin-seizoen nauw verbonden met de verdeling van liquiditeit. In de eerste twee bull-markten speelde Ethereum een centrale rol, en de uitbraak van ICO en DeFi stimuleerde de welvaart van de twee rondes van Altcoin-markten. Echter, in deze bull-markt, ondanks dat Bitcoin voortdurend de $100.000 grens nadert, lijken Ethereum en de meeste Altcoins aan momentum te ontbreken.</p>
<p>We geloven dat dit kan worden toegeschreven aan de hoge concentratie van fondsen in Bitcoin gedreven door spot ETF’s, wat het aandeel van fondsen dat naar Altcoins stroomt aanzienlijk heeft verminderd. De lancering van financiële producten zoals spot ETF’s en opties dit jaar heeft de positie van Bitcoin als wereldwijde veilige haven voor kapitaal verder versterkt, waardoor de aantrekkingskracht van verschillende Altcoins wordt verzwakt.<br><img src="https://gimg2.gateimg.com/image/article/17326027195.jpeg" alt=""><br>Bron: @0xENAS</p>
<p>Naarmate verschillende sectoren volwassen worden, zal cryptocurrency, net als de aandelenmarkt, onvermijdelijk evolueren naar differentiatie, wat een teken is van de geleidelijke volwassenheid van de markt. We hebben gezien dat sommige hoogwaardige activa, zoals SOL, SUI, DOGE, etc., meer financiële aandacht krijgen. Voor de meeste andere Altcoins worden echter de problemen van gebrek aan nieuwe verhaallijnen, onvoldoende liquiditeit en gebrek aan nieuwe fondsen steeds prominenter, en het is moeilijk om alleen op het harde werk van oude spelers terug te komen.</p>
<p>Daarnaast heeft ook het kenmerk van “speculeren op nieuwe munten in plaats van oude munten” in de branche geleid tot een liquiditeitskloof tussen nieuwe en oude munten. Vooruitkijkend naar de toekomst hebben we opgemerkt dat de macro-achtergrond ook voorwaarden schept voor de komst van het Altcoin-seizoen, en de Altcoin-index in de onderstaande afbeelding staat op 53, wat aangeeft dat de markt mogelijk grotere schommelingen ondergaat. Na de renteverhogingscyclus in 2022, de opschorting van renteverhogingen in september 2023, in combinatie met speculatie en consolidatiehandel van BTC-spot-ETF’s, verschuift de marktliquiditeit, hoewel beperkt, geleidelijk naar versoepeling.</p>
<p>Als gevolg hiervan wordt verwacht dat met het begin van de renteverlagingcyclus van dit jaar en de vriendelijke houding van Trump ten opzichte van crypto bij zijn aantreden, de marktliquiditeit verder zal worden vrijgegeven.<br><img src="https://gimg2.gateimg.com/image/article/17326027556.jpeg" alt=""><br>Bron: BLOCKCHAINCENTER.NET</p>
<p>Kortom, met de geleidelijke vrijgave van liquiditeit en de toenemende aandacht van beleggers voor opkomende markten, kan het algemene stijgseizoen van de gehele Altcoin-markt opnieuw aanbreken. Voor radicale beleggers kan actieve inzet op hoogwaardige Altcoin-projecten leiden tot meer lucratieve rendementen in een stierenmarkt, maar het is ook noodzakelijk om te focussen op onderscheidingsvermogen en analyse, en een voorzichtige bedrijfsfilosofie te handhaven.</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 enkele beleggingsaanbeveling. Alle investeringen brengen inherente risico's met zich mee; verstandige besluitvorming is essentieel.<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 zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>