Tm90aXppZSBxdW90aWRpYW5lIHwgTCdpbmRpY2UgZGVpIHByZXp6aSBhbCBjb25zdW1vIHBvc2l0aXZvIG5vbiDDqCByaXVzY2l0byBhIHBvcnRhcmUgQlRDIGZ1b3JpIGRhbGxhIHZvbGF0aWxpdMOgLCBHcmF5c2NhbGUgaGEgcHJvdGVzdGF0byBjb250cm8gaWwgdHJhdHRhbWVudG8gZGlzY3JpbWluYXRvcmlvIGRlbGxhIFNFQywgQ2F

2023-07-13, 04:06

<p><img src="https://gimg2.gateimg.com/image/article/16892294740713.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20La20proporzione20dei20fondi20di20investimento20in20criptovalute2020diminuita20e20Cathie20Wood20ha20ridotto20la20sua20partecipazione20nelle20azioni20di20Coinbase20per20la20prima20volta20Grayscale20protesta20contro20il20trattamento20discriminatorio20della20SEC212539"><a name="Crypto Daily Digest: La proporzione dei fondi di investimento in criptovalute è diminuita e Cathie Wood ha ridotto la sua partecipazione nelle azioni di Coinbase per la prima volta, Grayscale protesta contro il trattamento discriminatorio della SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: La proporzione dei fondi di investimento in criptovalute è diminuita e Cathie Wood ha ridotto la sua partecipazione nelle azioni di Coinbase per la prima volta, Grayscale protesta contro il trattamento discriminatorio della SEC</h2><p>Un rapporto di indagine di PwC mostra che tra i 59 fondi hedge tradizionali esaminati, la proporzione di fondi che investono in criptovalute è diminuita al 29%. Secondo l’indagine di PricewaterhouseCoopers e l’Alternative Investment Management Association (AIMA), la proporzione di fondi hedge tradizionali che investono in attività crypto è scesa dal 37% nel 2022 al 29% quest’anno.</p>
<p>Il rapporto aggiunge che un quarto dei fondi hedge che attualmente investono nel settore ha dichiarato che l’aumento dell’incertezza nella regolamentazione statunitense dell’industria crittografica potrebbe indurli a riconsiderare questa classe di attività. Il rapporto afferma che più del 70% delle decisioni di investimento dei 59 hedge fund intervistati sono state influenzate dagli eventi di mercato dell’anno scorso (il crollo di diverse società crittografiche di primo piano come FTX), con questi fondi che gestiscono un totale di 280 miliardi di dollari in attività.</p>
<p>I dati lenti dei suddetti fondi di investimento riflettono anche indirettamente il calo del mercato crittografico.</p>
<p>CoinMarketCap ha pubblicato la guida definitiva alle attività di scambio (CEX e DEX) nel primo semestre del 2023, con il volume totale di trading spot dei primi 20 scambi che è diminuito del 36% rispetto al trimestre precedente.</p>
<p>I contenuti di analisi pertinenti includono il volume delle transazioni, la dimensione del mercato e la copertura regionale/valutaria. Il rapporto mostra che nel secondo trimestre del 2023, le prime 20 borse hanno contribuito per un volume totale di trading spot di 1,67 trilioni di dollari, una diminuzione del 36% rispetto al trimestre precedente. Questa diminuzione indica una significativa frenata dell’attività di mercato, che era dominata dall’attività di trading attiva di rappresaglia alimentata dal raddoppio dei prezzi del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> nel primo trimestre del 2023 (2,6 trilioni di dollari).</p>
<p>A causa dell’impatto del ciclo ribassista sulla piattaforma CEX, il fondo Ark di Cathie Wood ha venduto per la prima volta da quasi un anno le azioni di Coinbase.</p>
<p>Secondo Bloomberg, Ark Investment, un fondo di Cathie Wood, ha ridotto la sua partecipazione nelle azioni di Coinbase per la prima volta in quasi un anno. Ha venduto 135.152 azioni di Coinbase il 11 luglio, segnando la prima vendita di azioni dal 26 luglio 2022. Ark è il quarto maggior detentore di Coinbase, e i documenti presentati ieri dalla Chicago Board of Options hanno aggiunto a… <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> sulla possibilità che gli Stati Uniti approvino <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF, con le azioni che salgono del 9,8%.</p>
<p>Grayscale ha scritto una lettera alla Corte d’Appello federale protestando contro il trattamento differenziato dei prodotti Bitcoin ETF da parte della SEC. Secondo l’annuncio ufficiale, gli avvocati di Grayscale Investments hanno presentato una lettera alla Corte d’Appello degli Stati Uniti per il Circuito del Distretto di Columbia, protestando contro il fatto che la Securities and Exchange Commission (SEC) degli Stati Uniti continua a rifiutarsi di approvare gli ETF Bitcoin spot come GBTC, mentre approva gli ETF Bitcoin futures con leva.</p>
<p>Grayscale indica l’approvazione della SEC per gli ETF future Bitcoin a leva, fornendo ulteriore supporto per la sua argomentazione legale che la SEC non sta agendo in alcun modo. Grayscale indica che, sebbene permettendo la negoziazione di prodotti future a leva, non vi sono ragioni sufficienti per continuare a rifiutare l’approvazione dei prodotti spot.</p>
<p>La traccia RWA è in aumento e il bond del tesoro statunitense tokenizzato supera i 600 milioni di dollari. Secondo i dati pubblicati da RWA. xyz, gli investitori cripto hanno investito 614 milioni di dollari in bond statunitensi attraverso diversi prodotti tokenizzati del tesoro, che raggruppano bond del tesoro statunitensi, bond e fondi monetari in token.</p>
<p>Poiché il rendimento dei buoni del tesoro statunitensi, che sono ampiamente considerati come tasso privo di rischio, supera il rendimento della Defi, la domanda degli investitori di buoni del tesoro statunitensi tokenizzati è in aumento.</p>
<p>Quest’anno, una serie di nuovi ingressi, come OpenEden, Ondo Finance e Maple Finance, hanno rilasciato prodotti obbligazionari del tesoro basati su blockchain per investitori esperti, aziende di asset digitali e DAO.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi506201"><a name="Tendenze principali dei token di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze principali dei token di oggi</h2><h3 id="h3-BTC983125"><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>Il grafico delle quattro ore continua a testare la convergenza verso il basso. Nel breve termine, è fondamentale mantenere il supporto a $30.213. Il volume di scambio è stato leggermente insufficiente nelle ultime 24 ore. Gli obiettivi al rialzo rimangono invariati a $32.235 e $33.085. L’obiettivo principale è $36.500 e $41.550.</p>
<h3 id="h3-ETH849126"><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>Il grafico a quattro ore mostra un potenziale pattern di inversione testa e spalle. Attualmente, si prevede che continui a testare il livello di $1.857, con una breve discesa a $1.870 al mattino. Il volume di trading a breve termine rimane basso. La strategia a lungo termine dovrebbe aspettare un ritracciamento al livello di $2.000 prima di considerare un cambiamento da ribassista a rialzista.</p>
<h3 id="h3-LTC758313"><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>A breve termine, <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> sta ancora formando un modello di fondo a testa e spalle. Il livello di $93.39 dovrebbe essere mantenuto, e attenzione dovrebbe essere prestata a un potenziale pullback al livello di $104.02. Un pullback di successo potrebbe portare a un continuo trend rialzista che mira a $126.26. Per un lungo periodo di detenzione, il prezzo potrebbe raggiungere $128.15.</p>
<h3 id="h3-GT694373"><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>Il grafico a quattro ore mostra un potenziale modello di testa e spalle al top. La neckline dovrebbe essere monitorata a $4.1882, con una linea di supporto a medio termine a $3.6040. La linea di supporto massimo è ancora in piedi al livello trimestrale. Gli obiettivi rialzisti principali sono $28.5658, $39.1555 e $45.05.</p>
<h2 id="h2-Macro20LIPC20ha20superato20le20aspettative20la20disinflazione20si2020rallentata20e20lultimo20rialzo20dei20tassi20di20interesse20potrebbe20avvicinarsi20a20luglio472967"><a name="Macro: L’IPC ha superato le aspettative, la disinflazione si è rallentata e l’ultimo rialzo dei tassi di interesse potrebbe avvicinarsi a luglio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: L’IPC ha superato le aspettative, la disinflazione si è rallentata e l’ultimo rialzo dei tassi di interesse potrebbe avvicinarsi a luglio</h2><p>A giugno, l’IPC core è aumentato del 4,8% su base annua e il tasso di crescita su base trimestrale è sceso dallo 0,4% allo 0,2%. Si tratta di una tendenza positiva, ma va anche notato che alcune delle voci secondarie più volatili hanno trascinato al ribasso l’inflazione, come gli hotel e i biglietti aerei. Guardando al futuro, riteniamo che l’inflazione statunitense nella seconda metà dell’anno possa mostrare una combinazione di “rallentamento dell’IPC core + rimbalzo dell’IPC totale”. Prudentemente, stimiamo che l’inflazione core e l’IPC complessiva saranno superiori al 3,5% entro la fine dell’anno.</p>
<p>Per il mercato, la disinflazione contribuirà ad alleviare le preoccupazioni riguardanti l’aumento dei tassi di interesse, ma potrebbe essere difficile modificare il risultato di tassi di interesse elevati che rimarranno elevati per un periodo più lungo. Ci aspettiamo che la Federal Reserve continui ad aumentare i tassi di interesse nella prossima riunione FOMC di luglio. Crediamo che il recente aumento dei tassi di interesse dei bond statunitensi rifletta non solo la persistenza dell’inflazione, ma anche i fondamentali migliori del’ economia degli Stati Uniti, migliori del previsto.</p>
<p>Nick Timiraos, un reporter del Wall Street Journal conosciuto come la “Nuova Agenzia di Notizie della Federal Reserve”, ha commentato i dati CPI di giugno degli Stati Uniti. Ha affermato che l’inflazione è scesa al suo livello più basso degli ultimi due anni il mese scorso, liberando gli americani dal periodo doloroso di aumento dei prezzi e aumentando la possibilità che la Federal Reserve smetta di aumentare i tassi di interesse dopo l’aumento di questo mese.</p>
<p>Il Dipartimento del Lavoro degli Stati Uniti ha dichiarato mercoledì che l’IPC a giugno è aumentato del 3% anno su anno, significativamente inferiore al picco del 9,1% nel giugno del 2022, e sceso dal 4% di maggio. L’ultima volta che l’inflazione si avvicinò al 3% fu a marzo 2021.</p>
<p>Gli investitori si sono rallegrati di questi dati, confermando che la Federal Reserve sta progredendo nel contenere l’alta inflazione. Gli ufficiali della Federal Reserve potrebbero comunque aumentare i tassi di interesse al massimo di 22 anni nel loro incontro dal 25 al 26 luglio, poiché il rallentamento dell’attività economica non ha soddisfatto le aspettative. Tuttavia, il rapporto sull’inflazione solleva dubbi su se la Federal Reserve aumenterà i tassi di interesse come previsto dalla maggior parte degli ufficiali il mese scorso (ossia, altri due rialzi).</p>
<p>Timiraos suggerisce che alcuni economisti sono ancora preoccupati che anche se i fattori trainanti della pandemia di COVID-19 scompaiono completamente, un mercato del lavoro forte continuerà a far salire l’inflazione. Se la crescita economica non rallenta ulteriormente, i salari potrebbero continuare a salire rapidamente, e una forte domanda di beni e servizi farà salire i salari. Se i consumatori si sentono sicuri del proprio lavoro, potrebbero continuare a spendere, rendendo più difficile ridurre l’inflazione.</p>
<p>A riguardo, il presidente della Richmond Fed, Barkin, che detiene i diritti di voto del FOMC l’anno prossimo, ha dichiarato anche che anche se la crescita economica a giugno rallenta, il tasso di crescita dell’indice dei prezzi al consumo degli Stati Uniti è ancora troppo veloce. Se il restringimento si ritira troppo presto, l’inflazione si ripresenterà con forza, ‘allora è necessaria un’azione ulteriore da parte della Federal Reserve’.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em> Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>