Tm90aXppZSBnaW9ybmFsaWVyZSB8IEFsbGVydGEgc3VsbGEgdnVsbmVyYWJpbGl0w6AgZGkgV2luUkFSLCBsYSBCYW5jYSBkZWkgUmVnb2xhbWVudGkgSW50ZXJuYXppb25hbGkgc3RhIGNvbnNpZGVyYW5kbyBsYSByZWdvbGFtZW50YXppb25lIHJlZ29sYXRvcmlhIGRlbCBzZXR0b3JlIGRlbGxlIGNyaXB0b3ZhbHV0ZSwgaWwgdGFzc28

2023-08-23, 04:12

<p><img src="https://gimg2.gateimg.com/image/article/16927712230823.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20La20Banca20per20gli20insediamenti20internazionali20sta20considerando20di20regolamentare20lo20sviluppo20dellindustria20delle20criptovalute20e20il20tasso20di20passaggio20spot20degli20ETF20potrebbe20aumentare20significativamente20in20futuro435366"><a name="Crypto Daily Digest: La Banca per gli insediamenti internazionali sta considerando di regolamentare lo sviluppo dell’industria delle criptovalute, e il tasso di passaggio spot degli ETF potrebbe aumentare significativamente in futuro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: La Banca per gli insediamenti internazionali sta considerando di regolamentare lo sviluppo dell’industria delle criptovalute, e il tasso di passaggio spot degli ETF potrebbe aumentare significativamente in futuro</h2><p>Se non puoi batterli, unisciti a loro.</p>
<p>Ieri, la Banca dei regolamenti internazionali (BRI) con sede a Basilea ha pubblicato uno studio secondo cui finora, gli asset crittografici non hanno diminuito ma hanno ingigantito i rischi finanziari delle economie sottosviluppate. Questa tecnologia può ancora essere applicata in vari modi costruttivi e la regolamentazione deve guidare l’innovazione in queste utili direzioni per la società.</p>
<p>La ricerca ha dimostrato che, considerando le difficoltà di implementazione e i rischi di sopprimere l’innovazione, è più consigliabile regolamentare l’industria delle criptovalute anziché vietarla completamente.</p>
<p>La possibilità di ottenere l’approvazione per la futura negoziazione di ETF spot negli Stati Uniti è aumentata significativamente.</p>
<p>Secondo YCharts.com, il prezzo di trading di GBTC venerdì era scontato del 26% rispetto al suo valore patrimoniale netto (NAV). Il 14 agosto, questa proporzione è scesa al di sotto del 24%, una diminuzione di circa 20 punti percentuali rispetto al 44% circa del 13 giugno.</p>
<p>L’analista di ricerca di Fineqia, Matteo Greco, ha dichiarato: “Il significativo restringimento indica un aumento significativo della probabilità di future approvazioni spot degli ETF negli Stati Uniti, spingendo gli investitori ad acquistare GBTC a significativi sconti, e crediamo che gli ETF saranno elencati in futuro.”</p>
<p>Chase White, un analista senior di ricerca e politica presso Compass Point Research &amp; Trading, prevede che dopo aver vinto in scala di grigi, lo sconto di GBTC potrebbe “restringersi significativamente”, forse al 10%.</p>
<p>Secondo i dati di Coinglas, il tasso attuale di premio negativo del Grayscale <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il Trust Fund (GBTC) al momento della pubblicazione è del 25,83%.</p>
<p>D’altra parte, resta sempre vigile per quanto riguarda le questioni di sicurezza crittografica.</p>
<p>Il Chief Information Security Officer di SlowMist, 23pds, ha dichiarato sulla piattaforma X che WinRAR ha esposto una vulnerabilità di esecuzione di codice in modalità remota (CVS-2023-40477), che consente agli aggressori di attirare gli obiettivi ad accedere a pagine dannose o semplicemente di aprire file dannosi per eseguire codice. Una volta che un utente esegue, potrebbe consentire agli hacker di controllare il computer e gli utenti di criptovaluta devono prestare attenzione all’aggiornamento. Allo stesso tempo, tieni presente che il cosiddetto “strumento di rilevamento delle vulnerabilità WinRAR” è anche un programma di phishing dannoso e presta attenzione ai rischi finanziari.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi934546"><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-BTC618722"><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/1692771262BTC.png" alt=""><br>Il grafico a 4 ore potrebbe essere in fase di formazione di un potenziale modello testa e spalle rialzista. Valutare se c’è un terzo test del supporto a $25.606. Se questo supporto tiene, potrebbe seguire un graduale movimento verso l’alto nel breve termine. Tuttavia, fare attenzione poiché il trend nel medio termine rimane ribassista.</p>
<h3 id="h3-SEI740826"><a name="SEI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEI</h3><p><img src="https://gimg2.gateimg.com/image/article/1692771278SEI.png" alt=""><br>La struttura a breve termine rimane ancora ribassista. Si consiglia di entrare in posizioni corte a $0.1668, con un obiettivo al livello inferiore di $0.1535. Se il trend al ribasso a breve termine continua, gli obiettivi sequenziali sono $0.1433, $0.1362, $0.1202 e $0.1060.</p>
<h3 id="h3-UNIBOT315762"><a name="UNIBOT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>UNIBOT</h3><p><img src="https://gimg2.gateimg.com/image/article/1692771294UNIBOT.png" alt=""><br>Il grafico a 4 ore ha quasi testato il livello di 107 USD, toccando precisamente la resistenza al ribasso di medio termine. C’è la possibilità di un significativo rimbalzo a breve termine. Per strategie di rapido rimbalzo a breve termine, si consiglia di entrare ed uscire rapidamente. L’obiettivo per un rimbalzo al rialzo è di 137,23 USD. Tuttavia, si tenga presente che il trend di medio termine è ancora ribassista.</p>
<h2 id="h2-Macro20i20costi20di20prestito20degli20Stati20Uniti20rimangono20elevati20e20i20tassi20dinteresse20elevati20rimangono20il20problema20principale814833"><a name="Macro: i costi di prestito degli Stati Uniti rimangono elevati e i tassi d’interesse elevati rimangono il problema principale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: i costi di prestito degli Stati Uniti rimangono elevati e i tassi d’interesse elevati rimangono il problema principale</h2><p>I verbali della riunione del tasso di sconto della Federal Reserve mostrano che i consigli di amministrazione della Fed di New York e di Atlanta hanno sostenuto il mantenimento del tasso di sconto invariato a luglio. Il primo è l’entità più importante nell’attuazione della politica monetaria della Federal Reserve e il presidente della banca ha diritti di voto permanenti nel FOMC.</p>
<p>Le vendite annuali totali di case completate negli Stati Uniti a luglio sono state di 4,07 milioni di famiglie, inferiori alle 4,15 milioni di famiglie previste e un nuovo minimo dal gennaio 2023; La diminuzione su base mensile è stata del 2,2%, superiore all’0,2% previsto.</p>
<p>Dal principio di quest’anno, i costi di prestito negli Stati Uniti sono stati elevati, ma il mercato immobiliare è ancora caldo. Ora finalmente vediamo una diminuzione dei dati, perché l’immobiliare è relativamente in ritardo.</p>
<p>Quindi in futuro, di fronte al contesto dei tassi d’interesse elevati, continuerà ad essere debole per un certo periodo di tempo, e quando i tassi d’interesse verranno abbassati l’anno prossimo, continuerà ad essere caldo.</p>
<p>Il presidente della Federal Reserve di Richmond, Barkin, ha dichiarato che c’è bisogno di restare aperti a un’ulteriore accelerazione economica, che potrebbe potenzialmente influenzare l’inflazione. Riguardo alla questione dell’aumento degli obiettivi di inflazione, ha affermato che ciò metterebbe a rischio la credibilità della Federal Reserve.</p>
<p>Fitch ha posto il Savings Bank of America (ASB) sotto osservazione negativa, seguendo simili declassamenti di Moody’s e S&amp;P su altri istituti bancari statunitensi. A questo punto, le tre maggiori agenzie di rating internazionali hanno adottato lo stesso approccio nei confronti dell’industria bancaria statunitense.</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. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>