RGFnZWxpamtzIG5pZXV3cyB8IE5pZXV3ZSB2b29yc2NocmlmdGVuIHZhbiBkZSBTRUMgenVsbGVuIGRlIHJlZ2VsZ2V2aW5nIHZvb3IgY3J5cHRvIHZlcnN0ZXJrZW4sIE1pY3JvU3RyYXRlZ3kgYmxpamZ0IHppam4gYmV6aXR0aW5nZW4gaW4gQml0Y29pbiB2ZXJncm90ZW4sIGhldCBNYWlubmV0IHZhbiBEeW1lbnNpb24gaXMgb2ZmaWN

2024-02-07, 06:15

<p><img src="https://gimg2.gateimg.com/image/article/17072865881_4.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Nieuwe20Regelgeving20van20SEC20Versterkt20Regulering20MicroStrategy20Blijft20Groeien202020Bitcoin2020Bezittingen930712"><a name="Crypto Dagelijks Overzicht: Nieuwe Regelgeving van SEC Versterkt Regulering, MicroStrategy Blijft Groeien   Bitcoin  Bezittingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Nieuwe Regelgeving van SEC Versterkt Regulering, MicroStrategy Blijft Groeien <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Bezittingen</h2><p>Op dinsdag heeft de SEC een definitieve regel goedgekeurd om meer financiële bedrijven onder haar toezicht te brengen, inclusief de handel in crypto-effecten. Deze regelgeving kan vereisen dat crypto-projecten zich registreren als handelaren. De SEC verklaarde dat zij geen specifieke soorten effecten (inclusief crypto-effecten) heeft uitgesloten van de reikwijdte van de definitieve regels. Het handelskader is gebaseerd op functionele analyse van effectenhandelsactiviteiten die door een individu worden uitgevoerd, in plaats van op het type effecten dat wordt verhandeld.</p>
<p>Voorzitter van de SEC, Gary Gensler, verklaarde in een verklaring dat ‘zonder vrijstellingen of uitzonderingen, als iemand op de facto wijze marktmaker handelt, zij zich bij ons moeten registreren als handelaar, wat in lijn is met de bedoeling van het Congres.’ Deze stap kan ernstige gevolgen hebben voor de digitale activabranche, vooral op het gebied van gedecentraliseerde financiën (DeFi).</p>
<p>Op 7 februari kondigde MicroStrategy (MSTR. O) officieel aan dat het bedrijf per 5 februari 2024 190.000 Bitcoins in bezit heeft, met een totale kostprijs van $5,93 miljard en een kostprijs van $31.224 per Bitcoin. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>. Het bedrijf verklaarde dat het in januari van dit jaar $37,2 miljoen heeft uitgegeven om zijn bezit van 850 Bitcoins te vergroten. Sinds het einde van het derde kwartaal vorig jaar heeft het een extra 31.755 Bitcoins gekocht, wat de grootste kwartaalstijging in de afgelopen drie jaar markeert en de 13e opeenvolgende kwartaalstijging in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> op zijn balans.</p>
<p>Aan de andere kant blijft de verkoopdruk van Grayscale afnemen. Volgens de nieuwste gegevens van Arkham zijn op 6 februari om 14:08 uur (UTC) ongeveer 1.767 BTC ter waarde van ongeveer $75,78 miljoen overgeboekt van Grayscale-gerelateerde adressen naar Coinbase Prime Deposit-adressen. Ook is er 899,9 BTC overgeboekt naar een nieuw adres, wat lijkt op het nieuwe bewaaradres van Grayscale.</p>
<p>Volgens de gegevens van BitMEX Research stroomde op de 18e handelsdag van het spot Bitcoin ETF (6 februari) $73 miljoen uit het GBTC-fonds. Sinds 11 januari 2024 is de totale uitstroom van GBTC $6,149 miljard, waarbij 147.792 BTC’s zijn uitgestroomd.</p>
<p>De upgrade van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Denchun komt steeds dichterbij. Op 7 februari zal de upgrade van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Denchun worden geactiveerd op het Holesky testnet, dat minder dan 12 uur vanaf nu is.</p>
<p>Er wordt gemeld dat dit de laatste testnet-fork is vóór het mainnet, en de mainnet-datum zou morgen tijdens de AllCoreDvs-conferentiegesprek (alle indicaties wijzen op begin tot medio maart) moeten worden bepaald. EIP-4844 komt binnenkort.</p>
<p>Op 7 februari is volgens officieel nieuws het Dymension-hoofdnetwerk officieel gelanceerd. Twee jaar geleden werd Dyvision geconceptualiseerd als een grootse visie, die een andere dimensie toevoegt aan de Interchain en een modulair Rollup Internet bouwt. Vandaag, met de geboorte van de eerste blockchain en Dymension, versnelt het exponentieel de Interchain, waardoor iedereen zijn eigen blockchain kan bouwen en deze kan verbinden met de cryptoeconomie.</p>
<p>Volgens Decrypt vond de verwachte airdrop van het modulaire blockchain-netwerk Dymension van het Cosmos-ecosysteem plaats in de vroege ochtend van dinsdag toen het mainnet online was, waarbij 70 miljoen DYM-tokens werden verstrekt aan vroege gebruikers en specifieke gemeenschappen, goed voor 7% van de totale aanbod.</p>
<p>Dymension noemde deze airdrop de “genesis rolldrop”, die kan worden gebruikt door meer dan een miljoen unieke portefeuilles op verschillende ketens en gemeenschappen, inclusief gebruikers op het netwerk. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, Celestia, en Ethereum uitgebreide netwerken zoals Arbitrum, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, Base en de aankomende Blast. Sommige gemeenschappen kunnen ook deelnemen aan airdrops, waaronder houders van de populaire Pudgy Penguins NFT-serie op Ethereum, evenals houders van de Mad Lads en Tensorians NFT-serie op Solana.</p>
<p>Hoewel er meer dan 1 miljoen portefeuilles zijn die aanspraak kunnen maken op deze 700 miljoen airdropped tokens, werd de aanvraag al in januari ingediend, waarbij uiteindelijk slechts 528.523 portefeuilles aanvragen indienden. Dit betekent dat ongeveer de helft van de in aanmerking komende gebruikers geen aanvraag heeft ingediend voor DYM, en deze tokens uiteindelijk zijn toegewezen aan andere gebruikers.</p>
<p>Op basis van de totale waarde van tokenplaatsingen is DYM momenteel de op een na grootste token-airdrop in 2024. Op basis van de huidige eenheidsprijs van DYM van $5,199 is de totale waarde van de tokens die via de lucht zijn gedropt ongeveer $364 miljoen.</p>
<p>Eerder heeft Jupiter vorige week 1 miljard JUP’s airdropped, met een totale waarde van $527 miljoen op basis van de huidige prijzen.<br>Wat betreft gegevensfluctuaties, volgens Bloomberg toont CCData-gegevens aan dat de handelsvolume van digitale activa op de spotmarkt in januari een 19-maand hoogtepunt heeft bereikt, bijna $1,4 biljoen, maar nog steeds lager dan het maandelijkse gemiddelde tijdens de cryptostierenmarkt in 2021.</p>
<p>Wintermute medeoprichter Evgeny Gaevoy zei: ‘we verwachten dat ons handelsvolume tegen het einde van het jaar weer op het niveau van 2021 zal zijn, vooral voor Bitcoin. Als alles het gekke niveau van 2021 bereikt, zullen we honderden miljoenen dollars aan handelsfondsen moeten ophalen.’</p>
<p>Bovendien verklaarde Chuan Jin Fong, Sales Director voor Azië, Europa, het Midden-Oosten en Afrika bij GSR Markets, dat het vooruitzicht voor de cryptomarkt verbeterd is nu de langetermijnkapitaalinstroom van ETF’s de verwachtingen overtreft.</p>
<h2 id="h2-Macro20Goud20nadert20204020Fed20zal20later20dit20jaar20de20rente20verlagen783418"><a name="Macro: Goud nadert $2.040, Fed zal later dit jaar de rente verlagen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Goud nadert $2.040, Fed zal later dit jaar de rente verlagen</h2><p>Op dinsdag 6 februari besteedden investeerders aandacht aan de toespraken van functionarissen van de Federal Reserve, in een poging om te beoordelen hoe recente economische gegevens de rentebeslissingen van de Fed zullen beïnvloeden. De Amerikaanse dollar, die in de afgelopen dagen sterker is geworden, is gedaald van zijn bijna drie maanden hoogtepunt. De Amerikaanse dollarindex sloot 0,29% lager op 104,15. De referentie-10-jarige Amerikaanse schatkistrendement is teruggekeerd onder de 4,10%, en het rentegevoelige 2-jarige Amerikaanse schatkistrendement is bijna 10 basispunten gedaald ten opzichte van het hoogste punt van een maandag.</p>
<p>Als gevolg hiervan steeg de spotgoudprijs en naderde het niveau van 2.040, uiteindelijk met 0,54% te sluiten op $2035,89 per ounce; Spotzilver steeg met 0,33% naar $22,43 per ounce.<br>Het aanbodrisico als gevolg van de gespannen situatie in het Midden-Oosten heeft de voortdurende opleving van internationale ruwe olie gestimuleerd, waarbij WTI-ruwe olie met 0,91% steeg tot $73,40 per vat; Brent-ruwe olie steeg met 0,89% tot $78,65 per vat.</p>
<p>De drie belangrijkste Amerikaanse aandelenindexen schommelden en sloten hoger, waarbij de Dow Jones Industrial Average met 0,37% steeg, de Nasdaq met 0,07% steeg en de S&amp;P 500-index met 0,23% steeg.</p>
<p>Op dinsdag hielden verschillende functionarissen van de Federal Reserve toespraken, waarbij ze meer aanwijzingen gaven over het monetaire beleid aan investeerders: Voorzitter van de Cleveland Fed, Mester, zei dat als de economie zich ontwikkelt zoals verwacht, beleidsmakers mogelijk het vertrouwen kunnen krijgen om later dit jaar de rente te verlagen, maar ze zei dat ze van mening is dat er geen haast is om de rentetarieven te verlagen.</p>
<p>Ondertussen stelde ze dat functionarissen van de Federal Reserve hopen meer bewijs te zien dat de inflatie afneemt en hun doel van 2% nadert, en ze waarschuwt tegen voortijdige renteverlagingen.</p>
<p>Haar opmerkingen weerspiegelen de opvattingen van verschillende beleidsmakers van de Federal Reserve in de afgelopen weken, waaronder voorzitter Powell, die verklaarde dat ze gerustgesteld moeten zijn en bereid moeten zijn tijd te besteden bij het overwegen van verlaging van de benchmark rentevoet van een 20-jaars hoogtepunt.</p>
<p>Mester, die dit jaar fungeert als lid van de roterende stemcommissie, verklaarde dat zij nog steeds verwacht dat er in 2024 drie renteverlagingen zullen plaatsvinden, in overeenstemming met de prognose die zij voorlegde voor de FOMC-vergadering in december. Na haar gesprek met verslaggevers zei ze dat renteverlagingen niet per se bij de kwartaalbijeenkomst hoeven te worden uitgevoerd wanneer de Federal Reserve een samenvatting van de economische prognose publiceert. “Ik denk dat we niet gebonden hoeven te zijn aan de economische prognose samenvatting, zolang we maar goed communiceren,” zei Mester.</p>
<p>Daarnaast gaf de voorzitter van de Federal Reserve Bank of Minneapolis, Kashkali, ook een aparte toespraak waarin hij de aanzienlijke vooruitgang in de inflatie vierde, maar benadrukte dat er meer vooruitgang nodig is.<br>Met een sterke arbeidsmarkt op de achtergrond zei Kashkali dat de Verenigde Staten dit jaar een recessie zullen vermijden, wat er ‘zeer veelbelovend’ uitziet. Hij noemde echter ook de risico’s van geopolitieke onrust waarmee de mondiale en binnenlandse economieën worden geconfronteerd.</p>
<p>De voorzitter van de Philadelphia Fed, Huck, verklaarde dinsdag in een onafhankelijk commentaar dat de Amerikaanse economie op het punt staat een zachte landing te bereiken.</p>
<p>In zijn toespraak aan de Rowan University in Glassboro, New Jersey, zei hij: “De gegevens tonen aan dat de inflatie blijft dalen, de arbeidsmarkt meer in evenwicht komt en de consumentenbestedingen sterk zijn - deze drie factoren zijn cruciaal voor ons om te blijven streven naar een zachte landing, en we blijven optimistisch over hen.” We zijn zeker nog niet geland en we zullen onze veiligheidsgordels moeten blijven vastmaken, maar naarmate de inflatie blijft dalen naar ons streefdoel van 2%, de werkgelegenheid sterk blijft en het consumentenvertrouwen verbetert, komt onze doellandingsbaan in zicht.”</p>
<p>Huck heeft dit jaar niet deelgenomen aan de stemming over het monetair beleid en heeft zijn standpunt over wanneer de Federal Reserve de rente zou moeten verlagen niet uitgedrukt in de voorbereide tekst. Huck heeft in december wel aangegeven dat de volgende stap van het beleid van de Federal Reserve het verlagen van de rente zou moeten zijn, maar er is geen noodzaak om onmiddellijk te beginnen of snel renteverlagingen door te voeren. Hij heeft zijn steun uitgesproken voor een ‘evenwichtige en dynamische aanpak’ om een zachte landing van de economie te bereiken.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te publiceren op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>