Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIEhpZ2ggSG9yaXpvbnRhbCwgTWVtZSBlIEFJIHNvbm8gZm9ydGk7IExhIENhbWVyYSBkZWkgcmFwcHJlc2VudGFudGkgZGVnbGkgU3RhdGkgVW5pdGkgaGEgYXBwcm92YXRvIGlsIENyeXB0byBNYXJrZXQgU3RydWN0dXJlIEFjdDsgTGUgInByZW9jY3VwYXppb25pIGRpIGNlbnRyYWxpenpheml

2024-05-23, 03:18

<p><img src="https://gimg2.gateimg.com/image/article/17164341871_15.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20La20Camera20dei20Rappresentanti20degli20Stati20Uniti20ha20approvato20il20Crypto20Market20Structure20Act20Taiko20ha20annunciato20il20lancio20della20pagina20di20richiesta20di20qualificazione20per20lairdrop20per20TKO20Le20preoccupazioni20per20la20centralizzazione20di20Cardano20hanno20portato20a20un20calo20del203020dei20prezzi20di20ADA402944"><a name="Crypto Daily Digest: La Camera dei Rappresentanti degli Stati Uniti ha approvato il Crypto Market Structure Act; Taiko ha annunciato il lancio della pagina di richiesta di qualificazione per l’airdrop per TKO; Le “preoccupazioni per la centralizzazione” di Cardano hanno portato a un calo del 30% dei prezzi di ADA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: La Camera dei Rappresentanti degli Stati Uniti ha approvato il <a href="/price" target="_blank" class="blog_inner_link">Crypto Market</a> Structure Act; Taiko ha annunciato il lancio della pagina di richiesta di qualificazione per l’airdrop per TKO; Le “preoccupazioni per la centralizzazione” di <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> hanno portato a un calo del 30% dei prezzi di ADA</h2><p>Prima di tutto, diamo un’occhiata alle 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 22 maggio, gli ETF spot Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (GBTC) hanno avuto un deflusso di denaro di 16,1 milioni di dollari; Nel frattempo, gli ETF spot Bitcoin di Fidelity (FBTC) hanno registrato un afflusso di 74,6 milioni di dollari, mentre gli ETF spot Bitcoin ARK 21Shares (ARKB) hanno registrato un afflusso di 3,5 milioni di dollari.</p>
<p><strong>La Camera dei rappresentanti degli Stati Uniti ha approvato il Crypto Market Structure Act</strong><br>Mercoledì, la Camera dei rappresentanti degli Stati Uniti ha approvato la legge FIT21 (21st Century Financial Innovation and Technology Act), guidata dai repubblicani, con 279 voti a favore e 136 contrari. L’approvazione di questo disegno di legge segna il primo voto su una legislazione cripto completa nella Camera dei rappresentanti, con 71 democratici che hanno votato a favore del disegno di legge, tra cui l’ex Speaker della Camera della California Nancy Pelosi.</p>
<p>FIT21 mira a regolare l’intera industria delle criptovalute e a dotare il Commodity Futures Trading Committee di maggior potere e finanziamento per supervisionare il mercato spot delle criptovalute e le “commodities digitali”, in particolare il Bitcoin. La legge prevede inoltre un processo che consente il trading sul mercato secondario di beni digitali inizialmente offerti come parte di contratti di investimento. Inoltre, il disegno di legge include disposizioni sulle stablecoin e sulla prevenzione del riciclaggio di denaro. Sebbene FIT21 sia improbabile che venga presentato al Senato quest’anno, il disegno di legge potrebbe gettare le basi per il prossimo Congresso a gennaio dell’anno prossimo.</p>
<p>Ron Hammond, Direttore delle relazioni governative presso la Blockchain Association, ha dichiarato che le opinioni del Congresso sulle criptovalute stanno cambiando. Crede che FIT21 rappresenti un “enorme punto di svolta”. Afferma: “Il legame tra gli elettori cripto e le prossime elezioni è innegabile e sembra che l’amministrazione Biden abbia finalmente iniziato a rendersi conto delle potenziali conseguenze di mantenere lo status quo”.</p>
<p>Prima del voto del FIT21, il Senato e la Camera dei Rappresentanti hanno approvato una misura per abrogare la dichiarazione contabile dei dipendenti della Securities and Exchange Commission, che stabiliva alcuni standard contabili per le società che ospitano criptovalute. La risoluzione ha ricevuto il sostegno di alcuni democratici, tra cui il leader della maggioranza al Senato e democratico dello Stato di New York Chuck Schumer. Tuttavia, la Casa Bianca ha dichiarato che il presidente Joe Biden avrebbe posto il veto al disegno di legge. Mercoledì, la Casa Bianca si è opposta al FIT21 ma è “ansiosa di lavorare con il Congresso” per sviluppare un quadro normativo sugli asset digitali.</p>
<p><strong>Taiko ha annunciato il lancio della pagina di consultazione della qualifica per l’aria TKO</strong><br>Taiko, un <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La rete L2 basata su zkRollup, ha annunciato ufficialmente il lancio della prima fase dell’airdrop TKO sulla piattaforma X questa mattina e ha lanciato la pagina di verifica delle qualifiche per l’airdrop. Nella prima fase, sarà fornito il 5% dell’offerta iniziale dei token e gli utenti avranno sette giorni per verificare le loro qualifiche. Dopo il completamento della verifica, si aprirà la finestra di raccolta e gli utenti idonei avranno un mese per raccogliere TKO.</p>
<p>L’applicazione per l’airdrop di TKO non è ancora stata lanciata. Si prega di fare riferimento alle informazioni ufficiali per partecipare all’applicazione e fare attenzione a eventuali truffe correlate. Secondo il modello economico del token TKO, la sua offerta totale è di 1 miliardo di monete. L’allocazione specifica include:</p>
<p>Gli account di DAO Teary rappresentano il 20%; Gli airdrop di Trailblazer rappresentano il 10%; La proporzione più alta degli airdrop di Genesis è del 5%; La liquidità e i market maker rappresentano il 5%; Gli investitori rappresentano l’11,62%; Taiko Labs/core team rappresentano il 20%; Le riserve della Taiko Foundation rappresentano il 16,88%; I Prover Bonds ufficiali di Taiko rappresentano l’1,5%, e così via.</p>
<p><strong><a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> Le “preoccupazioni di centralizzazione” hanno innescato un calo del 30% dei prezzi ADA</strong><br>Il prezzo di ADA è precipitato dopo che gli analisti hanno messo in discussione la centralizzazione della rete Cardano. L’analista di criptovalute Justin Bons ha affermato che la casa madre di Caldano, Input Output Global (IOG), controlla 5 delle 7 “chiavi Genesis” sulla blockchain, che sono state utilizzate fin dal 2015 per firmare ed stabilire i blocchi iniziali della blockchain di Caldano.</p>
<p>L’analista ha fatto notare che “Genesis Key permette modifiche di codice senza hard fork senza soluzione di continuità. Ha aggiunto: “Ciò significa che IOG può interrompere la catena, modificare gli orari di emissione, condurre revisioni, e così via, il che rappresenta un livello senza precedenti di controllo centralizzato sulla catena L1.”</p>
<p>A partire dal 22 maggio, il prezzo di ADA ha iniziato a diminuire dopo aver testato la linea di tendenza ascendente del triangolo. Al momento, il prezzo continuerà a scendere verso la linea di tendenza discendente di circa $0.44, una diminuzione del 6.5% rispetto al livello attuale. Tuttavia, durante questo periodo di aggiustamento del prezzo, l’offerta di ADA detenuta nell’indirizzo del gigante delle balene è leggermente aumentata, indicando che non ha prestato attenzione all’avvertimento di Boggs sulla cosiddetta centralizzazione di Caldano.</p>
<h2 id="h2-Tendenze20di20mercato20Prese20di20profitto20a20breve20termine20nel20mercato20ma20il20trend20positivo20a20lungo20termine20rimane20invariato356162"><a name="Tendenze di mercato: Prese di profitto a breve termine nel mercato, ma il trend positivo a lungo termine rimane invariato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: Prese di profitto a breve termine nel mercato, ma il trend positivo a lungo termine rimane invariato</h2><p>BTC: Bitcoin sta scambiando lateralmente a un livello elevato, temporaneamente scendendo sotto i $70.000, probabilmente a causa di prese di profitto a breve termine sul mercato. Tuttavia, il trend a lungo termine di Bitcoin rimane rialzista, specialmente nel contesto dell’incremento dell’incertezza economica globale.</p>
<p>ETF spot ETH: gli analisti di Bloomberg prevedono che la sua dimensione possa raggiungere solo il 10% degli ETF spot BTC. Questa previsione riflette una debole fiducia di mercato in Ethereum, ma potrebbe anche essere una stima conservativa. Una volta approvati gli ETF spot ETH, la domanda di mercato potrebbe aumentare significativamente.</p>
<h3 id="h3-Economia20Macro871844"><a name="Economia Macro:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Economia Macro:</h3><p>Correzione del mercato azionario degli Stati Uniti: i verbali della Federal Reserve suggeriscono che i tassi di interesse non saranno tagliati presto, il che è un fattore svantaggioso per il mercato azionario. Tuttavia, le prestazioni del leader tecnologico Nvidia hanno superato le aspettative e raggiunto livelli storici, indicando che le azioni tecnologiche potrebbero continuare a essere un punto luminoso nel mercato.</p>
<p>Mercato delle criptovalute: un ritracciamento nel mercato azionario statunitense potrebbe mettere pressione a breve termine sul mercato delle criptovalute, ma a lungo termine i fondi potrebbero <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> in asset ad alto rischio come le criptovalute alla ricerca di rendimenti più elevati.</p>
<h3 id="h3-Punti20caldi20del20mercato333639"><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>Meme concept coins:</strong><br>PEOPLE, MAGA, WIF, BOME, MANEKI: PEOPLE e MAGA hanno mostrato una forte performance guidata dal concetto delle elezioni USA. Il Meme su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Anche il volto di ’s ha avuto un buon rendimento, in particolare MANEKI, riprendendo più del 30% da un punto più basso. Con entrambi i candidati presidenziali statunitensi amichevoli con Meme, queste Meme coins potrebbero continuare a ricevere attenzione dal mercato.</p>
<p>Strategia di investimento: Nel breve termine, si può prestare attenzione alla volatilità di queste valute, che è adatta per gli investitori con preferenze ad alto rischio. Nel lungo periodo, è necessario essere all’erta di cambiamenti nel sentiment di mercato.</p>
<p><strong>Altre monete calde:</strong><br>EDU: Animoca Brands, il principale azionista, prevede di ricomprare, beneficiando direttamente del prezzo della valuta. Potrebbe continuare a salire nel breve termine.</p>
<p>BNX: Come progetto stellare del concetto GameFi, l’incremento in questa fase si avvicina a 10 volte. È importante notare che un aumento così elevato potrebbe innescare il prendere profitto.</p>
<p>HOOK: Si consiglia di prestare attenzione al suo sviluppo successivo e ai cambiamenti nel sentiment di mercato.</p>
<p><strong>Rete Layer2 Taiko:</strong><br>Annunciata l’airdrop del 5% dei token, principalmente per gli utenti di Taiko e la comunità LRC. Le notizie sugli airdrop di solito portano un breve periodo di riscaldamento del mercato, ma è necessario prestare attenzione alla reazione del mercato dopo l’airdrop.</p>
<p><strong>Monete concetto di intelligenza artificiale:</strong><br>LPT è salito rapidamente, ma le altre valute concettuali di intelligenza artificiale non hanno guadagnato in modo significativo. Ciò potrebbe essere dovuto alla forte risposta di mercato a specifiche notizie positive su LPT. Si consiglia di prestare attenzione alla tendenza generale dello sviluppo dei concetti di intelligenza artificiale e valutare se ci sono altre opportunità di crescita.</p>
<p>Il mercato attuale è pieno di opportunità ma anche di rischi. Gli investitori dovrebbero fare regolazioni flessibili in base alla loro tolleranza al rischio e alla dinamica di mercato. Per gli investitori ad alto rischio, si consiglia di concentrarsi su Meme coins e monete di concetto GameFi, mentre per gli investitori conservatori, si consiglia di tenere d’occhio opportunità di investimento a lungo termine in BTC ed ETH.</p>
<h2 id="h2-Macro20Verbali20della20riunione20della20Federal20Reserve20pubblicati20declino20complessivo20del20mercato20azionario20Le20aziende20tecnologiche20rappresentate20da20NVIDIA20continuano20a20performare20bene191605"><a name="Macro: Verbali della riunione della Federal Reserve pubblicati, declino complessivo del mercato azionario; Le aziende tecnologiche rappresentate da NVIDIA continuano a performare bene" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Verbali della riunione della Federal Reserve pubblicati, declino complessivo del mercato azionario; Le aziende tecnologiche rappresentate da NVIDIA continuano a performare bene</h2><p>Il 22 maggio, Reuters ha riferito che il mercato azionario statunitense ha chiuso al ribasso mercoledì mentre gli investitori digerivano i verbali dell’ultima riunione della Federal Reserve. Il leader dei semiconduttori NVIDIA ha registrato ricavi superiori alle aspettative, con il prezzo delle azioni della società in aumento di circa il 6% dopo la chiusura. Questa notizia ha anche spinto al rialzo i prezzi delle azioni di altri produttori di chip.</p>
<p>Dopo essere aumentato di quasi il 240% nel 2023, il prezzo delle azioni di Nvidia è salito di circa il 90% quest’anno. Gli investitori stanno prestando attenzione a capire se le prestazioni del primo trimestre di Nvidia possono soddisfare aspettative estremamente elevate e se l’importante aumento delle azioni legate all’intelligenza artificiale può essere sostenuto.</p>
<p>Diminuzione degli indici: l’indice Dow Jones è sceso dello 0,51%, l’indice Standard &amp; Poor’s è sceso dello 0,27% e l’indice Nasdaq è sceso dello 0,18%.</p>
<p>Secondo gli analisti intervistati da Reuters, il prezzo di chiusura dell’indice S&amp;P 500 quest’anno potrebbe essere vicino al suo livello attuale di 5302 punti, ma avvertono che le forti performance dell’indice potrebbero significare aggiustamenti in futuro. Parte del motivo per cui il mercato azionario è salito a un livello storico questo mese è dovuto al sentiment ottimistico dell’intelligenza artificiale, a una solida stagione di rendicontazione finanziaria e alla rinnovata speranza di un taglio dei tassi di interesse da parte della Federal Reserve quest’anno.</p>
<p>Secondo lo strumento FedWatch di CME, il mercato si aspetta una probabilità del 59% che la Federal Reserve taglierà i tassi di interesse di almeno 25 punti base nel suo incontro di settembre, inferiore al 65,7% visto nella precedente giornata di negoziazione.</p>
<p>Nel mercato asiatico, il 23 maggio diversi importanti indici di riferimento del mercato azionario in Asia hanno chiuso in ribasso giovedì mentre il mercato digeriva l’impatto delle politiche dei decisori politici delle principali economie tendenti ad adottare politiche di allentamento monetario paziente in mezzo a un’alta inflazione sostenuta.</p>
<p>Gli ultimi verbali della riunione sulle politiche della Federal Reserve sono stati più falchi del previsto, con il report sull’inflazione nel Regno Unito che ha ricevuto molta attenzione. La Banca della Nuova Zelanda è rimasta calma sulle questioni legate all’inflazione in Nuova Zelanda, portando gli investitori a ridurre le loro scommesse sulla velocità e l’entità dei tagli ai tassi di interesse globali.</p>
<p>L’indice azionario MSCI Asia Pacific è sceso dello 0,57%. L’australiano S&amp;P/ASX 200 è stato influenzato dal calo di alcuni prezzi delle materie prime, diventando una delle azioni con la maggior diminuzione, con un calo dell’0,8%. Dopo aver raggiunto un massimo di oltre nove mesi all’inizio di questa settimana, l’indice Hang Seng di Hong Kong ha subito delle prese di profitto ed è sceso dell’1,5%. L’indice delle blue chip cinese è diminuito dello 0,3%.</p>
<p>L’indice giapponese Nikkei ha raggiunto il suo livello più basso da oltre tre settimane, con lo yen in rialzo dello 0,6%. L’ultimo tasso di cambio tra lo yen giapponese e il dollaro americano è 156,85.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono diminuiti, con il Brent che ha perso lo 0,82% a 81,23 dollari al barile e il petrolio statunitense che è sceso leggermente dello 0,9% a 76,87 dollari al barile.</p>
<p>Il prezzo dell’oro è sceso dello 0,25% a $2.372,28 per oncia, lontano dal massimo storico di $2.449,89 raggiunto lunedì, poiché la prospettiva di aumenti dei tassi di interesse a lungo termine negli Stati Uniti ha offuscato parte del lustro dell’oro.</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, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>