Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIHRvcm5hIGEgJDYxLjAwMCwgTkVJUk9DVE8gZGl2ZW50YSBpbCB0b2tlbiBwacO5IGFjY2F0dGl2YW50ZQ==

2024-09-18, 04:06

<p><img src="https://gimg2.gateimg.com/image/article/17266322509.18.png" alt=""></p>
<h2 id="h2-Digest20giornaliero20delle20criptovalute20gli20ETF20BTC20hanno20registrato20ingenti20afflussi20con20una20probabilit20significativamente20aumentata20di20un20taglio20dei20tassi20di20interesse20di205020punti20base20a20settembre17971"><a name="Digest giornaliero delle criptovalute: gli ETF BTC hanno registrato ingenti afflussi, con una probabilità significativamente aumentata di un taglio dei tassi di interesse di 50 punti base a settembre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Digest giornaliero delle criptovalute: gli ETF BTC hanno registrato ingenti afflussi, con una probabilità significativamente aumentata di un taglio dei tassi di interesse di 50 punti base a settembre</h2><p>Secondo i dati degli investitori di Farside, l’afflusso netto di US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF spot sono stati di 186 milioni di dollari ieri. Tra di essi, Fidelity FBTC ha ricevuto un afflusso netto di 56 milioni di dollari, Ark ARKB ha ricevuto un afflusso netto di 42 milioni di dollari e Bitwise BITB ha ricevuto un afflusso netto di 45 milioni di dollari. BlackRock IBIT non ha flussi di fondi.</p>
<p>Gli Stati Uniti <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli spot ETF hanno registrato un deflusso di 15 milioni di dollari ieri, con un volume complessivo di scambi di ETF ETH relativamente piccolo. Tra questi, Grayscale ETHE ha registrato un deflusso di 17,9 milioni di dollari, mentre BlackRock ETHA non ha avuto ingresso o deflusso di fondi.</p>
<p><strong>Dati: il numero di indirizzi di deposito <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> CEX è sceso ai livelli più bassi degli ultimi anni, indicando una riduzione della pressione venditrice</strong></p>
<p>Secondo un recente rapporto di ricerca di CryptoQuant, il numero di indirizzi di deposito sulla piattaforma Bitcoin CEX è sceso a 132.100, il livello più basso in molti anni. Questo indicatore rappresenta il numero di indirizzi che inviano transazioni in entrata alla piattaforma di trading. L’analisi mostra che il livello più basso degli ultimi anni indica una diminuzione del numero di investitori che vendono Bitcoin su piattaforme di trading spot, il che potrebbe indicare una riduzione della pressione di vendita.</p>
<p>Ma anche il direttore della ricerca di CryptoQuant, Julio Moreno, ha affermato che quando i depositi sulle piattaforme di trading diminuiscono, potrebbe non indicare solo una diminuzione dell’interesse delle persone a vendere Bitcoin. Questo potrebbe anche significare una diminuzione della domanda complessiva di Bitcoin, poiché meno trader depositano fondi per scommettere sulle aumenti di prezzo.</p>
<p><strong>Eigenpie condurrà l’IDO il 20 settembre</strong></p>
<p>Eigenpie ha pubblicato sui social media che il suo IDO si terrà su Magpie Launchpad tramite la rete Arbitrum. Lo snapshot verrà effettuato tra il 18 e il 20 settembre per determinare l’allocazione della quota di IDO per i detentori di vlMGP, MGPs e distruttori di vlMGP. L’IDO inizierà alle 21:00 (ora di Pechino) del 20 settembre e terminerà alle 21:00 (ora di Pechino) del 24 settembre. L’allocazione delle azioni nella fase di collocamento privato è la seguente:</p>
<p>· I titolari di Eigenpie Points rappresentano il 70,59%<br>· I titolari di VLMGP rappresentano il 20,59%<br>· I distruttori di MGP/vlMGP rappresentano l’8,82%</p>
<p>Il round di collocamento privato sarà completato entro 24 ore, con un FDV di $3 milioni. Il round pubblico durerà 72 ore, con un FDV di $6 milioni, e il prezzo finale sarà determinato dividendo l’importo totale dei fondi impegnati in questo round per il numero totale di token venduti in questo round. La quota totale di token di IDO è di 3.600.000 EGP, e il token di equity privato sarà bloccato per 6 mesi e quindi sbloccato linearmente entro 2 anni. I token dell’offerta pubblica saranno sbloccati al 100% durante TGE.</p>
<p><strong>La probabilità che la Fed tagli i tassi di interesse di 50 punti base questa settimana è del 63%</strong></p>
<p>Secondo i dati di “FedWatch” di CME, la probabilità che la Federal Reserve riduca i tassi di interesse di 25 punti base a settembre è del 37,0%, e la probabilità di ridurre i tassi di interesse di 50 punti base è del 63,0%.</p>
<h2 id="h2-Tendenze20di20mercato20BTC20ha20guidato20la20generale20crescita20del20mercato20mentre20NEIROCTO20si2020distinto20dalla20folla475337"><a name="Tendenze di mercato: BTC ha guidato la generale crescita del mercato, mentre NEIROCTO si è distinto dalla folla" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC ha guidato la generale crescita del mercato, mentre NEIROCTO si è distinto dalla folla</h2><h3 id="h3-Monete20mainstream96180"><a name="Monete mainstream" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete mainstream</h3><p>BTC è tornato a $61.000 questa mattina presto e attualmente si sta consolidando intorno a $60.000. Gli ETF BTC hanno ripreso grandi afflussi e la Federal Reserve sta per tagliare i tassi di interesse;</p>
<p>ETH ha mostrato una debole performance, con quasi nessuna variazione di prezzo durante la giornata, ancora in bilico intorno ai $2.300, e gli ETF di ETH continuano a <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> fuori;</p>
<p>Le altcoin hanno seguito il rimbalzo generale del mercato, con ottime performance di NEIROCTO, BIGTIME, FIGHT e altri;</p>
<p>Per quanto riguarda gli indicatori di dati, l’indice AHR999 è stato 0,65 oggi, indicando un significativo rimbalzo dei prezzi di BTC; L’indice Fear &amp; Greed è 45 e il sentiment di mercato è migliorato dopo un aumento generale.</p>
<h3 id="h3-Punti20caldi20di20mercato189642"><a name="Punti caldi di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi di mercato</h3><p>Settore dei meme: NEIROCTO, FIGHT, BABYDOGE e altri sono saliti, con NEIROCTO che è diventato il token stella che guida il mercato con guadagni intraday superiori al 100%. NEIROCTO è il primo token Neiro implementato sulla blockchain Ethereum, che ha ricevuto grande attenzione dai fondi di mercato questa settimana e ha raddoppiato il suo prezzo entro 24 ore. FIGHT è una moneta meme legata al concetto di elezioni presidenziali negli Stati Uniti. Il candidato presidenziale americano Trump ha twittato slogan su FIGHT, che ha stimolato la sua ascesa. L’aumento intraday di FIGHT ha raggiunto una volta il 400%, ma è ora sceso bruscamente.</p>
<p>Settore GameFi: BIGTIME, MAVIA e altri hanno registrato forti aumenti, con BIGTIME che è diventato il token GameFi con le migliori performance con un aumento intraday del 45%. Il gioco BIGTIME è online da un anno ed è in costante crescita dal suo recente lancio su una piattaforma di trading coreana. Il progetto BIGTIME ha continuamente aggiornato i contenuti del gioco e costruito una buona comunità. E un altro gioco in ascesa, Mavia, è un gioco di strategia tower defense che è stato annunciato essere lanciato sul Web Ruby Marketplace ieri. Gli utenti possono scambiare asset in-game e verrà aggiunta la funzionalità di trading del token MAVIA al marketplace a novembre.</p>
<p>Concepto sociale: UXLINK è aumentato di oltre il 60%, con una capitalizzazione di mercato circolante attuale di $123 milioni e UXLINK è aumentato del 500% rispetto all’inizio del mese. Uxlink è il <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">web3</a> infrastruttura della piattaforma sociale e i token UXLink possono catturare il valore dell’intero ecosistema Uxlink.</p>
<h2 id="h2-Macroeconomia20lSampP2050020ha20raggiunto20un20nuovo20massimo20storico20la20Federal20Reserve20discuter20dei20tassi20dinteresse20domattina20presto243877"><a name="Macroeconomia: l’S&amp;P 500 ha raggiunto un nuovo massimo storico, la Federal Reserve discuterà dei tassi d’interesse domattina presto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia: l’S&amp;P 500 ha raggiunto un nuovo massimo storico, la Federal Reserve discuterà dei tassi d’interesse domattina presto</h2><p>I tre principali indici del mercato azionario statunitense hanno oscillato, con l’indice S&amp;P 500 che è salito dello 0,03% a 5634,58 punti; il Dow Jones Industrial Average è sceso dello 0,04% a 41606,18 punti; l’indice Nasdaq è salito dello 0,20% chiudendo a 17628,06 punti. Il rendimento del benchmark del Tesoro decennale è del 3,65%, mentre il rendimento del Tesoro a 2 anni, che è più sensibile al tasso di politica della Federal Reserve, è del 3,59%.</p>
<p>Questa settimana il mondo darà inizio alla ‘Settimana della Super Banca Centrale’, e l’attenzione dei mercati finanziari sarà incentrata sulle decisioni sui tassi di interesse annunciate dalla Federal Reserve e dalla Banca del Giappone. Inoltre, anche le banche centrali di diversi paesi come il Regno Unito, il Brasile, la Norvegia e l’Indonesia renderanno pubbliche le loro ultime risoluzioni sui tassi di interesse. Il Presidente della Banca Centrale Europea, Lagarde, e diversi membri terranno discorsi durante la settimana. Il noto giornalista macro Nick Timiraos, conosciuto come la ‘voce della Federal Reserve’, ha recentemente affermato che la Fed taglierà sicuramente i tassi di interesse questa settimana, ma è ancora incerto se l’entità di questo taglio sarà di 50 punti base o dei tradizionali 25 punti base.</p>
<p>Secondo i dati di ‘FedWatch’ del CME, la probabilità che la Federal Reserve riduca i tassi di interesse di 25 punti base a settembre è del 37,0%, mentre la probabilità di riduzione dei tassi di interesse di 50 punti base è del 63,0%.</p>
<h3 id="h3-Conclusion27901"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h3><p>Il sentimento generale nel mercato attuale si è ripreso, trainato da notizie macroeconomiche positive. Bitcoin e alcuni Altcoin hanno mostrato una forte performance, soprattutto nei settori Meme e GameFi, dove i token hanno mostrato un significativo impulso al rialzo. Tuttavia, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e alcuni asset stanno ancora mostrando debolezza, e gli investitori devono monitorare attentamente le dinamiche di mercato e i cambiamenti di politica, operare con cautela e allocare gli asset in modo ragionevole.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Glassa</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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentita la ripubblicazione 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>