RGFnZWxpamtzIG5pZXV3cyB8IERlIHdla2VsaWprc2UgaW5zdHJvb20gdmFuIEJUQyBFVEYncyBvdmVydHJvZiAkMyBtaWxqYXJkLCBzdGFhdCBCaXRjb2luIG9wIGhldCBwdW50IG9tIGRvb3IgZGUgJDEwMC4wMDAgZ3JlbnMgdGUgYnJla2VuPw==

2024-11-25, 04:49

<p><img src="https://gimg2.gateimg.com/image/article/173251001111.25.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETFs20zagen20een20wekelijkse20instroom20van20meer20dan20320miljard20SOL20ETF20wordt20naar20verwachting20goedgekeurd20tegen20het20einde20van20volgend20jaar132016"><a name="Crypto Dagelijkse Samenvatting: BTC ETF’s zagen een wekelijkse instroom van meer dan $3 miljard, SOL ETF wordt naar verwachting goedgekeurd tegen het einde van volgend jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF’s zagen een wekelijkse instroom van meer dan $3 miljard, SOL ETF wordt naar verwachting goedgekeurd tegen het einde van volgend jaar</h2><p>Volgens Farside Investor-gegevens was er afgelopen vrijdag een nettostroom van Amerikaanse spot. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De instroom van ETF’s bedroeg $490 miljoen. De instroom van BlackRock IBIT was $513 miljoen, en de uitstroom van Grayscale GBTC was $67,1 miljoen. Vorige week zagen de BTC ETF’s een wekelijkse instroom van meer dan $3 miljard, waarmee een historisch record werd gevestigd.</p>
<p>Afgelopen vrijdag, de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF’s ontvingen $91,3 miljoen aan instroom. De instroom van BlackRock’s ETHA was $99,7 miljoen, en de uitstroom van Grayscale ETHE was $18,6 miljoen.</p>
<p><strong>De president van de ETF Store: <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ETF’s worden naar verwachting uiterlijk eind volgend jaar goedgekeurd</strong></p>
<p>Nate Geraci, President of The ETF Store, zei: “Ik geloof dat er een grote mogelijkheid is dat de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ETF zal uiterlijk eind volgend jaar worden goedgekeurd en de SEC kan momenteel contact hebben met de uitgever over het product, wat duidelijk een positief signaal is.</p>
<p>Aangezien brancheleiders zoals Bitwise al aanvragen hebben ingediend, is Alexander Blume, CEO van Two Prime Digital Assets, het daar ook mee eens.</p>
<p>“Als ze geen goed gevoel van succes hebben, zullen ze geen tijd en geld verspillen aan dit,” zei Blume. Het succes en precedent van spot. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en spot <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF’s, in combinatie met een meer cryptocurrency-vriendelijk management- en regelgevingsklimaat, zullen leiden tot de lancering van het SOL ETF binnen het komende jaar.</p>
<p>Blume zei: ‘Zowel institutionele beleggers als particuliere beleggers kunnen cryptocurrencies verkrijgen via gereguleerde traditionele financiële kanalen zoals banken en beurzen, en via ETF’s, waardoor eerder niet-bestaande fondsen beschikbaar komen. Het is alsof je een zwembadslang vervangt door een brandslang, wat betekent dat potentiële momentum en speculatieve handel mogelijk een grotere impact kunnen hebben.’</p>
<p><strong>CryptoQuant CEO: De Bitcoinmarkt heeft nog geen schuim gevormd, en de doelkoers kan $141.000 bereiken</strong></p>
<p>Ki Young Ju, CEO van CryptoQuant, verklaarde in een document uitgegeven in X dat de Bitcoin-markt nog niet in het schuimstadium is beland. Vanuit het perspectief van de gerealiseerde marktkapitalisatie is de groeisnelheid van de marktwaarde niet significant in vergelijking met de cumulatieve instroom van on-chain fondsen. Op basis van de gestage opwaartse trend van de huidige marktwaarde is er nog steeds ruimte voor de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> omhoog te gaan, met een doelkoers van $141.000.</p>
<p>Ki Young Ju legde uit dat het bereiken van marktkapitalisatie de omvang van de kapitaalinstroom meet door de totale waarde van alle bitcoins bij de laatste on-chain overdracht te berekenen. Historische gegevens tonen aan dat tijdens bullmarkten de marktwaarde vaak de gerealiseerde marktwaarde overschrijdt en zijn hoogtepunt bereikt wanneer particuliere beleggers de markt betreden; Tijdens een bear-markt kan de marktwaarde onder de gerealiseerde marktwaarde dalen.</p>
<p><strong>Deze week’s ontgrendelingsgegevenslijst: SUI, OP, <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1INCH</a>, en andere tokens zullen grote ontgrendelingsbedragen ontvangen</strong></p>
<p>Volgens gegevens van Tokenomist.ai zullen tokens zoals SUI, OP en <a href="/price/1inch-1inch" target="_blank" class="blog_inner_link">1INCH</a> deze week aanzienlijke ontgrendeling ervaren, waaronder:</p>
<p>Immutable (IMX) zal ongeveer 24,52 miljoen tokens ontgrendelen om 8:00 Beijing-tijd op 29 november, met een verhouding van 1,47% ten opzichte van de huidige <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> en een waarde van ongeveer $42,17 miljoen;</p>
<p><a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>(OP) zal ongeveer 31,34 miljoen tokens ontgrendelen om 8:00 uur Beijing-tijd op 30 november, met een verhouding van 2,5% ten opzichte van de huidige <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> en een waarde van ongeveer $68,32 miljoen;</p>
<p>1inch (1INCH) zal ongeveer 98,74 miljoen tokens ontgrendelen om 20:00 uur Beijing tijd op 30 november, met een ratio van 7,72% ten opzichte van de huidige <a href="/price/flow-flow" target="_blank" class="blog_inner_link">flow</a> en een waarde van ongeveer $38,86 miljoen;</p>
<p>Sui (SUI) zal ongeveer 64,19 miljoen tokens ontgrendelen om 8:00 uur Beijing tijd op 1 december, met een verhouding van 2,26% ten opzichte van de huidige doorstroming en een waarde van ongeveer $216 miljoen.</p>
<h2 id="h2-Markttrends20Metaverse20SAND20en20MANA20stegen20terwijl20nieuwe20munten20zoals20PNUT20en20ACT20de20daling20leidden439023"><a name="Markttrends: Metaverse SAND en MANA stegen, terwijl nieuwe munten zoals PNUT en ACT de daling leidden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Metaverse SAND en MANA stegen, terwijl nieuwe munten zoals PNUT en ACT de daling leidden</h2><h3 id="h3-Markt20Hotspots331255"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Goed gevestigde munten zoals <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> and ELF hebben een aanzienlijke stijging gezien, en de stijging van tokenprijzen tijdens een bullmarkt heeft weinig te maken met de fundamenten van het project. De stijging van oude munten wordt veroorzaakt door de overloop van marktfondsen van nieuwe munten en de gekte van marktsentiment;</p>
<p>De conceptprotocollen SAND, MANA en andere metaverseprotocollen zijn gestegen, maar SAND en MANA zijn nog steeds met 90% gedaald in vergelijking met het hoogste punt van de vorige bullmarkt; Het concept van metaverse werd opgehypt in de vorige bullmarkt, en SAND en MANA kregen ook kortstondig tientallen keren meer winst in de vorige bullmarkt. Na drie jaar markttesten koopt de markt echter het concept van metaverse niet.</p>
<p>Populaire on-chain cryptocurrencies, zoals RIF en URO, zijn gestegen. RIF en URO zijn toonaangevende tokens in de levenswetenschappen, met een huidige marktkapitalisatie van iets meer dan $100 miljoen, wat aansluit bij het hete onderwerp van marktspeculatie. Hun relatief kleine marktkapitalisatie is geschikt voor speculatie, en het concept van levenswetenschappen kan een van de meer vernieuwende verhalen worden in deze ronde van markttrends.</p>
<h3 id="h3-Mainstream20Munten425474"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC handelt zijwaarts op een hoog niveau, met BTC ETF instroom die vorige week $3 miljard heeft overschreden, wat een nieuwe historische hoogtepunt heeft bereikt sinds de introductie van de ETF. Hoewel $100.000 een significante psychologische barrière is geworden voor BTC, blijft de toekomst van BTC positief en optimistisch;</p>
<p>ETH bereikte vorige week de $3.500 grens en is nu licht gedaald naar ongeveer $3.350. De ETH ETF’s zagen in de afgelopen vijf dagen meer dan $90 miljoen aan instroom;</p>
<p>De opkomst en ondergang van Altcoins variëren, met vroege sterke nieuwe munten zoals PNUT en ACT die de daling leiden, maar gevestigde munten trekken marktaandacht met aanzienlijke winsten aan.</p>
<h2 id="h2-Macroeconomisch20nieuws20de20drie20belangrijkste20Amerikaanse20aandelenindices20zijn20gezamenlijk20gestegen20en20de20verwachtingen20dat20de20Fed20de20rente20niet20zal20verlagen20zijn20toegenomen449940"><a name="Macro-economisch nieuws: de drie belangrijkste Amerikaanse aandelenindices zijn gezamenlijk gestegen en de verwachtingen dat de Fed de rente niet zal verlagen, zijn toegenomen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro-economisch nieuws: de drie belangrijkste Amerikaanse aandelenindices zijn gezamenlijk gestegen en de verwachtingen dat de Fed de rente niet zal verlagen, zijn toegenomen</h2><p>De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk hoger, waarbij de S&amp;P 500-index met 0,35% steeg tot 5.969,34 punten; de Dow Jones Industrial Average steeg met 0,97% tot 44.296,51 punten; de Nasdaq-index steeg met 0,16% tot 19.003,65 punten. Vorige week steeg de Dow Jones-index met 1,96% in een week, steeg de Nasdaq-index met 1,73% in een week en steeg de S&amp;P 500-index met 1,68% in een week. Het benchmark 10-jaars rendement op staatsobligaties bedraagt 4,41%, terwijl het 2-jaars rendement op staatsobligaties, dat het meest gevoelig is voor het beleidsrentebeleid van de Federal Reserve, 4,37% is.</p>
<p>Op woensdag 27 november (Peking tijd) zal de Federal Reserve de notulen van haar monetaire beleidsvergadering van november vrijgeven, die de aandacht van de markt hebben getrokken met betrekking tot inflatiegegevens, beleidsstandpunt, economisch vooruitzicht en andere gerelateerde onderwerpen. Daarnaast zal ook de inflatie-indicator waar de Federal Reserve zich het meest zorgen over maakt, de prijsindex voor persoonlijke consumptie-uitgaven (PCE) van oktober, op dezelfde dag worden vrijgegeven.</p>
<p>Analisten zijn over het algemeen van mening dat het opwaartse risico van toekomstige rentetarieven groter is dan het neerwaartse risico. In het kader van het beleid van Trump zullen zowel incrementele stimulansen van belastingverlagingen en verhoogde investeringen als aanbodverstoringen door tarieven en immigratie allemaal opwaartse verstoringen van de rentetarieven veroorzaken. De marktverwachting dat de Federal Reserve de rentetarieven in december niet zal verlagen, blijft stijgen. Volgens de FedWatch-tool van CME verwacht de markt dat er een kans van 47,3% is dat de renteverlagingen in december worden opgeschort, in vergelijking met 38,1% vorige week.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Ijs</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 beleggingsaanbevelingen. Alle beleggingen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>