RGFnZWxpamtzIG5pZXV3cyB8IEhldCBvZmZpY2nDq2xlIFR3aXR0ZXItYWNjb3VudCB2YW4gZGUgU0VDIGhlZWZ0IHZhbHNlIG5pZXV3c2JlcmljaHRlbiB2cmlqZ2VnZXZlbiwgQlRDIGRhYWxkZSBvbm1pZGRlbGxpamsgbWV0IDEwJSwgbWVlciBkYW4gJDUwIG1pbGpvZW4gd2VyZCBpbiAxIHV1ciB2ZXJrb2NodCwgQlRDIHdlcmQgbG9

2024-01-10, 03:53

<p><img src="https://gimg2.gateimg.com/image/article/17048713561_8.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Valse20ETFnieuws20vrijgegeven20vanwege20de20diefstal20van20het20officile20Twitteraccount20van20SEC20meer20dan205020miljoen20uitverkocht40538"><a name="Crypto Daily Digest: Valse ETF-nieuws vrijgegeven vanwege de diefstal van het officiële Twitter-account van SEC, meer dan $50 miljoen uitverkocht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Valse ETF-nieuws vrijgegeven vanwege de diefstal van het officiële Twitter-account van SEC, meer dan $50 miljoen uitverkocht</h2><p>Op 10 januari, vanwege het valse nieuws dat het officiële Twitter-account van de SEC gestolen was en de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF is goedgekeurd, de prijs van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> fluctueert sterk. Na bijna $48.000 te zijn gestegen, daalde het snel onder $45.000, met een korte termijn fluctuatie van bijna 10%. Op dit moment wordt het tijdelijk gerapporteerd op $45.800, met een daling van 2,7% in 24 uur.</p>
<p>Volgens Coinglass-gegevens heeft de Bitcoin-markt de afgelopen uur $56,2 miljoen verkocht, waarbij meerdere orders ongeveer 60% van het totaal uitmaken. De huidige positie van Bitcoin-futures is $19,74 miljard, een daling van 2,41% in de afgelopen 4 uur. Daarvan blijft CME de grootste handelsplatform voor Bitcoin-futures, met een houdvolume van $6,12 miljard en een marktaandeel van 30,99%.</p>
<p>Vervolgens tweette SEC-voorzitter Gary Gensler dat het officiële Twitter-account van de SEC was gehackt en dat ongeautoriseerde tweets waren geplaatst. De notering en handel in spot Bitcoin ETF’s zijn nog niet goedgekeurd. Eerder kondigde het officiële Twitter-account van de SEC aan dat Bitcoin spot ETF’s waren goedgekeurd voor notering op alle geregistreerde nationale effectenbeurzen. Op dit moment is de tweet verwijderd.</p>
<p>Bloomberg-analist Eric Balchunas verklaarde echter op zijn socialemediaplatform dat hoewel er aanwijzingen zijn dat de SEC officieel wordt gestolen, hij er meer toe neigt te geloven dat het valse nieuws over de goedkeuring van Bitcoin spot ETF’s door de SEC afkomstig is vanuit de SEC zelf, of dat hij een geplande tweet voor SEC-medewerkers heeft voorbereid maar de verkeerde datum heeft ingevoerd, omdat de bewoording van de tweet in overeenstemming is met de SEC-stijl en geen eenvoudige grap is.</p>
<p>Vervolgens vroegen sommige netizens wat het wachtwoord voor het X-platformaccount van de SEC was, en konden alleen het verkeerde antwoord geven. Hierover maakt Musk grappen: ‘LFG Doge To The Moon.’</p>
<p>De Amerikaanse SEC heeft bevestigd dat zij voorgestelde wijzigingen in de regels voor Bitcoin spot ETF’s van meerdere aanvragers, waaronder Invesco Galaxy, Valkyrie, Franklin, Ark 21Shares, Fidelity, VanEck, Hashdex, Wisdomtree, Bitwise, etc., heeft ontvangen.</p>
<p>Op 9 januari verklaarde Eric Balchunas, een senior ETF-analist bij Bloomberg, dat BlackRock zojuist hun S-1-amendement heeft ingediend op basis van opmerkingen die gisteren op het laatste moment zijn ontvangen. Op het eerste gezicht is het moeilijk om enige veranderingen te onderscheiden, maar wat belangrijk is, is dat deze ongekend snelle reactietijd van slechts 24 uur tussen het indienen van documenten, het ontvangen van opmerkingen en opnieuw indienen ons vertelt dat alle relevante partijen urgent verder gaan met dit project.</p>
<p>Eric Balchunas heeft ook verklaard dat verwacht wordt dat de SEC de goedkeuring van Bitcoin spot ETF’s zal aankondigen op woensdag van 16:00 tot 17:00 Eastern Time (5:00 tot 6:00 uur ‘s ochtends Beijing Time op donderdag) en ze op donderdag lokale tijd zal noteren.</p>
<p>Als reactie hierop verklaarde Steven McClurg, medeoprichter en Chief Information Officer van Valkyrie Investments, ook dat er wordt verwacht dat de spot Bitcoin ETF goedkeuring van de SEC zal ontvangen tegen het einde van de werkdag op woensdag en op donderdagochtend zal beginnen met handelen. Hij zei dat als de handel op donderdag begint, er naar verwachting $200 miljoen tot $400 miljoen aan investeringsfondsen zullen zijn. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stromen</a> in Valkyrie’s ETF stappen, en alle deelnemers kunnen in de eerste paar weken $4 tot $5 miljard aan instroom zien.</p>
<p>Fox-journalist Eleanor Terrett, die altijd aan de andere kant heeft gestaan, plaatste echter op sociale media dat de vijf leden van de SEC de goedkeuring van Bitcoin spot ETF’s kunnen uitstellen. De commissieleden zijn onder andere Gensler (D), Crenshaw (D), Peirce ®, Lizárraga (D) en Uyeda ®.</p>
<p>Hoewel er geen formele commissievergadering gepland staat voor de ETF’s, heeft elk commissielid duidelijk het recht om de hele commissie te bekijken en te stemmen volgens 17 CFR 201.431, zelfs als de kwestie is toegewezen en goedgekeurd via autorisatie. Deze clausule stelt een SEC-commissaris in staat om de hele commissie te verzoeken om zaken geautoriseerd door het personeel te bekijken.</p>
<p>Paradigm Policy Director Justin Slaughter verklaarde eerder dat de SEC (net als de Amerikaanse Commodity Futures Trading Commission en de meeste commissies) commissieleden kan toestaan om over bepaalde zaken te stemmen zonder een formele vergadering. Dit is een proces dat ‘seriatim’ wordt genoemd.</p>
<p>In de afgelopen weken heeft de markt geleidelijk een consensus gevormd dat of de BTC ETF wordt goedgekeurd of niet, een korte termijn aanpassing van 20-30% zal teweegbrengen. Maar volgens de on chain data-analyse van EMC Labs, kan de aanpassing in de afgelopen 6 weken zijn voltooid, wat zich manifesteert als een aanhoudende fluctuatie in de Bitcoin-prijzen tussen $41.000 en $45.000.</p>
<p>Dit resultaat kan drie belangrijke drijvende factoren hebben. Ten eerste hebben veel beleggers hun positieafbouwoperaties in de afgelopen maand voltooid, waarbij lange handen die munten meer dan 5 maanden vasthielden, voor het eerst in het afgelopen jaar een geconcentreerde verkoop van ongeveer 60.000 munten hebben ervaren. Momenteel is dit verkoopgedrag in feite gestopt; Short hands die binnen 5 maanden munten bevatten, hebben het afgelopen jaar netto meer dan 400.000 munten verkocht, waarbij ze volledige omzet hebben behaald tijdens verschillende consolidatieperioden tijdens de langzame opkomst van Bitcoin. Momenteel is de winstmarge op korte termijn minder dan 20% en is de verkoopmotivatie onvoldoende; Ten tweede versnelde de netto-instroom van stablecoins na 1 januari, met een stijging van $2,1 miljard per week, naderde de volledige maandgegevens van december en bereikte 40% van het vierde kwartaal van 2023; Ten derde ervaart Bitcoin nog steeds een netto-uitstroom van gecentraliseerde beurzen, maar de netto-uitstroom bevindt zich op een laag niveau in de afgelopen zes maanden. Of het kan betekenen dat de toevoeging van stablecoins nog niet volledig een Bitcoin-aankoop heeft gevormd en een koopkrachtondersteuning zal worden voor kortetermijnaanpassingen.</p>
<p>Kortom, de huidige prijs van Bitcoin kan op korte termijn zijn aangepast na goedkeuring van ETF’s. Zelfs als ETF’s de goedkeuring blijven uitstellen, kan de marktaanpassing mogelijk niet zo significant zijn als eerder verwacht.</p>
<h2 id="h2-Macro20Bitcoin20is20ontkoppeld20met20de20NASDAQindex20Deutsche20Bank20voorspelt20dat20de20Verenigde20Staten20dit20jaar20in20een20recessie20zal20belanden202575"><a name="Macro: Bitcoin is ontkoppeld met de NASDAQ-index, Deutsche Bank voorspelt dat de Verenigde Staten dit jaar in een recessie zal belanden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Bitcoin is ontkoppeld met de NASDAQ-index, Deutsche Bank voorspelt dat de Verenigde Staten dit jaar in een recessie zal belanden</h2><p>Op dinsdag steeg de Amerikaanse dollarindex lichtjes en sloot uiteindelijk met een daling van 0,217% op 102,51. Het rendement van de Amerikaanse schatkist bleef dalen, waarbij het rendement op 10-jarige schatkistobligaties tijdens de handel lager werd en sloot op 4,018%, verder verwijderd van een drie weken hoogtepunt; Het rendement op 2-jarige Amerikaanse schatkistobligaties, dat gevoeliger is voor het rentebeleid van de Federal Reserve, sloot op 4,366%.</p>
<p>Spotgoud schommelde zijwaarts in de buurt van het niveau van 2030, en sloot uiteindelijk 0,11% hoger op $2.030,34 per ounce. Spotzilver bleef tijdens de Amerikaanse sessie dalen, zakte onder de 23 en sloot 0,57% lager op $22,97 per ounce.</p>
<p>Het risico op overloop van het Israëlisch-Palestijnse conflict en de aanhoudende verstoring van de bevoorrading in Libië blijven een internationaal herstel van ruwe olie stimuleren. WTI ruwe olie steeg met 1,84% naar $72,14 per vat en het prijsverschil op de spotmarkt van WTI ruwe olie is voor het eerst sinds november vorig jaar verschoven naar een spot premie; Brent ruwe olie steeg met 1,47% naar $77,47 per vat.</p>
<p>De drie belangrijkste Amerikaanse aandelenindices hebben gemengde winsten en verliezen, waarbij de Dow Jones Industrial Average 0,42% lager sloot, de Nasdaq iets steeg en de S&amp;P 500-index met 0,15% daalde. Er wordt ook begrepen dat Bitcoin (BTC) onlangs is losgekoppeld van de NASDAQ (NDX) index, waarmee een einde komt aan de trend van synchrone beweging met de Wall Street Technology Heavy Stock Index gedurende het grootste deel van de afgelopen vier jaar.</p>
<p>Volgens gegevens bijgehouden door Fairlead Strategies is de 40-daagse correlatie tussen Bitcoin en NASDAQ momenteel nul, wat duidt op een gebrek aan correlatie tussen deze twee activaklassen. Sinds het begin van 2020 is de correlatie tussen Bitcoin en NASDAQ positief gecorreleerd geweest, en heeft tijdens de cryptobeermarkt in 2022 een piek van 0,8 bereikt.</p>
<p>De ineenstorting van de correlatie betekent ook dat Bitcoin nu kan dienen als een diversificatietool voor beleggingsportefeuilles. Fairlead Strategies verwacht dat Bitcoin gedurende een bepaalde periode onaangetast zal blijven door NASDAQ.</p>
<p>Met betrekking tot de recente verhitte discussies van de Federal Reserve over een zachte landing van de Amerikaanse economie, verklaarde Deutsche Bank in een rapport op maandag dat de historische ervaring laat zien dat deze trend vaak optreedt vóór een recessie.</p>
<p>Het rapport van de bank wees erop dat lagere inflatie, sterke werkgelegenheidsgegevens en signalen dat de Federal Reserve dit jaar zal overstappen op renteverlagingen, deze verklaring hebben gedreven, en wees erop dat nieuwsartikelen steeds vaker spreken over een ‘zachte landing’. Soortgelijke trends deden zich voor vóór de economische recessie begin jaren negentig, begin 21e eeuw en in 2008. En men gelooft dat het risico dat de Verenigde Staten in een economische recessie terechtkomen hoger is dan in 2022 of 2023.</p>
<p>Er wordt verwacht dat de Verenigde Staten dit jaar in een recessie zullen belanden, maar elke recessie kan mild zijn of geen significante impact hebben op de markt.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het herposten van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>