Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgcHJlbWlvIG5lZ2F0aXZvIGRpIEdCVEMgY29udGludWEgYSByaWR1cnNpLCBnbGkgaW52ZXN0aXRvcmkgc29ubyBvdHRpbWlzdGkgc3VnbGkgRVRGIHNwb3QgZGkgQlRDLCBhdHRlbnppb25lIGFsIENQSSBzdGFzZXJh

2023-07-12, 05:40

<p><img src="https://gimg2.gateimg.com/image/article/16891433850712.jpg" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20gli20ETF20spot20di20Bitcoin20sono20difficili20da20resistere20il20sito20delle20rivendicazioni20di20FTX2020online20e20FTT2020aumentato20del2024594457"><a name="Riepilogo giornaliero delle criptovalute: gli ETF spot di Bitcoin sono difficili da resistere, il sito delle rivendicazioni di FTX è online e FTT è aumentato del 24%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: gli ETF spot di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> sono difficili da resistere, il sito delle rivendicazioni di FTX è online e FTT è aumentato del 24%</h2><p>Di recente, Robert Kiyosaki, autore del best-seller “Padre ricco padre povero”, ha postato sui social media che ipotizzando che i paesi BRICS annuncino il lancio di valute di scambio garantite dall’oro il prossimo mese potrebbe cambiare la valutazione attuale del dollaro statunitense.</p>
<p>Considerando il prossimo deprezzamento del dollaro statunitense, Kiyosaki ha suggerito ai suoi seguaci di acquistare oro e argento come protezione contro l’inflazione galoppante nei prossimi mesi. Inoltre, Kiyosaki prevede che i prezzi del Bitcoin raggiungeranno $120.000 l’anno prossimo.</p>
<p>Il prezzo di Bitcoin ha raggiunto il suo livello più alto in 13 mesi durante il periodo passato, con un aumento massimo del 3,28%, toccando i $31.500. Questo è principalmente perché i gestori di fondi, tra cui BlackRock, la più grande società di gestione patrimoniale al mondo, pianificano di lanciare spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Fondi negoziati in borsa (ETF) quotati negli Stati Uniti. NASDAQ ha presentato nuovamente la richiesta di quotazione degli ETF di BlackRock, dopo che il regolatore dei titoli statunitense ha sollevato alcune preoccupazioni sulla richiesta iniziale.</p>
<p>Tuttavia, Jay Clayton, ex presidente della Securities and Exchange Commission degli Stati Uniti (SEC), ha espresso la sua opinione sul Bitcoin spot ETF. Quando la SEC ha approvato il Bitcoin futures ETF, riteneva che la protezione del mercato per gli investitori finali fosse sufficiente, ma all’epoca non vedeva tale protezione nel mercato Spot, quindi ha fatto una distinzione. Credo che le istituzioni che hanno richiesto i Bitcoin spot ETF attualmente credano che queste differenze siano scomparse e i prodotti Spot ora abbiano meno resistenza e maggiore efficienza per gli investitori. L’approvazione dei Bitcoin spot ETF è difficile da contrastare.</p>
<p>FTX sta tornando di nuovo? Secondo The Block, FTX ha lanciato un portale di reclami per i clienti. Secondo le informazioni sul sito web, i clienti individuali possono accedere alle informazioni del loro account e presentare domande che saranno incluse nel procedimento di bancarotta del Capitolo 11 di FTX. Il sito web sarà aperto ai clienti che hanno account su FTX.com, FTX US, Blockfolio, FTX EU, FTX JP e Liquid.</p>
<p>Dopo il lancio di questo sito delle richieste FTX, FTT ha sperimentato un aumento a breve termine. I dati di mercato mostrano che l’FTT era a $1.72, con un aumento giornaliero di oltre il 24%. Attualmente, il sito del portale delle richieste FTX mostra la non disponibilità, e il motivo non è ancora stato identificato.</p>
<p>Da quando BlackRock, una società di gestione patrimoniale, ha presentato la richiesta di lancio di spot bitcoin ETF negli Stati Uniti, il premio negativo di Grayscale Bitcoin Trust (GBTC) con oltre $ 19 miliardi rispetto al valore patrimoniale netto (NAV) continua a ridursi.</p>
<p>Secondo i dati di Ycharts, il premio negativo di GBTC è salito alle stelle fino al 50% alla fine dell’anno scorso e si manterrà intorno al 40% per la maggior parte del 2023. Tuttavia, dopo che BlackRock ha presentato documenti alla Securities and Exchange Commission (SEC) degli Stati Uniti a metà giugno, il premio negativo ha iniziato a ridursi rapidamente ed è sceso al 26% la scorsa settimana, il livello più basso da maggio 2022. Attualmente, il premio negativo si attesta intorno al 27%.</p>
<p>Ciò indica che lo sconto del Grayscale Bitcoin Trust Fund è significativamente diminuito, indicando che le persone hanno maggiori aspettative per la conversione degli Exchange Traded Funds (ETF) di Bitcoin spot.</p>
<p>Per quanto riguarda i dati, l’ultimo rapporto di DappRadar mostra che nel secondo trimestre del 2023, il volume totale bloccato (TVL) di DeFi è diminuito a $77,6 miliardi, con una diminuzione del 7,1% rispetto al mese precedente. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è ancora il leader nel campo DeFi, anche se il TVL di DeFi sulla catena <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> è leggermente diminuito del 2% rispetto al trimestre precedente. D’altra parte, all’inizio di giugno, la SEC degli Stati Uniti ha intentato una causa contro Binance e ha sostenuto che <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>(MATIC) apparteneva ai titoli, che ha avuto un impatto significativo sui due principali blockchain, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain e Polygon. Il TVL della <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain è diminuito del 19%, rendendola la blockchain più fortemente contratta tra tutte le statistiche; Il TVL sulla chain di <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> è diminuito di circa l’8%, dimostrando ulteriormente l’importante impatto causato dalle agenzie regolatorie statunitensi.</p>
<p>Il numero di ETH bloccati ha raggiunto i 23,9 milioni, rappresentando circa il 20% del <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a>. Tuttavia, poiché gli investitori sono diventati cauti riguardo ai rischi regolatori, l’afflusso di fondi si è rallentato dopo il boom iniziale. Dopo l’aggiornamento a Shanghai, è stato registrato un afflusso netto di 4,5 milioni di ETH bloccati, causando un aumento dei tempi di attesa per la creazione di nuovi validatori a circa un mese e mezzo e un rallentamento della velocità di afflusso di fondi nel mese scorso. Tom Wan, analista presso 21Shares, una società di investimento in asset digitali, ha dichiarato in un rapporto che “il rallentamento dello staking è probabilmente dovuto all’attenzione da parte delle autorità regolatorie.”</p>
<p>Secondo i dati di Dune, il numero attuale di account ERC-6551 ha superato i 2.000 ed è attualmente 2017. Si riferisce che ERC-6551 fornisce un conto contrattuale intelligente per ogni token ERC-721, consentendo ai token ERC-721 di possedere asset e interagire con le applicazioni senza modificare i contratti intelligenti o l’infrastruttura esistente di ERC-721.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi387972"><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-BTC709516"><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/1689143428BTC.png" alt=""><br>Il grafico a quattro ore continua a testare la convergenza al di sotto, con molteplici pullback a breve termine non riusciti. Sta aspettando un nuovo pullback sopra il livello di convergenza. L’obiettivo verso l’alto rimane invariato a $32.235 e $33.085. L’obiettivo principale è $36.500 e $41.550.</p>
<h3 id="h3-ETH770392"><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/1689143455ETH.png" alt=""><br>Stabilità a breve termine intorno al livello di $1,857, con una continua sfida stimata del livello di $1,9K. Ritiro mattutino a $1,880 con continuo calo del volume e convergenza. La strategia a lungo termine attende un retest del livello di $2,000 per il cambio di tendenza da ribassista a rialzista nel medio termine.</p>
<h3 id="h3-LTC150698"><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/1689143476LTC.png" alt=""><br>Il pattern a testa e spalle a breve termine potrebbe essere monitorato per un possibile ritest del livello di $104,02. Se si ritrae, il trend rialzista continuerà a puntare al livello di $126,26 e un ulteriore sostegno potrebbe portare a un test del livello di resistenza di $128,15.</p>
<h3 id="h3-BCH228777"><a name="BCH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BCH</h3><p><img src="https://gimg2.gateimg.com/image/article/1689143494BCH.png" alt=""><br>Uscendo dal modello del triangolo simmetrico, testa il livello chiave di resistenza a $269.08, raggiungendo il limite superiore della convergenza al mattino. Gli obiettivi del rimbalzo sono $345 e $385. La strategia a breve termine dipende dal modello di convergenza per determinare la direzione.</p>
<h2 id="h2-Macro20Consumo20e20crescita20del20credito20in20rallentamento20pu20lIPC20aumentare20la20fiducia20di20mercato20stasera378640"><a name="Macro: Consumo e crescita del credito in rallentamento, può l’IPC aumentare la fiducia di mercato stasera?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Consumo e crescita del credito in rallentamento, può l’IPC aumentare la fiducia di mercato stasera?</h2><p>Negli Stati Uniti è arrivato l’ordine di regolamentazione bancaria più “severo”, che impone requisiti patrimoniali più severi a una gamma più ampia di banche. Il vicepresidente della Federal Reserve Michael Barr ha annunciato riforme normative per le istituzioni con attività pari o superiori a 100 miliardi di dollari, proponendo standard patrimoniali più severi e richiedendo alle banche di riservare capitale aggiuntivo che può essere utilizzato per assorbire eventuali perdite.</p>
<p>Inoltre, la crescita del credito al consumo negli Stati Uniti si è significativamente rallentata a maggio. Il credito al consumo non rinnovabile (principalmente prestiti auto e debiti studenteschi) ha registrato un calo per la prima volta dall’impatto della pandemia di COVID-19.</p>
<p>Il membro del comitato direttivo della Banca centrale europea, Francois Villeroy de Galhau, ritiene che l’inflazione continuerà a diminuire e tornerà al livello del 2% entro il 2025; Ci stiamo avvicinando al picco dei tassi di interesse e, una volta raggiunto, sarà necessario mantenerlo a questo livello per un certo periodo di tempo.</p>
<p>L’indice di prosperità economica ZEW per la zona euro a luglio è stato -12,2, un nuovo minimo dallo scorso dicembre, con un valore precedente di -10; L’indice dello stato economico ZEW per luglio è stato -44,4, con un valore precedente di -41,9.</p>
<p>Il tasso di disoccupazione ILO nel Regno Unito per i tre mesi fino a maggio è del 4%, raggiungendo un nuovo massimo da gennaio 2022, con un previsto 3,8%, rispetto al precedente 3,8%; Il tasso di disoccupazione è salito al 4% a giugno, rispetto al precedente 3,9%. Il numero di dipendenti a tempo pieno nel Regno Unito è diminuito, i dati del mercato del lavoro sono stati deboli e il tasso di attività continua a tornare alla normalità.</p>
<p>In generale, l’analisi del mercato macro globale mostra alcune tendenze e cambiamenti, tra cui il rallentamento della crescita del credito al consumo, l’aumento della correlazione tra debito azionario e un’attività di private equity globale inferiore alle aspettative. Quindi vediamo se i dati importanti rilasciati stasera possono aumentare la fiducia del mercato.</p>
<p>Stasera alle 20:30 gli investitori si concentreranno sull’IPC di giugno degli Stati Uniti, nonché sulla discussione sull’inflazione del presidente della Fed di Richmond Thomas Barkin (che ha diritti di voto nel 2024).</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 riposting dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>