RGFnZWxpamtzIG5pZXV3cyB8IFZTIFN0YWJsZWNvaW4td2V0c3Zvb3JzdGVsIHZvb3JnZXN0ZWxkIHRlIG1pZGRlbiB2YW4gZ3JvZWkgdmFuIGRlIGNyeXB0b21hcmt0IGVuIHRlZ2Vuc2xhZ2VuIGluIGRlIHNlY3RvcjsgQWFuZGFjaHQgdm9vciBGZWQncyBCZWlnZSBCb29r

2023-04-17, 00:51

<p><img src="https://gimg2.gateimg.com/image/article/16816925420417.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting202020Bitcoin2020en202020Ethereum2020Opkomst20terwijl20startups20instorten20VS20Stablecoin20Bill20voorgesteld562861"><a name="Crypto Dagelijkse Samenvatting:   Bitcoin  en   Ethereum  Opkomst terwijl start-ups instorten; VS Stablecoin Bill voorgesteld" 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 <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Opkomst terwijl start-ups instorten; VS Stablecoin Bill voorgesteld</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> zagen opmerkelijke prijsstijgingen in de afgelopen week, respectievelijk met ongeveer 8,5% en 14,5% stijgen. De Shapella-upgrade voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> heeft geloofwaardigheid teruggebracht naar de markt, terwijl andere altcoins zoals ARB, SOL en IMX ook stijgingen zagen, waarbij de totale cryptomarkt vorige week met 9% steeg. Ondertussen sloten aandelen op vrijdag af na de resultaten van het kwartaalcijferseizoen.</p>
<p>In tegenstelling tot de bullish crypto markt, heeft de cryptocurrency industrie geleden in het afgelopen jaar, met faillissementen en regelgevende onderzoeken die achterbleven. Start-ups zoals FTX, Blockfi, Celsius en Voyager Digital zijn ingestort, en banken zoals Signature Bank, Silicon Valley Bank en Silvergate Capital Corp zijn ook mislukt. Private financiering voor crypto start-ups is met 80% gedaald vanaf het hoogste punt ooit naar $2.4 miljard in Q1 2023.</p>
<p>In het nieuws over regelgeving heeft de financiële commissie van het Huis van Afgevaardigden van de VS een ontwerp van de Stablecoin-wet uitgebracht, waarin een moratorium wordt voorgesteld voor Stablecoins die worden gedekt door cryptocurrencies en een onderzoek naar de mogelijke impact van een door de Federal Reserve uitgegeven CBDC. Het wetsvoorstel circuleert al sinds afgelopen najaar onder wetgevers en volgt op twee incidenten met Stablecoins in het afgelopen jaar. Een subcommissie zal een hoorzitting houden over Stablecoins en de voltallige commissie zal horen van SEC-voorzitter Gary Gensler.</p>
<h2 id="h2-Crypto20Totale20Markt20Kapitalisatie201243T200022020Neutrale20Vooruitzichten283689"><a name="Crypto Totale Markt Kapitalisatie $1.243T (-0.02%) - Neutrale Vooruitzichten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Totale Markt Kapitalisatie $1.243T (-0.02%) - Neutrale Vooruitzichten</h2><p><img src="https://gimg2.gateimg.com/image/article/1681692656Untitled0417 .png" alt=""></p>
<p>Vorige week kende de algehele cryptocurrency-markt een stijging van bijna 9% als gevolg van een toestroom van fondsen. Hoewel de grafiek van Tradingview mogelijk geen exacte weergave biedt van de marktkapitalisatie van crypto, dient het als een aanvullend instrument voor ons om een beter begrip te krijgen van het grotere plaatje. Door de implementatie van de Wyckoff-methodologie kunnen we waarnemen dat de marktkapitalisatie van crypto consequent een bullish trend vertoont na het doorlopen van verschillende accumulatiefasen gedurende de afgelopen 10 maanden.</p>
<p>Aangezien de marktkapitalisatie de cruciale aanbodzone nadert op ongeveer $ 1,30 biljoen - $ 1,32 biljoen, kan een mogelijke terugval naar $ 1,17 biljoen - 1,15 biljoen worden verwacht. Als de trend zich voortzet en de marktkapitalisatie de aanbodzone overtreft om het maandelijkse niveau van 1,37T te bereiken, zal er waarschijnlijk een terugval naar de leveringszone plaatsvinden, samen met een kleine distributiefase op lagere tijdsbestekken.</p>
<h2 id="h2-Macro20Beleggers20kijken20uit20naar20de20Beige20Book20van20de20Fed20te20midden20van20weddenschappen20van20renteverhogingen20door20swapshandelaren597532"><a name="Macro: Beleggers kijken uit naar de Beige Book van de Fed te midden van weddenschappen van renteverhogingen door swaps-handelaren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Beleggers kijken uit naar de Beige Book van de Fed te midden van weddenschappen van renteverhogingen door swaps-handelaren</h2><p>Vorige week zagen de Amerikaanse aandelen een stijging, met de S&amp;P 500 met 0,8% en de Nasdaq 100 met 0,1%. De financiële sector leidde de charge, met JPMorgan Chase &amp; Co. en Citigroup Inc. die sterke winstcijfers rapporteerden. Ook de opbrengsten van de schatkist stegen, waarbij de tweejaarsrente een wekelijks hoogtepunt van ongeveer 4,1% bereikte. Charles Schwab Corp. en State Street Corp. zullen deze week rapporten uitbrengen, waar beleggers nauwlettend op zullen letten voor tekenen van de gezondheid van de sector.</p>
<p>Op maandag stegen de Amerikaanse aandelenfutures iets, terwijl de Aziatische aandelenindices wijzen op een gemengde opening. Swapshandelaren wedden op een renteverhoging van een kwart procentpunt in mei, waarbij investeerders reikhalzend uitkijken naar de publicatie van het Beige Book van de Fed en commentaar van functionarissen. Inflatieverwachtingen stegen ook in april, waarbij consumenten prijzen met 4,6% op jaarbasis zien stijgen.</p>
<p>Deskundigen waarschuwen echter dat technocraten wereldwijd gevangen zitten in een intellectuele schuldenval, met een gebrek aan urgentie om arme landen te helpen. Het IMF voorspelt een terugkeer naar bijna 100% wereldwijde schuld ten opzichte van het BBP tegen 2028, met oproepen voor meer ingrijpende maatregelen, waaronder schuldverlichting tot $520 miljard. De minister van Financiën van Zambia heeft zelfs gewaarschuwd voor ontslagen van leraren en gezondheidswerkers als er niet snel hulp komt. Arme landen betalen de prijs voor de inflatiebestrijding van centrale banken in ontwikkelde landen, waarbij economen waarschuwen voor een ‘verloren decennium’ in de ontwikkeling van arme economieën.</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 standpunten van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>