Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgbWVyY2F0byBkZWxsZSBjcmlwdG92YWx1dGUgw6ggZXNwbG9zbywgVHJ1bXAgaGEgc2NlbHRvIHVuIHNvc3Rlbml0b3JlIGRlbGxlIGNyaXB0b3ZhbHV0ZSBjb21lIGNvbXBhZ25vIGRpIGNvcnNhOyBMYSBzdGFibGVjb2luIFVTQkQgaGEgcmFjY29sdG8gJDIsMjUgbWlsaW9uaSBuZWwgZmluYW5

2024-07-16, 04:01

<p><img src="https://gimg2.gateimg.com/image/article/17211023391_13.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20di20Crypto20Trump20ha20scelto20un20sostenitore20delle20criptovalute20come20suo20compagno20di20corsa20USBD20la20stablecoin20di20Bima20Labs20ha20raccolto2022520milioni20di20dollari20in20finanziamento20nella20fase20seed20TOP20ha20investito20in20Akedo20per20creare20un20gioco20su20Telegram358530"><a name="Riassunto giornaliero di Crypto: Trump ha scelto un sostenitore delle criptovalute come suo compagno di corsa; USBD, la stablecoin di Bima Labs, ha raccolto 2,25 milioni di dollari in finanziamento nella fase seed; TOP ha investito in Akedo per creare un gioco su Telegram" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero di Crypto: Trump ha scelto un sostenitore delle criptovalute come suo compagno di corsa; USBD, la stablecoin di Bima Labs, ha raccolto 2,25 milioni di dollari in finanziamento nella fase seed; TOP ha investito in Akedo per creare un gioco su Telegram</h2><p>Prima, esaminiamo l’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 15 luglio, il Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (FBTC) ha ricevuto un afflusso di 36,1 milioni di dollari, il Bitwise Bitcoin Spot ETF (BITB) ha ricevuto un afflusso di 15,2 milioni di dollari e l’ARK 21Shares Bitcoin Spot ETF (ARKB) ha ricevuto un afflusso di 117,2 milioni di dollari.</p>
<p><strong>Donald Trump ha scelto un sostenitore delle criptovalute, JD Vance, come suo compagno di corsa.</strong></p>
<p>Il candidato presidenziale repubblicano Donald Trump ha scelto il senatore JD Vance come suo compagno di corsa per il 2024. Vance è un sostenitore delle criptovalute che ha pubblicato post positivi sui social media e ha votato a favore di legislazioni pertinenti. Il 15 luglio, Trump ha annunciato su Truth Social che il senatore dell’Ohio si unirà alla sua campagna come candidato vicepresidente repubblicano.</p>
<p>Nel rapporto di divulgazione finanziaria presentato al Senato degli Stati Uniti nel 2022, Vance ha dichiarato di possedere Bitcoin del valore compreso tra $100.001 e $250.000. Ha anche votato a favore di una risoluzione congiunta per annullare la regola della Securities and Exchange Commission degli Stati Uniti che impone alle banche di elencare le criptovalute come passività nei loro bilanci - una legislazione che è stata respinta dal presidente Joe Biden.</p>
<p>Le criptovalute e la blockchain stanno diventando argomenti importanti nelle elezioni del 2024. Il team di campagna di Trump accetterà donazioni in criptovaluta e potrebbe guidare le piattaforme repubblicane, comprese le dichiarazioni a difesa dei minatori di BTC e contrarie alle valute digitali delle banche centrali.</p>
<p><strong>La stablecoin USBD di Bima Labs ha raccolto 2,25 milioni di dollari in finanziamenti per il round di seed</strong></p>
<p>Bima Labs ha annunciato un finanziamento di round seed di 2,25 milioni di dollari, guidato da Portal Ventures con la partecipazione di Draper Goren Blockchain, Sats Ventures, Luxor Technology, CoreDAO e Halo Capital. Gli investitori angelici includono Ryan Fang da <a href="/price/ankr-ankr" rel="nofollow noopener noreferrer" target="_blank">Ankr</a>, Brian Crain da Chorus One, Jeffrey Feng da Sei Labs, e Smokey da Berachain.</p>
<p>Bima Labs ha sviluppato USBD, una stablecoin garantita da Bitcoin, che viene coniata fornendo Bitcoin come liquidità di staking e token restanti come garanzia. USBD può essere utilizzato per scopi di prestito e di scambio in applicazioni finanziarie decentralizzate. USBD è attualmente lanciato sulla testnet e si prevede che il mainnet verrà lanciato nel quarto trimestre di quest’anno. In quel momento, Bima lancerà anche il suo token di governance BIMA.</p>
<p><strong>TOP ha investito in Akedo per costruire giochi Telegram nell’ecosistema della catena TON</strong></p>
<p>La società di venture capital <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> The Open Platform (TOP) ha effettuato un investimento strategico in Akedo Games per supportare lo sviluppo dei giochi di Telegram nell’ecosistema blockchain TON. Il team di Akedo Games ha partecipato allo sviluppo di giochi come PUBG Mobile, LOL, AFK Arena e Rise of Kingdoms.</p>
<p>Il primo gioco di Telegram di Akedo, Akedo, sarà rilasciato il 18 luglio con l’obiettivo di sfruttare la base utenti di 900 milioni di Telegram. Questo gioco permette ai giocatori di cliccare per ottenere i loro Akedogs NFT di Telegram, raccogliere, unire, coltivare e scambiare questi animali per potenziare le loro abilità di combattimento.</p>
<p>Il supporto strategico di TOP non include solo finanziamenti, ma utilizza anche la sua rete di sviluppatori di tecnologia blockchain TON e le risorse dell’ecosistema per garantire lo sviluppo sostenibile di Akedo.</p>
<h2 id="h2-Tendenze20di20mercato20BTC20sale20rapidamente20si20avvicina20ai206500020Gli20ETF20Ethereum20inizieranno20a20essere20negoziati20il202320luglio908389"><a name="Tendenze di mercato: BTC sale rapidamente, si avvicina ai $65.000. Gli ETF Ethereum inizieranno a essere negoziati il 23 luglio." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC sale rapidamente, si avvicina ai $65.000. Gli ETF <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> inizieranno a essere negoziati il 23 luglio.</h2><p>Il BTC è aumentato notevolmente, con i prezzi che si avvicinano a $65.000 in un momento. Gli ETF spot di Bitcoin hanno continuato a registrare afflussi netti, con afflussi che hanno raggiunto i $170 milioni ieri.</p>
<p>Anche l’ETH è aumentato, con un prezzo vicino a $3,500. Gli ETF spot sull’ETH saranno quotati per la negoziazione il 23 luglio.</p>
<p>Sotto la guida del mercato, gli Altcoin sono generalmente aumentati e le prestazioni complessive del mercato degli Altcoin sono solide. Il popolare token Meme sta guidando il mercato in termini di aumento dei prezzi.</p>
<p>Indicatori dei dati<br>Indice AHR999: l’indice odierno è a 0,87, continua a salire e si avvicina all’indice degli investimenti fissi.</p>
<p>Indice paura avidità: Attualmente a 65, indicando un significativo miglioramento del sentiment di mercato, addirittura entrando nella fascia avida.</p>
<h3 id="h3-Macroeconomia352396"><a name="Macroeconomia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia</h3><p>I tre principali indici del mercato azionario statunitense sono saliti insieme: le prestazioni complessive del mercato azionario statunitense sono state forti.</p>
<p>Discorso di Powell: il presidente della Federal Reserve Powell ha affermato che il percorso del declino dell’inflazione è fattibile, e le osservazioni accomodanti sono positive per il mercato degli asset a rischio.</p>
<h3 id="h3-Punti20caldi20del20mercato235647"><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>Settore dei meme</strong><br>I token Meme di tendenza hanno registrato un forte aumento: POPCAT, SATS, MYRO, FLOKI, WIF, BILLY e altri token hanno registrato un aumento superiore al 20%.</p>
<p>POPCAT raggiunge un massimo storico: la capitalizzazione di mercato supera gli 800 milioni di dollari.</p>
<p><strong>Settore dell’Intelligenza Artificiale</strong><br>Rimbalzo WLD: il rimbalzo short forzato WLD supera il 25%; A partire dal 24 luglio, WLD sbloccherà quasi 20 milioni di dollari di token al giorno per un periodo di due anni, il che potrebbe portare a una pressione di vendita sostenuta.</p>
<p>Altri token AI: ASI, un token formato dalla fusione di FET, AGIX e OCEAN, sta per essere lanciato sul mercato e potrebbe essere una buona opportunità di trading.</p>
<p>Performance del settore: Le principali narrazioni dei settori dell’IA e dei Meme in questa fase delle tendenze di mercato.</p>
<p><strong>Settore RWA</strong><br>Aumento complessivo: Il settore RWA è aumentato complessivamente di quasi il 10%.</p>
<p>Performance dei token principali: I principali token RWA come TOKEN, OM, POLYX hanno prestazioni migliori. RWA, come narrativa relativamente nuova in questa fase delle tendenze di mercato, merita un’attenzione continua.</p>
<p><strong>Concept di Polifi</strong><br>Trump aggiorna l’immagine del sito ufficiale: sospettato di aver annunciato un nuovo slogan di campagna come “Non temere”. I token Meme correlati una volta sono saliti quasi 100 volte su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> catena.</p>
<p>Narrativa futura: Il concetto delle elezioni presidenziali degli Stati Uniti potrebbe essere una delle narrazioni principali nel settore per i prossimi sei mesi.</p>
<h3 id="h3-Sommario186700"><a name="Sommario" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario</h3><p>Le prestazioni complessive del mercato sono forti, con aumenti significativi nei prezzi di BTC e ETH. L’afflusso di ETF spot di Bitcoin e l’adozione di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF spot hanno ulteriormente stimolato l’entusiasmo del mercato. Le performance dei settori Meme e AI sono particolarmente impressionanti, alimentando un sentimento positivo nell’intero mercato. Anche i concetti di RWA e Polifi sono diventati punti focali del mercato e meritano l’attenzione degli investitori. Il miglioramento dell’ambiente macroeconomico e le dichiarazioni accomodanti della Fed hanno fornito un forte sostegno al mercato.</p>
<h2 id="h2-Macro20Gli20investitori20puntano20sulla20vittoria20di20Trump20e20sui20tagli20dei20tassi20di20interesse20Wall20Street20chiude20in20rialzo20i20mercati20asiatici20scendono844495"><a name="Macro: Gli investitori puntano sulla vittoria di Trump e sui tagli dei tassi di interesse, Wall Street chiude in rialzo, i mercati asiatici scendono" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Gli investitori puntano sulla vittoria di Trump e sui tagli dei tassi di interesse, Wall Street chiude in rialzo, i mercati asiatici scendono</h2><p>Il 15 luglio, il mercato azionario di Wall Street ha chiuso in rialzo lunedì, proseguendo i guadagni di venerdì. Le aspettative degli investitori per la rielezione di Donald Trump come presidente sono sempre più alte, alimentando le speranze di un ambiente normativo più rilassato.</p>
<p>Nel frattempo, la possibilità che la Federal Reserve inizi a abbassare i tassi di interesse di riferimento già a settembre sta aumentando, il che ha anche aumentato l’appetito per il rischio del mercato. Nonostante tutti e tre i principali indici azionari statunitensi abbiano chiuso ben al di sotto dei massimi intraday, il Dow Jones Industrial Average ha raggiunto un nuovo massimo di chiusura storico.</p>
<p>Tre specifici principali indici: indice Dow Jones: in aumento dello 0,53; indice Standard &amp; Poor’s: in aumento dello 0,28%; indice NASDAQ: in aumento dello 0,40%.</p>
<p>Il presidente della Federal Reserve, Jerome Powell, ha ribadito nel suo discorso presso il Washington Economic Club che crede che l’economia degli Stati Uniti possa evitare una recessione. I dati recenti mostrano che ci sono stati progressi nel ridurre il tasso di inflazione al target del 2% della banca centrale. Pertanto, la previsione di mercato è <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> le aspettative di un totale di tre tagli dei tassi di interesse entro la fine dell’anno sono state potenziate e la Federal Reserve entrerà nella fase prevista di taglio dei tassi di interesse già a settembre.</p>
<p>Il 16 luglio, i mercati azionari asiatici sono caduti nelle prime contrattazioni di martedì, nonostante i commenti accomodanti della Federal Reserve abbiano scatenato scommesse di mercato che gli Stati Uniti ridurranno ulteriormente i tassi di interesse quest’anno, il dollaro statunitense è salito per il secondo giorno consecutivo.</p>
<p>L’indice azionario MSCI Asia Pacific è sceso dell’0,5%, mentre l’indice Nikkei è salito dello 0,4% dopo che il Giappone è tornato dalle vacanze pubbliche. Per quanto riguarda la Cina, a causa del vice di Trump JD Vance che si trova in diretta conflitto con la Cina, questo influenzerà il sentiment del mercato nei confronti della Cina. L’indice composite di Shanghai è sceso dello 0,21%, mentre l’indice Hang Seng di Hong Kong è sceso dell’1,36%. La debole performance dei dati economici attuali in Cina ha aumentato il rischio che Pechino non sia in grado di raggiungere il suo obiettivo di crescita del 5%.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono scesi a causa delle preoccupazioni per il rallentamento dell’economia cinese che sta sopprimendo la domanda. I future sul petrolio greggio Brent sono scesi dello 0,2% a $84,72 al barile, mentre i future sul petrolio greggio West Texas Intermediate (WTI) sono scesi dello 0,2% a $81,77 al barile.</p>
<p>L’oro è salito dello 0,2% a $2.426,18 all’oncia, avvicinandosi a un massimo di due mesi.</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 ripostaggio dell'articolo a condizione che sia citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>