RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBvbmRlcnZpbmR0IHJlZ2VsZ2V2aW5nc3VpdGRhZ2luZ2VuLCBTRUMgdmVyZ2VsaWprdCBtYXJrdCBtZXQgamFyZW4gMjA7IFRlY2hub2xvZ2lzY2hlIGFhbmRlbGVuIHN0aW11bGVyZW4gYnVsbG1hcmt0LCBGZWQtYmVsZWlkIHdvcmR0IGhlcm92ZXJ3b2dlbg==

2023-06-09, 01:01

<p><img src="https://gimg2.gateimg.com/image/article/16862723360609.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Bitcoin20staat20voor20regelgevingsuitdagingen20terwijl20de20voorzitter20van20de20SEC20de20cryptomarkt20vergelijkt20met20de20aandelenmarkt20van20de20jaren201920540388"><a name="Crypto Dagelijkse Samenvatting: Bitcoin staat voor regelgevingsuitdagingen terwijl de voorzitter van de SEC de cryptomarkt vergelijkt met de aandelenmarkt van de jaren 1920." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> staat voor regelgevingsuitdagingen terwijl de voorzitter van de SEC de cryptomarkt vergelijkt met de aandelenmarkt van de jaren 1920.</h2><p>De weg naar het doorbreken van het niveau van $27.500 lijkt moeilijk voor Bitcoin, ondanks het veerkrachtige herstel van de steun op $25.500. Beleggers maken zich zorgen vanwege de toegenomen regelgevende controle en rechtszaken gericht op grote beurzen zoals Coinbase en Binance. De U.S. Securities and Exchange Commission (SEC) neemt vastberaden handhavingsmaatregelen tegen cryptocurrency-gerelateerde activiteiten, mogelijk in een poging eerdere regelgevende tekortkomingen recht te zetten. Daarnaast temperen zorgen over een mogelijke wereldwijde recessie de vooruitzichten voor risicovolle activa, waaronder cryptocurrencies, en recente negatieve macro-economische gegevens, zoals de daling van de import in China en de krimp van het bruto binnenlands product (BBP) van Japan, dragen bij aan het heersende pessimisme.</p>
<p>Beroemde miljardairinvesteerder Ray Dalio heeft de bezorgdheid verder vergroot door te waarschuwen voor hoge inflatie en buitensporige schulden in de Verenigde Staten. Deze zorgen worden versterkt door de dringende noodzaak voor de Amerikaanse overheid om geld in te zamelen na het bereiken van het schuldenplafond. Ook de mogelijkheid van de Europese Centrale Bank om de inflatie te bestrijden wordt belemmerd door de recessie in de eurozone, zoals blijkt uit herziene schattingen van Eurostat.</p>
<p>De derivatenmarkten van Bitcoin weerspiegelen een bearish outlook, waarbij professionele handelaren gepositioneerd zijn voor een lage waarschijnlijkheid van de BTC-prijs die $27.500 overschrijdt. In plaats daarvan lijkt een herstest van het ondersteuningsniveau van $25.500 waarschijnlijker.</p>
<p>Echter, te midden van de recente rechtszaken van de SEC tegen Binance en Coinbase, vonden crypto-investeerders een sprankje hoop in positieve banengegevens uit de Verenigde Staten. De onverwachte stijging van de aanvankelijke werkloosheidsuitkeringen suggereert een mogelijke versoepeling van de arbeidsmarkt. Deze ontwikkeling zou de Amerikaanse centrale bank kunnen aanzetten om zijn voortdurende reeks renteverhogingen stop te zetten, een stap die gunstig zou kunnen zijn voor de activaprijzen.</p>
<p>Hoewel de aankondigingen van de SEC bezorgdheid hebben gewekt binnen de cryptobranche, blijft de marktsentiment, zoals aangegeven door de Fear and Greed-index, neutraal. Het ontbreken van significante prijsactie suggereert dat investeerders relatief onaangedaan zijn door de regelgevende ontwikkelingen. Echter, gegevens van Glassnode onthullen een verschuiving in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> handelsvolume van de Verenigde Staten naar Aziatische markten, mogelijk beïnvloed door het regulerende standpunt van de SEC.</p>
<p>In een toespraak op de Piper Sandler Global Exchange &amp; Fintech Conference, trok SEC-voorzitter Gary Gensler parallellen tussen de huidige crypto-markt en de aandelenmarkt van de jaren 1920. Gensler karakteriseerde de crypto-markt als vol met oplichting, fraudeurs en Ponzi-schema’s. Hij pleitte voor de toepassing van effectenwetten op de crypto-markt, waarbij hij het belang van naleving en het scheiden van uitwisseling, effectenmakelaar en clearingfuncties benadrukte. Gensler betoogde dat deze maatregelen, vergelijkbaar met de regelgeving die in de jaren 1930 aan de aandelenmarkt werd opgelegd, noodzakelijk zijn om de bestaande problemen in de crypto-ruimte aan te pakken. Critici beschuldigen Gensler echter van het hanteren van een overdreven ruime regelgevende benadering die innovatie binnen de Amerikaanse crypto-industrie verstikt.</p>
<h2 id="h2-Bitcoin20BTC202645020022020Neutrale20Outlook217504"><a name="Bitcoin (BTC) $26,450 (-0.2%) - Neutrale Outlook" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC) $26,450 (-0.2%) - Neutrale Outlook</h2><p><img src="https://gimg2.gateimg.com/image/article/1686272471Untitled0609 1.png" alt=""></p>
<p>In de afgelopen 24 uur is er beperkte activiteit geweest en een merkbare afname van het handelsvolume voor BTC. Dit suggereert dat investeerders een voorzichtige benadering aannemen en zich onthouden van het maken van belangrijke stappen terwijl ze wachten op verdere duidelijkheid na de recente grote liquidatie-evenementen die plaatsvonden in de vorige week.</p>
<p><strong>Overzicht:</strong></p>
<ul>
<li><strong><em>Dichtstbijzijnde dagelijkse steunzone: 26380 - 25818</em></strong></li><li><strong><em>Dichtstbijzijnde dagelijkse weerstandszones: 26700 - 27260</em></strong></li><li><strong><em>Sleutelniveau: 25243 (Dagelijks 200EMA)</em></strong></li></ul>
<p><strong>Dagelijkse weerstandszones</strong></p>
<ol>
<li>26700 - 27260</li><li>27790 - 28420</li><li>29096 - 29885</li></ol>
<p><strong>Dagelijkse ondersteuningszones</strong></p>
<ol>
<li>26380 - 25818</li><li>25360 - 25240</li><li>24570 - 24270</li></ol>
<h2 id="h2-Macro20Technologieaandelen20stuwen20bullish20markt20als20beleggers20Fedbeleid20heroverwegen294506"><a name="Macro: Technologieaandelen stuwen bullish markt als beleggers Fed-beleid heroverwegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Technologieaandelen stuwen bullish markt als beleggers Fed-beleid heroverwegen</h2><p>In een opmerkelijke marktrally leidden technologieaandelen een rally die de winst van de S&amp;P 500 voorbij de belangrijke 20% mijlpaal bracht, wat wijst op een volwaardige bullmarkt. Ondanks een stijging van het aantal werkloosheidsaanvragen die wijst op een afkoeling van de arbeidsmarkt, kreeg de technologiesector een krachtige impuls en trotseerde daarmee de speculatie over langdurig hogere rentetarieven door de Federal Reserve.</p>
<p>Beleggers heroverwegen nu het traject van het monetaire beleid van de Fed na onverwachte renteverhogingen door centrale banken in Australië en Canada. Hoewel handelaren tegen juli volledig een andere verhoging hadden ingeprijsd, hebben deze onvoorziene acties door andere centrale banken tot een herbeoordeling geleid. Krishna Guha, een analist van Evercore ISI, benadrukte dat marktbewegingen op basis van deze acties van centrale banken waarschijnlijk zullen vervagen, aangezien de Fed de belangrijkste prijsbepaler blijft.</p>
<p>De rally in technologische aandelen werd geleid door grote spelers in de industrie zoals Nvidia Corp. en Advanced Micro Devices Inc., die aanzienlijke winsten boekten te midden van de gekte rond kunstmatige intelligentie-gerelateerde aandelen. De Nasdaq 100-index steeg met een indrukwekkende 1,3%, als aanvulling op de stijging van 0,6% van de S&amp;P 500. Ook Adobe Inc. zag een opmerkelijke stijging van 5% toen het plannen onthulde voor een nieuwe abonnementsdienst voor kunstmatige intelligentie, inclusief auteursrechtdiensten.</p>
<p>In Europa bleef de Stoxx 600-index relatief onveranderd, met de aandacht die verschuift naar SBB, een bedrijf dat centraal staat in de voortdurende vastgoedcrisis in Zweden. SBB heeft een aanzienlijke tegenslag ondervonden toen S&amp;P Global Ratings zijn beoordelingen verlaagde, waardoor de al ernstige financieringscrisis van het bedrijf verergerde. Deze ontwikkelingen benadrukken de uitdagingen waarmee SBB en de bredere vastgoedmarkt in Zweden worden geconfronteerd.</p>
<p>Met betrekking tot Aziatische markten staan aandelen op het punt hoger te openen, gebruikmakend van het positieve momentum dat wordt gegenereerd door de technologie-aandelenrally in de Verenigde Staten. Futures voor benchmarks in Australië, Japan en Hongkong zijn vooruitgegaan, wat wijst op een tweede opeenvolgende wekelijkse winst voor de regionale index. Ondertussen tonen Amerikaanse aandelenfutures beperkte veranderingen, terwijl de markt de implicaties van de recente renteverhogingen door andere centrale banken verwerkt.</p>
<p>Nu de markten hun focus verleggen, ligt de schijnwerper op de Chinese inflatiegegevens, die naar verwachting minimale veranderingen zullen laten zien, waardoor de noodzaak van verdere stimulering wordt versterkt. Bovendien heeft de sterkere dan verwachte economische groei van Japan in het eerste kwartaal de yen versterkt, die standhield te midden van marktfluctuaties.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Peter L. </strong>, Onderzoeker bij Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 wordt er juridische actie ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>