RGFpbHkgTmV3cyB8IFdhbGwgU3RyZWV0IHN0aWpndCBvcCBiYW5rcHJlc3RhdGllcywgdGVyd2lqbCBGT01DLXJlbnRlYmVzbHVpdCBlbiBtYXJrdGZhY3RvcmVuIGRyZWlnZW4=

2023-03-22, 01:43

<p><img src="https://gimg2.gateimg.com/image/article/16794492250322.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Wall20Street20ziet20opleving20van20aandelen20en20banken20stijgen20maar20onzekerheid20doemt20op20over20het20rentebesluit20van20de20Fed677468"><a name="Crypto Daily Digest: Wall Street ziet opleving van aandelen en banken stijgen, maar onzekerheid doemt op over het rentebesluit van de Fed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Wall Street ziet opleving van aandelen en banken stijgen, maar onzekerheid doemt op over het rentebesluit van de Fed</h2><p>Goedemorgen, handelaren! Laten we deze woensdag genadeloos grijpen en er het beste van maken! 🚀</p>
<p>De VIX van Wall Street, een graadmeter voor volatiliteit, daalde toen aandelen herstelden en banken stegen. De verzekering van de autoriteiten dat de recente financiële onrust niet tot een volledige crisis zou leiden, nam de bezorgdheid weg. Maar er is nog steeds onzekerheid over het besluit van de Federal Reserve om de rente al dan niet te verhogen. Het risico op een kredietcrisis neemt toe en de S&amp;P 500 zou een bodem kunnen vinden op 3.800. Bedrijven hebben ook geïnvesteerd in de Amerikaanse investment-grade obligatiemarkt, wat een andere zorgwekkende ontwikkeling is.</p>
<p>In Azië worden stijgende aandelenkoersen verwacht omdat beleggers zich voorbereiden op de rentebeslissing van de Federal Reserve. De aandelen stegen in Australië en de futures voor benchmarks in Japan en Hong Kong stegen ook. Hoewel de verkoop van overheidsobligaties naast stijgende aandelenprijzen wijst op een nieuwe appetijt voor risico, blijven sommige experts voorzichtig.</p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> overschreed $28.000 toen het Federal Open Market Committee zijn tweedaagse monetaire beleidsvergadering begon om te beslissen of het de rente opnieuw moet verhogen. Ether steeg ook bijna 2%. Traditionele markten werden ook groen te midden van een bankenrally en verbeterde investeerder <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>.</p>
<p>Coinbase’s aandelen zijn voor de zevende achtereenvolgende sessie gestegen en hebben het hoogste niveau bereikt sinds augustus op $84 per aandeel, gedreven door de stijging in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De prijs van Coinbase steeg opnieuw na een periode van aanhoudende dalingen. Andere aandelen die blootgesteld zijn aan crypto stegen ook. Coinbase is echter nog steeds 53% lager dan vorig jaar als gevolg van regelgevingsdruk en sectorbrede besmettingsangst. Coinbase betoogde dinsdag voor het Amerikaanse Hooggerechtshof dat geschillen over het dwingen van klanten tot arbitrage de rechtbanken tijdelijk moeten bevriezen terwijl de argumenten worden uitgespeeld. Dit zou belangrijk kunnen zijn voor Coinbase en andere crypto-bedrijven wanneer ze botsen met klanten, omdat het voorkomen kan dat gênante informatie aan het licht komt tijdens arbitrage.</p>
<h2 id="h2-Onderwerp20van20de20dag20PreFOMCrentebesluit2020Overwegingen20voor20handelaren527717"><a name="Onderwerp van de dag: Pre-FOMC-rentebesluit - Overwegingen voor handelaren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderwerp van de dag: Pre-FOMC-rentebesluit - Overwegingen voor handelaren</h2><p>Afgelopen weekend verkocht Credit Suisse zijn meer dan 100 jaar oude vermogensbeheerbedrijf, Credit Suisse Asset Management (CSAM), aan UBS voor $3 miljard. Geruchten suggereren dat CSAM aanzienlijke verliezen heeft geleden als gevolg van overbelichting aan risicovolle derivatentransacties. De verkoop heeft zorgen doen ontstaan over de stabiliteit van andere financiële instellingen en vragen doen rijzen over wie nog meer risico loopt.</p>
<p>Beleggers overwegen ook de impact van de verwachte renteverhoging van 25 basispunten door de Federal Reserve in maart, met verschillende meningen onder investeringsbanken. Terwijl Goldman Sachs voorspelt dat de Fed de rente niet opnieuw zal verhogen, voorspellen analisten van JPMorgan het tegenovergestelde.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679449363Untitled0322 1.jpeg" alt=""></p>
<p>De recente onrust in de banksector zorgt voor deflatoire trends en het aanscherpen van de financiële omstandigheden. Dit komt neer op een aanzienlijke renteverhoging, wat het risico op een scherpere economische vertraging verhoogt. (Gegevens per Apollo Global Management)</p>
<p>Ondanks recente bankfaillissementen en marktvolatiliteit herstelden Amerikaanse aandelen zich maandag en dinsdag licht, waarbij de Dow Jones beter presteerde dan de Nasdaq. Beleggers moeten echter voorzichtig blijven, aangezien een zwak herstel kan wijzen op een verder risico op een aanzienlijke marktdaling, vooral als technologieaandelen verzwakken. De correlatie van BTC met de Nasdaq stond op het moment van schrijven hoog op 0,76.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679449378Untitled0322 2.png" alt=""></p>
<p>Minder dan 20% van de beleggers is momenteel bullish op de markt, wat het laagste percentage is sinds september 2022. Ondertussen is het bearish sentiment de afgelopen weken voor de vierde keer toegenomen en bereikte het met 48,4% de hoogste stand van het jaar. (Gegevens volgens de American Association of Individual Investors)</p>
<p>De Amerikaanse dollar heeft zijn daling voortgezet en is onder een belangrijk technisch ondersteuningsniveau van 103,5 gedaald. De verkoop van CSAM aan UBS kan de euro ten goede komen nu de dollar verder verzwakt. De goudprijs onderging een kleine correctie na een korte opleving na de bankfaillissementen, maar het valt nog te bezien of deze de komende dagen zal blijven stijgen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679449404Untitled0322 3.jpeg" alt=""></p>
<p>De goudprijzen stijgen en bereiken nieuwe hoogtepunten van 52 weken, met een aanzienlijke stijging van de vraag naar dit veilige toevluchtsoord. Goud nadert all-time hoogtepunten in verschillende valuta en bevindt zich nog steeds in een meerjarig bereik tussen $1.680/oz en $2.060/oz in Amerikaanse dollars. Het volgende doel voor goud is de 2020⁄2022all-time highs van ongeveer $2.070/oz. Andere edelmetalen, met name zilver, zijn ook de moeite waard om in de gaten te houden om de opwaartse trend in goud te bevestigen. (Gegevens per Grindstone Intelligence)</p>
<p>Traders en investeerders moeten rekening houden met verschillende punten voordat de Federal Open Market Committee (FOMC) rentebeslissing neemt:</p>
<ol>
<li><p>De oorzaak van de aanzienlijke verliezen van Credit Suisse die hebben geleid tot de verkoop van haar vermogensbeheeractiviteiten aan UBS voor $3 miljard is onduidelijk, maar speculatie suggereert dat er sprake was van een te grote blootstelling aan riskante derivatenhandel.</p>
</li><li><p>Er zijn zorgen geuit over andere financiële instellingen en de mogelijkheid van onverwachte ineenstortingen die de markt verder zouden kunnen schaden, waarbij geruchten circuleren over JPMorgan en Goldman Sachs die betrokken zijn bij soortgelijke transacties als Credit Suisse.</p>
</li><li><p>Er is onzekerheid over de toekomstige koers van de Federal Reserve na opeenvolgende bankcrises. Er wordt verwacht dat de Fed de rente in maart met 25 basispunten zal verhogen, maar investeringsbanken hebben verschillende verwachtingen, waarbij Goldman Sachs voorspelt dat er geen verdere renteverhogingen zullen plaatsvinden, terwijl JPMorgan-analisten het tegenovergestelde voorspellen. Het gebrek aan consensus suggereert dat wat voor beleid de Fed ook aanneemt, sommigen mogelijk niet tevreden zullen zijn en de markt op korte termijn volatiel kan zijn.</p>
</li></ol>
<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 enkele beleggingssuggestie.<br></em><div><em></em> Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>