Tm90aXppZSBxdW90aWRpYW5lIHwgVGVzbGEgaGEgZWxpbWluYXRvIGlsIGNhbXBvIEJUQywgaWwgcHJpbW8gc2F0ZWxsaXRlIGJsb2NrY2hhaW4gYWwgbW9uZG8gw6ggc3RhdG8gbGFuY2lhdG8gY29uIHN1Y2Nlc3NvLCBEQUkgaGEgc3VwZXJhdG8gQlVTRCBkaXZlbnRhbmRvIGxhIHRlcnphIHN0YWJsZWNvaW4gcGnDuSBncmFuZGU=

2023-07-24, 03:35

<p><img src="https://gimg2.gateimg.com/image/article/16901782410724.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20il20primo20satellite20blockchain20visivo20in20orbita20al20mondo2020stato20lanciato20con20successo20il20conto20alla20rovescia20dellevento20di20halving20LTC2020salito20a201020giorni20e20DAI20ha20superato20BUSD20diventando20la20terza20stablecoin20pi20grande263937"><a name="Crypto Daily Digest: il primo satellite blockchain visivo in orbita al mondo è stato lanciato con successo, il conto alla rovescia dell’evento di halving LTC è salito a 10 giorni e DAI ha superato BUSD diventando la terza stablecoin più grande" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: il primo satellite blockchain visivo in orbita al mondo è stato lanciato con successo, il conto alla rovescia dell’evento di halving LTC è salito a 10 giorni e DAI ha superato BUSD diventando la terza stablecoin più grande</h2><p>Secondo Red Star News, alle 5:07 del 22 luglio (UTC), il satellite “Tai’an” (Star Times-16) è stato lanciato con successo in orbita presso il centro di lancio satellitare di Jiuquan in Cina, trasportando il sesto razzo vettore Ceres 1. Questo è il primo satellite blockchain visivo in orbita al mondo, che segna anche il completamento della dodicesima missione spaziale di NationStar Aerospace e il processo di interconnessione del satellite Star Age AI. <a href="/price/constellation-dag" rel="nofollow noopener noreferrer" target="_blank">Costellazione</a> verrà promosso in modo costante nel 2023.</p>
<p>Si comprende che il satellite “Tai’an” (Star Times-16) utilizza la piattaforma satellitare intelligente leggera ADASAT-30 sviluppata da NationStar Aerospace e configura un carico utile di remote sensing iperspettrale ad alte prestazioni. Nel frattempo, è dotato del carico utile blockchain ADAChain in orbita e del sistema di schermi satellitari sviluppato in modo innovativo da NationStar Aerospace per la prima volta e implementerà il primo storage di certificati blockchain visivi in orbita al mondo e servizi commerciali, e lancerà una serie di applicazioni di contenuti di calcolo spaziale come la prima piattaforma sociale di vita digitale nello spazio (Interstellar Immortal Passenger) al mondo.</p>
<p>OpenSea nel mercato NFT ha annunciato il lancio di Deals, una funzione di scambio NFT peer-to-peer che aiuta i commercianti ad aggiungere preferiti e interagire direttamente con altri collezionisti. Deals permetterà ai collezionisti di scambiare NFT tra loro, incluso WETH, supportato dal protocollo nativo NFT di OpenSea, Seaport.</p>
<p>OpenSea ha aggiunto che l’obiettivo del prodotto è rendere il processo di scambio NFT affidabile e evitare che gli utenti vengano ingannati da siti web o collegamenti di terze parti contraffatti durante le transazioni.</p>
<p>Secondo l’interfaccia di pagamento per l’acquisto di auto Tesla, il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il campo nel codice sorgente è stato eliminato. Si riporta che Tesla ha annunciato il suo supporto per il pagamento in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> per l’acquisto di auto il 24 marzo 2021 e ha ritirato il suo supporto il 13 maggio dello stesso anno.</p>
<p>I dati mostrano che ci sono ancora circa 10 giorni (5.868 blocchi) prima del <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> La ricompensa per blocco del (LTC) si dimezza. Il dimezzamento è previsto per il 2 agosto e la ricompensa per blocco sarà ridotta da 12.5 LTC a 6.25 LTC.</p>
<p>Chi è attualmente l’Imperatore della Profezia Gate.io: Indovina il prezzo di LTC e condividi 25.000 LTC in premi in corso. Accogliamo tutti a partecipare attivamente. <a href="https://www.gate.io/activities/guess-price/?ch=LTCprice_WB_20230720&amp;utm_campaign=TR_ECt0LFlE&amp;utm_content=&amp;utm_medium=CPM&amp;utm_source=CH_czI0EJaM&amp;utm_term=" target="_blank">Indovina adesso</a>!</p>
<p>Secondo i dati di CoinMarketCap, il valore di mercato della stablecoin DAI ha superato BUSD diventando la terza stablecoin più grande. Al momento della stesura, il valore di mercato di DAI era di $4.598 miliardi, seconda solo a <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>($83,8 miliardi) e USDC ($26,8 miliardi), mentre il valore di mercato di BUSD era di $3,85 miliardi, posizionandosi al quarto posto per valore di mercato tra le stablecoin attuali.</p>
<p>Il 24 luglio, Worldcoin, un’azienda di criptovalute fondata da Sam Altman, CEO di OpenAI, ha pubblicato una foto sui social media e ha scritto ‘È il momento. 24.7.23’, ciò implicava che oggi sarebbe stata rilasciata una notizia importante.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi125093"><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-BTC313780"><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/1690178288BTC.png" alt=""><br>Il mercato attualmente oscilla in una fase di consolidamento senza una direzione chiara. Non è stato in grado di superare i $30.480 USD e rimane supportato sopra i $29.500 USD. Utilizzare la strategia di vendita alta e acquisto basso per entrate opportuniste. Se si verifica un breakout, i potenziali obiettivi sono $36.000 USD e un massimo intorno ai $40.500 USD. Se scende sotto i $26.500 USD, aumenta la possibilità di mettere fine al rimbalzo di quest’anno.</p>
<h3 id="h3-ETH9554"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1690178317ETH.png" alt=""><br>La tendenza a breve termine è scesa al di sotto del primo supporto chiave nella struttura ascendente. Un approccio conservativo è quello di attendere una rottura al di sopra dei 2.036 USD come segnale rialzista. L’obiettivo a medio termine è fissato a 2.358 USD e una rottura al di sopra dei 2.036 USD segnalerebbe un passaggio a una posizione rialzista.</p>
<h3 id="h3-LTC53871"><a name="LTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1690178338LTC.png" alt=""><br>Monitorare se LTC può stabilizzarsi sopra i 93,39 USD per una potenziale posizione a breve termine. Il quadro a breve termine è un mix di sentimenti rialzisti e ribassisti.</p>
<h2 id="h2-Macro20Linflazione20si20sta20rallentando20e20un20aumento20dei20tassi20di20interesse20del202520bp2020diventato20un20consenso20Focalizzarsi20sui20dati20importanti20di20mercoled20e20gioved184262"><a name="Macro: L’inflazione si sta rallentando e un aumento dei tassi di interesse del 25 bp è diventato un consenso; Focalizzarsi sui dati importanti di mercoledì e giovedì" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: L’inflazione si sta rallentando e un aumento dei tassi di interesse del 25 bp è diventato un consenso; Focalizzarsi sui dati importanti di mercoledì e giovedì</h2><p>Secondo i dati, i responsabili della Federal Reserve si stanno preparando ad aumentare i tassi di interesse al livello più alto degli ultimi 22 anni mercoledì, pur mantenendo un trend restrittivo, indicando che ulteriori azioni potrebbero essere intraprese più avanti quest’anno.</p>
<p>Si prevede che il Federal Open Market Committee (FOMC) aumenterà i tassi di interesse di un quarto di punto percentuale al 5,25% -5,5%, che è l’11° aumento dei tassi di interesse negli ultimi 16 mesi.</p>
<p>L’aumento dei tassi di interesse a luglio è stato effettuato dopo una pausa a giugno, per rallentare il ritmo degli aumenti dei tassi quando i tassi di interesse si avvicinavano a un livello sufficiente per riportare l’inflazione al target del 2% nel tempo.</p>
<p>Tuttavia, Powell e altri responsabili politici sperano comunque di mostrare un’atteggiamento risoluto e di riservarsi l’opzione di aumentare nuovamente i tassi di interesse per evitare un’altra impennata dei prezzi.</p>
<p>James Knightley, capo economista internazionale della Netherlands International Bank, ha affermato: “L’inflazione si sta rallentando, ma non abbastanza velocemente per la Federal Reserve; dato che il mercato del lavoro rimane forte, i funzionari non prenderanno rischi”.</p>
<p>Mercoledì 27 luglio 2023, alle 19:00 (UTC), la Federal Reserve ha deciso di aumentare i tassi di interesse. Il mercato si aspetta o ha concordato che questa stretta dei tassi sarà di 25 punti base.</p>
<p>Dopo aver aumentato i tassi di interesse alle 19:30 (UTC) del 27, Powell terrà una conferenza stampa alle 19:30 (UTC). Molte delle sue dichiarazioni si prevede che siano state parzialmente digerite dal mercato, come l’aumento dei tassi di interesse di 25 punti base, ma sarà falco nel sottolineare che l’economia è ancora in surriscaldamento e continuerà a valutare se alzare i tassi di interesse in futuro o quanti volte in base ai dati.</p>
<p>Giovedì (28 luglio) è una giornata intensa, con l’aumento dei tassi di interesse alle 19:00 (UTC) e i dati sui sussidi di disoccupazione per la settimana rilasciati alle 13:30 (UTC), con un valore precedente di 22,8. Oltre ai dati sulla disoccupazione, saranno anche pubblicati dati come il tasso annuo di crescita del PIL per il secondo trimestre.</p>
<p>Questo mercoledì e giovedì sono giorni cruciali, quindi è importante monitorare le fluttuazioni di mercato.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</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 alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga fatto riferimento a 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>