Tm90aXppZSBnaW9ybmFsaWVyZSB8IElsIGdvdmVybm8gdGVkZXNjbyB0cmFzZmVyaXNjZSAkMTcyTSBkaSBCVEMsIGZhY2VuZG8gY2FkZXJlIGlsIEJUQyBzb3R0byBpICQ1N0s7IEhhbXN0ZXIgS29tYmF0IHBpYW5pZmljYSBkaSBlbWV0dGVyZSB0b2tlbiBzdWxsYSBibG9ja2NoYWluIFRPTg==

2024-07-05, 04:37

<p><img src="https://gimg2.gateimg.com/image/article/17201541591_6-05.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Il20governo20tedesco20trasferir2017220milioni20in20Bitcoin20in20pi20sedi20Hamster20Kombat20pianifica20di20emettere20token20sulla20blockchain20TON20Blast20salta20al20settimo20posto20nella20lista20delle20reti20pi20grandi20dopo20un20grande20airdrop53295"><a name="Crypto Daily Digest: Il governo tedesco trasferirà $172 milioni in Bitcoin in più sedi; Hamster Kombat pianifica di emettere token sulla blockchain TON; Blast salta al settimo posto nella lista delle reti più grandi dopo un grande airdrop." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Il governo tedesco trasferirà $172 milioni in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> in più sedi; Hamster Kombat pianifica di emettere token sulla blockchain TON; Blast salta al settimo posto nella lista delle reti più grandi dopo un grande airdrop.</h2><p>Giovedì 4 luglio, il mercato statunitense è stato chiuso in occasione del Giorno dell’Indipendenza.</p>
<p><strong>Il governo tedesco trasferirà $172 milioni in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> a più sedi</strong></p>
<p>Il governo tedesco ha recentemente effettuato un trasferimento di Bitcoin su larga scala, che potrebbe avere un impatto significativo sul mercato. Hanno trasferito oltre 3.000 bitcoin (del valore approssimativo di 172 milioni di dollari) a indirizzi diversi, e secondo i dati della piattaforma di analisi on-chain Arkham Intelligence, i primi 1.300 bitcoin sono stati trasferiti a exchange cripto centralizzati, mentre i restanti 1.700 bitcoin sono stati trasferiti a un portafoglio separato.</p>
<p>Da febbraio 2024, questo portafoglio è stato contrassegnato come correlato al governo tedesco, che detiene 50.000 bitcoin e ha gradualmente trasferito la maggior parte dei suoi fondi nei mesi scorsi. In combinazione con i prossimi pagamenti di compensazione di Mt. Gox, questi trasferimenti su larga scala da parte dei governi tedesco e americano potrebbero generare una maggiore pressione venditrice rispetto al mercato del Bitcoin.</p>
<p><strong>Il CEO di Telegram: Hamster Kombat ha intenzione di emettere token sulla blockchain TON</strong></p>
<p>Il CEO di Telegram, Patel Du Rove, ha annunciato sul suo canale personale che Hamster Kombat ha intenzione di emettere i suoi token sulla blockchain TON, con l’obiettivo di portare i vantaggi della blockchain a centinaia di milioni di utenti.</p>
<p>Hamster Kombat è diventato l’ultimo fenomeno di successo su Internet, con 239 milioni di persone registrate in soli tre mesi. Questa mini applicazione di Telegram ha raggiunto 100 milioni di utenti attivi mensili entro 73 giorni, con nuovi utenti giornalieri che vanno da 4 a 5 milioni, rendendola uno dei servizi digitali in più rapida crescita al mondo.</p>
<p>Recentemente, gli ecosistemi di Telegram e TON hanno ricevuto molta attenzione. Secondo i dati di Coingecko, il valore di mercato di TON ha superato i 19,1 miliardi di dollari, superando <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> e si classifica nono per valore di mercato.</p>
<p><strong>Blast salta al settimo posto nella classifica delle reti più grandi dopo un massiccio airdrop</strong></p>
<p>A partire da novembre 2023, dopo un controverso “periodo di visita anticipata”, Blast ha ufficialmente lanciato il suo mainnet a febbraio. Da quando è stato lanciato il mainnet, vari indicatori di Blast sono in aumento. In base al valore totale bloccato (TVL), Blast è diventato il settimo network più ampio con asset che si avvicinano a 1,5 miliardi di dollari.</p>
<p>Il lancio di Blast ha attirato molti sostenitori e sviluppatori di grande nome, tra i quali il più importante è che fornisce entrate native su stablecoin e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>. Questo tipo di entrate fa risaltare Blast sul mercato, con un’impennata degli indicatori on-chain dopo il rilascio dell’airdrop. Blast ha emesso 17 miliardi di token, dimostrando un forte slancio di sviluppo, ed è probabile che questa tendenza continui.</p>
<p>Nella prima fase degli airdrop, Blast ha allocato 100 miliardi (50% dell’offerta totale) alla comunità e ha dichiarato che ci saranno altri airdrop nei prossimi tre anni. Dall’avvio della richiesta di airdrop il 26 giugno, non c’è stato un aumento significativo degli indirizzi attivi e del volume di scambi. Il suo valore di mercato ha raggiunto i 493 milioni di dollari il giorno del suo rilascio. Tuttavia, i token BLAST hanno anche subito un tipico fenomeno di vendita durante l’airdrop, con una diminuzione del valore di mercato.</p>
<p>A metà giugno, Blast ha guidato OP Mainnet in termini di volume di transazioni e media mobile di 7 giorni degli indirizzi attivi. Sebbene ancora molto lontano da Arbitrum One e Base, entrambi gli indicatori sono stati costantemente in aumento dal lancio della mainnet.</p>
<h2 id="h2-Tendenze20di20mercato581962"><a name="Tendenze di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato</h2><p>L’attuale sentiment del mercato è estremamente basso, con le principali criptovalute BTC ed ETH che registrano cali significativi. Di seguito è riportata un’analisi specifica delle tendenze del mercato e dei fattori che lo influenzano:</p>
<p>BTC è sceso sotto i 57.000 dollari, con una significativa diminuzione della volatilità. La grande quantità di trasferimenti dalla borsa Mt.Gox, le continue vendite da parte del governo tedesco e gli outflow degli ETF spot di BTC hanno intensificato il sentimento di mercato e aumentato la propensione al rischio degli investitori.</p>
<p>ETH è sceso sotto i 3.100$, risentendo anche della flessione generale del mercato.</p>
<p>Le altcoin hanno in generale subito un significativo declino, e ci sono a malapena valute sul mercato che sono aumentate.</p>
<h3 id="h3-Macroeconomia597116"><a name="Macroeconomia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia</h3><p>I mercati azionari e obbligazionari degli Stati Uniti sono chiusi per un giorno a causa del Giorno dell’Indipendenza. La mancanza di attività di trading significative nel mercato potrebbe portare a un aumento della volatilità nel mercato delle criptovalute.</p>
<p>Indice del dollaro USA: L’indice del dollaro USA è sceso al livello di 105 e ha chiuso a 105,13, raggiungendo un nuovo minimo da metà giugno. Il deprezzamento del dollaro USA è di solito vantaggioso per le criptovalute, ma il sentiment attuale del mercato è estremamente basso e non è riuscito a stimolare i prezzi delle criptovalute.</p>
<h3 id="h3-Hotspot20di20mercato556459"><a name="Hotspot di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato:</h3><p>Public Chain Ton: Il prezzo di TON è sceso di oltre il 10% seguendo il mercato generale. Il CEO di Telegram ha annunciato che Hamster Kombat emetterà token sulla blockchain Ton. In tre mesi, Hamster Kombat ha registrato 239 milioni di persone e aggiunge 4-5 milioni di nuovi utenti ogni giorno.</p>
<p>Concept di Politifi: MAGA e PEOPLE sono scesi di oltre il 30% oggi. Dopo il dibattito sulla campagna presidenziale degli Stati Uniti del 27 giugno, il token del concetto di Polifii è generalmente diminuito. Ciò potrebbe essere dovuto a un aumento dell’incertezza politica e della propensione al rischio degli investitori.</p>
<p>Attualmente il mercato è in uno stato estremamente lento, con le principali criptovalute e Altcoin che registrano significativi cali. Le modifiche nell’ambiente macroeconomico, le chiusure di mercato nei mercati azionari e obbligazionari statunitensi, così come eventi di mercato caldo come grandi deflussi sulla piattaforma Mt.Gox e la continua vendita da parte del governo tedesco, hanno avuto un impatto negativo sul sentiment di mercato. Il sentiment e le tendenze di mercato sono spesso ciclici, e mantenere una strategia di investimento calma e razionale può aiutare a ottenere migliori rendimenti negli ambienti di mercato volatili.</p>
<h2 id="h2-Macro20Il20mercato20statunitense2020chiuso20le20borse20asiatiche20raggiungono20un20nuovo20massimo20Dopo20la20schiacciante20vittoria20del20Partito20Laburista20il20trend20della20sterlina2020rimasto20calmo673570"><a name="Macro: Il mercato statunitense è chiuso; le borse asiatiche raggiungono un nuovo massimo; Dopo la schiacciante vittoria del Partito Laburista, il trend della sterlina è rimasto calmo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Il mercato statunitense è chiuso; le borse asiatiche raggiungono un nuovo massimo; Dopo la schiacciante vittoria del Partito Laburista, il trend della sterlina è rimasto calmo</h2><p>Il 4 luglio il mercato statunitense è stato chiuso per la festa dell’Indipendenza e l’attenzione del pubblico si è spostata sul dibattito presidenziale. Durante la discussione, l’età e l’agilità mentale di Biden hanno attirato l’attenzione. Un sondaggio del Wall Street Journal ha mostrato che Trump ha sconfitto Biden del 48% al 42%, aumentando il suo vantaggio di un punto percentuale; un sondaggio del New York Times ha mostrato che il vantaggio di Trump si è ampliato al 49%, un aumento di tre punti percentuali rispetto al 43%.</p>
<p>Nonostante la pressione per ritirarsi dalla campagna, Biden ha ribadito la sua determinazione a continuare a candidarsi alle elezioni presidenziali del 2024 in una telefonata con lo staff della campagna mercoledì, così come in incontri con legislatori democratici e governatori, nel tentativo di superare l’impatto negativo della scarsa performance nel dibattito della settimana scorsa.</p>
<p>Venerdì i dati sull’occupazione negli Stati Uniti sono diventati il focus del calendario economico. Si prevede che le assunzioni rallentino e il tasso di disoccupazione aumenti leggermente, lasciando spazio per tagli dei tassi di interesse negli Stati Uniti. Una serie di dati deludenti, tra cui l’indice di attività del settore dei servizi ISM degli Stati Uniti, che è sceso ai minimi livelli dal 2020 all’inizio di questa settimana, ha aumentato al 73% la possibilità di un taglio dei tassi di interesse a settembre nel mercato e si prevede che i tassi vengano tagliati di 47 punti base quest’anno.</p>
<p><strong>I mercati azionari asiatici raggiungono un nuovo massimo; Dopo la schiacciante vittoria del Partito Laburista, il trend della sterlina è rimasto calmo</strong></p>
<p>Il 5 luglio, i mercati azionari asiatici hanno raggiunto un nuovo massimo all’apertura mentre gli investitori valutavano la possibilità di un taglio dei tassi di interesse negli Stati Uniti a settembre e rimanevano ottimisti. Nel frattempo, l’euro ha raggiunto un massimo di tre settimane prima delle elezioni generali francesi.</p>
<p>La sterlina si è rafforzata a $1.2767 poiché ci si aspetta che il Partito Laburista del Regno Unito ottenga una vittoria schiacciante alle elezioni, ponendo fine ai 14 anni di mandato del Partito Conservatore al potere. In altri aspetti, il dollaro americano si è leggermente indebolito e il rendimento dei titoli del tesoro statunitense a Tokyo è leggermente aumentato, in quanto si è ripreso il trading dopo la festa del Giorno dell’Indipendenza.</p>
<p>L’indice Nikkei e l’indice composito di Tokyo sono saliti ai livelli record, e l’indice di riferimento di Taiwan è salito di conseguenza. L’indice azionario MSCI Asia Pacific è salito dello 0,2%, raggiungendo il suo livello più alto in due anni; Samsung prevede che i suoi profitti aumenteranno più di 15 volte nel secondo trimestre, aiutando l’indice KOSPI della Corea del Sud a raggiungere un picco di due anni.</p>
<p>Il governo giapponese ha reso noti venerdì i dati che mostrano una diminuzione imprevista della spesa delle famiglie a maggio. Lo yen debole ha soppresso il potere d’acquisto dei consumatori, complicando ulteriormente le prospettive dei tassi di interesse. Lo yen giapponese è leggermente salito a 160,9 rispetto al dollaro statunitense. Venerdì, i futures dell’indice FTSE sono aumentati dello 0,3%.</p>
<p>Nel mercato delle materie prime, il indebolimento del dollaro statunitense ha spinto i prezzi dell’oro al loro più grande aumento settimanale in un mese, con un aumento del 1,4% a $2,357 per oncia. I prezzi del petrolio hanno raggiunto il loro livello più alto da aprile, con i prezzi dei futures del petrolio greggio Brent che rimangono sopra i $87 al barile. In precedenza, il calo delle scorte di petrolio greggio statunitense ha superato le aspettative, indicando una forte domanda di prezzi del petrolio in vista della stagione estiva di guida negli Stati Uniti.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; 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. La ripubblicazione dell'articolo sarà consentita 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>