RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBicmVla3Qgdm9vciBkZSBlZXJzdGUga2VlciAkMTAwLjAwMCwgQWx0Y29pbnMgYmxpanZlbiBzdGlqZ2Vu

2024-12-05, 03:22

<p><img src="https://gimg2.gateimg.com/image/article/173337846012.05.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20Doorbreekt20voor20de20Eerste20Keer2010000020Altcoins20Blijven20Rally20Voortzetten639414"><a name="Crypto Dagelijkse Samenvatting: BTC Doorbreekt voor de Eerste Keer $100,000, Altcoins Blijven Rally Voortzetten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC Doorbreekt voor de Eerste Keer $100,000, Altcoins Blijven Rally Voortzetten</h2><p>Trump nomineert Paul Atkins als voorzitter van de SEC; <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptocurrency markt</a> ervaart een terugval na een breedgedragen rally.</p>
<p>Op 5 december kondigde de Republikeinse president Donald Trump woensdag aan dat hij Paul Atkins zou voordragen als voorzitter van de Amerikaanse Securities and Exchange Commission (SEC).</p>
<h3 id="h3-MicroStrategy20verkoopt20meer20dan20620miljard20aan20converteerbare20obligaties20om20Bitcoin20te20kopen20Hedgefondsen20kopen20voor20arbitrage20weddenschappen184616"><a name="MicroStrategy verkoopt meer dan $6 miljard aan converteerbare obligaties om Bitcoin te kopen; Hedgefondsen kopen voor arbitrage weddenschappen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MicroStrategy verkoopt meer dan $6 miljard aan converteerbare obligaties om <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> te kopen; Hedgefondsen kopen voor arbitrage weddenschappen</h3><p>Eli Pars, Co-Chief Investment Officer bij Calamos Advisors LLC, is een van de kopers van de meer dan $6 miljard aan converteerbare obligaties die dit jaar door MicroStrategy zijn verkocht, die worden gebruikt om voortdurend uit te breiden. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> reserves. Net als veel andere managers maakt Pars gebruik van deze notities voor marktneutrale arbitrage-inzetten, waarbij ze profiteren van de aanzienlijke volatiliteit van de onderliggende activa.</p>
<h3 id="h3-Vertegenwoordiger20van20de20ZuidKoreaanse20regeringspartij20roept20opnieuw20op20tot20het20aftreden20van20president20Yoon20Sukyeol20terwijl20hij20ook20probeert20de20afzettingsmotie20tegen20hem20te20blokkeren16026"><a name="Vertegenwoordiger van de Zuid-Koreaanse regeringspartij roept opnieuw op tot het aftreden van president Yoon Suk-yeol, terwijl hij ook probeert de afzettingsmotie tegen hem te blokkeren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vertegenwoordiger van de Zuid-Koreaanse regeringspartij roept opnieuw op tot het aftreden van president Yoon Suk-yeol, terwijl hij ook probeert de afzettingsmotie tegen hem te blokkeren</h3><p>Han Dong-hoon, de vertegenwoordiger van de regeringspartij van Zuid-Korea, heeft opnieuw opgeroepen tot het aftreden van president Yoon Suk-yeol, maar probeert ook de afzettingsmotie tegen hem te blokkeren.</p>
<h3 id="h3-Putin20Bitcoin20is20beter20dan20dollarreserves20niemand20kan20Bitcoin20verbieden923328"><a name="Putin: Bitcoin is beter dan dollarreserves; niemand kan Bitcoin verbieden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Putin: Bitcoin is beter dan dollarreserves; niemand kan Bitcoin verbieden</h3><p>De Russische president Vladimir Putin stelde woensdag de noodzaak van het aanhouden van deviezenreserves ter discussie en verklaarde dat dergelijke reserves gemakkelijk voor politieke redenen kunnen worden geconfisqueerd. Hij gaf aan dat het investeren van deze reserves binnenlands aantrekkelijker is.</p>
<h3 id="h3-November20CEX20Handelsvolume20bereikt2027120biljoen20hoogste20niveau20sinds20mei20202133587"><a name="November CEX Handelsvolume bereikt $2,71 biljoen, hoogste niveau sinds mei 2021" class="reference-link"></a><span class="header-link octicon octicon-link"></span>November CEX Handelsvolume bereikt $2,71 biljoen, hoogste niveau sinds mei 2021</h3><p>Volgens gegevens van The Block Pro bereikte het handelsvolume op CEX $2,71 biljoen in november, het hoogste niveau sinds mei 2021 ($4,16 biljoen).</p>
<h3 id="h3-Privacy20Blockchain20Namada20voltooit20fase20120van20Mainnetlancering726059"><a name="Privacy Blockchain Namada voltooit fase 1 van Mainnet-lancering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Privacy Blockchain Namada voltooit fase 1 van Mainnet-lancering</h3><p>De privacy blockchain Namada heeft de voltooiing van fase 1 van zijn mainnet-lancering aangekondigd, waarbij staking- en governance-functies nu live zijn.</p>
<p>Meitu verkoopt ongeveer 31.000 <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en 940 Bitcoin<br>Volgens marktnieuws heeft Meitu ongeveer 31.000 <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en 940 Bitcoin verkocht. Het bedrijf verklaarde dat ongeveer 80% van de opbrengst van de cryptocurrency-verkopen zal worden gebruikt om speciale dividenden te betalen.</p>
<h2 id="h2-Marktanalyse20ETH20wint20kracht20ten20opzichte20van20BTC20Altcoins20ervaren20rotatie360751"><a name="Marktanalyse: ETH wint kracht ten opzichte van BTC; Altcoins ervaren rotatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktanalyse: ETH wint kracht ten opzichte van BTC; Altcoins ervaren rotatie</h2><h3 id="h3-Markthoogtepunten411808"><a name="Markthoogtepunten:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markthoogtepunten:</h3><ul>
<li>De altcoin-seizoensindex is gestegen tot 90. Na een stijging van altcoins was er vanochtend een kleine terugval. De RWA-sector en CEX-platformtokens, die gisteren nog de winst leidden, hebben ook correcties gezien, terwijl Virtuals Protocol en <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">Tron</a> ecosysteemtokens zijn de weg aan het leiden.</li></ul>
<p>-Gegevens tonen aan dat sinds 5 november de totale marktkapitalisatie van cryptocurrency exclusief BTC (TOTAL2) eenzijdige opwaartse trend heeft ervaren, met een stijging van ongeveer 98,8% na een dieptepunt van $856,1 miljard bereikt te hebben op 5 november. De altcoin seizoensindex heeft de 90 overschreden, en bereikte een nieuw hoogtepunt voor het jaar. Ondertussen is het marktaandeel van Bitcoin (BTC.D) gedaald naar 51,4%, een daling van 10,38% vanaf het hoogtepunt van 61,78% op 21 november.</p>
<p>-Beïnvloed door vermeldingen op grote beurzen, stegen tokens zoals MOG, KAIA, GIGA, AERO en TURBO gisteravond.</p>
<p>-Belangrijke beurzen, waaronder Gate.io, zullen naar verwachting op 9 december MOVE (Movement) spot trading lanceren. Movement is een populair geparelliseerd Move-EVM-protocol.</p>
<h3 id="h3-Markttrends335306"><a name="Markttrends:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends:</h3><p>-BTC is gestaag gestegen en heeft voor het eerst de $100.000 grens doorbroken. Gisteren zagen Bitcoin spot ETF’s een nettostroom van $550 miljoen. Gegevens geven aan dat het aanbod van korte termijn houders (STH) bijna 3,28 miljoen Bitcoin heeft bereikt, een niveau dat historisch geassocieerd wordt met marktpieken. Dit suggereert toenemende retailinteresse. Toch zet de toegenomen winstneming door langetermijnhouders (LTH) druk op de opwaartse momentum van Bitcoin, wat verdere winsten kan belemmeren.</p>
<p>-ETH is voorbij $3.800 gestegen, wat een stijging van 3,71% betekent in de afgelopen 24 uur. ETH spot ETF’s hebben significant netto instroom gezien gedurende tien opeenvolgende werkdagen, wat bijdraagt aan een groeiend bullish sentiment op de markt.</p>
<p>-De marktdominantie van Bitcoin is licht gestegen, terwijl altcoins blijven een stijgende trend handhaven. Het gevestigde DeFi- uitleenprotocol <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Compound</a>(COMP) heeft een snelle opleving doorgemaakt, met een stijging van 40% in 24 uur, waarmee een nieuw hoogtepunt voor meerdere maanden wordt bereikt.</p>
<h2 id="h2-Macro20Federal20Reserve20verwacht20pauze20in20renteverlagingen20Amerikaanse20aandelenindices20sluiten20hoger798355"><a name="Macro: Federal Reserve verwacht pauze in renteverlagingen; Amerikaanse aandelenindices sluiten hoger" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Federal Reserve verwacht pauze in renteverlagingen; Amerikaanse aandelenindices sluiten hoger</h2><p>Fed-voorzitter Jerome Powell verklaarde onlangs dat de toestand van de Amerikaanse economie beter is dan verwacht sinds september, wat erop wijst dat de Federal Reserve voorzichtiger kan zijn met renteverlagingen. Vanwege de sterke Amerikaanse economie kan de Fed enige terughoudendheid betrachten bij het verlagen van de rente.</p>
<p>Deze verklaring werd door de markt geïnterpreteerd als lichtelijk havikachtig, maar er werd niet direct ingegaan op de vraag of er in december een renteverlaging zou plaatsvinden, wat enige onzekerheid laat bestaan over de verwachtingen voor toekomstige renteverlagingen. Alle drie de belangrijkste Amerikaanse aandelenindices sloten hoger, waarbij aandelen gerelateerd aan cryptocurrency de winsten aanvoerden.</p>
<p>Bovendien heeft de formele nominatie van Paul Atkins door Trump als voorzitter van de SEC een korte termijnsboost gegeven aan de cryptocurrency-markt. Vergeleken met de huidige voorzitter van de SEC, Gary Gensler, wordt verwacht dat Atkins een meer toegeeflijke houding aanneemt ten opzichte van cryptocurrencies, met plannen om meerdere regelgevingen te herzien en hervormingen te bevorderen ter bevordering van kapitaalvorming.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Charle Y.</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; verstandige 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 zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>