RGFnZWxpamtzIE5pZXV3cyB8IENyeXB0byBLYXBpdGFhbGluc3Ryb29tIEJlcmVpa3RlIEVlbiBOaWV1dyBIb29ndGVwdW50LCBNZWl0dSBCZWRyaWpmIFZlcmFuZGVyZGUgVmVybGllemVuIEluIFdpbnN0ZW4gRGFua3ppaiBIYWFyIENyeXB0byBCZXppdHRpbmdlbiwgT3ByaWNodGVyIFpodSBTdSB2YW4gM0FDIFJhYWRkZSBBbHRjb2l

2023-07-18, 03:52

<p><img src="https://gimg2.gateimg.com/image/article/16896585020718.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20ETHCC20officieel20geopend20oprichter20Zhu20Su20van203AC20raadt20Altcoins20aan20Nettostroom20van20cryptofondsen20heeft20een20nieuw20hoogtepunt20bereikt67482"><a name="Crypto Dagelijks Overzicht: ETHCC officieel geopend; oprichter Zhu Su van 3AC raadt Altcoins aan; Nettostroom van cryptofondsen heeft een nieuw hoogtepunt bereikt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: ETHCC officieel geopend; oprichter Zhu Su van 3AC raadt Altcoins aan; Nettostroom van cryptofondsen heeft een nieuw hoogtepunt bereikt</h2><p>De nauwlettend gevolgde <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De Community Conference ETHCC 6 is officieel geopend in Parijs, Frankrijk.</p>
<p>De 4-daagse conferentie zal meerdere bijeenkomsten, groepsdiscussies en feesten organiseren. Op de eerste dag van EthCC zullen er 12 lezingen zijn over verschillende vakgebieden zoals blockchain economie, DeFi en beveiliging. Veel projectpartijen hebben tijdens de conferentie nieuwe versies en producten uitgebracht.</p>
<p>Bijvoorbeeld, Lens Protocol, het <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> sociale protocol, heeft officieel zijn V2-versie uitgebracht tijdens de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Paris EthCC-conferentie, Mantle Network, de Ethereum Layer 2-oplossing, heeft officieel de alfaversion van zijn hoofdnetwerk gelanceerd tijdens de conferentie, en <a href="/price/gnosis-gno" rel="nofollow noopener noreferrer" target="_blank">Gnosis</a> Chain heeft <a href="/price/gnosis-gno" target="_blank" class="blog_inner_link">Gnosis</a> Pay uitgebracht, een gedecentraliseerd betalingsnetwerk, en Gnosis Card, een zelfbeheerde debetkaart, tijdens de ETHCC-conferentie.</p>
<p>Zhu Su, de oprichter van Three Arrows Capital, deelde op sociale mediaplatforms zijn opmerkelijke Altcoins tijdens deze cyclus en gaf redenen voor aanbevelingen, waaronder op het gebied van DeFi, DeFi/CeFi en Memecoins.</p>
<p>Onder hen omvatten DeFi-velden MKR (RWA on-chain yield), SNX (ui &amp; ux enhanced update), COMP (continue constructie door bearmarkten) en <a href="/price/aave-aave" target="_blank" class="blog_inner_link">AAVE</a> (overleving in meerdere risicobeheerexperimenten);</p>
<p>DeFi/CeFi-velden: RLB (crypto on-chain casino), OX (crypto claims en handelsplatform Open Exchange native tokens);</p>
<p>Memecoins velden: PEPE (volgende ‘Shib’).</p>
<p>Onlangs kondigde het bekende Chinese softwarebedrijf Meitu Group aan dat het verwacht dit jaar in de eerste helft van het jaar verliezen om te zetten in winst, met een nettowinst voor aandeelhouders tussen RMB 220 miljoen en RMB 265 miljoen, vergeleken met een nettverlies van ongeveer RMB 266 miljoen in dezelfde periode vorig jaar.</p>
<p>De belangrijkste reden voor de verwachte ommekeer is dat per 30 juni 2023 de marktprijs van de gekochte cryptocurrency hoger was dan die op 31 december 2022, waardoor de waardevermindering van de gekochte cryptocurrency met ongeveer 185 miljoen RMB werd teruggedraaid.</p>
<p>Sinds de aankoop van cryptocurrency in maart en april 2021 heeft de Meitu Group volgens het cryptocurrency investeringsplan geen cryptocurrency gekocht of verkocht.</p>
<p>Op het gebied van gegevens blijkt uit de wekelijkse rapportage van CoinShares dat de nettostroom van digitale activa-investeringsproducten vorige week $137,4 miljoen bedroeg, met een cumulatieve instroom van $742 miljoen over de afgelopen vier weken. Dit is de grootste instroom sinds het vierde kwartaal van 2021.</p>
<p>Daarvan is de nettostroom van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De instroom van beleggingsproducten bedroeg vorige week $139,8 miljoen en de uitstroom van beleggingsproducten die <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> shorten was $3,2 miljoen, een netto uitstroom gedurende 12 opeenvolgende weken. De netto uitstroom van Ethereum beleggingsproducten bedroeg $1,6 miljoen, waardoor het de digitale activum is met de grootste kapitaaluitstroom dit jaar.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20Vandaag727228"><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-BTC842628"><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/1689658557BTC.png" alt=""><br>Gisteren doorbrak BTC de ondersteuning van $30.210, waarbij het zijn consolidatie voortzette met aanzienlijke volatiliteit en betrokkenheid bij zowel long- als shortposities. Vanochtend keerde het terug naar de neklijn van $30.200, met belangrijke ondersteuning op $29.495. Tenzij dit wordt doorbroken, zijn de volgende doelen $32.235 en $33.085. De belangrijkste doelen zijn $36.500 en $41.550.</p>
<h3 id="h3-ETH352432"><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/1689658586ETH.png" alt=""><br>ETH vertoont een bullish patroon met een dagelijkse tijdsbestek hoofd-en-schouder bodemformatie. Het houdt stand op de kritieke steun van $1,857. Voor conservatieve handelaren is het het beste om te wachten op een doorbraak boven de belangrijke weerstand op $2,036 om long posities in te nemen. Het middellange termijn doel is rond $2,358, en een doorbraak van $2,036 zou een verschuiving naar een bullish standpunt signaleren.</p>
<h3 id="h3-XRP428255"><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/1689658608XRP.png" alt=""><a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> heeft zijn consolidatie op hoog niveau voortgezet na een aanzienlijke bullish beweging. Met een spothandelsrendement van 102,20% zou een aanhoudende opwaartse trend op korte termijn gericht kunnen zijn op $ 1,0105, $ 1,3705 en $ 1,9755. Krimpende prijs en volume moeten worden beschouwd als bearish signalen.</p>
<h3 id="h3-GT642098"><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/1689658627GT.png" alt=""><br>GT test het niveau van $4,1882 op de 4-uursgrafiek, met de kans om boven de hoogste van vorige week op $4,4890 uit te breken en de bovenste neklijn te bereiken op $4,6420. De middellangetermijnondersteuning is $3,6040, terwijl de belangrijkste ondersteuning rond de kwartaallijn ligt. De langetermijn stierenkoersdoelen zijn $28,56, $39,15 en $45,05.</p>
<h2 id="h2-Macro20de20markt20pleitte20voor20een20Amerikaanse20economische20recessie20investeerders20wachtten20op20de20renteverhogingen20die20op20de2027e20zouden20plaatsvinden856139"><a name="Macro: de markt pleitte voor een Amerikaanse economische recessie, investeerders wachtten op de renteverhogingen die op de 27e zouden plaatsvinden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: de markt pleitte voor een Amerikaanse economische recessie, investeerders wachtten op de renteverhogingen die op de 27e zouden plaatsvinden</h2><p>Gisteravond stegen de Amerikaanse aandelen licht, waarbij de Dow Jones-index met 0,2% steeg, de S&amp;P 500-index met 0,4% steeg, en de Nasdaq-index met 0,9% steeg. Amerikaanse staatsobligaties stegen licht. Het rendement van 10-jarige Amerikaanse staatsobligaties daalde met ongeveer 3 basispunten tot 3,805%, dicht bij het midden van het intraday rendementsbereik van 3,77% -3,83%. De goudprijs bleef onveranderd, schommelend rond $1950. Ondanks de goede CPI-gegevens die vorige week zijn vrijgegeven, moeten beleggers nog steeds volledig bullish zijn.</p>
<p>Vanuit de focus van de huidige marktspeculatie heeft de Amerikaanse Dollar Index nieuwe onzekerheden toegevoegd. De markt is begonnen met hypen over de zwakte of zelfs recessie van de Amerikaanse economie. De hoofdeconoom van Goldman Sachs heeft de waarschijnlijkheid van een Amerikaanse economische recessie verlaagd tot 20%, waarbij wordt gesteld dat hoewel wordt verwacht dat de Federal Reserve volgende week opnieuw zijn referentierentevoet zal verhogen, dit de laatste kan zijn in een reeks renteverhogingen die vorig jaar zijn begonnen.</p>
<p>Citigroup-strateeg Chris Montagu en het team verklaarden dat investeerders lijken zich voor te bereiden op een zachte landing in de Amerikaanse economie en de reactie die werd veroorzaakt door recente economische gegevens is daar bewijs van. Na de rustige handel begin juli zorgden gunstige gegevens over de Amerikaanse economie in de afgelopen week voor een toename van nieuwe longposities in de S&amp;P 500-index.</p>
<p>De netto instroom van Nasdaq-100 was vlak en zowel long- als shortposities namen toe. De S&amp;P 500-index en de Nasdaq-100 keerden terug naar een hoger niveau, maar iets lager dan het hoogtepunt in juni. Hoewel dit geen signaal is om te verkopen, weerspiegelt de positie de mate waarin de marktwaarde overgewaardeerd is.</p>
<p>Allianz Chief Economic Advisor El-Erian verklaarde dat het idee dat de Amerikaanse economie een recessie kan vermijden momenteel gangbaar is en er geen reden is om tegen de trend in te gaan. Alles wat we zien, inclusief CPI, PPI, en banknieuws, wijst op een zachte landing.</p>
<p>Toen Wall Street begon te pleiten voor het risico op een recessie, verklaarde de Amerikaanse minister van Financiën Janet Yellen dat de Verenigde Staten goede vooruitgang hadden geboekt bij het terugdringen van de inflatie en niet verwachtten dat de economie in een recessie zou belanden.</p>
<p>Deze week is de Federal Reserve een periode van stilte ingegaan en zal er niet te veel volatiliteit op de markt zijn. Op macro-niveau zullen we moeten wachten op meer informatie die naar buiten komt na de renteverhoging op 27 juli, en dan kunnen we beoordelen of er nog steeds een renteverhoging is.</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 opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>