RGFnZWxpamtzIG5pZXV3cyB8IERlIGNvbnRyb3ZlcnNlIG92ZXIgZGUgWnVpZC1Lb3JlYWFuc2Uga3Jpamdzd2V0IGhlZWZ0IGRlIG1hcmt0ZW4gb25ydXN0aWcgZ2VtYWFrdDsgQlRDIGRhYWxkZSBhYW52YW5rZWxpamsgZW4gc3RlZWcgZGFhcm5hLCBzdGFiaWxpc2VyZW5kIHJvbmQgJDk2LDAwMA==

2024-12-04, 03:37

<p><img src="https://gimg2.gateimg.com/image/article/173328338212.04.png" alt=""></p>
<h2 id="h2-Dagelijks20overzicht20de20controverse20over20de20ZuidKoreaanse20krijgswet20heeft20de20markten20verstoord20BTC20daalde20aanvankelijk20en20steeg20vervolgens20stabiliserend20rond2096000175641"><a name="Dagelijks overzicht: de controverse over de Zuid-Koreaanse krijgswet heeft de markten verstoord; BTC daalde aanvankelijk en steeg vervolgens, stabiliserend rond $96,000" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dagelijks overzicht: de controverse over de Zuid-Koreaanse krijgswet heeft de markten verstoord; BTC daalde aanvankelijk en steeg vervolgens, stabiliserend rond $96,000</h2><p>Gisteravond, de Zuid-Koreaanse <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> ondervond een korte crash als gevolg van de aankondiging van de krijgswet door president Yoon Suk-yeol, waardoor BTC daalde tot ongeveer $63.000 en wat leidde tot aanzienlijke negatieve premies in veel altcoins. Echter, na de stemming van de Nationale Assemblee om het verbod op te heffen, begonnen cryptocurrencies te herstellen, waarbij BTC momenteel stijgt naar ongeveer $96.000 en altcoins ook tekenen van herstel vertonen.</p>
<h3 id="h3-70320Waarschijnlijkheid20dat20de20Federal20Reserve20de20rente20met202520basispunten20verlaagt20in20december846407"><a name="70,3% Waarschijnlijkheid dat de Federal Reserve de rente met 25 basispunten verlaagt in december" class="reference-link"></a><span class="header-link octicon octicon-link"></span>70,3% Waarschijnlijkheid dat de Federal Reserve de rente met 25 basispunten verlaagt in december</h3><p>Volgens de FedWatch-tool van CME is de kans dat de Federal Reserve de huidige rentetarieven handhaaft tot december 29,7%, terwijl de kans op een renteverlaging van 25 basispunten 70,3% is.</p>
<h3 id="h3-Grayscale20past20aan20om20Solana20Trust20om20te20zetten20naar20ETF142127"><a name="Grayscale past aan om Solana Trust om te zetten naar ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Grayscale past aan om <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Trust om te zetten naar ETF</h3><p>Grayscale en de New York Stock Exchange (NYSE) hebben een 19b-4-aanvraag ingediend bij de SEC om de Grayscale <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Trust (GSOL) in een Solana ETF. Bovendien zullen verschillende Solana ETF-aanvragen op 25 januari volgend jaar hun eerste beoordelingsdeadline halen.</p>
<h3 id="h3-Ethereum20Foundation20kondigt20Q3subsidielijst20aan20totaalbedrag20aan20subsidies20bedraagt2012848820miljoen269398"><a name="Ethereum Foundation kondigt Q3-subsidielijst aan, totaalbedrag aan subsidies bedraagt $12.8488 miljoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum Foundation kondigt Q3-subsidielijst aan, totaalbedrag aan subsidies bedraagt $12.8488 miljoen</h3><p>In het derde kwartaal, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De Stichting heeft in totaal $12.8488 miljoen toegewezen aan verschillende projecten, die betrekking hebben op gebieden zoals gemeenschapsonderwijs, consensuslaag, cryptografie en zero-knowledge proofs, ontwikkelaarservaring en -tools, uitvoeringslaag en laag 2.</p>
<h3 id="h3-South20De20regerende20partij20van20Korea20kan20Yoon20Sukyeol20eisen20om20af20te20treden20stelt20kabinetsontslag20en20ontslag20van20minister20van20Defensie20voor123395"><a name="South De regerende partij van Korea kan Yoon Suk-yeol eisen om af te treden, stelt kabinetsontslag en ontslag van minister van Defensie voor" class="reference-link"></a><span class="header-link octicon octicon-link"></span>South De regerende partij van Korea kan Yoon Suk-yeol eisen om af te treden, stelt kabinetsontslag en ontslag van minister van Defensie voor</h3><p>Na de controverse over de staat van beleg hield de regerende People Power Party van Zuid-Korea op 4 december een spoedvergadering om de reacties te bespreken op het besluit van president Yoon Suk-yeol om de staat van beleg op te heffen. Eerder werd Yoon’s aankondiging van “noodstaat van beleg” bekritiseerd door partijvertegenwoordiger Han Dong-hoon als een vergissing.</p>
<h3 id="h3-Fox20News20Reports20Perianne20Boring20Considered20for20CFTC20Chair314076"><a name="Fox News Reports: Perianne Boring Considered for CFTC Chair" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fox News Reports: Perianne Boring Considered for CFTC Chair</h3><p>Volgens berichten van Fox News wordt Perianne Boring overwogen voor de positie van voorzitter van de Commodity Futures Trading Commission (CFTC) onder de regering-Trump.</p>
<h3 id="h3-Curves20geannualiseerde20omzet20in20de20afgelopen203020dagen20nadert203720miljoen20bijna202320meer20dan20vorige20maand975280"><a name="Curve’s geannualiseerde omzet in de afgelopen 30 dagen nadert $37 miljoen, bijna 23% meer dan vorige maand" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Curve’s geannualiseerde omzet in de afgelopen 30 dagen nadert $37 miljoen, bijna 23% meer dan vorige maand</h3><p>Gegevens van Token Terminal tonen aan dat de gedecentraliseerde exchange Curve Finance bijna $37 miljoen aan jaarlijkse omzet heeft behaald in de afgelopen 30 dagen, een bijna 23% stijging ten opzichte van de vorige maand, toe te schrijven aan de stijgende vraag naar hefboomeffecten en de introductie van nieuwe spaarbanken en de scrvUSD token.</p>
<h2 id="h2-Marktanalyse20BTC20heeft20zijn20verliezen20verkleind20en20gestabiliseerd20rond209600020met20opkomende20lokale20markthotspots970727"><a name="Marktanalyse: BTC heeft zijn verliezen verkleind en gestabiliseerd rond $96.000, met opkomende lokale markthotspots." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktanalyse: BTC heeft zijn verliezen verkleind en gestabiliseerd rond $96.000, met opkomende lokale markthotspots.</h2><h3 id="h3-Markthoogtepunten792621"><a name="Markthoogtepunten:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markthoogtepunten:</h3><p>-De recente Zuid-Koreaanse controverses over de staat van beleg veroorzaakten een korte daling van verschillende cryptocurrencies, maar dit incident heeft het algehele optimistische sentiment op de markt na de Amerikaanse verkiezingen niet significant gedempt. The <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto market</a> zag een herstel, met behoud van een brede opwaartse trend, met sectoren zoals RWA, Layer 1, <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">Tron</a> ecosysteem en inies leiden de winsten.</p>
<ul>
<li><a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> De stijging van ‘s heeft het marktsentiment versterkt, wat heeft geleid tot een grotere interesse in gevestigde projecten met een hoge marktkapitalisatie zoals AVAX, NEAR, <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a>, ONDO, en HBAR, die een gemiddelde stijging van meer dan 30% zagen.</li></ul>
<p>-Speculatie rond de volgende voorzitter van de SEC heeft interesse gewekt in tokens zoals RSR en DTF. Het nieuws dat Trump Paul Atkins heeft gekozen als de volgende voorzitter van de SEC - die eerder advies gaf aan het RSR-project - zorgde in eerste instantie voor een stijging van meer dan 50% van de RSR, maar de prijs daalde weer toen bekend werd dat Atkins niet geneigd was de rol te aanvaarden. Ondertussen steeg DTF, gerelateerd aan RSR, van $0,012 naar $0,03, een stijging van 235%, voordat het weer daalde naar $0,023. Daarnaast trekken HBAR en <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> de aandacht vanwege hun banden met andere kandidaten voor voorzitter van de SEC.</p>
<p>-Meme tokens zoals POPCAT, CHILLGUY, FARTCOIN en CLANKER zagen aanzienlijke winsten. Naarmate de fondsen verschoven naar de handel in gevestigde altcoins, nam de impact van on-chain meme tokens af, waarbij slechts een paar populaire meme tokens een sterke interesse behielden.</p>
<h3 id="h3-Markttrends454340"><a name="Markttrends:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends:</h3><p>-BTC is hersteld boven $96.000. Sinds de overwinning van Trump bij de Amerikaanse verkiezingen op 5 november is er meer dan 171.000 BTC opgenomen van grote beurzen, waardoor de beursreserves zijn gedaald tot 2,46 miljoen BTC, het laagste niveau in jaren. Onlangs is de nettostroom van fondsen naar BTC-spot-ETF’s vertraagd, wat wijst op een verschuiving naar ETH-spot-ETF’s.</p>
<p>-ETH ondergaat een consolidatie op hoog niveau, nadat het vanochtend boven de $3.700 is gestegen, wat een stijging van 1,90% in 24 uur weergeeft. Er zijn negen opeenvolgende werkdagen netto instroom in spot ETF’s geweest, wat aangeeft dat de stijging van ETH een altcoin bullmarkt kan veroorzaken.</p>
<p>-BTC’s marktdominantie is licht afgenomen, maar altcoins blijven stijgen, met inies en <a href="/price/tron-trx" target="_blank" class="blog_inner_link">Tron</a> ecosysteem tokens die de sterkste opwaartse trends laten zien; de 24-uurs stijging van TRX bereikte 77,98%, waarmee een nieuw all-time high werd bereikt.</p>
<h2 id="h2-Macro20Nieuws20Naar20aanleiding20van20de20controverse20over20de20staat20van20beleg20in20ZuidKorea20blijft20de20cryptomarkt20stijgen554445"><a name="Macro Nieuws: Naar aanleiding van de controverse over de staat van beleg in Zuid-Korea, blijft de cryptomarkt stijgen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws: Naar aanleiding van de controverse over de staat van beleg in Zuid-Korea, blijft de cryptomarkt stijgen.</h2><p>Gisteravond leidde de aankondiging van de staat van beleg tot een flash crash in de Zuid-Koreaanse cryptomarkt, wat resulteerde in ernstige negatieve premies in talrijke handelsparen. Echter, met de stemming van de Nationale Vergadering om het verbod op te heffen, is de markt gestabiliseerd, hoewel de Koreaanse aandelenmarkt met bijna 2% daalde bij opening en de won een nieuw dieptepunt bereikte.</p>
<p>Amerikaanse aandelen sloten gemengd, maar de algehele trend blijft een gestage stijging, wat de marktsentiment weerspiegelt dat wordt aangedreven door de groeiende verwachtingen van een renteverlaging in december, zoals aangegeven door verschillende functionarissen van de Federal Reserve. Momenteel staat de waarschijnlijkheid van een renteverlaging van 25 basispunten in december op 70,3%.</p>
<p>Bovendien is het opmerkelijk dat Trump vandaag naar verwachting de volgende voorzitter van de SEC zal aankondigen, hoewel het lijkt dat Paul Atkins, die de voorkeur had voor de functie, mogelijk niet bereid is om deze te aanvaarden. Volgens de voorspellingsmarkt Kalshi is de kans dat Atkins de volgende voorzitter van de SEC wordt, toegenomen. De nieuwe voorzitter van de SEC zal aanzienlijke invloed hebben op de regulering van cryptocurrencies, en we zullen deze belangrijke ontwikkeling blijven volgen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Charle Y.</strong>, Onderzoeker bij Gate.io<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 is toegestaan om het artikel te herpubliceren mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>