RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBicmVla3QgZG9vciAkMTA3LjAwMCwgYmVyZWlrdCBlZW4gbmlldXcgaGlzdG9yaXNjaCBob29ndGVwdW50LCBGTE9LSSBTdWJjb2luIENBVCBzdGVlZyBtZXQgNDAl

2024-12-17, 04:31

<p><img src="https://gimg2.gateimg.com/image/article/173440971312.17.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETFs20blijven20grote20instroom20ontvangen20HYPE20blijft20sterk20stijgen20en20trekt20marktaandacht235958"><a name="Crypto Dagelijkse Samenvatting: BTC ETF’s blijven grote instroom ontvangen, HYPE blijft sterk stijgen en trekt marktaandacht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF’s blijven grote instroom ontvangen, HYPE blijft sterk stijgen en trekt marktaandacht</h2><p>Volgens de gegevens van Farside Investors was er gisteren een nettostroom vanuit de VS. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De netto-instroom van spot-ETF’s bedroeg $637,5 miljoen. BlackRock IBIT had een netto-instroom van $418,8 miljoen, Fidelity FBTC had een netto-instroom van $116,1 miljoen en Ark ARKB had een netto-instroom van $47,7 miljoen.</p>
<p>Gisteren was er een nettostroom van Amerikaanse <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De netto-inflow van spot-ETF was $20,4 miljoen. Bitwise ETHW had een netto-inflow van $8,7 miljoen, Grayscale ETH had een netto-inflow van $7,6 miljoen en de gegevens van BlackRock’s ETHA zijn nog niet bijgewerkt.</p>
<p><strong>HYPE’s marktkapitalisatie overtreft LTC en staat op de 26e plaats op de cryptoranglijst, tijdelijk gerapporteerd op $9.3 miljard </strong></p>
<p>Volgens Hyperliquid-gegevens bleef HYPE zijn opwaartse trend voortzetten en brak door de $28, met een stijging van 13,26% in 24 uur, waarmee een nieuw historisch hoogtepunt werd bereikt. De marktkapitalisatie werd tijdelijk gerapporteerd op $9,3 miljard, waarmee LTC werd overtroffen om op de 26e plaats te komen op de cryptoranglijst, met een handelsvolume van $336 miljoen in 24 uur.</p>
<p>Volgens de gegevens van DefiLlama bedraagt het huidige TVL-rapport van Hyperliquid $3,114 miljard, en het platform heeft al activa (ondersteuning van USDC en USDT) van $2,164 miljard binnengehaald.</p>
<p>Hyperliquid is een Layer1 blockchain die speciaal is ontworpen voor gedecentraliseerde derivatenhandel, en de mainnet is nog niet gelanceerd. Op dit moment heeft Hyperliquid nog geen enkele investering geaccepteerd. Op dit moment moeten on-chain stortingen en opnames van Hyperliquid nog steeds via Arbitrarum worden overbrugd, en meer dan 60% van de USDC-tokens op de Arbitrarum-keten worden aangehouden door Hyperliquid-adressen.</p>
<p><strong>De marktkapitalisatie van het DeSci-project ResearchCoin (RSC) heeft kortstondig meer dan $140 miljoen bereikt, waarmee een nieuw historisch hoogtepunt is bereikt.</strong></p>
<p>Volgens de marktinformatie van Gate.io heeft de marktkapitalisatie van het DeSci-project ResearchCoin (RSC) kortstondig $140 miljoen overschreden, waarmee een nieuw historisch hoogtepunt is bereikt. Het wordt nu gerapporteerd op $113 miljoen, met een stijging van 16,87% in 24 uur.</p>
<p>ResearchCoin is een crypto-onderzoeksplatform mede-opgericht door Coinbase CEO Brian Armstrong en anderen, behorend tot de DeSci (gedecentraliseerde wetenschap) track. Het project heeft als doel het traditionele publicatiemodel van wetenschappelijke tijdschriften te veranderen. Gebruikers verdienen ResearchCoins (RSC’s) door inhoud te publiceren op ResearchHub, en het aantal RSC’s dat ze ontvangen is evenredig met de waarde van de inhoud die door andere communityleden wordt waargenomen.</p>
<p><strong>MicroStrategy verhoogt de holdings van 15.350 BTC met ongeveer $1,5 miljard</strong></p>
<p>Gisteravond plaatste de oprichter van MicroStrategy, Michael Saylor, op sociale media dat MicroStrategy zijn bezit van 15.350 Bitcoins heeft vergroot tegen een gemiddelde prijs van ongeveer $100.386, met een totale waarde van ongeveer $1,5 miljard.</p>
<p>Op dit moment bezit MicroStrategy 439.000 Bitcoins met een totale aankoopprijs van ongeveer $27,1 miljard en een gemiddelde aankoopprijs van ongeveer $61.725.</p>
<h2 id="h2-Markttrends20BTC20blijft20sterk20Cat20Meme20Coin20CAT20stijgt570248"><a name="Markttrends: BTC blijft sterk, Cat Meme Coin CAT stijgt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC blijft sterk, Cat Meme Coin CAT stijgt</h2><h3 id="h3-Markt20Hotspots250159"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De nieuwe munt VANA is gelanceerd en na de lancering steeg de prijs van VANA even boven de $35. De huidige stijging is echter afgenomen tot ongeveer 40%. VANA is een EVM-compatibele Layer1 blockchain met een huidige circulatie van ongeveer 30% en een marktkapitalisatie van $800 miljoen. De gemeenschap gelooft dat de rat trap van VANA ernstig is en in werkelijkheid zijn er niet veel tokens in handen van echte gebruikers terechtgekomen.</p>
<p>Meme coin CAT is met meer dan 40% gestegen. CAT is een subcoin van de goed gevestigde trending meme coin FLOKI. In september van dit jaar heeft FLOKI CAT-tokens uitgedeeld aan gebruikers die meer dan 400.000 FLOKI-tokens bezitten. Op het moment van de airdrop bedroeg de marktkapitalisatie van CAT ongeveer $100 miljoen en de huidige circulerende marktkapitalisatie van CAT is $410 miljoen. Wanneer de marktkapitalisatie van een gevestigde coin te groot is om gemakkelijk te verkopen, is het uitdelen van een andere token om de marktkapitalisatie te splitsen en vervolgens te verkopen om populariteit te winnen een andere manier om een gevestigde coin te beheren.</p>
<h3 id="h3-Mainstream20Munten126366"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC blijft sterk, brak vanochtend door de $107.000, terwijl BTCD de afgelopen week is blijven stijgen;</p>
<p>ETH is relatief sterk en consolideert nog steeds rond $4,000. ETH presteert minder goed dan SOL in de beginfase van deze markttrend, en de huidige wisselkoers ETH/SOL is omgekeerd;</p>
<p>Altcoins hebben over het algemeen een terugval ervaren, BTC steeg door bloedzuigende activiteiten, en er komen geen nieuwe hete onderwerpen op de markt naar voren. Trending projecten op SOL en <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> kettingen tijdelijk gestopt.</p>
<h2 id="h2-Macro20nieuws20De20Amerikaanse20aandelenmarkt20is20gemengd20op20en20neer20gegaan20en20de20Fed20zal20deze20week20vroeg20op20donderdagochtend20haar20rentevergadering20houden397610"><a name="Macro nieuws: De Amerikaanse aandelenmarkt is gemengd op en neer gegaan, en de Fed zal deze week vroeg op donderdagochtend haar rentevergadering houden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: De Amerikaanse aandelenmarkt is gemengd op en neer gegaan, en de Fed zal deze week vroeg op donderdagochtend haar rentevergadering houden</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt schommelden, waarbij de S&amp;P 500-index met 0,38% steeg tot 6.074,08 punten; De Dow Jones Industrial Average daalde met 0,25% tot 43.717,48 punten; De Nasdaq-index steeg met 1,24% en sloot af op 20.173,89 punten. Het referentiepunt voor de 10-jaars Amerikaanse staatsobligatierendement is 4,39%, terwijl het rendement van de 2-jaars Treasury, het meest gevoelig voor het rentebeleid van de Federal Reserve, 4,25% bedraagt.</p>
<p>Volgens CME’s ‘FedWatch’ is de waarschijnlijkheid dat de Fed de huidige rentetarieven ongewijzigd houdt tot december 4,6%, en de waarschijnlijkheid van een cumulatieve renteverlaging van 25 basispunten is 95,4%. Het rapport van Goldman Sachs suggereert dat de Federal Reserve kan aangeven het tempo van renteverlagingen te vertragen tijdens de vergadering van deze week. Hoewel het deze week nog steeds de rente met 25 basispunten zal verlagen, duiden de recente opmerkingen van de Fed op een bereidheid om te vertragen, waaronder lagere dan verwachte werkloosheidscijfers in de VS en inflatie nog steeds boven de doelstelling. Goldman Sachs voorspelt dat de Federal Reserve de rentetarieven zal blijven verlagen in maart, juni en september volgend jaar, met uiteindelijke tarieven iets hoger dan 3,5% tot 3,75%.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Glacé</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; 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 als referentie wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>