RGFnZWxpamtzIG5pZXV3cyB8IENpcmNsZSBwbGFudCB2b2xnZW5kIGphYXIgbmFhciBkZSBiZXVycyB0ZSBnYWFuOyBkZSBoYW5kaGF2aW5nc2FjdGllcyB2YW4gZGUgQW1lcmlrYWFuc2UgY3J5cHRvLXdldHRlbiBoZWJiZW4gZWVuIGhpc3RvcmlzY2ggaG9vZ3RlcHVudCBiZXJlaWt0OyBkZSBpbnN0cm9vbSB2YW4gY3J5cHRvLWZvbmR

2023-11-08, 06:09

<p><img src="https://gimg2.gateimg.com/image/article/16994246581108.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20Amerikaanse20handhavingsacties20op20het20gebied20van20crypto20bereikten20in20202320een20historisch20hoogtepunt20Circle20heeft20plannen20om20volgend20jaar20naar20de20beurs20te20gaan565738"><a name="Crypto Dagelijkse Samenvatting: De Amerikaanse handhavingsacties op het gebied van crypto bereikten in 2023 een historisch hoogtepunt, Circle heeft plannen om volgend jaar naar de beurs te gaan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De Amerikaanse handhavingsacties op het gebied van crypto bereikten in 2023 een historisch hoogtepunt, Circle heeft plannen om volgend jaar naar de beurs te gaan</h2><p>Volgens een rapport van de Wall Street Journal verklaarde de Amerikaanse onderminister van Financiën, Wally Adeyemo, op dinsdag tijdens de jaarlijkse bijeenkomst van de Securities Industry and Financial Markets Association in Washington dat de regering-Biden hoopt dat het Congres nieuwe bevoegdheden zal verlenen om de illegale gebruik van cryptocurrency te bestrijden, en noemde dat Hamas publiekelijk heeft geprobeerd geld in te zamelen via cryptocurrency, wat heeft geleid tot ‘grotere bezorgdheid over het illegaal financieel gebruik van digitale activa’.</p>
<p>Hij verklaarde dat het Ministerie van Financiën heeft gecommuniceerd met de Democraten en Republikeinen over mogelijke maatregelen die ze kunnen nemen. Het Congres moet op sommige plaatsen actie ondernemen. Het Ministerie van Financiën zal doorgaan met actie ondernemen en samenwerken met wetgevers om de crypto-industrie aan te moedigen om verantwoord te innoveren. Adeyemo riep ook op tot zelfregulering in de crypto-industrie.</p>
<p>Bovendien heeft het aantal zaken in de digitale activa sector volgens het Law Enforcement Report voor het fiscale jaar 2023 dat vandaag door de Commodity Futures Trading Commission (CFTC) is vrijgegeven, een historisch hoogtepunt bereikt. De CFTC Law Enforcement Department (DOE) voerde in 2023 in totaal 96 handhavingsacties uit, resulterend in boetes, compensatie en inbeslagname van meer dan $4,3 miljard. Daarvan zijn 47 acties gerelateerd aan digitale activa, wat meer dan 49% van alle acties vertegenwoordigt. In tegenstelling hiermee heeft de CFTC in fiscaal jaar 2022 in totaal 18 handhavingsacties uitgevoerd met betrekking tot digitale activa.</p>
<p>Volgens Bloomberg toonde het financiële rapport van Robin Hood voor het derde kwartaal een netto-inkomen van $467 miljoen, lager dan de gemiddelde analistenverwachting van $478,9 miljoen, maar een stijging van 29% vergeleken met dezelfde periode vorig jaar. De op transactie gebaseerde omzet bedroeg $185 miljoen, een daling op jaarbasis van 11%, voornamelijk als gevolg van een op jaarbasis daling van 55% van de nominale handelsvolume in crypto tot $23 miljoen.</p>
<p>Robinhood verklaarde in een verklaring dat het, naarmate het wereldwijd uitbreidt, van plan is om de handel in cryptovaluta en de makelaarsdiensten in het Verenigd Koninkrijk te lanceren in de komende weken. De aandelenprijs van Robin Hood daalde ongeveer 7% in de late handel op de New Yorkse markt, maar is dit jaar toch bijna 20% gestegen.</p>
<p>Op 8 november overweegt Circle Internet Financial Ltd., de uitgever van de stabiele valuta USDC, volgens Bloomberg met insiders, om in het begin van 2024 genoteerd te worden. Het bedrijf voert onderhandelingen met consultants om zich voor te bereiden op een mogelijke beursgang. Op dit moment is de relevante beoordeling nog steeds aan de gang en het is onzeker of Circle uiteindelijk wel naar de beurs zal gaan.</p>
<p>Hoewel het onduidelijk is welke waardering Circle zoekt in zijn IPO, was de waardering van het bedrijf toen het in 2022 probeerde te fuseren met het acquisitiebedrijf Concord Acquisition Corp. $9 miljard. Een vertegenwoordiger van Circle verklaarde in een verklaring dat het worden van een genoteerd Amerikaans bedrijf al lang deel uitmaakt van de strategische visie van Circle, maar we zullen niet reageren op de geruchten.</p>
<p>CoinShares, een bedrijf voor het beheer van digitale activa, meldde maandag dat crypto-fondsen hun beste instroom sinds de crypto-stierenmarkt in 2021 hebben gezien, aangezien investeerders de markt blijven overspoelen. Volgens CoinShares-gegevens hadden investeringsvoertuigen die cryptocurrencies aanhouden vorige week een nettostroom van $261 miljoen, wat positieve instroom voor zes opeenvolgende weken betekent, met een totaal van $767 miljoen.</p>
<p>James Butterfill, onderzoeksdirecteur bij CoinShares, wees erop dat “deze instroom nu in lijn is met de instroom in juli 2023 en de grootste is sinds het einde van de bullmarkt in december 2021.” <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>(BTC) fondsen domineren nog steeds de activaklasse en zorgen voor het grootste deel van de instroom, met ongeveer $229 miljoen vorige week en $842 miljoen dit jaar.</p>
<p>Butterfill legde uit dat dit mogelijk te wijten is aan de toenemende kans dat spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s worden goedgekeurd in de Verenigde Staten en enkele zwakke macro-economische gegevens ondersteunen. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Fonds kende zijn grootste instroom sinds augustus 2022 en bereikte $17,5 miljoen.</p>
<h2 id="h2-Belangrijkste20trends20van20vandaag20in20tokens427194"><a name="Belangrijkste trends van vandaag in tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends van vandaag in tokens</h2><h3 id="h3-BTC313799"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1699424701BTC.png" alt=""><br>In de vroege uren van gisteren keerde Bitcoin (BTC) terug naar de oplopende trendlijn, bleef onder het korte termijn gemiddelde. Vervolgens steeg het naar een hoogtepunt van $35.888, maar worstelde nog steeds om het psychologische niveau van $36.000 te doorbreken. Op korte termijn blijft BTC stabiel rond het gemiddelde bewegen, wat aangeeft dat er volgende week mogelijk een significante beweging kan plaatsvinden.</p>
<h3 id="h3-ETH345865"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1699424721ETH.png" alt=""><br>Afgelopen weekend slaagde <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> (ETH) erin om boven de $1.857 te stabiliseren en doorbrak de algehele neerwaartse trend, waarmee een zeven maanden durende daling werd beëindigd. Korte termijn prijsactie lijkt te consolideren, waarbij $1.840 dient als een sterke ondersteuningsniveau. Afwachten van een duidelijke richting is een conservatieve strategie.</p>
<h3 id="h3-ID609596"><a name="ID" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ID</h3><p><img src="https://gimg2.gateimg.com/image/article/1699424739ID.png" alt=""><br>De vier-uur grafiek voor ID toont een volledig hoofd en schouders patroon, met de neckline doorbraak op $0,2870. Een conservatieve aanpak zou zijn om te wachten op een blijvende doorbraak boven $0,2870 en als doel $0,3618 te hebben. Exit strategieën kunnen gebruik maken van Fibonacci-extensieniveaus (0,3045, 0,3154, enz.).</p>
<h2 id="h2-Macro20Amerikaanse20aandelen20stijgen20al20720dagen20op20rij20De20inflatiedruk20neemt20toe20Federal20Reserve20Bowman20heeft20aangegeven20dat20verdere20renteverhogingen20nodig20zijn869387"><a name="Macro: Amerikaanse aandelen stijgen al 7 dagen op rij; De inflatiedruk neemt toe; Federal Reserve Bowman heeft aangegeven dat verdere renteverhogingen nodig zijn" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Amerikaanse aandelen stijgen al 7 dagen op rij; De inflatiedruk neemt toe; Federal Reserve Bowman heeft aangegeven dat verdere renteverhogingen nodig zijn</h2><p>Op dinsdag stegen de drie belangrijkste Amerikaanse aandelenindices zeven opeenvolgende handelsdagen, waarbij de Dow Jones Industrial Average met 0,17% steeg, de Nasdaq met 0,9% steeg en de S&amp;P 500-index met 0,25% steeg. De Nasdaq China Golden Dragon Index sloot 0,7% lager.</p>
<p>De Amerikaanse dollarkoers bleef herstellen van de scherpe daling van vorige week en eindigde met een stijging van 0,209% op 105,52. Amerikaanse obligatierendementen hervatten hun daling, waarbij de rendementen op langlopende Amerikaanse obligaties de daling leidden. Het rendement van de 10-jarige Amerikaanse schatkist sloot op 4,571%; Het rendement van de 2-jarige Amerikaanse schatkist, dat gevoeliger is voor het rentebeleid van de Federal Reserve, sloot op 4,915%.</p>
<p>Spotgoud daalde voor de tweede opeenvolgende handelsdag en sloot 0,43% lager op $1969,26 per ounce, het laagste in bijna drie weken; Spotzilver sloot 1,73% lager op $22,63 per ounce.</p>
<p>Als zwakke wereldwijde economische gegevens de zorgen overschaduwden dat de oorlog tussen Israël en Hamas zou kunnen uitlopen op een bredere regionale conflict, kelderden de internationale olieprijzen, waarbij zowel de olieprijzen nieuwe dieptepunten bereikten sinds 24 juli. WTI ruwe olie daalde met 4,69% tot $77,08 per vat; Brent ruwe olie sloot 4,40% lager op $81,40 per vat.</p>
<p>Vorige week werd algemeen aangenomen dat de Federal Reserve had beëindigd, en nu vertelt de Fed een volledig tegenovergesteld verhaal. In feite had deze situatie kunnen worden voorzien - de Fed moet zijn financiële omgeving aanscherpen om inflatie te bestrijden. Laten we eens kijken naar wat deze functionarissen hebben gezegd.</p>
<p>Voorzitter van de Federal Reserve van Minneapolis, Kashkari: Indien nodig zal de Federal Reserve meer maatregelen nemen met betrekking tot rentetarieven, en het FOMC heeft de inhoud van renteverlagingen nog niet besproken.</p>
<p>Chicago Fed Chairman Goolsbee: Als het rendement op langlopende schatkistpapier hoog blijft, is het waarschijnlijk gelijk aan het aanscherpen van het beleid. De eerste taak bij het veranderen van de rentepositie is de voortgang van de inflatie;</p>
<p>Federal Reserve Governor Bowman: Verdere renteverhogingen worden nog steeds verwacht.</p>
<p>Voorzitter van de Dallas Fed, Logan: Inflatie is nog steeds te hoog en de gegevens lijken te bewegen naar 3% in plaats van 2%.</p>
<p>Federal Reserve Governor Waller: De economie in het derde kwartaal groeit snel en de Federal Reserve houdt deze situatie nauwlettend in de gaten. De stijging van de 10-jarige Amerikaanse staatsobligatierendementen is een ‘aardbeving’.</p>
<p>Het GDPNow-model van de Atlanta Fed voorspelt dat de groeisnelheid van het BBP van de VS in het vierde kwartaal 2,1% zal zijn, in vergelijking met de vorige schatting van 1,2%.</p>
<p>Functionarissen van de Federal Reserve benadrukten deze week hun waakzaamheid tegen inflatie, en binnen enkele dagen lijken ze een collectieve neiging te hebben om pieken in de rentetarieven te keren.</p>
<p>Volgens analisten kan het voorkomen dat wanneer deze verschuiving (duifachtig) plaatsvindt, dit plotseling kan gebeuren, en “verdere stijgingen van de werkloosheid of een andere negatieve impact kunnen een katalysator worden voor deze situatie.”</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 mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het herdrukken van het artikel wordt toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p></div></div></div></div>