RGFnZWxpamtzIG5pZXV3cyB8IEV0aGVyZXVtLXVwZ3JhZGUgc3RpbXVsZWVydCBjcnlwdG8tdm9vcnVpdHppY2h0ZW4sIEVUSC1kb21pbmFudGllIHN0ZWVnIG1ldCA1JTsgV2luc3QgZW4ga2FucyBvcCByZWNlc3NpZSBudSBpbiBmb2N1cw==

2023-04-14, 01:04

<p><img src="https://gimg2.gateimg.com/image/article/16814337880414.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting202020Ethereum2020Shapellaupgrade20van20s20doet20Etherprijsrally20ontbranden20vermindert202020Bitcoin2020Dominantie20Frankrijk20lokt20cryptobedrijven20ondanks20wereldwijde20onderdrukking481830"><a name="Crypto Dagelijkse Samenvatting:   Ethereum  Shapella-upgrade van ‘s doet Ether-prijsrally ontbranden, vermindert   Bitcoin  Dominantie; Frankrijk lokt cryptobedrijven ondanks wereldwijde onderdrukking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Shapella-upgrade van ‘s doet Ether-prijsrally ontbranden, vermindert <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Dominantie; Frankrijk lokt cryptobedrijven ondanks wereldwijde onderdrukking</h2><p>De succesvolle upgrade van de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> het netwerk van proof-of-work naar proof-of-stake te veranderen, bekend als Shapella, heeft geleid tot een stijging van de prijs van Ether boven de $2.000, bijna 6% omhoog. De upgrade maakte de opname mogelijk van meer dan 17,4 miljoen gestaakte tokens, ter waarde van $35 miljard, van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> het proof-of-stake blockchain van ‘s, waarbij zorgen worden weggenomen dat ETH-investeerders mogelijk niet in staat zouden zijn om hun tokens terug te vorderen die vastzitten in staking-contracten. De prijsstijging van Ether met 4,7% in de afgelopen 24 uur leidde de opwaartse trend van de bredere cryptoprijzen, terwijl <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> bleef achter bij altcoins met slechts een stijging van 1,6% gedurende de dag. Dit heeft een daling (-1,94%) veroorzaakt in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>’s dominantiepercentage van bijna een recordhoogte van bijna twee jaar (49%).</p>
<p>De koers van ether die in ETH staking contracts wordt gestort, is sinds januari 2021 gestaag gestegen, wat erop wijst dat het actief in de smaak valt. Het succesvol afronden van Shapella wijst op verminderd risico, verhoogde liquiditeit en een stijging van de waarde van het actief. Ondertussen is de bullish outlook voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Mijnwerkers worden geholpen door de afkoeling van de inflatie en de banenmarkt, wat de Federal Reserve ertoe kan brengen om te pauzeren of zelfs zijn lange reeks renteverhogingen van meer dan een jaar terug te draaien. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De aandelen van mijnwerkers stegen sterk op donderdag, met Marathon Digital en Hut 8 Mining respectievelijk met 14,6% en 15,9%.</p>
<p>In Frankrijk, ondanks de crackdowns op digitale activa in andere landen zoals China en Singapore, heeft de gastvrije benadering van president Emmanuel Macron bedrijven aangetrokken zoals Circle Internet Financial en een paar van de grootste beurzen om van Parijs hun Europese basis te maken. Het aandeel van Frankrijk in durfkapitaaldeals in de cryptoruimte is in het eerste kwartaal gestegen. Er zijn echter nog steeds uitdagingen zoals het Franse arbeidssysteem en een mogelijke politieke backlash mocht crypto betrokken raken bij meer spraakmakende schandalen.</p>
<h2 id="h2-Bitcoin2020Dominantie20BTCD20479320062456892"><a name="Bitcoin  Dominantie (BTC.D) 47,93% (-0,62%)" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Dominantie (BTC.D) 47,93% (-0,62%)</h2><p><img src="https://gimg2.gateimg.com/image/article/1681434225Untitled0414 1.png" alt=""></p>
<h2 id="h2-Ether20Dominantie20ETHD20204320281889695"><a name="Ether Dominantie (ETH.D) 20.43% (+2.81%)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ether Dominantie (ETH.D) 20.43% (+2.81%)</h2><p><img src="https://gimg2.gateimg.com/image/article/1681434239Untitled0414 2.png" alt=""></p>
<h2 id="h2-Macro20Bank20Job20en20inflatiedata20wijzen20op20een20stabiele20arbeidsmarkt20verzwakkende20economie20Winst20en20kans20op20recessie20nu20in20focus223796"><a name="Macro: Bank Job en inflatiedata wijzen op een stabiele arbeidsmarkt, verzwakkende economie; Winst en kans op recessie nu in focus" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Bank Job en inflatiedata wijzen op een stabiele arbeidsmarkt, verzwakkende economie; Winst en kans op recessie nu in focus</h2><p>Amerikaanse aandelen boekten winst na zwakkere banen- en inflatiegegevens dan verwacht, wat erop wijst dat de renteverhogingen van de Federal Reserve mogelijk tot een einde komen. Hierdoor steeg de S&amp;P 500 met 1,3% en won de Nasdaq 100 2,0%. Aan de andere kant stegen de Treasury-rendementen en verloor de dollar terrein ten opzichte van een mandje valuta’s. De dollar verzwakte ten opzichte van al zijn Group-of-10 collega’s voor de tweede dag op rij, waardoor een maatstaf voor de sterkte van de greenback naar het laagste niveau in meer dan twee maanden daalde. Amazon.com-aandelen stegen ook met 4,7% na de lancering van technologie voor cloudklanten en een AI-marktplaats. SoftBank Group Corp daalde echter vanwege plannen om zijn belang in Alibaba Group Holding Ltd te verminderen.</p>
<p>Ondertussen wordt verwacht dat de Aziatische aandelenmarkten hoger zullen openen, na een rally op de Amerikaanse aandelenmarkt, aangezien economische gegevens suggereren dat de Federal Reserve mogelijk het einde nadert van haar agressieve renteverhogingscyclus. Futures voor aandelengrondslagen in Australië, Japan en Hong Kong geven allemaal aan dat de markten hoger zullen openen, terwijl de Amerikaanse futures weinig veranderd waren. Dit gebeurt terwijl de dollar blijft verzwakken ten opzichte van een mandje valuta, wat goed nieuws kan zijn voor exporteurs in de regio.</p>
<p>Beleggers zullen nu nauwlettend in de gaten houden hoe het gaat met de bankwinsten, die van start zullen gaan met JPMorgan Chase &amp; Co., Wells Fargo &amp; Co., en Citigroup Inc. op vrijdag. De commentaren van leidinggevenden over de waarschijnlijkheid van een recessie worden naar verwachting het middelpunt van de belangstelling.</p>
<p>Het is het vermelden waard dat werkloosheidsaanvragen voor de week die eindigde op 8 april stegen tot 239.000, vergeleken met een mediane schatting van 235.000. Dit voegt bewijs toe dat de arbeidsmarkt begint te verzachten. Bovendien daalden producentenprijzen in maart met de meeste sinds het begin van de pandemie.</p>
<p>Deze gegevens geven echter aan dat inflatie niet verrassend is aan de positieve kant en dat de arbeidsmarkt stabiel lijkt. “Het eerste is dat inflatie niet verrassend is aan de positieve kant, en tegelijkertijd lijkt de arbeidsmarkt stabiel. En dus krijgen we vandaag een soort optimistische kijk waarbij we bijna een situatie hebben zoals bij Goudlokje waar inflatie zal vertragen, maar de economie niet instort”, aldus Que Nguyen, Chief Investment Officer van aandelenstrategieën bij Research Affiliates.</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 beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits 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>