RGFpbHkgTmV3cyB8IFRlbGVncmFtIGhhIGxhbmNpYXRvIHVuIE1pbmkgUHJvZ3JhbSBwZXIgcGFnYXJlIGJlbmkgZGlnaXRhbGk7IExhIGRpdnVsZ2F6aW9uZSBkZWxsZSBwYXJ0ZWNpcGF6aW9uaSBkaSBSb2FyaW5nIEtpdHR5IGhhIHNwaW50byBHYW1lU3RvcCBhIHNhbGlyZSBkaSB1biBhbHRybyA0NyU=

2024-06-07, 03:52

<p><img src="https://gimg2.gateimg.com/image/article/17177322361_6-05.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Telegram20ha20lanciato20Telegram20Stars20per20pagare20beni20digitali20Sandbox20ha20completato20un20finanziamento20di202020milioni20con20un20aumento20del204520per20SAND20Roaring20Kitty20ha20dichiarato20una20posizione20di2058620milioni20su20GME20facendo20salire20il20prezzo20delle20azioni20di20GameStop20del2047403305"><a name="Crypto Daily Digest: Telegram ha lanciato Telegram Stars per pagare beni digitali; Sandbox ha completato un finanziamento di $20 milioni, con un aumento del 4,5% per SAND; Roaring Kitty ha dichiarato una posizione di $586 milioni su GME, facendo salire il prezzo delle azioni di GameStop del 47%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Telegram ha lanciato Telegram Stars per pagare beni digitali; Sandbox ha completato un finanziamento di $20 milioni, con un aumento del 4,5% per SAND; Roaring Kitty ha dichiarato una posizione di $586 milioni su GME, facendo salire il prezzo delle azioni di GameStop del 47%</h2><p>Innanzitutto, esaminiamo le attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Secondo i dati di Farside Investor, il 6 giugno gli ETF Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot (GBTC) hanno continuato a registrare deflussi di fondi per 37,6 milioni di dollari. Nel frattempo, l’afflusso di fondi per il Fidelity Bitcoin spot ETF (FBTC) è stato di 3,1 milioni di dollari, il deflusso per il Bitwise Bitcoin spot ETF (BITB) è stato di 3,1 milioni di dollari, e il deflusso per l’ARK 21Shares Bitcoin spot ETF (ARKB) è stato di 96,6 milioni di dollari.</p>
<p><strong>Telegram ha lanciato il sistema di pagamento di programmi mini digitali Telegram Stars</strong><br>La piattaforma di messaggistica sociale Telegram ha lanciato “Telegram Stars”. È un nuovo token in-app che può essere utilizzato per acquistare beni digitali e servizi sulla piattaforma.</p>
<p>Il 6 giugno, il CEO dell’azienda, Pavel Durov, ha dichiarato in un post su Telegram che “con Telegram Stars, i mini-programmi possono ora accettare pagamenti per servizi digitali su Android e iOS utilizzando i metodi di pagamento più comodi”. Gli sviluppatori possono anche scambiare le loro Stars per <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a> (TON) attraverso la piattaforma Fragment, una piattaforma principalmente utilizzata per il trading di nomi utente di Telegram. <a href="/price/toncoin-ton" target="_blank" class="blog_inner_link">Toncoin</a> è una criptovaluta nativa che supporta la rete aperta di Telegram. Durov ha aggiunto: “Possono anche utilizzare Stars per promuovere ulteriormente le loro applicazioni su Telegram.”</p>
<p>Inoltre, Telegram utilizzerà Stars per sovvenzionare gli annunci acquistati tramite Apple e Google e trarre una commissione del 30% dalle vendite di prodotti digitali. Durov ritiene che questo incentiverebbe economicamente gli sviluppatori a costruire prodotti digitali su Telegram.</p>
<p>Il 6 giugno, Telegram ha dichiarato in un post: “Gli aggiornamenti futuri porteranno ulteriori funzionalità a Stars, come ad esempio fornire regali per i creatori di contenuti e altro ancora.”</p>
<p>Di recente, Telegram ha ottenuto un grande successo con Notcoin. Notcoin è una delle applicazioni più popolari sulla piattaforma, con 35 milioni di utenti accumulati nei primi cinque mesi dopo il lancio. Anche la rete TON ha ricevuto molta attenzione. Secondo i dati di CoinGecko, TON ha recentemente raggiunto un massimo storico di $7,65, ma è poi sceso a $7,50. Tuttavia, la sua capitalizzazione di mercato di $18,2 miliardi è ancora $7 miliardi inferiore al picco di $25,2 miliardi raggiunto il 12 aprile.</p>
<p><strong>Sandbox ha raccolto $20 milioni con una valutazione di $1 miliardo, e SAND è salito del 4.5%</strong> <a href="/price/the-sandbox-sand" rel="nofollow noopener noreferrer" target="_blank">Il Sandbox</a> The Sandbox, una piattaforma metaverse, ha raccolto $20 milioni con una valutazione di $1 miliardo per migliorare la sua piattaforma di giochi multiplayer generati dagli utenti. Secondo il comunicato stampa, Kingsway Capital e Animoca Brands hanno guidato il round di finanziamento, con LG Tech Ventures e True Global Ventures che hanno partecipato anche all’investimento. Due anni fa, <a href="/price/the-sandbox-sand" target="_blank" class="blog_inner_link">The Sandbox</a> aveva pianificato di raccogliere $400 milioni con una valutazione di $4 miliardi.</p>
<p>Secondo i dati di CoinDesk, il token nativo di Sandbox, SAND, è aumentato del 4,5% dalla notizia del round di finanziamento e attualmente ha una capitalizzazione di mercato di 1,1 miliardi di dollari. Parte dei fondi sarà utilizzata per sviluppare un metaverso decentralizzato per dispositivi mobili, che dovrebbe essere lanciato nel 2025. Sandbox aggiornerà anche i suoi strumenti Game Maker e l’editor 3D.</p>
<p>Sandbox ha 5,7 milioni di account utente collegati ai portafogli crittografici e ha creato oltre 1.000 esperienze generate dagli utenti dalla versione Alpha lanciata nel novembre 2023.</p>
<p><strong>Roaring Kitty ha rivelato una posizione di $586 milioni su GME, facendo salire il prezzo delle azioni di GameStop del 47%</strong><br>Keith Gill (conosciuto come RoaringKitty o DeepF - kingValue) ha svelato la sua ultima grande scommessa sulle azioni di GameStop. Secondo lo screenshot pubblicato su Reddit, le posizioni azionarie e le opzioni di Gill ammontano ora a circa 586 milioni di dollari. Giovedì ha annunciato che farà uno streaming live su YouTube venerdì. Il prezzo delle azioni di GameStop è salito del 47% alla chiusura.</p>
<p>Questa misura ha colpito anche il mercato degli asset digitali. Secondo i dati di CoinGecko, anche se il mercato cripto nel complesso sta diminuendo, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>- Il token meme GME basato negli Stati Uniti è aumentato di oltre l’80% nelle ultime 24 ore. Anche se i token GME sono ispirati a GameStop, non hanno alcuna connessione con l’azienda.</p>
<h2 id="h2-Tendenze20di20mercato993416"><a name="Tendenze di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato</h2><p>BTC si consolida sopra i $70.000, e il suo prezzo è relativamente stabile. La ripresa del dominio di BTC indica un aumento della fiducia di mercato in BTC, con i fondi che tornano dagli Altcoins a BTC.</p>
<p>ETH è sceso sotto i $3.800 la scorsa notte, mostrando un po’ di volatilità.</p>
<p>Altcoins: la maggior parte degli Altcoins ha registrato un calo generale e ha avuto una prestazione scarsa.</p>
<p>La performance attiva del settore Meme potrebbe aver attirato alcuni fondi speculativi.</p>
<h3 id="h3-Macroeconomia38517"><a name="Macroeconomia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia</h3><p>Dopo aver raggiunto un massimo storico, il mercato azionario statunitense è attualmente in una tendenza volatile.</p>
<p>La Banca centrale europea ha abbassato i tassi di interesse per la prima volta in cinque anni, e questa politica potrebbe avere un impatto sui mercati finanziari globali.</p>
<h3 id="h3-Punti20caldi20del20mercato937452"><a name="Punti caldi del mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi del mercato:</h3><p><strong>Io.net:</strong><br>Io.net sta per essere lanciato e, come progetto leader nel calcolo decentralizzato dell’IA, la sua valutazione fuori borsa ha raggiunto $3.5 miliardi. Sei mesi fa, la valutazione durante il finanziamento era solo di $300 milioni, un aumento significativo.</p>
<p>Rispetto ad altri progetti di traccia, RNDR ha una capitalizzazione di mercato di $5 miliardi e AKT ha una capitalizzazione di mercato di $1 miliardo.</p>
<p><strong>Meme Coins sulla catena Solana:</strong><br>MOTHER: Emesso dalla celebrità Iggy e supportato e promosso da note comunità crypto come KOL Ansem.</p>
<p>GME: Influenzato dall’importante aumento del titolo GME nello stesso nome del mercato azionario statunitense, il GME sulla catena <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> è salito di oltre il 100% in un solo giorno.</p>
<p><strong>Il protocollo di ponte cross-chain W:</strong><br>Il protocollo del ponte cross-chain W è aumentato del 15% nei giorni scorsi, e il team del progetto ha annunciato che attiverà lo staking di W, il che potrebbe comportare in futuro l’airdrop di token dell’ecosistema.</p>
<p><strong>Il BRETT della Base Chain:</strong><br>Il BRETT della Base Chain è aumentato del 30%, diventando la meme coin più preziosa quotata sulla Base Chain. La sua attuale capitalizzazione di mercato è di quasi 1,4 miliardi di dollari ed è stata lanciata su Gate.io.</p>
<p>La consolidazione e la ripresa della dominanza di BTC indicano una forte fiducia di mercato in BTC. In un contesto di incertezza macroeconomica, BTC può essere considerato un bene rifugio. L’emergere di nuovi progetti come Io.net e il protocollo di bridge cross-chain W hanno portato nuove opportunità di investimento sul mercato. Tuttavia, gli investitori devono avere una comprensione dettagliata dello sfondo del progetto e delle prospettive di sviluppo. In generale, la volatilità attuale del mercato e le prestazioni attive dei progetti più caldi offrono agli investitori diverse scelte di investimento, ma devono anche essere vigili riguardo ai rischi di mercato e di progetto.</p>
<h2 id="h2-Macro20La20Banca20Centrale20Europea20ha20annunciato20il20suo20primo20taglio20dei20tassi20di20interesse20degli20ultimi20anni20e20la20pubblicazione20di20un20rapporto20sulle20retribuzioni20agricole20potrebbe20stimolare20un20rimbalzo20dei20mercati20globali419469"><a name="Macro: La Banca Centrale Europea ha annunciato il suo primo taglio dei tassi di interesse degli ultimi anni, e la pubblicazione di un rapporto sulle retribuzioni agricole potrebbe stimolare un rimbalzo dei mercati globali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: La Banca Centrale Europea ha annunciato il suo primo taglio dei tassi di interesse degli ultimi anni, e la pubblicazione di un rapporto sulle retribuzioni agricole potrebbe stimolare un rimbalzo dei mercati globali</h2><p><strong>Prima della pubblicazione dei dati sull’occupazione negli Stati Uniti, l’indice S&amp;P 500 e l’indice Nasdaq hanno chiuso leggermente al ribasso</strong><br>Secondo Reuters, giovedì mattina l’indice S&amp;P 500 e il Nasdaq sono saliti e hanno raggiunto un nuovo massimo intraday prima della pubblicazione del rapporto chiave sul mercato del lavoro. Tuttavia, a causa del calo delle azioni tecnologiche, alla fine hanno chiuso in ribasso.</p>
<p>I dati specifici sono i seguenti: il Dow Jones è salito dello 0,20%, l’S&amp;P è sceso dello 0,02% e il Nasdaq è sceso dello 0,09%.</p>
<p>Gli investitori possono monitorare il rapporto sugli occupati non agricoli degli Stati Uniti, che sarà pubblicato venerdì. Inoltre, i dati settimanali sulle domande di sussidio di disoccupazione pubblicati giovedì indicano un allentamento del mercato del lavoro, il che potrebbe spingere la Federal Reserve a iniziare a ridurre i tassi di interesse.</p>
<p>La Banca centrale europea (BCE) ha annunciato un taglio dei tassi giovedì, segnando il primo taglio dei tassi dal 2019. L’altro ieri, la Banca del Canada è diventata il primo paese del G7 a ridurre i tassi d’interesse chiave della politica. Queste due banche centrali, insieme alla banca centrale svedese e alla banca centrale svizzera, hanno avviato i rispettivi cicli di allentamento monetario, iniettando nuova vitalità nel rimbalzo dell’appetito per il rischio globale, mentre il mercato sta scommettendo sempre di più che la Federal Reserve possa tagliare i tassi di interesse a settembre.</p>
<p><strong>Si prevede che i mercati azionari asiatici si riprendano ogni settimana a causa dei tagli dei tassi di interesse</strong><br>Il 7 giugno, nelle prime contrattazioni in Asia, trainate dal ciclo di allentamento dei tassi d’interesse avviato dalle principali banche centrali questa settimana, ci si aspetta che i mercati azionari asiatici pongano fine alle due settimane consecutive di declino venerdì, e il mercato si aspetta che la Federal Reserve segua presto l’esempio.</p>
<p>L’indice azionario MSCI Asia Pacific ha seguito l’ascesa dei mercati azionari globali, con l’Asia in rialzo dello 0,3% nelle prime contrattazioni e quasi del 3% questa settimana. Anche l’indice Hang Seng di Hong Kong è salito dello 0,14%, mentre le azioni cinesi blue chip sono aumentate leggermente dello 0,23%. La tendenza di mercato è stabile mentre i trader attendono il rilascio del rapporto sull’occupazione non agricola degli Stati Uniti venerdì. Si prevede che l’occupazione non agricola negli Stati Uniti aumenterà di 185.000 il mese scorso.</p>
<p>I dati diffusi venerdì hanno mostrato che la spesa delle famiglie in Giappone è aumentata per la prima volta in 14 mesi ad aprile rispetto allo stesso periodo dell’anno scorso. Tuttavia, la crescita è stata debole, indicando che i consumatori rimangono cauti nonostante l’aumento dei prezzi. Secondo i dati del Ministero giapponese degli Affari Generali, la spesa dei consumatori ad aprile è aumentata dello 0,5% rispetto allo stesso periodo dell’anno scorso, leggermente inferiore all’aumento atteso del 0,6% dal mercato.</p>
<p>Il dollaro americano è sceso vicino al minimo di otto settimane contro un paniere di valute nel mercato del denaro, con un calo settimanale di circa lo 0,5%. L’euro è salito dello 0,05% a $1,0895, continuando i leggeri guadagni della giornata di negoziazione precedente poiché la Banca Centrale Europea ha aumentato le sue aspettative di inflazione e non ha divulgato il momento dei successivi tagli dei tassi.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono leggermente diminuiti. I futures del petrolio greggio Brent sono scesi dello 0,09% a 79,80 dollari al barile, mentre i futures del petrolio greggio West Texas Intermediate negli Stati Uniti sono scesi dello 0,1% a 75,48 dollari al barile. L’oro spot è sceso dello 0,2% a 2.370,82 dollari l’oncia.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Icing</strong>, Ricercatore 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à consentito ripostare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>