RGUgbWFya3Qgc3Rpamd0IG92ZXIgaGV0IGFsZ2VtZWVuLCBtZXQgb3B0aW1pc3Rpc2NoZSBzZW50aW1lbnRlbiwgYW5hbHlzZWVyIGRlIG5pZXV3ZSByb25kZSB2YW4gZGUgb3B3YWFydHNlIGN5Y2x1cw==

2024-10-17, 08:07

<p><img src="https://gimg2.gateimg.com/image/article/17291522321692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR817121"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Sinds oktober, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> prijzen zijn begonnen te stabiliseren en te herstellen, waardoor sterke winsten worden behaald in sectoren zoals MEME, AI en DePIN.</p>
<p>Onlangs is de DePIN-sector opnieuw rood geworden, met indrukwekkende prestaties van <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a>(GRT), AIOZ Network (AIOZ), IoTX (IOTX), en anderen.</p>
<p>De recente stijging in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptocurrency markt</a> heeft significante verschillen laten zien ten opzichte van eerdere zwakke oplevingen, wat meer marktvertrouwen biedt voor meer optimistische verwachtingen in de toekomst.</p>
<h2 id="h2-Inleiding705721"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Na een lange neergang, de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> heeft eindelijk een langverwachte opleving doorgemaakt. Sinds het begin van oktober zijn de prijzen van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> zijn begonnen te stabiliseren en te herstellen, wat de opleving van sectoren zoals MEME en AI stimuleert. We hebben dit ook genoemd in recente blogartikelen. Dit artikel geeft een algemeen overzicht van de recente opkomst van de marktsector en kijkt vooruit naar de toekomstige richting voor iedereen.</p>
<h2 id="h2-Zelfverificatie20van20het20oktoobereffect20de20opleving20van20de20markt20wordt20gedreven20door20de20stijging20van20BTC725914"><a name="Zelfverificatie van het ‘oktoobereffect’, de opleving van de markt wordt gedreven door de stijging van BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zelfverificatie van het ‘oktoobereffect’, de opleving van de markt wordt gedreven door de stijging van BTC</h2><p>Onlangs is de cryptomarkt eindelijk uit het dal gekomen en heeft een krachtige opleving doorgemaakt, waarbij sommigen zelfs beweren dat dit een zelfbevestiging is van de markt onder het ‘oktobergeluid’.</p>
<p>Specifiek gezien zijn de BTC-prijzen sinds september fluctuerend omhoog gegaan, maar ze zijn altijd beperkt gebleven door druk bij de $60.000 grens. Naarmate oktober begon, bleef de prijs stijgen tot ongeveer $68.000. Op de datum van schrijven is BTC gestegen naar het dagelijkse technische trendlijn-druk niveau, en zodra het effectief door deze weerstand heen breekt, zal de opwaartse ruimte geopend worden.<img src="https://gimg2.gateimg.com/image/article/17291531151.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Ondertussen herstelde ETH ook, maar zoals we al meerdere keren hebben vermeld in onze blogberichten, is het opwaartse momentum zwakker dan dat van BTC. Er zijn tekenen van verbetering, maar het is niet consistent. Momenteel ligt het hoogste herstel rond de $2.700, met het sterkste drukniveau van $2.800 daarboven.<img src="https://gimg2.gateimg.com/image/article/17291531332.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Met de stabilisatie en opwaartse trend van BTC is ook de vervalsingssector weer begonnen te herstellen, waardoor de al lange tijd slapende markt een zeldzame adempauze krijgt. Meme, als de absolute belangrijkste drijvende kracht van deze bullmarkt, presteert nog steeds goed. Base Meme en <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Meme zijn respectievelijk met 17,9% en 12,7% gestegen in de afgelopen zeven dagen. Populaire tokens zijn onder andere BOME, TURBO, MEW, SPX, BRETT, DEGEN, enz.</p>
<p>Bovendien leiden opkomende sectoren zoals DePIN, DID en Fans Token de markt, met respectievelijk winsten van 23,7%, 15,8% en 8,5% in de afgelopen zeven dagen. Ondertussen zijn niche sectoren zoals cross-chain en <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Ook infrastructuur is in trek bij fondsen, met respectievelijk winsten tot 160,5% en 20,8% in de afgelopen 7 dagen.<img src="https://gimg2.gateimg.com/image/article/17291531543.jpeg" alt=""><br>Bron: CoinGecko</p>
<p>Kortom, gezien de algemene opwaartse trend, markt <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">optimisme</a> is actief aan het terugkeren. De marktwaarde van cryptocurrency is ook gestegen van 2,148 biljoen Amerikaanse dollars naar 2,416 biljoen Amerikaanse dollars in de afgelopen maand. De marktwaarde van de vervalsingssector ligt slechts één stap verwijderd van de piek van de laatste bullmarkt.</p>
<h2 id="h2-Het20interpreteren20van20de20nieuwe20speculatieaanwijzingen20van20sterke20sectoren20in20deze20ronde22911"><a name="Het interpreteren van de nieuwe speculatieaanwijzingen van sterke sectoren in deze ronde" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het interpreteren van de nieuwe speculatieaanwijzingen van sterke sectoren in deze ronde</h2><p>Deze bullmarkt heeft nieuwe sectoren voortgebracht zoals AI, DePIN, RWA, DeSci, enz. Over het algemeen is de Meme-sector echter geëvolueerd naar een compleet nieuw en complex systeem en wordt zelden beïnvloed door de algehele omgeving om in een langdurige neergang te belanden. De recente leidende opleving weerspiegelt ook de dominante positie van de Meme-sector op de markt.</p>
<p>Meme: De ontwikkelingstrend van tokens in de MEME-sector tijdens deze bullmarkt is sterk afhankelijk van marktsentiment en verkeer, waarbij complexe en voortdurend veranderende kenmerken worden vertoond. Vanaf de populariteit van PEPE vorig jaar die de Meme-enthousiasme aanwakkerde, met verschillende openbare keteninies die eind vorig jaar verschenen, de gedecentraliseerde muntuitgiftegolf gedomineerd door BOME en SLERF in maart van dit jaar, gevolgd door internetberoemdheden, schattige huisdieren en woordenschatmemes, zoals MOTHER en MOODENG, evenals recent controversiële memen met dezelfde naam in hoofdletters en kleine letters en weer tot leven gebrachte cultstijlmemes zoals NEIRO en SPX, kan worden gezegd dat de evolutie van Meme-projecten op Ethereum, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, Base, en andere ketens zijn geleidelijk verbeterd en vormen niet langer een niet-mainstream sector in de vorige stieren- en vissentailmarkt.<br><img src="https://gimg2.gateimg.com/image/article/17291531894.jpeg" alt=""><br>Bron: Gate.io</p>
<p>DePIN: Het concept van DePIN is ontstaan uit een nieuw concept dat in het begin van 2023 werd voorgesteld door het toonaangevende instituut Messari in zijn onderzoeksrapport ‘The DePIN Sector Map’. Het wordt gedefinieerd als ‘het implementeren van fysieke infrastructuur en hardwarenetwerken in de echte wereld met behulp van versleutelde economische protocollen.’</p>
<p>Hoewel het DePIN-concept aanvankelijk beperkte populariteit had na de introductie, is het een veelbesproken onderwerp geworden in de branche als de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">Cryptomarkt</a> herstelt geleidelijk en de interesse van investeerders in de <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Het veld neemt toe, vooral tijdens het Hong Kong <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Carnival in april 2023.</p>
<p>Meerdere DePIN-projecten kwamen geleidelijk uit de conceptuele fase in de tweede helft van 2023. DePIN-concepttokens vertegenwoordigd door <a href="/price/helium-hnt" rel="nofollow noopener noreferrer" target="_blank">Helium</a> Mobile, Honey, etc., hebben uitstekend gepresteerd op de markt en zijn een van de populairste tracks buiten inies geworden.</p>
<p>Onlangs is de DePIN-sector opnieuw rood geworden, met indrukwekkende prestaties van <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a>(GRT), AIOZ Network (AIOZ), IoTX (IOTX), en anderen.<br><img src="https://gimg2.gateimg.com/image/article/17291532145.jpeg" alt=""><br>Bron: CoinGecko</p>
<p>Op de schrijfdatum heeft de totale marktkapitalisatie van de DePIN-sector $23,8 miljard bereikt. Volgens het onderzoeksrapport van Messari wordt verwacht dat de omvang van de DePIN-markt tegen 2028 $3,5 biljoen zal bedragen, wat aangeeft dat er nog aanzienlijk groeipotentieel is.</p>
<p>AI-sector: Vanaf de lancering van het generatieve kunstmatige intelligentieproduct ChatGPT begin 2023 is het gebied van versleutelde AI begonnen op te komen, met tokens in sectoren zoals <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a> (FET), <a href="/price/near-protocol-near" rel="nofollow noopener noreferrer" target="_blank">Near Protocol</a> NEAR, Worldcoin (WLD) en andere cryptocurrencies die momenteel veel aandacht in de markt krijgen.</p>
<p>Tegen 2024 heeft de voortdurende uitbreiding van de AI-markt de vraag naar infrastructuur zoals DePIN-netwerken gestimuleerd, en dus projecten zoals io.net (IO), <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Render</a> ( <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">RENDER</a>) Akash Network (AKT), die gedecentraliseerde CPU’s/GPU’s verzamelen om AI-rekencapaciteit te bieden, krijgen veel aandacht.</p>
<p>Bovendien hebben BitTensor (TAO), Triathon (GROW) en anderen ook positieve vooruitgang geboekt bij het decentraliseren van gegevensprivacy, en hun recente muntprijzen hebben het goed gedaan.<br><img src="https://gimg2.gateimg.com/image/article/17291532356.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Het is vermeldenswaard dat het gebruik van AI om munten uit te geven de reguleringen in de echte wereld kan omzeilen. Onlangs zijn MEME’s van AI-concepten zoals TURBO en GOAT blijven stijgen, wat aangeeft dat het crypto-ecosysteem in combinatie met AI een steeds diverser en efficiënter ontwikkelingstrend vertoont.</p>
<p>Fans Token: Fan Tokens zijn cryptocurrencies die eigenschappen combineren zoals MEME, NFT en real-world adoptie, meestal uitgegeven door teams, clubs of beroemdheden, met als doel exclusieve lidmaatschapsvoordelen te bieden aan hun fans. We hebben dit sector ook specifiek besproken in ons artikel “ <a href="https://www.gate.io/blog/4597/4597" target="_blank">Drijven Fan Tokens een sterke opleving in de MEME-sector?</a> Deze week uitgebracht, wat hier niet herhaald zal worden.</p>
<p>Op de schrijfdatum is de marktwaarde van deze sector in de afgelopen 7 dagen met 5,8% gestegen, met een totale marktwaarde van bijna 300 miljoen Amerikaanse dollars.</p>
<h2 id="h2-Spot20ETFs20Ervaren20Doorlopende20Netto20Instromingen20Brede20Range20Volatiliteit20Komt20Ten20Einde695660"><a name="Spot ETF’s Ervaren Doorlopende Netto Instromingen, Brede Range Volatiliteit Komt Ten Einde" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Spot ETF’s Ervaren Doorlopende Netto Instromingen, Brede Range Volatiliteit Komt Ten Einde</h2><p>Terugkijkend, achter deze opleving op de markt ligt het gecombineerde effect van meerdere gunstige factoren. Ten eerste heeft Slim Geld, nauw verwant aan de cryptocurrency markt, ons aanwijzingen gegeven. Terwijl de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> markt geleidelijk stabiliseert ondersteund door mijnbouw stopprijzen, heeft de bewindvoerder van Mt. Gox de deadline voor terugbetaling aan crediteuren verlengd tot 31 oktober 2025, waardoor marktzorgen over verkopen zijn verminderd. Als gevolg hiervan zijn sommige institutionele fondsen begonnen met <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> terug in de cryptomarkt. In oktober werden bijna 20.000 BTC gestort in BTC-spot-ETF’s, en ETH-spot-ETF’s beginnen ook geleidelijk aan geld te ontvangen, wat wijst op de verbetering van het huidige fondssentiment.<img src="https://gimg2.gateimg.com/image/article/17291532777.jpeg" alt=""><br>Bron: coinglass</p>
<p>Natuurlijk blijft het renteverlagingbeleid van de Federal Reserve een belangrijke macrofactor die van invloed is op het herstel van de Bitcoin-prijzen. Rente verlagingen zorgen meestal voor meer liquiditeit en beleggers zoeken in deze context naar hoogrenderende activa. Als een hoogrisico- en hoogrendementsactivum is Bitcoin een populaire keuze geworden voor kapitaalinstroom. De recente stijging van Bitcoin is echter nog steeds binnen een brede waaier van schommelingen, wat aangeeft dat gebruikers en instellingen een afwachtende houding aannemen ten opzichte van toekomstige markttrends en op zoek zijn naar krachtigere economische gegevens en beleidssignalen. Kortom, de impact van het renteverlagingbeleid van de Federal Reserve op de markt blijft op lange termijn en geleidelijk.</p>
<p>Bovendien verstoren de Amerikaanse presidentsverkiezingen van november nog steeds de cryptocurrency-markt. Trump stelde ooit voor om Bitcoin of “crypto-cheque” te gebruiken om Amerikaanse staatsobligaties te betalen om een schuldencrisis te voorkomen. Hoewel dit misschien absurd lijkt, vergroot het wel het vertrouwen van de markt in cryptocurrencies. Daarnaast heeft de huidige vice-president Harris ook toezeggingen gedaan om een regelgevend kader voor cryptocurrency te ondersteunen en meer investeringszekerheid te bieden aan zwarte Amerikanen die digitale activa bezitten of eerder hebben gehad om het contact met zwarte mannelijke kiezers te versterken. Dit nieuws heeft ook een bepaald stimulerend effect op de trend van digitale valuta. <img src="https://gimg2.gateimg.com/image/article/17291532988.jpeg" alt=""><br>Bron: Polymarket</p>
<p>Natuurlijk, zoals we bespraken in het artikel “ <a href="https://www.gate.io/blog/4486/does-it-fall-every-september-everything-you-know-about-the-september-market-trend" target="_blank">Valt het elke september? Alles wat je moet weten over de september markttrend</a>” dat elke september tot een daling leidt, is populair geworden, de “oktobergolf” die elk oktober zal stijgen, wordt zeer verwacht.</p>
<p>Zoals weergegeven in de onderstaande afbeelding, geeft historische gegevens aan dat Bitcoin meestal een sterke seizoensgebonden markt ervaart in de tweede helft van oktober. Dit seizoenspatroon heeft inderdaad enige ondersteuning geboden voor de stijging van de Bitcoin-prijzen.<br><img src="https://gimg2.gateimg.com/image/article/17291533109.jpeg" alt=""><br>Bron: coinglass</p>
<p>Kortom, de recente stijging in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> toonde duidelijke kenmerken die verschilden van eerdere zwakke oplevingen, wat meer marktvertrouwen en optimistischere verwachtingen voor de toekomst opleverde. We zullen dit blijven volgen.</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 mening van de onderzoeker en vormt geen enkele beleggingssuggestie. Alle investeringen brengen inherente risico's met zich mee; verstandige besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>