Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgbWVyY2F0byBjcml0dG9ncmFmaWNvIHN0YSBmbHV0dHVhbmRvIGFsIHJpYmFzc28sIGNvbiB1biBuZXR0byBjYWxvIGRlbCBudW1lcm8gZGkgbnVvdmkgcG9ydGFmb2dsaSBCVEM7IGxhIEZvbmRhemlvbmUgVE9OIHN1cHBvcnRhIGlsIHBlcm1lc3NvIGFnbGkgdXRlbnRpIGRpIGludmlhcmUgVVN

2024-05-20, 03:40

<p><img src="https://gimg2.gateimg.com/image/article/17161763931_12.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20di20Crypto20Il20numero20di20nuovi20portafogli20Bitcoin2020diminuito20nettamente20Oobit20ha20collaborato20con20TON20per20consentire20agli20utenti20di20inviare20USDT20tramite20Telegram20Kroma20ha20annunciato20il20lancio20di20Spectrum20e20i20piani20di20espansione551477"><a name="Riepilogo giornaliero di Crypto: Il numero di nuovi portafogli Bitcoin è diminuito nettamente; Oobit ha collaborato con TON per consentire agli utenti di inviare USDT tramite Telegram; Kroma ha annunciato il lancio di Spectrum e i piani di espansione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero di Crypto: Il numero di nuovi portafogli <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è diminuito nettamente; Oobit ha collaborato con TON per consentire agli utenti di inviare USDT tramite Telegram; Kroma ha annunciato il lancio di Spectrum e i piani di espansione</h2><p>Innanzitutto, esaminiamo le attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF. Secondo i dati di Farside Investor, il 20 maggio gli ETF spot di Grayscale Bitcoin (GBTC) hanno continuato a registrare deflussi di 276,2 milioni di dollari; nel frattempo, gli ETF spot di Fidelity Bitcoin (FBTC) hanno registrato un afflusso di 99,4 milioni di dollari, gli ETF spot di Bitwise Bitcoin (BITB) un afflusso di 20,8 milioni di dollari, gli ETF spot di ARK 21Shares Bitcoin (ARKB) un afflusso di 10 milioni di dollari e gli ETF spot di iShares Trust Bitcoin (IBIT) un afflusso netto di 38,1 milioni di dollari.</p>
<p>Il blocco ha riferito che in precedenza, con lo sviluppo degli ecosistemi Bitcoin come gli ETF Bitcoin spot e gli ordinari, nonché l’imminente halving, il numero medio di nuovi indirizzi Bitcoin settimanali si avvicinava al livello più alto raggiunto dal picco storico nel dicembre 2017.</p>
<p>Ora, mentre questi messaggi e progetti perdono gradualmente la loro attualità, proprio come all’inizio del 2018, l’entusiasmo per il nuovo progetto Bitcoin si è affievolito e il numero di nuovi indirizzi che si uniscono alla rete è drasticamente diminuito. Oltre alla diminuzione del numero di nuovi indirizzi Bitcoin, anche altri indicatori correlati hanno mostrato un trend al ribasso, il più importante dei quali è che il reddito dei minatori misurato dalla potenza di calcolo è sceso a un minimo storico. Inoltre, i costi delle transazioni online e gli indicatori del volume delle transazioni on-chain sono anche diminuiti.</p>
<p>Tuttavia, nonostante il calo delle metriche on-chain, i nuovi protocolli sulla rete Bitcoin stanno attirando un interesse da record da parte delle società di venture capital. Questi segnali potrebbero gettare le basi per un futuro ritorno.</p>
<p>Il 17 maggio è stato annunciato che l’applicazione di pagamento mobile Oobit ha stretto una partnership con la Fondazione TON per integrare la sua criptovaluta nativa TON. <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a> Inserendo <a href="/price/toncoin-ton" target="_blank" class="blog_inner_link">Toncoin</a> nella sua piattaforma, Gate.io promuove l’uso delle criptovalute come metodo di pagamento. Il team ha dichiarato che i possessori di Toncoin possono utilizzare Tap&amp;Pay presso oltre 100 milioni di rivenditori in tutto il mondo. Questa integrazione rafforzerà ulteriormente la collaborazione annunciata di recente tra… <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> la più grande azienda del settore degli asset digitali e la Fondazione TON.</p>
<p>Secondo un’altra comunicato stampa sul sito web di Tether, gli utenti possono inviare USDT come messaggio diretto su Telegram e utilizzare lo stesso USDT per pagamenti istantanei di crypto tap su Oobit.</p>
<p>Kroma ha lanciato Spectrum il 14 maggio 2024, un servizio di stake protoplasti avanzato per cambiare completamente il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Panoramica del Layer 2. Alti guadagni possono essere ottenuti attraverso il re-staking utilizzando i token di staking in vari giochi ed ecosistemi DeFi su Kroma. Spectrum offre agli utenti l’opportunità di sfruttare il potenziale di ETH, stETH ed eETH, consentendo loro di generare maggiori ricavi nel campo della finanza decentralizzata (DeFi).</p>
<p>La differenza dalle piattaforme di staking tradizionali è che Spectrum ha lanciato in modo innovativo una “ricompensa sestupla”, tra cui il tasso di interesse annuo Ethereum, la ricompensa pesante di staking, i punti EigenLayer per il blocco degli asset Ethereum, i punti di fedeltà Etherfi, KSP (Kroma Spectrum Point) e l’airdrop di wemix.e. Kroma farà un airdrop di 40.000 wemix.e agli utenti in base al KSP accumulato, fornendo un nuovo tipo di ricompensa di garanzia.</p>
<p>La piattaforma ha introdotto spETH, un token di rischio proprietario per la sintesi di asset. Gli utenti che utilizzano spETH possono massimizzare la liquidità dei loro asset <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> depositati e ottenere una vasta gamma di opportunità di trading, nonché ulteriori opportunità di profitto all’interno dei protocolli e delle applicazioni DeFi estensive della piattaforma.</p>
<p>Spectrum ha integrato con successo con dApps ben noti come Standard Protocol, Light Bank, Layer Bank, Shoebil, Zapanki Swap, Wellxy, PrixmSwap e iZUMi Finance, e ha ottenuto ampi consensi. Questa integrazione pone le basi per ulteriori espansioni, poiché Spectrum spera di continuare i suoi sforzi innovativi per integrare più dApps.</p>
<h2 id="h2-Tendenze20di20mercato20il20mercato20manca20di20argomenti20caldi20e20lintero20mercato2020in20un20trend20discendente20fluttuante820304"><a name="Tendenze di mercato: il mercato manca di argomenti caldi e l’intero mercato è in un trend discendente fluttuante" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il mercato manca di argomenti caldi e l’intero mercato è in un trend discendente fluttuante</h2><p>BTC ha brevemente superato i $67,500 durante il fine settimana ma ha poi sperimentato un calo, attualmente scendendo a circa $66,500. Questo calo ha portato a una diminuzione diffusa delle Altcoin, e anche le Meme coin che in precedenza avevano una buona performance hanno cominciato a calare. Il mercato manca di punti caldi stimolanti e il sentiment degli investitori è relativamente tiepido.</p>
<p>Per quanto riguarda la macroeconomia, il mercato azionario statunitense ha sperimentato volatilità, e Nvidia rilascerà i suoi risultati questa settimana, il che potrebbe avere un certo impatto sul mercato. Gli investitori monitoreranno attentamente le performance per valutare le tendenze delle azioni tecnologiche e dell’intero mercato.</p>
<h3 id="h3-Hotspot20di20mercato558254"><a name="Hotspot di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato:</h3><p>Public chain FTM up: FTM ha annunciato che effettuerà un upgrade del suo Sonic nel terzo trimestre, e dopo l’upgrade verrà sostituito con un nuovo token S in un rapporto di 1:1. Questa notizia potrebbe fornire un po’ di slancio agli acquisti per i token FTM, e gli investitori prestereanno attenzione agli effetti e alle reazioni di mercato dopo l’upgrade.</p>
<p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> L’ecosistema Oracle Protocol PYTH crolla: Saranno sbloccati quasi 800 milioni di token PYTH questa settimana. Prima e dopo lo sblocco del massiccio token, potrebbero verificarsi significative fluttuazioni di mercato e gli investitori devono valutare attentamente i rischi.</p>
<p>Le nuove monete hanno avuto prestazioni scadenti: Recentemente, nuove monete come NOT, BB e REZ hanno fatto breccia, e i token VC con un alto valore di mercato, una volta lanciati, non sono più richiesti sul mercato. Negli ultimi sei mesi, l’80% dei token in monete nuove simili è diminuito, con una caduta media di oltre il 20%. Questo indica che gli investitori stanno diventando più cauti riguardo alla nuova moneta e devono scegliere con attenzione gli obiettivi di investimento.</p>
<p>Zksync di Layer2 prevede un token airdrop: questa notizia potrebbe attirare l’attenzione degli investitori, che monitoreranno attentamente i dettagli e il programma dell’airdrop. Nel mercato attuale, BTC ha sperimentato un breve calo, causando un declino generale nelle Altcoin e nelle Meme coin. Il mercato manca di punti caldi stimolanti e il sentiment degli investitori è relativamente indifferente. Gli investitori devono valutare attentamente i rischi di mercato, prestare attenzione alle tendenze macroeconomiche e settoriali e scegliere obiettivi adatti alle loro strategie di investimento.</p>
<h2 id="h2-Macro20i20mercati20azionari20statunitensi20potrebbero20continuare20a20raggiungere20livelli20storici20mentre20i20mercati20azionari20asiatici20aprono20al20rialzo928300"><a name="Macro: i mercati azionari statunitensi potrebbero continuare a raggiungere livelli storici, mentre i mercati azionari asiatici aprono al rialzo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: i mercati azionari statunitensi potrebbero continuare a raggiungere livelli storici, mentre i mercati azionari asiatici aprono al rialzo</h2><p>Lo scorso venerdì 17 maggio, il mercato azionario degli Stati Uniti ha raggiunto un massimo storico, dimostrando l’atteggiamento ottimista del mercato verso le prospettive economiche. Allo stesso tempo, i mercati azionari asiatici sono stati positivamente influenzati all’apertura di lunedì.</p>
<p>I nuovi segni di raffreddamento economico hanno calmato le preoccupazioni sull’inflazione nel mese di maggio e hanno contribuito ad elevare i tre principali indici azionari statunitensi ai massimi storici questa settimana. L’indice S&amp;P 500 è aumentato dell’11% finora quest’anno. Sulla base delle tendenze storiche, gli strategist di mercato suggeriscono che il mercato azionario spesso forma momentum quando si riprende da pullback di scala simile, e anche dopo aver recuperato terreno perso, di solito continua ad aumentare.</p>
<p>Gli investitori ritengono che le persone <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> La discussione sull’economia che si sta avvicinando ad un cosiddetto atterraggio morbido è riemersa, e le previsioni di forti profitti stanno spingendo ulteriormente il mercato azionario verso l’alto. Gli investitori presteranno attenzione anche ai dati sulla durata dei beni durevoli e sulla fiducia dei consumatori della prossima settimana per trovare ulteriori segni che la crescita economica si stia raffreddando abbastanza da supportare il taglio dei tassi di interesse di quest’anno.</p>
<p>In termini di azioni tecnologiche, il prezzo delle azioni del colosso dei semiconduttori Nvidia è aumentato a causa della sua passione per l’intelligenza artificiale e presenterà i risultati trimestrali mercoledì.</p>
<p>Anche i mercati azionari asiatici hanno mostrato segnali positivi all’apertura lunedì. La Cina ha annunciato una misura storica per stabilizzare l’industria immobiliare lo scorso venerdì, con la banca centrale che fornisce fondi aggiuntivi di 1 trilione di yuan (circa 138 miliardi di dollari) e rilassando le normative sui prestiti ipotecari. Anche i governi locali stanno preparandosi ad acquistare “alcuni” appartamenti. Questo ha spinto l’Hang Seng Index a un massimo di 9 mesi.</p>
<p>L’indice Nikkei del Giappone è salito dello 0,9% nella sessione di trading mattutina. Allo stesso tempo, l’Indice MSCI Asia Pacifico è stato influenzato dai guadagni iniziali nei mercati azionari australiani e sudcoreani, salendo dello 0,25% al suo livello più alto in due anni.</p>
<p>Nel mercato valutario, il dollaro statunitense ha registrato la sua più grande diminuzione settimanale contro l’euro in due mesi e mezzo la scorsa settimana ma è rimasto stabile nelle prime ore di negoziazione asiatiche lunedì. L’euro è rimasto stabile a $1,0873 lunedì. Lo yen giapponese si è leggermente indebolito contro il dollaro statunitense, a 155,82 yen per dollaro.</p>
<p>Per quanto riguarda le materie prime, un elicottero che trasportava il Presidente dell’Iran è precipitato in una fitta nebbia, attirando l’attenzione dei trader verso il Medio Oriente. I future del petrolio greggio Brent hanno raggiunto un massimo di una settimana nelle prime contrattazioni, con un prezzo al barile di $84.14.</p>
<p>I prezzi dell’oro si aggirano intorno a un massimo storico di $2,423 per oncia.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Icing</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 ripostare dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>