RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBzdHVpdCBvcCB3ZWVyc3RhbmQgYmlqICQzMGssIEVUSCBoZXJzdGVsdDsgV2FsbCBTdHJlZXQgbG9vcHQgdm9vcnppY2h0aWcgdm9vcnVpdCBvcCBiYW5lbnJhcHBvcnQsIEJpZyBUZWNoIGhlcnN0ZWx0IG5hIG9wbWVya2luZ2VuIHZhbiBCdWxsYXJk

2023-04-07, 03:11

<p><img src="https://gimg2.gateimg.com/image/article/16808368690407.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht202020Bitcoin2020Struggles20op2030k20ETH20Bounces20Back20Big20Tech20herstelt20amp20Wall20Street20voorzichtig20voor20jobs20rapport77884"><a name="Crypto Dagelijks Overzicht:   Bitcoin  Struggles op $30k, ETH Bounces Back; Big Tech herstelt &amp; Wall Street voorzichtig voor jobs rapport" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Struggles op $30k, ETH Bounces Back; Big Tech herstelt &amp; Wall Street voorzichtig voor jobs rapport</h2><p><em>“ <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> strijdt tegen de weerstand van $30k, Ether stijgt met 4% met de Shanghai hard fork. <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> 20% winst behaald, terwijl USDC &amp; BUSD dalen als gevolg van bankproblemen. Wall Street voorzichtig voorafgaand aan het banenrapport, waarin wordt verwacht dat er in maart 230.000 banen zijn toegevoegd. Geldmarktfondsen bereiken een nieuw hoogtepunt van $5,25 biljoen.</em></p>
<p>Goedemorgen, handelaren! Laten we deze vrijdag meedogenloos grijpen en er het beste van maken! 🚀</p>
<hr>
<h2 id="h2-Crypto202020Bitcoin2020Struggles20to20Break2030K20Ether20Bounces20Back20Trader20Made20MillionDollar20Profit20met202020Dogecoin2020Tijdens20de20Elon20Musk20Rally339416"><a name="Crypto:   Bitcoin  Struggles to Break $30K, Ether Bounces Back; Trader Made Million-Dollar Profit met   Dogecoin  Tijdens de Elon Musk Rally" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Struggles to Break $30K, Ether Bounces Back; Trader Made Million-Dollar Profit met <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> Tijdens de Elon Musk Rally</h2><p><em>“Tree of Alpha,” een Twitter-handelaar, verdiende meer dan $1 miljoen in 30 minuten handelen <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> tijdens de Elon Musk rally. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> struggelt om door de weerstand van $30.000 te breken. Experts geloven dat de cryptomarkt te maken heeft met hoge volatiliteit. De waarde van Ether schommelt, maar is onlangs met 4% gestegen vanwege een aankomend evenement genaamd de Shanghai hard fork, wat mogelijk meer investeerders zal aantrekken. <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> De marktwaarde van Gate.io is dit jaar met 20% gestegen, terwijl de USDC van Circle een kwart van zijn waarde heeft verloren en de BUSD van Paxos meer dan de helft van zijn waarde heeft verloren als gevolg van problemen bij banken en regelgevingskwesties.</em></p>
<p>TreeofAlpha was even trending <a href="/price/optimism-op" target="_blank" class="blog_inner_link">op Crypto</a> Twitter. Niet verrassend nadat bekend werd dat ze groot succes hadden behaald, met meer dan een miljoen dollar verdiend in slechts 30 minuten door te handelen. <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> (DOGE) tijdens de Elon Musk-rally. Dat is gek, toch? Blijkbaar zag Tree of Alpha dat <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> was overal op Twitter, dus zetten ze er $8 miljoen op in. Toen de prijs $0,095 bereikte, haalden ze het geld eruit en maakten ze een fortuin.</p>
<p>Hoe dan ook, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> heeft de laatste tijd moeite gehad om door de weerstand van $30k te breken. Experts denken dat investeerders niet zeker weten wat ze moeten doen, maar sommige mensen geloven dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> kan in april weer stijgen, op basis van de trends van voorgaande jaren.</p>
<h2 id="h2-Bitcoin2020BTC20279819200192020Neutrale20Outlook390199"><a name="Bitcoin  (BTC) $27981.9 (-0.19%) - Neutrale Outlook" 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> (BTC) $27981.9 (-0.19%) - Neutrale Outlook</h2><p><img src="https://gimg2.gateimg.com/image/article/1680836969Untitled0407.png" alt=""></p>
<p><strong>Overzicht:</strong></p>
<ul>
<li><strong><em>Dichtstbijzijnde dagelijkse ondersteuningszone: 27840 - 27520</em></strong></li><li><strong><em>Dichtstbijzijnde dagelijkse weerstandszône: 28160 - 28380</em></strong></li><li><strong><em>Sleutelniveau: 26580 (laag op 18 maart)</em></strong></li></ul>
<p><strong>Dagelijkse weerstandszones</strong></p>
<ol>
<li>28160 - 28380</li><li>28870 - 29180</li><li>29800 - 31000</li></ol>
<p><strong>Dagelijkse ondersteuningszones</strong></p>
<ol>
<li>27840 - 27520</li><li>26910 - 26580</li><li>25780 - 25510</li></ol>
<h3 id="h3-ETH296021"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p>Ondertussen is de waarde van Ether ook heen en weer geslingerd. Het daalde onlangs naar onder de $1.900, maar steeg vervolgens met 4% vanwege het aanstaande evenement Shapella hard fork upgrade, wat meer investeerders naar Ether staking zou kunnen brengen. En over staking gesproken, tokens voor liquid staking (LSP’s) bewogen niet veel op donderdag.</p>
<h3 id="h3-USDT145196"><a name="USDT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>USDT</h3><p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> heeft het ook behoorlijk goed gedaan. De marktwaarde is dit jaar met 20% gestegen dankzij de <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> Network, dat populair is in China. Aan de andere kant heeft de digitale valuta USDC van Circle een kwart van zijn waarde verloren, en de digitale valuta BUSD van Paxos is dit jaar meer dan gehalveerd in waarde geraakt. Dat komt doordat Circle wat bankproblemen had, en toezichthouders Paxos hebben verteld om te stoppen met het maken van meer van zijn valuta.</p>
<h2 id="h2-Macro20Banengroei20blijft20stabiel20werkloosheid20laag20wat20zal20het20betekenen20voor20de20Fed371637"><a name="Macro: Banengroei blijft stabiel, werkloosheid laag: wat zal het betekenen voor de Fed?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Banengroei blijft stabiel, werkloosheid laag: wat zal het betekenen voor de Fed?</h2><p><em>“Wall Street speelt op veilig voor het banenrapport en de grote technologiebedrijven maken een comeback nadat Bullard heeft gezegd dat kredietvoorwaarden geen recessie zullen veroorzaken. De S&amp;P 500 verwacht zwakke groei dit kwartaal en handelaren wachten op het loonlijstrapport om aanwijzingen te krijgen over de volgende beleidsmaatregel van de Fed, met een voorspelde toevoeging van 230.000 banen en lage werkloosheidscijfers. Het geldmarkt fonds bereikte een nieuw hoogtepunt van $5,25 biljoen, maar mensen investeren langzamer dan verwacht.”</em></p>
<p>Wall Street speelt op veilig in afwachting van het banenrapport van vrijdag.</p>
<p>De aandelenmarkt boekte lichte winsten en de obligatiehandel was gemengd, terwijl de dollar nauwelijks bewoog. Grote technologiebedrijven leidden de weg in het herstel, nadat St. Louis Fed-president James Bullard zijn gedachten uitte dat strakkere kredietvoorwaarden de economie niet in een recessie zullen storten.</p>
<p>Handelaren zijn echter onzeker over de loongegevens en of deze inflatieverkoeling of economische zorgen zullen laten zien, dus ze houden zich terug. Bovendien heeft het aankomende kwartaalcijferseizoen extra belang, omdat dit kwartaal naar verwachting het dieptepunt in de winstgroei van de S&amp;P 500 zal vertegenwoordigen.</p>
<p>Intussen waren de Amerikaanse aandelenfutures grotendeels onveranderd in dunne handel voorafgaand aan een driedaags weekend. Het loonrapport, dat door de Amerikaanse regering op vrijdag zal worden vrijgegeven, zal handelaren aanwijzingen geven over de volgende beleidsmaatregel van de Federal Reserve.</p>
<p>Verwacht wordt dat het rapport zal laten zien dat er in maart nog steeds 230.000 banen zijn toegevoegd en dat de werkloosheid dicht bij een historisch laag niveau blijft. Ten slotte hebben geldmarkt-fondsen een nieuw recordhoogte bereikt met een totaal vermogen van $5,25 biljoen, hoewel de instroom is vertraagd ten opzichte van het recente snelle tempo.</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 enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen worden er juridische stappen ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>