RGFnZWxpamtzIG5pZXV3cyB8IERlIGhhdmlrYWNodGlnZSByZW50ZXZlcmxhZ2luZyB2YW4gZGUgRmVkIHZlcm9vcnphYWt0IGVlbiBkYWxpbmcgdmFuIGRlIG1hcmt0LCBoZXQgYWx0Y29pbi1zZWl6b2VuIHdhY2h0IG5vZyBzdGVlZHMgb3AgZWVuIHRlcnVndHJla2tpbmcgdmFuIGRlIEJUQy1kb21pbmFudGll

2024-12-20, 03:17

<h2 id="h2-Dagelijkse20samenvatting20BTC20ETF20ziet20zeldzame20grote20uitstroom20markt20nog20steeds20in20hebzuchtzone216661"><a name="Dagelijkse samenvatting: BTC ETF ziet zeldzame grote uitstroom, markt nog steeds in hebzuchtzone" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dagelijkse samenvatting: BTC ETF ziet zeldzame grote uitstroom, markt nog steeds in hebzuchtzone</h2><p>Volgens Farside Investors, de VS. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De spot ETF had gisteren een nettostroom van $671 miljoen. Daarvan had Fidelity’s FBTC een uitstroom van $208 miljoen, Grayscale’s BTC een uitstroom van $188 miljoen en de gegevens van BlackRock moeten nog worden bijgewerkt.</p>
<h3 id="h3-De20Amerikaanse20Ethereum20spot20ETF20zag20een20nettostroom20van206020miljoen20waarbij20Bitwise20ETHW20en20Grayscale20ETHE20respectievelijk20uitstromen20van206820miljoen20en2058120miljoen20zagen20Ook20de20gegevens20van20BlackRocks20ETHA20zijn20nog20in20behandeling444564"><a name="De Amerikaanse Ethereum spot ETF zag een nettostroom van $60 miljoen, waarbij Bitwise ETHW en Grayscale ETHE respectievelijk uitstromen van $6,8 miljoen en $58,1 miljoen zagen. Ook de gegevens van BlackRock’s ETHA zijn nog in behandeling." class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Amerikaanse <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> spot ETF zag een nettostroom van $60 miljoen, waarbij Bitwise ETHW en Grayscale ETHE respectievelijk uitstromen van $6,8 miljoen en $58,1 miljoen zagen. Ook de gegevens van BlackRock’s ETHA zijn nog in behandeling.</h3><p>Crypto Fear and Greed Index daalt naar 74, markt nog steeds in hebzucht<br>Volgens Alternative.me daalde de Crypto Fear and Greed Index vandaag naar 74 (van 75 gisteren), wat aangeeft dat hoewel de marktenthousiasme iets is afgekoeld, het nog steeds in een ‘hebzucht’ zone bevindt.</p>
<p>(Opmerking: De Fear and Greed Index leest 0-100 en wordt berekend op basis van verschillende factoren, waaronder volatiliteit (25%), marktomvang (25%), sentiment op sociale media (15%), enquêtes (15%), de marktdominantie van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (10%) en Google Trends (10%).)</p>
<h3 id="h3-VIX20Index20stijgt20met207420wat20erop20wijst20dat20Bitcoin20mogelijk20een20lokale20bodem20heeft20bereikt400956"><a name="VIX Index stijgt met 74%, wat erop wijst dat Bitcoin mogelijk een lokale bodem heeft bereikt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>VIX Index stijgt met 74%, wat erop wijst dat Bitcoin mogelijk een lokale bodem heeft bereikt</h3><p>Volgens CoinDesk steeg de CBOE Volatility Index (VIX) gisteren met 74%, wat de grootste stijging op één dag markeert sinds februari 2018 en de op één na hoogste ooit. Deze piek werd veroorzaakt door de renteverlaging van 25 basispunten door de Fed en de havikachtige opmerkingen van Jerome Powell, wat leidde tot paniek op de markt. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> zakte kort onder $100.000, terwijl de Amerikaanse aandelen ongeveer 3% daalden.</p>
<p>Historisch gezien duiden scherpe stijgingen in de VIX er vaak op dat Bitcoin een lokaal dieptepunt heeft bereikt. Bijvoorbeeld, nadat de VIX in februari 2018 met 116% steeg, herstelde Bitcoin van $6.891 naar meer dan $11.000. Op soortgelijke wijze, in augustus 2024, toen de VIX met 65% steeg, herstelde Bitcoin van $54.000 naar $64.000.</p>
<h3 id="h3-Top20Trader20Eugene20Momenteel20gericht20op20SOL20onder20belangrijke20munten886322"><a name="Top Trader Eugene: Momenteel gericht op SOL onder belangrijke munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Top Trader Eugene: Momenteel gericht op SOL onder belangrijke munten</h3><p>Tophandelaar Eugene Ng Ah Sio legde uit waarom hij momenteel gefocust is op SOL onder belangrijke munten:</p>
<p>Op alle grafieken (SOLBTC, SOLETH en SOLUSD) bevinden we ons op of in de buurt van de ‘waarde’-niveaus op hogere tijdframes (HTF).</p>
<ol>
<li><p>De huidige waardering onder $200 biedt vandaag een goede instapmogelijkheid voor bulls.</p>
</li><li><p>De financieringsrente is afgenomen en is nu negatief, wat erop wijst dat er enige vorm van doorlopend contracthedging plaatsvindt, aangezien het open interest (OI) nauwelijks is veranderd. Dit suggereert dat meerdere marktdeelnemers SOL gebruiken om te hedgen in korte posities vanwege verzwakte momentum sinds SOL piekte op $260.</p>
</li></ol>
<p>Zoals @docXBT al zei, zijn dit belangrijke niveaus om te respecteren, vooral op hogere tijdframes. Als stier ben ik bereid om op deze niveaus in te stappen. Als deze niveaus echter niet standhouden, kunnen we snel in een risicovolle zone belanden.</p>
<p>Eerder plaatste Eugene Ng Ah Sio dat hij zijn portefeuille ‘opnieuw in evenwicht heeft gebracht en nu volledig bullish is op SOL. Hij heeft ongeveer $1 miljoen verloren aan meme-munten en is nu op zoek naar een herstelmogelijkheid.’</p>
<h2 id="h2-Marktanalyse20USUAL20stijgt20met20meer20dan205020altcoins20dalen20met20meer20dan2020862215"><a name="Marktanalyse: USUAL stijgt met meer dan 50%, altcoins dalen met meer dan 20%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktanalyse: USUAL stijgt met meer dan 50%, altcoins dalen met meer dan 20%</h2><p><strong>Hoogtepunten:</strong><br>-USUAL trotseerde de trend en steeg met meer dan 50%, waarmee het de markt leidde. Usual Labs is een stablecoin-protocol en het stablecoin-product, USD0, is een “collateralized stablecoin” die wordt ondersteund door staatsobligaties (ook wel staatsobligaties genoemd). Vanwege het gebruik van M0 als onderpand, wordt het “USD0” genoemd. Sinds de lancering eind augustus is het circulerende aanbod van USD0 gegroeid tot $ 1,2 miljard. Van 19 december tot vandaag is het circulerende aanbod van USD0 met meer dan $ 200 miljoen toegenomen. De huidige marktkapitalisatie van USUAL is $ 600 miljoen, met een volledig verwaterde waardering (FDV) van $ 5,5 miljard.</p>
<p>-Layer2-protocollen MOVE en SCR zijn gestegen, waarbij MOVE de dag leidt met een stijging van 30%. MOVE heeft momenteel een marktkapitalisatie van $1,88 miljard en staat op de 60e plaats op de markt, nog steeds ver achter populaire Layer2-tokens zoals ARB en OP.</p>
<p><strong>Algemene trends:</strong><br>-BTC is de afgelopen drie dagen gedaald, met zeldzame grote uitstroom van BTC ETF’s. De markt zal waarschijnlijk op lagere niveaus consolideren op korte termijn, maar op middellange tot lange termijn blijft de prijs van BTC op een bodem.</p>
<p>-ETH is gedaald tot onder de $3.400, en is vier opeenvolgende dagen gedaald, zwaar beïnvloed door de algemene marktdaling.</p>
<p>-Altcoins zijn over het algemeen lager, met de meeste altcoins die meer dan 20% verlies lijden gedurende de dag. Het altcoin-seizoen staat nog steeds on hold en we moeten mogelijk wachten op een terugtrekking van de BTC-dominantie voordat het kan beginnen.</p>
<h2 id="h2-Macro20Nieuws20Amerikaanse20aandelenindices20fluctueren20terwijl20de20markt20zich20aanpast20aan20de20havikachtige20houding20van20de20Fed699103"><a name="Macro Nieuws: Amerikaanse aandelenindices fluctueren terwijl de markt zich aanpast aan de havikachtige houding van de Fed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Amerikaanse aandelenindices fluctueren terwijl de markt zich aanpast aan de havikachtige houding van de Fed</h2><p>Amerikaanse aandelenindices hadden gemengde resultaten: de S&amp;P 500 daalde met 0,09% naar 5.867,08, de Dow Jones steeg met 0,04% naar 42.342,24 en de Nasdaq daalde met 0,10% naar 19.372,77. Het rendement op 10-jarige Amerikaanse staatsobligaties bedraagt ​​4,57% en het rendement op 2-jarige obligaties, dat het meest gevoelig is voor het beleid van de Fed, bedraagt ​​4,32%.</p>
<p>Na de havikachtige renteverlaging van de Fed en de voorspelling van vertraging van versoepeling volgend jaar, verzwakten de langlopende Amerikaanse schatkistobligaties op donderdag en werd de rendementscurve steiler dan ooit in ongeveer 30 maanden. Het rendement op 2-jarige schatkistobligaties daalde met 6 basispunten naar 4,295%, terwijl het rendement op 10-jarige obligaties steeg met 4 basispunten naar 4,56%, op het hoogste niveau sinds mei. Het rendement op 2-jarige obligaties ligt nu 0,26 procentpunten lager dan het rendement op 10-jarige obligaties. De steilheid van de rendementscurve wordt toegeschreven aan aanhoudende inflatie en economische veerkracht, waardoor beleggers terughoudend zijn om langlopende obligaties aan te houden.<br>Ian Lyngen, hoofd van de Amerikaanse rentestrategie bij BMO Capital Markets, merkte op dat ‘de zwakte in langlopende obligaties te wijten is aan de havikachtige houding van de Fed en de druk van het groeiende aanbod van schatkistobligaties. De trend van een steilere rendementscurve zal waarschijnlijk doorgaan tot 2024’.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> icing</strong>, Gate.io-onderzoeker<br><div>Vertaler: Sally<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten 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 op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>