RGFnZWxpamtzIG5pZXV3cyB8IFBvc2l0aWV2ZSBDUEkgc2xhYWdkZSBlciBuaWV0IGluIG9tIEJUQyB1aXQgZGUgdm9sYXRpbGl0ZWl0IHRlIGxlaWRlbiwgR3JheXNjYWxlIHByb3Rlc3RlZXJkZSB0ZWdlbiBkZSBkaXNjcmltaW5lcmVuZGUgYmVoYW5kZWxpbmcgZG9vciBkZSBTRUMsIENhdGhpZSBXb29kIHZlcm1pbmRlcmRlIGhhYXI

2023-07-13, 04:06

<p><img src="https://gimg2.gateimg.com/image/article/16892294740713.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Het20aandeel20van20cryptoinvesteringsfondsen20is20gedaald20en20Cathie20Wood20heeft20voor20het20eerst20haar20belang20in20Coinbaseaandelen20verminderd20Grayscale20protesteert20tegen20discriminatoire20behandeling20door20de20SEC904016"><a name="Crypto Dagelijks Overzicht: Het aandeel van crypto-investeringsfondsen is gedaald, en Cathie Wood heeft voor het eerst haar belang in Coinbase-aandelen verminderd, Grayscale protesteert tegen discriminatoire behandeling door de SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Het aandeel van crypto-investeringsfondsen is gedaald, en Cathie Wood heeft voor het eerst haar belang in Coinbase-aandelen verminderd, Grayscale protesteert tegen discriminatoire behandeling door de SEC</h2><p>Een enquêterapport van PwC toont aan dat onder de 59 traditionele hedgefondsen die zijn onderzocht, het percentage fondsen dat investeert in cryptocurrencies is gedaald naar 29%. Volgens het onderzoek van PricewaterhouseCoopers en de Alternative Investment Management Association (AIMA) is het percentage traditionele hedgefondsen dat investeert in crypto-activa gedaald van 37% in 2022 naar 29% dit jaar.</p>
<p>Het rapport voegt eraan toe dat een kwart van de hedgefondsen die momenteel investeren in het veld hebben verklaard dat de toegenomen onzekerheid in de Amerikaanse regelgeving van de cryptografie-industrie ertoe kan leiden dat ze deze activaklasse heroverwegen. Het rapport stelt dat meer dan 70% van de investeringsbeslissingen van 59 ondervraagde hedgefondsen werden beïnvloed door de marktgebeurtenissen van vorig jaar (het instorten van verschillende belangrijke cryptobedrijven zoals FTX), waarbij deze fondsen in totaal $280 miljard aan activa beheren.</p>
<p>De trage gegevens van de bovengenoemde beleggingsfondsen weerspiegelen ook indirect de neergang op de cryptomarkt.</p>
<p>CoinMarketCap heeft de ultieme gids uitgebracht voor exchange-activiteiten (CEXs en DEXs) in de eerste helft van 2023, waarbij het totale spot handelsvolume van de top 20 beurzen met 36% is afgenomen in vergelijking met het vorige kwartaal.</p>
<p>De relevante analyse-inhoud omvat transactievolume, marktomvang en regionale/valutadekking. Het rapport toont aan dat in het tweede kwartaal van 2023 de top 20 beurzen samen $1,67 biljoen bijdroegen aan het totale spot-handelsvolume, een daling van 36% ten opzichte van het vorige kwartaal. Deze daling duidt op een significante vertraging in de marktactiviteit, die werd gedomineerd door terugkerende actieve handelsactiviteit gedreven door de verdubbeling van de Bitcoin-prijzen in het eerste kwartaal van 2023 ($2,6 biljoen).</p>
<p>Als gevolg van de impact van de bearish cyclus op het CEX-platform heeft Cathie Wood’s Ark Fund ook voor het eerst in bijna een jaar Coinbase-aandelen verkocht.</p>
<p>Volgens Bloomberg heeft Ark Investment, een fonds onder Cathie Wood, voor het eerst in bijna een jaar zijn aandelen in Coinbase verminderd. Het heeft 135.152 Coinbase-aandelen verkocht op 11 juli, wat de eerste verkoop van het aandeel markeert sinds 26 juli 2022. Ark is de op drie na grootste aandeelhouder van Coinbase, en de documenten die gisteren zijn ingediend bij de Chicago Board of Options voegden toe. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> over de mogelijkheid dat de VS goedkeurt <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s, met het aandeel dat met 9,8% stijgt.</p>
<p>Grayscale heeft een brief geschreven aan het Federale Hof van Beroep om te protesteren tegen de gedifferentieerde behandeling van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF-producten door de SEC. Volgens de officiële aankondiging hebben de advocaten van Grayscale Investments een brief ingediend bij het Hof van Beroep van de Verenigde Staten voor het District van Columbia, waarin zij protesteren tegen het feit dat de Amerikaanse Securities and Exchange Commission (SEC) nog steeds weigert spot Bitcoin ETF’s zoals GBTC goed te keuren, terwijl ze hefboom Bitcoin futures ETF’s goedkeuren.</p>
<p>Grayscale geeft aan dat de goedkeuring van de SEC voor op hefboomwerking gebaseerde Bitcoin-futures ETF’s, meer steun biedt voor zijn juridische argument dat de SEC op welke manier dan ook handelt. Grayscale geeft aan dat hoewel het toestaan van verhandelbare futuresproducten op hefboomwerking, er geen voldoende reden is om door te gaan met het weigeren van de goedkeuring van spotproducten.</p>
<p>De RWA-track stijgt en de getokeniseerde Amerikaanse schatkistbon overstijgt $600 miljoen. Volgens de gegevens die zijn vrijgegeven door RWA. xyz hebben crypto-investeerders via verschillende getokeniseerde schatkistbonproducten $614 miljoen geïnvesteerd in Amerikaanse obligaties, obligaties en monetaire fondsen die in tokens zijn verpakt.</p>
<p>Naarmate het rendement van Amerikaanse staatsobligaties, die algemeen worden beschouwd als risicovrij tarief, het rendement van Defi overschrijdt, neemt de vraag van investeerders naar getokeniseerde Amerikaanse staatsobligaties toe.</p>
<p>Dit jaar hebben een reeks nieuwe spelers, zoals OpenEden, Ondo Finance en Maple Finance, blockchain-gebaseerde schatkistobligatieproducten uitgebracht voor volwassen investeerders, digitale activabedrijven en DAO’s.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20Vandaag637631"><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-BTC537890"><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/1689229610BTC.png" alt=""><br>Op de vier-uur grafiek blijft de convergentie aan de onderkant getest worden. Op korte termijn is het cruciaal om de steun op $30.213 te behouden. Het handelsvolume is de afgelopen 24 uur iets ontoereikend geweest. De opwaartse doelen blijven onveranderd op $32.235 en $33.085. Het belangrijkste doel is $36.500 en $41.550.</p>
<h3 id="h3-ETH627120"><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/1689229633ETH.png" alt=""><br>De vier-uur grafiek toont een potentieel hoofd-en-schouders top patroon. Momenteel wordt verwacht dat het blijft testen van het niveau van $1,857, met een korte dip tot $1,870 in de ochtend. De handelsvolume op korte termijn blijft laag. De langetermijnstrategie moet wachten op een terugval naar het niveau van $2,000 voordat er wordt overwogen om van bearish naar bullish over te schakelen.</p>
<h3 id="h3-LTC86497"><a name="LTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1689229656LTC.png" alt=""><br>Op korte termijn, <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> vormt nog steeds een bodempatroon van een hoofd en schouders. Het niveau van $93,39 moet worden gehandhaafd en er moet aandacht worden besteed aan een mogelijke terugtrekking tot het niveau van $104,02. Een succesvolle terugtrekking kan leiden tot een voortgezette bullish trend met als doel $126,26. Voor langdurig vasthouden kan de prijs $128,15 bereiken.</p>
<h3 id="h3-GT488834"><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/1689229680GT.png" alt=""><br>Het vieruurschema toont een potentieel kop- en schouderspatroon. De neklijn moet worden bewaakt op $4.1882, met een medium-termijn steunlijn op $3.6040. De maximale steunlijn houdt nog steeds stand op kwartaalniveau. De belangrijkste bullish doelen zijn $28.5658, $39.1555 en $45.05.</p>
<h2 id="h2-Macro20CPI20overtrof20de20verwachtingen20desinflatie20vertraagde20en20de20laatste20renteverhogingen20kunnen20mogelijk20plaatsvinden20in20juli608695"><a name="Macro: CPI overtrof de verwachtingen, desinflatie vertraagde, en de laatste renteverhogingen kunnen mogelijk plaatsvinden in juli" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: CPI overtrof de verwachtingen, desinflatie vertraagde, en de laatste renteverhogingen kunnen mogelijk plaatsvinden in juli</h2><p>In juni is de kern-CPI met 4,8% op jaarbasis gestegen en is het kwartaal-op-kwartaalgroeicijfer gedaald van 0,4% naar 0,2%. Dit is een positieve trend, maar er moet ook worden opgemerkt dat sommige van de meer volatiele subonderdelen de inflatie hebben doen dalen, zoals hotels en vliegtickets. Vooruitkijkend geloven we dat de Amerikaanse inflatie in de tweede helft van het jaar een combinatie van ‘kern-CPI-vertraging + totale CPI-onderkant-uitstoot’ zou kunnen vertonen. Voorzichtig schatten we dat de kern- en totale CPI-inflatie tegen het einde van het jaar boven de 3,5% zal liggen.</p>
<p>Voor de markt zal de disinflatie helpen om zorgen over renteverhogingen te verminderen, maar het kan moeilijk zijn om het resultaat van langdurig hoge rentetarieven te veranderen. We verwachten dat de Federal Reserve de rentetarieven zal blijven verhogen tijdens de aanstaande FOMC-vergadering in juli. We geloven dat de recente stijging van de Amerikaanse obligatierentes niet alleen de hardnekkigheid van inflatie weerspiegelt, maar ook de beter-dan-verwachte fundamenten van de Amerikaanse economie.</p>
<p>Nick Timiraos, een Wall Street Journal verslaggever die bekend staat als het ‘Nieuwe Federal Reserve Nieuwsagentschap’, reageerde op de CPI-gegevens van juni van de Verenigde Staten. Hij verklaarde dat de inflatie vorige maand daalde naar het laagste niveau in meer dan twee jaar, waardoor Amerikanen werden bevrijd van de pijnlijke periode van stijgende prijzen en de mogelijkheid toenam dat de Federal Reserve zal stoppen met het verhogen van de rente na de renteverhoging van deze maand.</p>
<p>Het Amerikaanse ministerie van Arbeid verklaarde woensdag dat de CPI in juni op jaarbasis met 3% is gestegen, aanzienlijk lager dan het hoogtepunt van 9,1% in juni 2022, en gedaald van 4% in mei. De laatste keer dat de inflatie bijna 3% benaderde was in maart 2021.</p>
<p>Beleggers juichten over deze gegevens, waaruit blijkt dat de Federal Reserve vordert in het beteugelen van hoge inflatie. Functionarissen van de Federal Reserve kunnen nog steeds de rente verhogen naar het hoogste niveau in 22 jaar tijdens hun vergadering van 25 tot 26 juli, aangezien de vertraging in economische activiteit niet aan de verwachtingen voldeed. De inflatierapport roept echter vragen op of de Federal Reserve de rente zal verhogen, zoals de meeste functionarissen vorige maand voorspelden (d.w.z. nog twee verhogingen).</p>
<p>Timiraos suggereert dat sommige economen nog steeds bezorgd zijn dat zelfs als de drijvende factoren van de COVID-19 pandemie volledig afnemen, een sterke arbeidsmarkt zal blijven bijdragen aan inflatie. Als economische groei niet verder vertraagt, kunnen lonen blijven stijgen en zal sterke vraag naar goederen en diensten de lonen omhoog drijven. Als consumenten zich zeker voelen over hun baan, kunnen ze blijven uitgeven, waardoor het moeilijker wordt om de inflatie te verminderen.</p>
<p>Wat betreft dit verklaarde Richmond Fed-voorzitter Barkin, die volgend jaar stemrecht heeft in het FOMC, ook dat zelfs als de economische groei in juni vertraagt, de groeisnelheid van de Amerikaanse CPI nog steeds te snel is. Als het aanscherpen te vroeg wordt teruggetrokken, zal de inflatie krachtig herstellen, “dan is er meer actie nodig van de Federal Reserve.”</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 standpunten 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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>