Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgcHJlenpvIGRlbGxlIGF6aW9uaSBkZWkgbWluZXIgZGkgQlRDIMOoIGF1bWVudGF0byBkZWwgMTAlIGEgY2F1c2EgZGVsIHNvc3RlZ25vIGRpIFRydW1wOyBMYXllcjMgaGEgYW5udW5jaWF0byBsYSByYWNjb2x0YSBkaSBmb25kaSBkaSAkMTVNIG5lbGxhIGZhc2UgZGkgZmluYW56aWFtZW50byB

2024-06-13, 03:28

<p><img src="https://gimg2.gateimg.com/image/article/17182491481_9.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20dopo20che20Trump20ha20promesso20di20sostenere20i20minatori20americani20il20prezzo20delle20azioni20dei20minatori20di20Bitcoin2020aumentato20del201020Layer320ha20annunciato20il20finanziamento20di201520milioni20nella20fase20A20prima20del20rilascio20e20dellairdrop20dei20token20Terraform20ha20accettato20di20pagare2044720miliardi20come20giudizio20proposto20alla20SEC922470"><a name="Riepilogo giornaliero delle criptovalute: dopo che Trump ha promesso di sostenere i minatori americani, il prezzo delle azioni dei minatori di Bitcoin è aumentato del 10%; Layer3 ha annunciato il finanziamento di $15 milioni nella fase A prima del rilascio e dell’airdrop dei token; Terraform ha accettato di pagare $4,47 miliardi come giudizio proposto alla SEC." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: dopo che Trump ha promesso di sostenere i minatori americani, il prezzo delle azioni dei minatori di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è aumentato del 10%; Layer3 ha annunciato il finanziamento di $15 milioni nella fase A prima del rilascio e dell’airdrop dei token; Terraform ha accettato di pagare $4,47 miliardi come giudizio proposto alla SEC.</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 12 giugno, gli ETF Bitcoin spot di Fidelity (FBTC) hanno ricevuto un afflusso di 50,6 milioni di dollari, gli ETF Bitcoin spot di Bitwise (BITB) hanno ricevuto un afflusso di 14,5 milioni di dollari, e gli ETF Bitcoin spot di ARK 21 Shares (ARKB) hanno ricevuto un afflusso di 8,5 milioni di dollari.</p>
<p><strong>Il prezzo delle azioni dei minatori di Bitcoin è salito del 10% dopo che Trump ha promesso di sostenere i minatori americani</strong><br>Mercoledì, il secondo giorno dopo che il candidato alla presidenza degli Stati Uniti Donald Trump ha promesso di rafforzare le operazioni minerarie degli Stati Uniti, le azioni minerarie di Bitcoin sono aumentate notevolmente.</p>
<p>Trump ha dichiarato in un post del 12 giugno che spera che “tutto il Bitcoin sarà prodotto negli Stati Uniti!!!” e che questo aiuterà gli Stati Uniti a dominare il settore energetico. Trump ha detto che questa dichiarazione è stata fatta dopo aver incontrato alcuni dirigenti del settore.</p>
<p>Secondo quanto riportato, Trump ha anche promesso a questi dirigenti che, se fosse eletto presidente a novembre, sosterrà pienamente l’industria. Secondo i dati di Google Finance, TeraWulf (WULF) e Hut 8 Mining (HUT) sono i primi dieci minatori di Bitcoin con il maggior aumento di valore di mercato, rispettivamente +10,5% e +10,07% il 12 giugno. Core Scientific (CORZ), Iris Energy (IREN) e Cipher Mining (CIFR) sono saliti rispettivamente del 9,87%, 9,72% e 8,94%.</p>
<p>L’11 giugno, Trump ha discusso con diversi dirigenti del settore a Haihu Manor su come il mining di Bitcoin possa rafforzare la rete elettrica e creare più opportunità di lavoro. Gli esecutivi partecipanti hanno espresso che l’esperienza dell’incontro quella sera è stata molto positiva.</p>
<p><strong>Layer3 ha annunciato una raccolta di fondi di 15 milioni di dollari in finanziamento di serie A prima del rilascio del token e dell’airdrop</strong><br>Il protocollo di distribuzione dei token Layer3 sta per subire l’emissione di token e airdrop. Mercoledì, Layer3 ha annunciato di aver raccolto con successo 15 milioni di dollari in finanziamenti di serie A. La società ha inoltre raccolto 2,5 milioni di dollari nel 2021, e i suoi precedenti 3,7 milioni di dollari di finanziamenti strategici non dichiarati sono stati raccolti da società come Electric e ParaFi nel 2022. Il finanziamento di serie A ha portato l’ammontare totale del finanziamento di Layer3 a 21,2 milioni di dollari.</p>
<p>Mercoledì, Layer3 ha dichiarato che questa tornata di finanziamento è guidata da ParaFi e Greenfield Capital, con aziende come Electric Capital, Immune, Lattice, Tioga, LeadBlock e Amber che partecipano anche. I co-fondatori di Layer3 hanno dichiarato che il progetto ha iniziato a raccogliere fondi per questa tornata di finanziamento ad aprile e si è concluso a maggio. Questa tornata di finanziamento adotta una struttura di equità e warrant token, ma la valutazione deve ancora essere divulgata.</p>
<p>Layer3 è un protocollo di distribuzione di token che consente ai progetti di distribuire token per attirare e trattenere gli utenti. Unifica le attività degli utenti tra più blockchain e applicazioni, consentendo ai protocolli di allocare i token in modo più efficace.</p>
<p>Layer3 ha annunciato il finanziamento di serie A, in coincidenza con il lancio e l’airdrop del suo token nativo L3 quest’estate. Il mese scorso, Layer3 ha lanciato il token di governance e utilità L3, con un’offerta totale di 300 milioni. L’airdrop iniziale distribuirà il 5% dell’offerta totale, ovvero 15 milioni di token, ai primi adottanti e ai CUBE minters. Kumar ha dichiarato che CUBE è un NFT “dinamico” coniato dopo aver completato il compito.</p>
<p>Lo snapshot dell’airdrop è stato effettuato il 10 maggio. Layer3 ha allocato il 51% dell’offerta totale alla comunità, mentre le informazioni dettagliate sulle altre allocazioni devono ancora essere divulgate.</p>
<p>Layer3 sta ancora sviluppando un nuovo protocollo di intelligenza artificiale per ottimizzare le strategie di distribuzione dei token, che dovrebbe essere lanciato entro la fine di quest’anno. Kumar ha dichiarato che il protocollo di intelligenza artificiale aprirà nuove vie per l’emissione di progetti e la distribuzione di token, e renderà Layer3 più personalizzato per soddisfare i consumatori finali.</p>
<p><strong>Terraform ha accettato di pagare $4.47 miliardi come giudizio proposto alla SEC</strong><br>La Securities and Exchange Commission (SEC) degli Stati Uniti ha presentato mercoledì una proposta di decisione finale, chiedendo al giudice Jed Rakov del Tribunale del distretto meridionale di New York di approvare il piano Terraform.</p>
<p>Nel febbraio 2023, la SEC ha presentato accuse contro Terraform e Do Kwon per la stablecoin algoritmica <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD (USD) che si era collassato un anno fa, affermando di aver ingannato e truffato gli investitori. Le due parti hanno discusso senza fine sulla quantità di risarcimento. Secondo la decisione proposta attuale, Terraform pagherà $3,58 miliardi di guadagni illegali e $420 milioni di multe civili, vietando a Do Kwon di diventare dirigente o direttore di qualsiasi società quotata.</p>
<p>La SEC credeva in precedenza che Do Kwon dovesse pagare circa $204 milioni all’ente di fallimento di Terraform da distribuire agli investitori danneggiati.</p>
<h2 id="h2-Tendenze20di20mercato90874"><a name="Tendenze di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato</h2><p>BTC è rimbalzato vicino a $70.000 dopo la pubblicazione dei dati CPI ma è sceso sotto i $68.000 dopo un discorso del presidente della Fed Powell. Questo mostra l’alta sensibilità del mercato ai dati macroeconomici e ai cambiamenti di politica.</p>
<p>ETH è anche tornato a circa $3.550 dopo un significativo rimbalzo.</p>
<p>Altcoins: Nonostante il forte calo di BTC ed ETH nelle prime ore del mattino, gli Altcoins hanno comunque mantenuto un buon aumento, il che potrebbe indicare che gli investitori stanno cercando altre opportunità di investimento ad alto rischio e alto rendimento.</p>
<h3 id="h3-Macroeconomia10766"><a name="Macroeconomia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia</h3><p>Le azioni statunitensi sono salite: le azioni statunitensi hanno continuato a raggiungere livelli storici, riflettendo gli investitori’ <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> sul futuro outlook economico.</p>
<p>Dati IPC: I dati IPC sono scesi al minimo di 3 anni, stimolando un aumento del mercato degli asset a rischio e indicando che la pressione inflazionistica potrebbe indebolirsi.</p>
<p>Politica della Fed: La matrice dei punti mostra che i tassi di interesse saranno abbassati solo una volta quest’anno e si prevede che verranno abbassati quattro volte nel 2025. Ciò indica che la Federal Reserve mantiene ancora un atteggiamento cauto nei confronti della politica monetaria.</p>
<h3 id="h3-Hotspot20di20mercato272863"><a name="Hotspot di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato:</h3><p>DePIN concept leader IO: IO è aumentato di quasi il 50%, superando i 6 dollari, con un tasso di vacanza elevato dello 0,1% nel mercato dei contratti. Fonti della community hanno rivelato che IO potrebbe lanciare presto una funzione di staking, che potrebbe ulteriormente stimolare l’aumento del prezzo.</p>
<p>Il settore dei concetti di intelligenza artificiale ha registrato un significativo rimbalzo sotto la guida delle azioni tecnologiche statunitensi, con LPT, RNDR, ARKM e altri settori che si comportano bene. Il rimbalzo potrebbe essere dovuto all’ottimismo del mercato riguardo allo sviluppo tecnologico futuro.</p>
<p>BTC Iscrizione PIZZA: PIZZA è salito del 20%, con un aumento significativo delle detenzioni degli indirizzi principali. Come il primo Meme di Unisat Wallet, PIZZA attualmente ha una capitalizzazione di mercato di quasi $150 milioni e si posiziona al 405º posto.</p>
<p>Token di concetto meme: i token meme hanno avuto un ruolo più prominente nel rimbalzo del mercato. Il MOTHER e il MANEKI di <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> La catena è rimbalzata di oltre il 20%, e il MAGA della catena Eth è rimbalzato di oltre il 30% in un momento. Si dice che Trump abbia più sostegno popolare alle elezioni presidenziali, il che potrebbe avere un effetto trainante sui token Meme correlati.</p>
<p>Il mercato attuale ha un’alta volatilità e gli investitori devono operare con cautela. La volatilità del mercato criptato è particolarmente degna di nota, specialmente sotto l’influenza dei dati macroeconomici e dei cambiamenti di politica. Gli investitori dovrebbero monitorare da vicino gli hotspot e le tendenze del mercato gestendo i rischi quando partecipano al mercato.</p>
<h2 id="h2-Macro20Lindice20SampP2050020e20lindice20Nasdaq20hanno20raggiunto20nuovi20massimi20di20chiusura20influenzati20dallIPC20e20dalla20Fed463123"><a name="Macro: L’indice S&amp;P 500 e l’indice Nasdaq hanno raggiunto nuovi massimi di chiusura influenzati dall’IPC e dalla Fed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: L’indice S&amp;P 500 e l’indice Nasdaq hanno raggiunto nuovi massimi di chiusura influenzati dall’IPC e dalla Fed</h2><p>I dati economici importanti pubblicati il 12 giugno sono arrivati come una sorpresa: il Dipartimento del Lavoro degli Stati Uniti ha riportato che l’Indice dei Prezzi al Consumo (IPC) è rimasto invariato a maggio a causa di una diminuzione dei prezzi della benzina.</p>
<p>I dati sull’inflazione più deboli del previsto hanno spinto al rialzo il mercato azionario all’apertura, con l’indice S&amp;P 500 e l’indice Nasdaq che hanno raggiunto nuovi massimi di chiusura per il terzo giorno consecutivo mercoledì. Tuttavia, a causa delle previsioni della Federal Reserve di un solo taglio dei tassi quest’anno, questi due indici hanno alla fine registrato un calo rispetto ai loro massimi giornalieri.</p>
<p>I principali indicatori sono i seguenti: l’indice Dow Jones è sceso dello 0,1%, l’indice S&amp;P 500 è aumentato dello 0,9% e l’indice Nasdaq è aumentato dell’1,5%.</p>
<p>La Fed ha concluso una riunione di due giorni sulla politica monetaria, ha deciso di mantenere i tassi di interesse invariati e ha emesso una dichiarazione di politica e un Sommario delle proiezioni economiche (SEP). Dopo che il presidente della Federal Reserve, Jerome Powell, ha tenuto un discorso in una conferenza stampa, il mercato azionario ha fluttuato, con gli indici S&amp;P 500 e NASDAQ che hanno ridotto i loro guadagni negli scambi tardivi, e l’indice Dow Jones ha chiuso vicino alla parità. Dopo la pubblicazione del rapporto CPI, i trader hanno aumentato le scommesse sui tagli dei tassi d’interesse della Fed a settembre e dicembre.</p>
<p>Il panorama rivisto della Federal Reserve include una diminuzione del numero di tagli dei tassi di interesse quest’anno, un leggero aumento del tasso di disoccupazione e un aumento dei tassi di interesse a lungo termine, il che ha portato a un significativo raffreddamento nel mercato azionario, nel mercato dei cambi e nei mercati dei titoli a reddito fisso nelle ultime ore di negoziazione di mercoledì negli Stati Uniti. La previsione della Federal Reserve per marzo include tre tagli dei tassi di interesse, ciascuno del 25 punti base. Alla fine della riunione dall’11 al 12 giugno, la dichiarazione ha menzionato il mantenimento dei tassi di interesse invariati, in linea con le aspettative di mercato.</p>
<p>Il 13 giugno, il mercato asiatico probabilmente riceverà un impulso poiché i tassi di inflazione negli Stati Uniti inferiori alle aspettative hanno scatenato l’appetito per il rischio degli investitori e le fluttuazioni dei prezzi degli asset. Tuttavia, poiché le nuove previsioni economiche della Federal Reserve si orientano verso una posizione falconiana, potrebbe limitare questo slancio.</p>
<p>Recentemente, l’effetto cumulativo degli asset cinesi è stato significativo. La significativa diminuzione del mercato azionario e dello yuan ha spinto le banche statali a vendere dollari americani per sostenere lo yuan, suscitando dubbi degli investitori sulla Cina come destinazione di investimento. Il mercato azionario cinese è diminuito del 5% nelle ultime tre settimane, il doppio rispetto all’indice MSCI Asia (escluso il Giappone), ed ha avuto una performance molto peggiore rispetto all’indice Nikkei in Giappone, che è rimasto piatto, e rispetto ai mercati azionari statunitensi e globali che hanno raggiunto nuovi massimi.</p>
<p>Nel mercato delle valute, le valute asiatiche si sono rafforzate rispetto al dollaro americano giovedì, ad eccezione dello yen giapponese, a causa dell’inflazione inferiore alle aspettative negli Stati Uniti. Prima dell’incontro della Banca del Giappone e dato che i responsabili politici degli Stati Uniti hanno lasciato intendere che i tassi di interesse rimarranno alti per un po’ di tempo, lo yen è rimasto sotto pressione.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono scesi giovedì mattina mentre gli investitori stavano elaborando la notizia che la Fed non avrebbe tagliato i tassi di interesse nel prossimo futuro. Le sufficienti scorte di petrolio greggio e carburante degli Stati Uniti hanno ulteriormente messo pressione sul mercato. I future del petrolio greggio Brent sono scesi dello 0,17% a 82,46 dollari al barile, mentre i future del West Texas Intermediate (WTI) sono scesi dello 0,2% a 78,34 dollari al barile.</p>
<p>Il prezzo dell’oro è leggermente aumentato dopo che la Fed ha aggiornato le sue previsioni economiche, con l’oro in contanti che è salito dello 0,2% a $2.320,76 per oncia.</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 si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>