RGFnZWxpamtzIG5pZXV3cyB8IEJlYXIgTWFya2V0IGlzIHZvb3JiaWosIGRlIHVpdHNwcmFrZW4gdmFuIFhSUCBibGlqdmVuIG9uemVrZXIsIHJlbnRldmVyaG9naW5nZW4gaGFuZ2VuIGluIGRlIGx1Y2h0LCBmb2N1cyBvcCBBbWVyaWthYW5zZSBkZXRhaWxoYW5kZWxzZ2VnZXZlbnM=

2023-07-17, 04:21

<p><img src="https://gimg2.gateimg.com/image/article/16895765490717.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20berenmarkt20is20geindigd20XRPuitspraken20blijven20onzeker20en20zkSync20Era20overtreft20Arbitrum20en20wordt20de20L2koning246714"><a name="Crypto Dagelijkse Samenvatting: De berenmarkt is geëindigd, XRP-uitspraken blijven onzeker, en zkSync Era overtreft Arbitrum en wordt de L2-koning" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De berenmarkt is geëindigd, XRP-uitspraken blijven onzeker, en zkSync Era overtreft Arbitrum en wordt de L2-koning</h2><p>Komt de berenmarkt echt ten einde? Onlangs plaatste Arthur, de oprichter van DeFiance Capital, op sociale media dat hij persoonlijk gelooft dat 14 juli 2023 het officiële einde markeert van de berenmarkt van 2022-2023, om de volgende redenen:</p>
<ol>
<li><p>De ergste macro-economische verkrapping is voorbij, de CPI is gedaald en de reële rentetarieven zijn positief. Het is mogelijk om volgend jaar renteverlagingen te zien.</p>
</li><li><p>Sinds BlackRock heeft aangevraagd voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> ETF, instellingen hebben cryptocurrency consequent geaccepteerd als een asset class.</p>
</li><li><p>Als de SEC zelfs niet kan winnen van de token ( <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>) die waarschijnlijk wordt gedefinieerd als een effect, dan wordt de kans dat andere tokens als effecten worden erkend aanzienlijk verminderd.</p>
</li><li><p>De meeste korte termijn speculanten hebben de markt verlaten, en afgezien van enkele duidelijke unlock schema’s, zullen huidige muntbezitters mogelijk niet op korte termijn verkopen.</p>
</li><li><p>Er is een ernstig tekort aan niet-BTC- en ETH-configuraties op de markt en er is nog veel te doen.</p>
</li><li><p>Het beleid van Hong Kong om cryptocurrency welkom te heten is waar en betrouwbaar, wat de deur zal openen naar een nieuwe wereld voor Aziatische financiële instellingen om op een legale manier cryptocurrency binnen te gaan.</p>
</li></ol>
<p>Na vorige week ‘Crazy Thursday’ te hebben ervaren, is de populariteit van <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> nu afgekoeld.</p>
<p>Voormalig SEC-functionaris John Reed Stark heeft verklaard dat het oordeel over XRP mogelijk kan worden aangevochten en teruggedraaid. Stark verklaarde dat het oordeel van de rechtbank in de Ripple-zaak op meerdere manieren verontrustend is. Het oordeel lijkt in strijd te zijn met de missie van de SEC om beleggers te beschermen.</p>
<p>Stark verklaarde verder dat de uitspraak niet alleen arrogant is, maar ook beledigend, omdat het ervan uitgaat dat particuliere beleggers meestal dwaas zijn. De uitspraak over de XRP-munt zal waarschijnlijk worden aangevochten.</p>
<p>Brad Garlinghouse, CEO van Ripple, gelooft dat de Amerikaanse Securities and Exchange Commission (SEC) een lang proces zal ondergaan voordat het de mogelijkheid heeft om in beroep te gaan tegen de uitspraak in de zaak tegen Ripple Labs. Hij zei: ‘Vanuit juridisch oogpunt bepaalt de huidige wet dat XRP geen effect is. Eerlijk gezegd zijn we erg optimistisch voordat de SEC de mogelijkheid heeft om in beroep te gaan (wat enkele jaren zal duren).’</p>
<p>Garlinghouse benadrukte ook dat dit de eerste keer is dat de SEC de “cryptocurrency-zaak” heeft verloren. Hij noemde de SEC een “pestkop” en achtervolgde deelnemers in de encryptie-industrie die niet in staat waren om “gepaste verdediging” te voeren.</p>
<p>Volgens L2BEAT-gegevens was het aantal transacties van zkSync Era in de afgelopen 30 dagen 23,75 miljoen, meer dan dat van Arbitrum, 23,59 miljoen, waardoor het de grootste is. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L2-project in de afgelopen maand; MakerDAO mede-oprichter Rune en kocht MKR opnieuw na anderhalve maand; Het actieve adresaantal van Sui is meer dan 1 miljoen; Worldcoin, een cryptobedrijf mede-opgericht door OpenAI CEO Sam Altman, kondigde aan dat World ID tijdens de testfase meer dan 2 miljoen mensen heeft geregistreerd.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag956369"><a name="Belangrijkste Token Trends van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste Token Trends van vandaag</h2><h3 id="h3-BTC693974"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1689576650BTC.png" alt=""><br>Deze week blijft de markt schommelingen en intense gevechten tussen stieren en beren ervaren. Op korte termijn wordt een mogelijke terugval verwacht, met een cruciale ondersteuning op $30.200 USD en een belangrijke weerstand op $29.495 USD. Aan de bovenkant zijn de doelen ingesteld op $32.235 USD en $33.085 USD, met topdoelen op $36.500 USD en $41.550 USD.</p>
<h3 id="h3-ETH134202"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1689576671ETH.png" alt=""><br>Op de dagelijkse grafiek is een bullish head and shoulders patroon te zien. Risiconemende handelaren moeten het belangrijke ondersteuningsniveau op $1.918 USD nauwlettend in de gaten houden, terwijl conservatieve handelaren kunnen wachten op een doorbraak boven de belangrijke weerstand op $2.036 USD voordat ze longposities innemen. Het middellangetermijndoel is ingesteld op $2.358 USD, en een doorbraak boven $2.036 USD duidt op een bullish signaal.</p>
<h3 id="h3-XRP947333"><a name="XRP" class="reference-link"></a><span class="header-link octicon octicon-link"></span>XRP</h3><p><img src="https://gimg2.gateimg.com/image/article/1689576720XRP 11.29.26.png" alt=""><br>Na een aanzienlijke prijsbeweging ervaart XRP een hoog niveau van convergentie. Het huidige prijsmomentum suggereert potentiële doelen op $1,0105 USD, $1,3705 USD en $1,9755 USD. Een afnemende prijsbeweging en volume worden beschouwd als bearish signalen.</p>
<h3 id="h3-GT628904"><a name="GT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>GT</h3><p><img src="https://gimg2.gateimg.com/image/article/1689576739GT.png" alt=""><br>Op korte termijn moet aandacht worden besteed aan het niveau van $4.1882 USD, met een mogelijke uitbraak naar het vorige hoogtepunt op $4.4890 USD, en een hogere neklijn op $4.6420 USD. De middellangetermijnsteun bevindt zich op $3.6040 USD, terwijl de maximale steun rond de kwartaaltrendlijn blijft, gericht op significante hoogtepunten op $28.56 USD, $39.15 USD en $45.05 USD.</p>
<h2 id="h2-Macro20CPI20blijft20een20marktkatalysator20de20VS20wordt20verwacht20de20rente20te20verhogen20investeerders20kijken20naar20morgens20horror20data435232"><a name="Macro: CPI blijft een marktkatalysator, de VS wordt verwacht de rente te verhogen, investeerders kijken naar morgen’s ‘horror data’" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: CPI blijft een marktkatalysator, de VS wordt verwacht de rente te verhogen, investeerders kijken naar morgen’s ‘horror data’</h2><p>De CPI-gegevens van de afgelopen week in de VS hebben de wereldwijde financiële markten doen schudden.</p>
<p>Nu de inflatie in de Verenigde Staten lijkt onder controle te zijn, zullen investeerders nauwlettend toezien op eventuele verschillen in economische ontwikkeling tussen landen, waarbij de focus waarschijnlijk ligt op de gegevens van het BBP van China en de detailhandelsverkopen in de Verenigde Staten. De groeivooruitzichten van deze twee grootste economieën ter wereld zullen naar verwachting van invloed zijn op het marktsentiment.</p>
<p>Bovendien zal inflatiedata de economische agenda blijven beheersen. Landen die CPI-gegevens publiceren zijn onder andere Canada, Japan en het Verenigd Koninkrijk. Ook de komst van het financiële rapportageseizoen kan nieuwe ontwikkelingen in gang zetten. <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Golven</a>.</p>
<p>Vanwege de aanstaande rentevergadering in juli zullen functionarissen van de Federal Reserve een periode van stilte ingaan. Maar deze week uitten verschillende havikachtige functionarissen steun voor verdere renteverhogingen.</p>
<p>Onder hen verklaarde Neil Kashkari, voorzitter van de Minneapolis Federal Reserve en lid van de stemmende commissie van de FOMC in 2023, dat banken zich moeten voorbereiden op een verhoging van de rente in het g dat beleidsmakers de rente verder moeten verhogen om hardnekkige inflatie te bestrijden. Federal Reserve-gouverneur Waller verklaarde ook dat hij de verhoging van de rente ondersteunt tijdens de FOMC-vergadering van juli en dat hij dit jaar tweemaal de rente moet verhogen, elk met 25 basispunten.</p>
<p>Wat betreft de duif-standpunt, verklaarde het 2024 FOMC-stemmingscomité en de voorzitter van de Atlanta Federal Reserve, Bostick, dat hij van mening is dat de rentetarieven niet verder hoeven te stijgen en dat het huidige beleid ‘duidelijk’ in beperkende gebieden is en dat de Federal Reserve geduldig kan blijven.</p>
<p>Ondanks de frequente meldingen van inflatiedata verklaarde Federal Reserve Governor Waller, die aan het einde van deze week sprak, dat hij nog steeds de mogelijkheid steunt om de rente dit jaar twee keer te verhogen, aangezien hij meer bewijs moet zien van een “duurzame” daling van de inflatie.</p>
<p>In feite is het niet alleen inflatiedata die de beslissingen van de Fed beïnvloedt, wat de beoordelingen van beleggers compliceert. Zoals Waller zei: ‘De sterke kracht van de arbeidsmarkt en de algehele robuuste prestaties van de Amerikaanse economie geven ons ruimte om het beleid verder aan te scherpen.’</p>
<p>Dinsdag zullen de gegevens over de Amerikaanse detailhandelsverkopen voor juni, bekend als “horrorgegevens”, worden vrijgegeven, waarbij de detailhandelsverkopen naar verwachting licht zullen versnellen tot 0,5% op maandbasis, wat aangeeft dat de consumentenbestedingen tijdens het zomerhoogseizoen een hoge vlucht nemen. De gegevens over de start van nieuwe woningen en bouwvergunningen worden woensdag bekendgemaakt en het totale aantal woningverkopen wordt donderdag bekendgemaakt.</p>
<p>Als de gegevens de tekenen van herstel op de Amerikaanse vastgoedmarkt verder versterken, kan de Amerikaanse dollar tijdelijk enige stimulans ontvangen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<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 op dit artikel. Het opnieuw plaatsen van het artikel wordt toegestaan mits Gate.io als referentie wordt genoemd. In alle glen zal er juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>