Tm90aXppZSBxdW90aWRpYW5lIHwgRlRYIMOoIHN0YXRvIGFwcHJvdmF0byBwZXIgbGlxdWlkYXJlIGkgc3VvaSBhc3NldCBjcmlwdG8sIGkgcHJlbWkgZnV0dXJpIEV0aGVyZXVtIHNvbm8gYmFzc2ksIGlsIG1lcmNhdG8gY3JpcHRvIHN0YSB2aXZlbmRvIHVuYSBncmF2ZSBjcmlzaSBkaSBsaXF1aWRpdMOg

2023-09-14, 04:09

<p><img src="https://gimg2.gateimg.com/image/article/16946733030914.jpg" alt=""></p>
<h2 id="h2-Riepilogo20Cripto20Giornaliero20La20nota20societ20di20giochi20online20Linekong20Interactive20ha20istituito20un20deposito20e20acquistato20circa2010020BTC20FTX2020stata20approvata20per20liquidare20i20suoi20asset20cripto272537"><a name="Riepilogo Cripto Giornaliero: La nota società di giochi online Linekong Interactive ha istituito un deposito e acquistato circa 100 BTC, FTX è stata approvata per liquidare i suoi asset cripto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo Cripto Giornaliero: La nota società di giochi online Linekong Interactive ha istituito un deposito e acquistato circa 100 BTC, FTX è stata approvata per liquidare i suoi asset cripto</h2><p>Secondo quanto riportato, Linekong Interactive Group Co., Ltd (08267. HK), una società quotata di Hong Kong, ha annunciato che, secondo i comunicati della società del 15 giugno, 7 luglio, 8 agosto e 17 agosto 2023, il gruppo ha acquistato un totale di 92,4712 unità di… <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> nelle transazioni di mercato pubblico, con un valore in contanti totale di circa $2.66 milioni.</p>
<p>L’annuncio afferma che il consiglio di amministrazione raccomanda di cercare l’approvazione preventiva da parte degli azionisti per autorizzare e dare potere ai direttori di effettuare potenziali acquisti di criptovalute durante il periodo di autorizzazione, con una considerazione totale non superiore a $5 milioni. Il gruppo ha inoltre osservato che il prezzo delle criptovalute potrebbe fluttuare significativamente, quindi il consiglio di amministrazione è interessato a investire nelle criptovalute più grandi per valore di mercato, come <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p>MetaMask ha annunciato una nuova funzionalità chiamata Snaps, che consente di estendersi a catene non EVM come Cosmos, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, e Starknet. Snaps è un modulo software che può essere integrato con MetaMask, consentendo l’uso di portafogli su diverse catene.</p>
<p>Secondo Coindesk, un giudice distrettuale del Delaware ha approvato un ordine che consente alla piattaforma di trading di criptovalute FTX dichiarata fallita di vendere ed investire i suoi 3,4 miliardi di dollari di criptovalute. Il piano prevede che la maggior parte dei token possa essere venduta solo per 100 milioni di dollari a settimana, ma il limite superiore per ciascun token potrebbe essere permanentemente aumentato a 200 milioni di dollari. Quando si vendono Bitcoin, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e altri token, le autorità di regolamentazione devono notificare l’Ufficio del Trustee degli Stati Uniti con 10 giorni di anticipo.</p>
<p>Secondo le ultime notizie, FTX ha revisionato la sua proposta di vendere miliardi di dollari in asset criptovalutari, ma considerando l’eventuale impatto della transazione sul mercato, la proposta rivista afferma comunque che FTX non emetterà un annuncio di negoziazione in anticipo.</p>
<p>Nelle ultime settimane, rispetto ai futures di Bitcoin, i futures di Ethereum hanno avuto un premio più basso, e il divario si è continuato ad ampliare nella scorsa settimana.</p>
<p>Rispetto al mercato spot, i futures di Ethereum attualmente sono scambiati con uno sconto. Ciò indica che il Chicago Mercantile Exchange (CME) ha mostrato un’aspettativa eccezionalmente pessimistica in vista delle aspettative degli ETF sui futures di Ethereum.</p>
<p>La società di ricerca sulle criptovalute K33 Research ha affermato che, “a causa dell’attesa quotazione degli Ethereum futures ETF a ottobre, considerata una notizia positiva, le attuali performance dei futures di Ethereum sembrano un po’ strane. Non ci sono altre indicazioni che gli ETF Ethereum saranno respinti e storicamente la differenza tra Ethereum e i futures di Bitcoin non è una preoccupazione.”</p>
<p>Secondo l’ultimo rapporto di Glassnode, un’azienda di intelligence di mercato crittografico, il mercato crittografico sta attualmente vivendo una grave stretta di liquidità, con entrambi i volumi di trading on-chain e off-chain che sono scesi ai minimi storici. Gli analisti hanno sottolineato che, sebbene Bitcoin ed Ethereum abbiano registrato afflussi netti di capitali dall’inizio di quest’anno, tutti e tre gli asset sono tornati a afflussi neutrali o negativi dalla fine di agosto, indicando stasi e incertezza.</p>
<p>Gli indicatori on chain di Glassnode mostrano che il volume totale delle transazioni in dollari di Bitcoin è sceso a una media giornaliera di $2.44 miliardi, lo stesso livello di ottobre 2020. Nel mercato dei derivati off chain, il volume giornaliero di trading di Bitcoin ha raggiunto un minimo storico, scendendo a $12 miliardi per la prima volta dal suo punto più basso nel 2022.</p>
<p>Nonostante il calo del mercato, la tendenza al mantenimento rimane forte. Glassnode definisce il gruppo dei detentori a lungo termine come un’entità on chain che detiene token per più di 155 giorni, con le detenzioni del gruppo che raggiungono un massimo storico di 14,7 milioni di Bitcoin. Nel frattempo, la fornitura di detentori a breve termine (detenendo per meno di 155 giorni) è scesa al suo livello più basso dal 2011.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi787088"><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-BTC472389"><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/1694673357BTC.png" alt=""><br>La tendenza generale mantiene ancora una struttura di trading laterale e alle 8:00 di stamattina ha toccato precisamente il punto di svolta del trend al ribasso, raggiungendo la parte superiore dell’intervallo di trading a $26.510. Se la struttura ribassista a breve termine continua, questo punto di svolta sarà la migliore posizione per vendere allo scoperto. Continuate a monitorare il livello di supporto all’interno dell’intervallo di trading.</p>
<h3 id="h3-ID267827"><a name="ID" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ID</h3><p><img src="https://gimg2.gateimg.com/image/article/1694673380ID.png" alt=""><br>Il grafico a quattro ore è sceso dal suo massimo storico di $0,8445 a $0,2070. Nel breve termine, si sta formando un triangolo convergente a basso livello, che potrebbe indicare una rottura entro la fine di questo mese (forse anche prima). Il prezzo attuale si trova in una struttura a metà asse. Una strategia conservativa suggerisce di entrare vicino al supporto della trendline, con obiettivi di profitto stimati a $0,2425 durante un rimbalzo. Il livello di supporto chiave si trova a $0,1680.</p>
<h3 id="h3-TRB321106"><a name="TRB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TRB</h3><p><img src="https://gimg2.gateimg.com/image/article/1694673414TRB.png" alt=""><br>A breve termine, il grafico delle quattro ore è ancora in fase di consolidamento a livelli elevati, ma il trend generale è orientato verso una struttura rialzista. Ieri ha testato due volte $29,32 al massimo e si è ritirato rapidamente a $23,35, ritracciandosi precisamente fino alla fine di un triangolo convergente. Si stima che il mercato sia ancora in fase di consolidamento. Il supporto a breve termine si trova a $29,32 e gli obiettivi sono $31,95, $33,61, $34,95 e $36,29 in sequenza.</p>
<h2 id="h2-Macro20lIPC20incontra20le20aspettative20la20Federal20Reserve20potrebbe20non20aumentare20pi20i20tassi20di20interesse691406"><a name="Macro: l’IPC incontra le aspettative, la Federal Reserve potrebbe non aumentare più i tassi di interesse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: l’IPC incontra le aspettative, la Federal Reserve potrebbe non aumentare più i tassi di interesse</h2><p>Il tasso annuale dell’IPC non stagionale degli Stati Uniti a agosto ha raggiunto il 3,7%, un nuovo massimo da maggio di quest’anno, ed è aumentato per la seconda volta consecutiva; Il tasso annuale dell’IPC di base non stagionale negli Stati Uniti ha registrato il 4,3% a agosto, che è un nuovo minimo da settembre 2021 ed è in calo da sei mesi consecutivi; Dopo l’adeguamento trimestrale a agosto, il tasso mensile dell’IPC negli Stati Uniti ha raggiunto un nuovo massimo del 0,6% da giugno 2022. Il tasso dell’IPC di base è aumentato dello 0,3% rispetto a luglio, segnando la prima accelerazione in sei mesi. Dopo la pubblicazione dei dati sull’IPC di base, la scommessa del mercato sul rialzo dei tassi di interesse da parte della Federal Reserve prima di novembre è aumentata.</p>
<p>Le aspettative degli economisti sono che i prezzi al consumo aumenteranno dello 0,6% mese su mese e del 3,6% su base annua ad agosto. Questo sarà superiore all’aumento dello 0,2% mese su mese a luglio e all’aumento del 3,2% su base annua. Ma se vengono esclusi i progetti alimentari ed energetici volatili, questi economisti si aspettano che i cosiddetti prezzi core aumentino dello 0,2% mese su mese ad agosto, allo stesso tasso di giugno e luglio - un periodo di dati relativamente miti rispetto ai mesi precedenti.</p>
<p>Gli economisti stimano che il CPI core sia aumentato del 4,3% anno su anno ad agosto, un rallentamento rispetto all’aumento del 4,7% anno su anno a luglio. Il raffreddamento del tasso di inflazione core quest’estate ha gettato le basi per la Federal Reserve per mantenere la stabilità dei tassi di interesse la prossima settimana, e i dati del CPI di agosto forniranno un riferimento per la Federal Reserve per discutere se sia necessario aumentare nuovamente i tassi di interesse più tardi quest’anno. La Federal Reserve ha alzato aggressivamente i tassi di interesse per oltre un anno, cercando di abbassare l’inflazione rallentando la crescita economica.</p>
<p>Dai dati di ieri sera da soli, si può vedere che ci sono emozioni contrastanti. Anche se il tasso annuo dell’IPC è stato alto, il CPI core soddisfa ancora le aspettative. In questa situazione, il mercato naturalmente non ha troppa volatilità, come possiamo vedere dal mercato azionario. I tre principali indici azionari degli Stati Uniti hanno fluttuato, con il Dow in ribasso dello 0,2%, il Nasdaq in rialzo dello 0,29% e l’indice S&amp;P 500 in rialzo dello 0,12%.</p>
<p>Inoltre, alcuni grandi investitori obbligazionari statunitensi hanno dichiarato mercoledì che nonostante l’aumento dei prezzi dell’energia che ha portato a un aumento dell’inflazione ad agosto, ritengono che la Federal Reserve abbia raggiunto il picco dei rialzi dei tassi di interesse.</p>
<p>La Federal Reserve ha aumentato i tassi di interesse di 25 punti base a luglio. Le scommesse sul mercato dei futures sui fondi federali mostrano che i trader generalmente credono che la Federal Reserve manterrà i tassi di interesse invariati alla fine della riunione del FOMC il 20 settembre. Tuttavia, mercoledì sera, il mercato ha valutato al 40% la possibilità di un ulteriore aumento di 25 punti base a novembre.</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 si faccia 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>