RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0by1tYXJrdGVuIHppZW4gYWFuemllbmxpamtlIGRhbGluZ2VuIG51IGRlIEVVIGRlIE1pQ0Etd2V0Z2V2aW5nIGZpbmFsaXNlZXJ0IGVuIHRlY2hyZXV6ZW4gemljaCB2b29yYmVyZWlkZW4gb20ga3dhcnRhYWxjaWpmZXJzIHRlIHJhcHBvcnRlcmVu

2023-04-24, 01:18

<p><img src="https://gimg2.gateimg.com/image/article/16822990260424.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting202020Bitcoin2020en20Ether20doet20aanzienlijke20dalingen20EU20rondt20MiCAwetgeving20af20om20cryptosector20te20reguleren20VK20onder20druk20om20hetzelfde20te20doen596396"><a name="Crypto Dagelijkse Samenvatting:   Bitcoin  en Ether doet aanzienlijke dalingen; EU rondt MiCA-wetgeving af om cryptosector te reguleren, VK onder druk om hetzelfde te doen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en Ether doet aanzienlijke dalingen; EU rondt MiCA-wetgeving af om cryptosector te reguleren, VK onder druk om hetzelfde te doen</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en Ether, twee van de grootste cryptocurrencies, hebben aanzienlijke prijsdalingen gezien in de afgelopen week. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De prijs daalde met ongeveer 9% tot $27,590, waardoor sommige handelaren vrezen voor een hervatting van de neerwaartse trend en winst boeken. Sommige analisten voorspellen echter dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> kan koopinteresse vinden in de zone van $26.600- $25.000 en een hogere bodem vormen die als lanceerplatform kan dienen voor de volgende rally. Ondanks de recente prijsdaling verwachten de meeste analisten een mogelijke rally die wordt veroorzaakt door de aankomende halvering in april 2024, mogelijk naar <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> voorbij $50,000. Echter zouden de recente Amerikaanse regelgevingsmaatregelen voor cryptocurrencies en inflatiezorgen kunnen beperken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Prijsstijging op korte termijn van ‘s.</p>
<p>Ether is gedaald tot $1.860, waarmee alle prijswinsten van zijn recente rally na de succesvolle implementatie van de Shanghai-upgrade zijn uitgewist. ETH is meer dan 11% gedaald vanaf een hoogtepunt van $2.140 op zondag te midden van bredere prijsdalingen op de cryptomarkt.</p>
<p>Aan de andere kant, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> De stablecoin van Gate.io, USDT, heeft zijn een-op-een inwisseling met de Amerikaanse dollar hersteld, met een waarde van ongeveer $ 81,4 miljard. Dit komt dicht in de buurt van het terugwinnen van de volledige marktwaarde die verloren is gegaan na de ineenstorting van de algoritmische concurrent TerraUSD minder dan een jaar geleden. <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> De herstel van ’s wordt ondersteund door zijn dominante rol in crypto als een middel voor transacties en waardeopslag.</p>
<p>In Europa heeft de EU haar MiCA-regelgeving voor de regulering van de cryptosector afgerond, wat druk legt op andere rechtsgebieden zoals het Verenigd Koninkrijk om hun eigen regels te implementeren. Hoewel de Financial Services and Markets Bill van het Verenigd Koninkrijk bepalingen bevat voor de regulering van crypto, stelt het MiCA-pakket specifieke autorisatievereisten vast voor crypto-dienstverleners en token-uitgevers. De duidelijkheid van de EU over de regulering geeft haar een voorsprong, maar de gefaseerde aanpak van het Verenigd Koninkrijk stelt het in staat zich gemakkelijker aan te passen aan veranderingen in de sector.</p>
<h2 id="h2-Cryptototaalmarktwaarde201127T200152020Neutrale20outlook944920"><a name="Cryptototaalmarktwaarde $1.127T (-0.15%) - Neutrale outlook" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cryptototaalmarktwaarde $1.127T (-0.15%) - Neutrale outlook</h2><p><img src="https://gimg2.gateimg.com/image/article/1682299124Untitled0424 1.png" alt=""></p>
<p>Bij nadere beschouwing van het 4-uurstijdsbestek zien we dat er geen daaropvolgende terugtrekking is geweest na de langste rode kaars op 21 april om 16:00 uur UTC. Dit suggereert dat veel kopers momenteel afzien van aankopen totdat de prijzen gunstiger voor hen worden. Vooruitkijkend wordt verwacht dat de totale marktkapitalisatie van cryptocurrencies steun zal vinden in de vorige vraagzone ($1.097T - $1.085T), hoewel er een mogelijkheid is van een korte daling naar het gebied van $1.058T voordat het snel terugkeert naar de vraagzone.</p>
<h2 id="h2-Macro20Markten20bereiden20zich20voor20op20een20drukke20week20van20economische20gegevens20Techreuzen20Microsoft20Meta20en20Amazon20maken20hun20kwartaalcijfers20bekend625147"><a name="Macro: Markten bereiden zich voor op een drukke week van economische gegevens; Techreuzen Microsoft, Meta en Amazon maken hun kwartaalcijfers bekend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Markten bereiden zich voor op een drukke week van economische gegevens; Techreuzen Microsoft, Meta en Amazon maken hun kwartaalcijfers bekend</h2><p>Voorafgaand aan een week vol economische gegevens die inzichten kunnen bieden in toekomstige rentetarieven, daalden Amerikaanse aandelenfutures en de dollar ten opzichte van belangrijke valuta’s. Hoewel S&amp;P 500- en Nasdaq 100-futures daalden in de vroege Aziatische handel, klommen futures in Japan. In swaps-markten wordt verwacht dat de Federal Reserve de rentetarieven in de komende weken zal verhogen, gevolgd door een reeks rentedalingen later in het jaar. De VS, de eurozone, Zweden en Japan zullen deze week BBP-gegevens en monetaire beslissingen vrijgeven. Ook worden er resultaten verwacht van Microsoft, Meta Platforms en Amazon.</p>
<p>Officiële gegevens tonen aan dat de economie van China in het eerste kwartaal met zijn snelste tempo in een jaar is gegroeid, meer dan de verwachtingen van economen. Jaar-op-jaar groeide het BBP met 4,5%, waarbij de detailhandelsverkopen in maart met 10,6% stegen en de vaste activa investeringen met 5,1% in Q1 toenamen. S&amp;P Global Ratings suggereert dat er een opwaarts risico is voor de huidige prognose van 5,5%. De herstel na 2022 wordt echter verwacht geleidelijk te zijn in plaats van V-vormig, vanwege de groei in industriële output die onder de pre-pandemische niveaus blijft en de voortdurende krimp van vastgoedinvesteringen, ondanks de uitbreiding van woningverkopen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Peter L. </strong>, Gate.io-onderzoeker<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. Herpublicatie van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>