RGFnZWxpamtzIG5pZXV3cyB8IEFsdGNvaW4tc2Vpem9lbiBpbiB2b2xsZSBibG9laSwgSGlwcG8gTU9PREVORyBzdGlqZ3QgbWVlciBkYW4gMTAwJSBpbnRyYWRheQ==

2024-12-03, 07:16

<h2 id="h2-Crypto20Dagelijks20Overzicht20350M20Grote20Instroom20in20BTC20ETFs20Altcoins20Breed20stijgend651608"><a name="Crypto Dagelijks Overzicht: $350M Grote Instroom in BTC ETF’s, Altcoins Breed stijgend." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: $350M Grote Instroom in BTC ETF’s, Altcoins Breed stijgend.</h2><p>Volgens gegevens van Farside Investor, registreerden Amerikaanse spot BTC ETF’s gisteren een netto instroom van $353M. Onder deze, leidde BlackRock’s IBIT met $338M, terwijl Fidelity’s FBTC een instroom van $25.1M zag.</p>
<p>Op zondag heeft de Amerikaanse <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Spot ETF’s zagen een instroom van $24,2M. BlackRock’s ETHA won $5,59M, Fidelity’s FETH won $1,99M, terwijl Grayscale’s ETHE een uitstroom had van $4,44M.</p>
<h3 id="h3-LTCs20Recent20Surge20Puts20Nearly208020of20Holders20in20Profit772316"><a name="LTC’s Recent Surge Puts Nearly 80% of Holders in Profit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LTC’s Recent Surge Puts Nearly 80% of Holders in Profit</h3><p>Volgens Gate.io marktgegevens is LTC in de afgelopen week meer dan 27% gestegen, waardoor het aantal winstgevende adressen aanzienlijk is toegenomen.</p>
<p>Uit gegevens van IntoTheBlock blijkt dat medio november ongeveer 60% van de LTC-houders winst maakte. Op 2 december was dit percentage gestegen tot bijna 80%, met meer dan 6,37 miljoen LTC-adressen (ongeveer 79,37%) die nu winst maken, zoals blijkt uit de instroom/uitstroommetingen.</p>
<h3 id="h3-Perspectief20Koreas20Crypto20Market20Retail20Volume20Surges20Altcoins20in20Focus702425"><a name="Perspectief: Korea’s Crypto Market Retail Volume Surges; Altcoins in Focus" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perspectief: Korea’s <a href="/price" target="_blank" class="blog_inner_link">Crypto Market</a> Retail Volume Surges; Altcoins in Focus</h3><p>Volgens het nieuwste rapport van 10X Research hebben er sinds Trump’s verkiezing belangrijke veranderingen plaatsgevonden in de handelsactiviteit. Hoewel zijn inauguratie nog zeven weken verwijderd is, wijzen vroege benoemingen op een aanzienlijke verschuiving naar crypto-vriendelijk beleid in de Amerikaanse overheid. Deze trend zal naar verwachting voortduren en mogelijk handelsmogelijkheden uitbreiden.</p>
<p>Overheden in andere landen, met name Zuid-Korea, nemen ook meer crypto-vriendelijke standpunten in. Omdat de VS voorop loopt bij het bepalen van cryptoregulerende trends (of het versoepelen van regelgeving), wordt verwacht dat er een wereldwijde golf van crypto-vriendelijk beleid zal volgen. Kleinere crypto-tokens, waaronder alpha-tokens, kunnen blijven groeien.</p>
<p>In de afgelopen 24 uur is de handelsvolume voor particulieren in Zuid-Korea’s <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> steeg naar $18B, wat het op één na hoogste handelsvolume van dit jaar markeert, waarbij het handelsvolume van $14B van de lokale aandelenmarkt wordt overtroffen. Ripple ( <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>) leidde met een volume van $6,3 miljard, gevolgd door DOGE ($1,6 miljard), XLM ($1,3 miljard), ENS ($900 miljoen), HBAR ($800 miljoen) en SHIB ($600 miljoen). Deze hoogvolatiele cryptocurrencies worden voornamelijk gedreven door particuliere handelaren, die gebruik maken van en de trends op basis van momentum versterken.</p>
<p>BTC financieringspercentages blijven relatief mild, jaarlijks 15%, terwijl de handelsvolumes voor de detailhandel in Zuid-Korea zijn gestegen naar $18B - een historisch verschil. Het is duidelijk dat de huidige focus van de markt op altcoins ligt.</p>
<h3 id="h3-Fed20Hawk20Waller20Geneigd20om20een20renteverlaging20te20ondersteunen20in20december112526"><a name="Fed Hawk Waller: Geneigd om een renteverlaging te ondersteunen in december" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fed Hawk Waller: Geneigd om een renteverlaging te ondersteunen in december</h3><p>Federal Reserve Governor Christopher Waller verklaarde dat hij geneigd is om een renteverlaging te ondersteunen tijdens de vergadering van de Fed later deze maand. Hij merkte echter ook op dat hij open blijft staan voor het handhaven van de rentetarieven.</p>
<p>In een voorbereide toespraak voor de Washington conferentie van maandag zei Waller: ‘Het beleid blijft voldoende restrictief. Een verdere renteverlaging bij de volgende vergadering zal de monetaire beleidskoers niet significant veranderen en laat voldoende ruimte over om het tempo van de verlagingen indien nodig te vertragen om op koers te blijven richting het inflatiedoel.’<br>Waller uitte bezorgdheid over inflatiegegevens die de afgelopen twee maanden iets hoger waren dan verwacht. Hij vergeleek zichzelf met een mixed martial artist die ‘inflatie wurgt, wachtend tot het opgeeft, maar het ontsnapt altijd op het laatste moment.’ Hij benadrukte dat de Fed de inflatie niet opnieuw zal laten versnellen. ‘Overgave is onvermijdelijk; inflatie is nog niet uit de octagon ontsnapt,’ zei hij. Ondanks de recente hardnekkigheid van de inflatie, geven economische gegevens en prognoses aan dat de inflatie terug zal keren naar het 2%-doel van de Fed.</p>
<h2 id="h2-Marktanalyse20MOODENG20stijgt20meer20dan2010020intraday20Oracle20leider20LINK20stijgt20met2040672508"><a name="Marktanalyse: MOODENG stijgt meer dan 100% intraday; Oracle leider LINK stijgt met 40%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktanalyse: MOODENG stijgt meer dan 100% intraday; Oracle leider <a href="/price/link-ln" target="_blank" class="blog_inner_link">LINK</a> stijgt met 40%</h2><h3 id="h3-Markthoogtepunten675214"><a name="Markthoogtepunten:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markthoogtepunten:</h3><p>-MOODENG, een meme-token, steeg meer dan 100% intraday en klom van $0,295 naar $0,68 gisteravond. MOODENG, geïnspireerd door de hippo meme uit Thailand, heeft momenteel een circulerende marktkapitalisatie van $620M, wat wereldwijd op de 211e plaats staat, met aanzienlijk groeipotentieel.</p>
<ul>
<li><a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a>, het toonaangevende oracle-protocol, steeg met meer dan 40%, waardoor de marktkapitalisatie de drempel van $15 miljard overschreed en wereldwijd op de 24e plaats kwam. Als een onmisbaar protocol voor DeFi-projecten, kan de prijsherstel van LINK in deze rally een mogelijke opleving in de DeFi-sector signaleren.<h3 id="h3-Algemene20markttrends640085"><a name="Algemene markttrends:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Algemene markttrends:</h3>-BTC: Daalde kort onder de $94.500 vanmorgen vroeg, maar herstelde zich tot boven $96.000. BTCD blijft dalen en BTC kan een tijdje consolideren.</li></ul>
<p>-ETH: Volgde BTC met lichte terugtrekkingen, maar ETH-ecosysteem en DeFi-projecten zijn aan het opleven.</p>
<p>-Altcoins: Breed stijgend als fondsen <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> in de sector, met memetokens en DeFi-projecten als leiders.</p>
<h2 id="h2-Macronieuws20Gemengde20prestaties20van20de20Amerikaanse20aandelenmarkt20Verdeelde20meningen20over20het20rentebeleid20van20de20Fed137089"><a name="Macro-nieuws: Gemengde prestaties van de Amerikaanse aandelenmarkt; Verdeelde meningen over het rentebeleid van de Fed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro-nieuws: Gemengde prestaties van de Amerikaanse aandelenmarkt; Verdeelde meningen over het rentebeleid van de Fed</h2><p>De Amerikaanse aandelenmarkt vertoonde gemengde prestaties:</p>
<p>De S&amp;P 500 steeg met 0,24% naar 6047,15 punten.</p>
<p>-Dow daalde met 0,29% tot 44782,00 punten.</p>
<p>-Nasdaq steeg met 0,97% tot 19403,95 punten.</p>
<p>Het referentiepunt voor de 10-jaars Treasury-rente stond op 4,19%, terwijl de 2-jaars rente, die gevoeliger is voor Fed-beleidsrentes, op 4,17% stond.</p>
<p>De verlaging van de rente met 25 basispunten door de Fed in november bracht het referentietarief op 4,5%-4,75%. Echter, de laatste notulen van de vergadering temperden het marktsentiment en suggereren dat het traject van renteverlaging binnenkort wellicht zal pauzeren.</p>
<p>Deze tweede renteverlaging van het jaar bedraagt in totaal 75 basispunten, waardoor de referentierente terugkeert naar het niveau van februari 2023. Er is aanzienlijke marktonenigheid over of de Fed zal doorgaan met het verlagen van de rente in december.</p>
<p>Nick Timiraos, de “Fed Whisperer,” merkte op dat functionarissen opties bespraken om de renteverlagingen te vertragen of te pauzeren. Havikachtige vertegenwoordiger Kashkari betoogde dat een renteverlaging van 25 basispunten in december redelijk zou zijn, maar benadrukte zorgen over inflatie. Duifachtige vertegenwoordiger Goolsbee verwacht dat de Fed de rente zal blijven verlagen, tenzij er bewijs is van economische oververhitting.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>icing</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsvoorstellen. 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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>