RGFnZWxpamtzIE5pZXV3cyB8IEJUQyBvdmVyc2NocmVlZCAkODkuMDAwLCB3YXQgcmVzdWx0ZWVyZGUgaW4gZWVuIG5pZXV3ZSBoaXN0b3Jpc2NoZSBob29ndGUsIEFJIE1lbWUgQUNUIHN0ZWVnIDIwIGtlZXIgYmlubmVuIGVlbiBkYWc=

2024-11-12, 04:39

<p><img src="https://gimg2.gateimg.com/image/article/173138618311.12.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20ETH20ETFs20behaalden20een20record20dagelijkse20nettostroom20MicroStrategy20kondigde20een20extra20220miljard20aan20BTCbezit20aan845835"><a name="Crypto Dagelijkse Samenvatting: ETH ETF’s behaalden een record dagelijkse nettostroom, MicroStrategy kondigde een extra $2 miljard aan BTC-bezit aan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: ETH ETF’s behaalden een record dagelijkse nettostroom, MicroStrategy kondigde een extra $2 miljard aan BTC-bezit aan</h2><p>Volgens de gegevens van Farside Investor bedraagt de nettostroom van US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De handelsvolume van spot ETF’s bedroeg gisteren $1.093 miljard, waaronder $736 miljoen van BlackRock IBIT, $135 miljoen van Fidelity FBTC en $108 miljoen van Ark ARKB.</p>
<p>De vermogensbeheerschaal van IBIT, een <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF onder BlackRock Group overtreft die van iShares IAU, een van de grootste goud-ETF’s. FactSet-gegevens tonen aan dat IBIT afgelopen week ongeveer $1 miljard aan financieringsinstromen heeft ontvangen, met een totale instroom van $27 miljard sinds de lancering in januari. Per afgelopen vrijdag bedroeg de vermogensbeheerschaal van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF IBIT $34,3 miljard, vergeleken met de vermogensbeheerschaal van IAU van iets minder dan $33 miljard.</p>
<p>Gisteren, de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Spot ETF’s ontvingen $194 miljoen aan instroom, behaalden vier opeenvolgende dagen een grote netto instroom en zetten een record neer voor de grootste dagelijkse instroom sinds de notering van de ETH ETF’s. Fidelity FETH instroom was $115 miljoen, Grayscale Mini ETH instroom was $63,3 miljoen en BlackRock ETHA-gegevens zijn nog niet bijgewerkt.</p>
<p><strong>CoinShares: De nettostroom van beleggingsproducten in digitale activa bedroeg vorige week $1,98 miljard</strong></p>
<p>Volgens het meest recente wekelijkse rapport van CoinShares, zagen digitale activa-investeringsproducten een instroom van $1,98 miljard na de Amerikaanse verkiezingen, wat de vijfde opeenvolgende week van instroom markeert en de instroom van het jaar tot nu toe op een recordhoogte van $31,3 miljard brengt. Als gevolg van de prijsstijging van vorige week heeft de wereldwijde beheerde vermogensgrootte ook een nieuw historisch hoogtepunt bereikt van $116 miljard. Het handelsvolume is gestegen met $20 miljard, hoewel het geen nieuw record is, is het het hoogste niveau sinds april van dit jaar.</p>
<p>Vanuit regionaal perspectief zijn deze kapitaalstromen voornamelijk geconcentreerd in de Verenigde Staten, waar het instroombedrag $1,95 miljard heeft bereikt, hoewel ook de instroom vanuit Zwitserland en Duitsland is toegenomen, respectievelijk $23 miljoen en $20 miljoen.</p>
<p><strong>MicroStrategy heeft de holdings van 27.200 BTC verhoogd met ongeveer $2,03 miljard</strong></p>
<p>MicroStrategy-oprichter Michael Saylor plaatste op sociale media dat MicroStrategy zijn bezit van 27.200 Bitcoins heeft vergroot tegen een gemiddelde prijs van ongeveer $74.463, met een totale waarde van ongeveer $2,03 miljard.</p>
<p>Vanaf 10 november 2024 heeft MicroStrategy 279.420 Bitcoins in bezit met een totale aankoopprijs van ongeveer $11,9 miljard en een gemiddelde aankoopprijs van ongeveer $42.692.</p>
<p><strong>Standard Chartered Bank: SOL wordt verwacht BTC en ETH te overtreffen tegen het einde van 2025</strong></p>
<p>Standard Chartered Bank verklaarde in een onderzoeksrapport dat als de Republikeinse Partij uitgebreid wint, de nieuwe Amerikaanse regering beleid ten gunste van de digitale activa-industrie zou kunnen bevorderen, wat zou kunnen leiden tot de totale marktkapitalisatie van de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> uitbreiden tot $10 biljoen tegen het einde van 2026.</p>
<p>Standard Chartered Bank verklaarde dat zij geloven dat er een reeks factoren gunstig zal zijn voor de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> in de beginfase van de nieuwe Amerikaanse regering, inclusief regelgevingsveranderingen en aanpassingen aan de positie van de Securities and Exchange Commission (SEC), die kunnen leiden tot een meer toegeeflijke houding ten opzichte van digitale activa.</p>
<p>De bank verklaarde dat deze positieve ontwikkelingen de totale marktkapitalisatie van de cryptomarkt kunnen verviervoudigen van de huidige $2,5 biljoen naar $10 biljoen tegen het einde van 2026. Geoff Kendrick, hoofd van digitaal vermogensonderzoek bij Standard Chartered Bank, schreef: ‘Het stijgende tij moet alle digitale activa stimuleren, waarbij degenen die het meest relevant zijn voor eindgebruikscases naar verwachting het meest zullen profiteren.’ Het rapport suggereert ook dat de nieuwe Amerikaanse regering overweegt om een Bitcoin-reserve op te richten, maar dit wordt gezien als een ‘gebeurtenis met een lage waarschijnlijkheid maar een grote impact’.</p>
<p>De bank herhaalde haar doel van ongeveer $200.000 voor Bitcoin (BTC) en $10.000 voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>(ETH) tegen het einde van 2025, en verklaarde dat het verwacht <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>(SOL) om de twee cryptocurrencies met de hoogste marktkapitalisatie te overtreffen.</p>
<h2 id="h2-Markttrends20ACT20steeg20meer20dan202020keer20op20een20dag20en20de20AIsector20steeg20collectief849608"><a name="Markttrends: ACT steeg meer dan 20 keer op een dag en de AI-sector steeg collectief" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: ACT steeg meer dan 20 keer op een dag en de AI-sector steeg collectief</h2><h3 id="h3-Markt20Hotspots963836"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>-De on-chain meme coins ACT en PNUT zijn gestegen, waarbij ACT tijdens de dag meer dan 20 keer is gestegen. ACT is een van de twee AI-memes die gedoneerd zijn door a16z, de andere is GOAT; De huidige circulerende marktkapitalisatie van ACT is $400 miljoen, en de circulerende marktkapitalisatie van GOAT is $820 miljoen. ACT heeft meer mainstream beurzen genoteerd en de marktkapitalisatie heeft nog steeds wat ruimte voor verbetering. PNUT is een eekhoornmeme-project waar Musk vaak op Twitter verscheen, met een dagelijkse stijging van meer dan 8 keer. Het is zeer waarschijnlijk dat het in de toekomst de steun van Musk zal blijven ontvangen, en de huidige circulerende marktkapitalisatie van PNUT is $390 miljoen;</p>
<p>-De goed gevestigde meme leider DOGE blijft stijgen, met een dagelijkse stijging van bijna 20% en een marktkapitalisatie van $50 miljard, waarmee het op de 6e plaats staat in de hele markt en 40% achterloopt <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> dat op de vijfde plaats staat. DOGE is de meest bekende meme zowel binnen als buiten de cryptomarkt, profiterend van de invloed van Musk en de Amerikaanse verkiezingen. DOGE is niet ver verwijderd van het bereiken van een historisch hoogtepunt van $0,7;</p>
<ul>
<li>De AI-sector, inclusief WLD, IO, AI, FET en anderen, is gezamenlijk gestegen. De AI-sector is al een van de belangrijkste verhalen in deze ronde van markttrends, en in combinatie met de populaire prestaties van AI-meme GOAT en ACT is de algehele prestatie van de AI-sector relatief sterk.</li></ul>
<h3 id="h3-Mainstream20Munten929034"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC heeft de $89.000 overschreden, waarmee een nieuw historisch hoogtepunt werd bereikt. Het vriendelijke macro-economische en beleidsbeleid heeft meer vertrouwen in BTC geïnjecteerd;</p>
<p>ETH overtrof $3.300, met een grote instroom van meer dan $200 miljoen in de ETH ETF’s gisteren, wat een record vestigde voor de grootste dagelijkse instroom sinds de notering van de ETH ETF’s;</p>
<p>Altcoins stegen over het algemeen en het totale effect van de AI-sector is goed. Als het Altcoin-seizoen komt, presteren on-chain memes meestal beter.</p>
<h2 id="h2-Macro20nieuws20Amerikaanse20aandelen20sloten20collectief20hoger20waarschijnlijkheid20van20renteverlaging20in20december20afgenomen797570"><a name="Macro nieuws: Amerikaanse aandelen sloten collectief hoger, waarschijnlijkheid van renteverlaging in december afgenomen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: Amerikaanse aandelen sloten collectief hoger, waarschijnlijkheid van renteverlaging in december afgenomen</h2><p>Belangrijke Amerikaanse aandelenindices blijven historische hoogtepunten bereiken. Bij het sluiten van de handel steeg de Dow Jones Industrial Average met 0,69% naar 44.293,13 punten, steeg de S&amp;P 500-index met 0,1% naar 6.001,35 punten en steeg de Nasdaq met 0,06% naar 19.298,76 punten. Dit is de eerste keer in de geschiedenis van de Dow Jones Industrial Average dat deze boven de 44.000 punten sluit, en ook de eerste keer in de geschiedenis van de S&amp;P dat deze boven de 6.000 punten sluit. Aandelen van cryptobedrijven zagen een sterke stijging, waarbij Canaan Technology met meer dan 41% steeg, MicroStrategy met meer dan 25% steeg en Coinbase met meer dan 19% steeg.</p>
<p>Clark Geranen, Chief Market Analyst bij CalBay Investments, verklaarde dat het doorbreken van de 6.000 puntengrens van de S &amp; P 500-index een ‘belangrijke psychologische mijlpaal’ is die mogelijk meer interesse van investeerders in aandelen kan trekken, aangezien er nog steeds een grote hoeveelheid geld wacht in geldmarktfondsen en obligaties. Anderen geloven echter dat de onzekerheid over Trump’s economische vooruitzichten in zijn tweede termijn en de volatiliteit van de obligatiemarkt beleggers  houden op meer turbulentie in de toekomst.</p>
<p>“De eerste reactie van de markt na de verkiezingen is om te kiezen en te beslissen welke beleidsopties aan te pakken. Onze ervaring is dat dergelijke beperkte reacties nooit duurzame investeringsmogelijkheden hebben opgeleverd, en we hebben de neiging om even te pauzeren en potentiële belangrijke beleidsmaatregelen zorgvuldiger te onderzoeken,” zei Paul Christopher, Global Investment Strategy Director bij het Wells Fargo Investment Research Institute.</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 mening van de onderzoeker en vormt geen beleggingsadvies. Alle beleggingen 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 is toegestaan mits 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>