RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBFVEYncyBoZXJ2YXR0ZW4gZ3JvdGUgbmV0dG9zdHJvbWVuIGVuIEJUQyBkb21pbmFudGllcGVyY2VudGFnZSBrZWVydCB0ZXJ1ZyBuYWFyIGVlbiBob29ndGVwdW50IHZhbiA1NyU=

2024-12-27, 03:14

<p><img src="https://gimg2.gateimg.com/image/article/173526914512.27.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20BTC20ETFs20hervatten20grote20netto20instroom20Jupiter20van20plan20om20volgende20maand2070020miljoen20JUP20te20airdroppen709158"><a name="Crypto Dagelijks Overzicht: BTC ETF’s hervatten grote netto instroom, Jupiter van plan om volgende maand 700 miljoen JUP te airdroppen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: BTC ETF’s hervatten grote netto instroom, Jupiter van plan om volgende maand 700 miljoen JUP te airdroppen</h2><p>Volgens gegevens van Farside Investors, de Verenigde Staten <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De spot ETF had gisteren een nettostroom van $475 miljoen. BlackRock IBIT had een nettostroom van $56,5 miljoen, Fidelity FBTC had een nettostroom van $254 miljoen en Ark ARKB had een nettostroom van $187 miljoen.</p>
<p>Gisteren, de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De spot ETF kende een nettostroom van $89 miljoen. Fidelity FETH had een instroom van $83 miljoen, en de gegevens van BlackRock’s ETHA zijn nog niet bijgewerkt.</p>
<p><strong>Citi-analist: Cryptocurrencies worden verwacht sterke groei te zien in 2025</strong></p>
<p>Citi-analisten voorspellen sterke groei voor cryptocurrencies in 2025, gedreven door het beleid van Trump, toenemende instroom van ETF’s en innovatie van stablecoins. De beweging van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> boven $100.000 kan slechts het begin zijn.</p>
<p>De SEC-nominaties van Trump en zijn pro-crypto houding hebben een markt gevormd die vriendelijker is voor digitale activa. ETF’s hebben de deur geopend voor meer investeerders, terwijl de voortdurende ontwikkeling van stablecoins de groei van gedecentraliseerde financiën (DeFi) heeft gestimuleerd.</p>
<p><strong>Als <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Als het bedrag hoger is dan $97,000, zal de cumulatieve liquiditeitsintensiteit van short orders van mainstream CEX 483 miljoen bereiken</strong></p>
<p>Volgens Coinglass-gegevens, als Bitcoin door $ 97.000 breekt, zal de cumulatieve liquidatie-intensiteit van de short-bestelling op mainstream CEX 483 miljoen bereiken. Daarentegen, als Bitcoin onder de $ 95.000 daalt, zal de cumulatieve liquidatie-intensiteit van de long-bestelling op mainstream CEX 272 miljoen bereiken.</p>
<p>De liquidatiegrafiek toont in hoeverre de onderliggende prijs zal worden beïnvloed wanneer deze een bepaalde positie bereikt. Een hogere ‘liquidatiebalk’ geeft aan dat de prijs sterker zal reageren op de liquiditeitsgolf later.</p>
<p><strong>Jupiter is van plan om volgende maand 700 miljoen JUP uit te delen via een airdrop, en het aantal in aanmerking komende wallets is ongeveer 2,3 miljoen.</strong></p>
<p>Jupiter heeft aangekondigd dat het volgende maand een Jupuary airdrop zal houden, met in totaal 700 miljoen JUP-tokens ter waarde van meer dan $590 miljoen. Het totale bedrag aan JUP dat aan gebruikers is toegewezen, is 425 miljoen, waarvan 75 miljoen JUP gereserveerd zijn voor stakers.</p>
<p>Er zijn ongeveer 2,3 miljoen in aanmerking komende portefeuilles, waaronder 2 miljoen Swap-handelsgebruikers en 320.000 professionele handelaren, die een beloning van 0,1 JUP kunnen ontvangen voor elke 1 JUP die wordt gestaked. Jupiter benadrukte dat het distributieplan een concept is en onderhevig is aan aanpassingen.</p>
<h2 id="h2-Markttrends20Nieuwe20munten20ME20PENGU20en20anderen20stegen20Altcoins20ontbreken20nieuwe20verhalen308235"><a name="Markttrends: Nieuwe munten ME, PENGU en anderen stegen, Altcoins ontbreken nieuwe verhalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Nieuwe munten ME, PENGU en anderen stegen, Altcoins ontbreken nieuwe verhalen</h2><h3 id="h3-Markt20Hotspots347926"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>MIRA, een nieuwe meme-token op de keten, is gestegen en bijna 100 keer gestegen in 4 uur; MIRA is het verhaal van de vader van een dokter die zijn dochter behandelt voor een zeldzame ziekte. Het is geretweet door Desci’s populaire project BIO, en de tokenprijs is scherp gedaald;</p>
<p>Nieuwe munten ME, THE, MOVE, PENGU en anderen stegen. De verkoopdruk van airdrops van particuliere beleggers na de lancering van deze nieuwe munten was in feite uitgeput, maar de stijging was niet duidelijk en het marktperspectief blijft nog te bezien.</p>
<h3 id="h3-Mainstream20Munten254452"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC steeg naar ongeveer $100.000 gedurende de dag en viel toen terug. Het consolideert momenteel rond de $96.000. Er was gisteren een grote instroom in BTC ETF, maar de prijs werd niet direct weerspiegeld in de prijs van BTC, en de korte termijn markttrend is onduidelijk;</p>
<p>ETH daalde onder de $3.400 en viel niet verder. De ETH ETF behield ook grote nettostromen;</p>
<p>Altcoins vielen over het algemeen terug en de markt ontbrak aan nieuwe verhalen.</p>
<h2 id="h2-Macro20Nieuws20De20drie20belangrijkste20Amerikaanse20aandelenindexen20vertoonden20verschillende20trends20en20de20kans20dat20de20Fed20de20rente20in20januari20ongewijzigd20laat20is20872475366"><a name="Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindexen vertoonden verschillende trends, en de kans dat de Fed de rente in januari ongewijzigd laat is 87,2%." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: De drie belangrijkste Amerikaanse aandelenindexen vertoonden verschillende trends, en de kans dat de Fed de rente in januari ongewijzigd laat is 87,2%.</h2><p>De drie belangrijkste Amerikaanse aandelenindices hadden gemengde trends, waarbij de S&amp;P 500-index met 0,04% daalde tot 6.037,59 punten; de Dow Jones-index steeg met 0,07% tot 43.325,80 punten; en de Nasdaq-index daalde met 0,05% tot 20.020,36 punten. Het referentiepunt voor de 10-jarige Amerikaanse staatsleningen is 4,58% en het 2-jarige rendement op Amerikaanse staatsleningen, dat het meest gevoelig is voor het rentetarief van de Fed, bedraagt 4,30%.</p>
<p>Volgens CME’s “FedWatch” is de kans dat de Fed de rente in januari volgend jaar ongewijzigd zal laten 87,2%, en de kans op een renteverlaging met 25 basispunten is 12,8%. De kans dat de huidige rente ongewijzigd blijft in maart volgend jaar is 50,6%, de kans op een cumulatieve renteverlaging van 25 basispunten is 44,1%, en de kans op een cumulatieve renteverlaging van 50 basispunten is 5,4%.</p>
<p>Orient Securities zei dat de vergadering van de Federal Reserve in december kan worden beschouwd als het duidelijke keerpunt van de Fed. Na de vergadering werd de markt snel geprijsd. Momenteel is volgens de prijzen van futures op de federal funds rate het aantal verwachte renteverlagingen in 2025 slechts 1,5 keer, met een termijn van 1 jaar. De verwachting van het forward FFR-punten is aangepast naar 30bp. Vanuit dit oogpunt heeft de markt in feite de havikachtige prijsstelling van het monetaire beleid voltooid. Gezien het feit dat de havikachtige verwachtingen van de markt voor de Federal Reserve in 2025 in feite volledig zijn verhandeld, kan de Amerikaanse dollarindex dicht bij de top liggen. Als harde indicatoren zoals werkgelegenheid en werkloosheidscijfers in de daaropvolgende economische fundamenten aanzienlijk verslechteren, kan dit een sleutelknooppunt worden dat de correctietrend van de Amerikaanse dollarindex in gang zet.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Icing</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; 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 mits 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>