Tm90aXppZSBxdW90aWRpYW5lIHwgQml0Y29pbiBFVEYgY29udGludWFubyBhIGdlbmVyYXJlIGZsdXNzaSBuZXR0aSBpbiBlbnRyYXRhOyBHb2xkbWFuIFNhY2hzIHBpYW5pZmljYSBkaSBsYW5jaWFyZSB0cmUgZm9uZGkgdG9rZW5penphdGk7IElsIE1pbmlzdGVybyBkZWxsJ0VuZXJnaWEgc3RhIHJlZGlnZW5kbyB1biBudW92byBzb25

2024-07-11, 03:44

<p><img src="https://gimg2.gateimg.com/image/article/17206692761_9.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20Goldman20Sachs20pianifica20di20lanciare20tre20fondi20tokenizzati20il20Ministero20dellEnergia20ha20iniziato20a20redigere20un20nuovo20sondaggio20sui20miner20di20Bitcoin20il20piano20di20staking20di20Starknet20sar20attivo20sulla20mainnet20nel20quarto20trimestre913546"><a name="Riepilogo giornaliero delle criptovalute: Goldman Sachs pianifica di lanciare tre fondi tokenizzati; il Ministero dell’Energia ha iniziato a redigere un nuovo sondaggio sui miner di Bitcoin; il piano di staking di Starknet sarà attivo sulla mainnet nel quarto trimestre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: Goldman Sachs pianifica di lanciare tre fondi tokenizzati; il Ministero dell’Energia ha iniziato a redigere un nuovo sondaggio sui miner di Bitcoin; il piano di staking di Starknet sarà attivo sulla mainnet nel quarto trimestre</h2><p>Innanzitutto, 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 10 luglio gli ETF spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> di Grayscale (GBTC) hanno registrato un deflusso di fondi di 8,2 milioni di dollari. Nel frattempo, gli ETF spot Bitcoin di Fidelity (FBTC) hanno registrato un afflusso di fondi di 57,8 milioni di dollari, gli ETF spot Bitcoin di Bitwise (BITB) hanno registrato un afflusso di fondi di 4,7 milioni di dollari e gli ETF spot Bitcoin di ARK 21Shares (ARKB) hanno registrato un afflusso di fondi di 11,3 milioni di dollari.</p>
<p><strong>Goldman Sachs ha intenzione di lanciare tre fondi tokenizzati</strong></p>
<p>Goldman Sachs ha intenzione di lanciare tre progetti di tokenizzazione entro la fine di quest’anno per entrare nell’industria crittografica. Secondo la rivista Fortune, Matthew McDermott, responsabile globale degli asset digitali presso Goldman Sachs, ha dichiarato che uno di questi fondi mirerà all’industria dei fondi statunitense, l’altro si concentrerà sul mercato europeo del debito e il terzo piano è quello di creare un mercato di asset tokenizzati.</p>
<p>Rispetto ai concorrenti come BlackRock, Franklin Templeton e Fidelity, Goldman Sachs ha scelto di utilizzare principalmente reti con licenza anziché blockchain completamente decentralizzate, principalmente per motivi di regolamentazione. Goldman Sachs ha iniziato a collaborare con reti blockchain con licenza già nel 2021 e ha lanciato prodotti per il trading di derivati crittografici liquidati in contanti.</p>
<p>Il CEO di BlackRock ritiene che la tokenizzazione sia la “prossima generazione” del mercato, e il prodotto finanziario basato su blockchain BUIDL dell’azienda ha recentemente raggiunto un valore di mercato di oltre $500 milioni. Franklin Templeton ha lanciato fondi basati su blockchain e relativi token BENJI su <a href="/price/stellar-xlm" rel="nofollow noopener noreferrer" target="_blank">Stellar</a> e <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, mentre Fidelity International ha tokenizzato azioni in fondi di mercato monetario.</p>
<p>McDermott da molto tempo è un sostenitore della trasformazione digitale, in particolare della blockchain. Ha contribuito a istituire la divisione degli asset digitali di Goldman Sachs nel 2021 e ha guidato gli sforzi per lanciare prodotti per il trading di derivati crittografici liquidati in contanti. Tuttavia, Sharmin Mossavar Rahmani, Chief Investment Officer di Goldman Sachs Wealth Management, ha dichiarato in un’intervista al The Wall Street Journal nell’aprile scorso di non vedere alcuna domanda da parte dei clienti per le criptovalute.</p>
<p><strong>Il Ministero dell’Energia ha iniziato a redigere un nuovo sondaggio sui minatori di Bitcoin</strong></p>
<p>Dopo essere stata citata in giudizio in un tribunale del Texas per aver cercato di ottenere “richieste urgenti di raccolta dati”, il Dipartimento dell’Energia degli Stati Uniti ha rinnovato i suoi sforzi per condurre un’indagine volta a ottenere informazioni relative all’uso dell’energia mineraria crittografica nel carico di lavoro di prova degli Stati Uniti. L’Agenzia delle Informazioni sull’Energia (EIA), dipartimento statistico del Ministero dell’Energia, ha tenuto il suo primo dibattito pubblico mercoledì, sperando di progettare un piano di indagine migliore.</p>
<p>Steve Harvey dell’EIA ha sottolineato durante la discussione che l’EIA spera di affrontare tre questioni chiave prima di progettare nuove indagini: in primo luogo, quali fattori specifici sono più importanti nell’uso energetico del mining di criptovalute PoW, come percepito dai partecipanti al settore o dagli astanti; In secondo luogo, quali dati dovrebbe raccogliere l’istituto; In terzo luogo, esistono informazioni esistenti che possono sostituire i sondaggi o ridurre i costi. Harvey ha anche sottolineato che durante la prima indagine di richiamo, l’EIA, dopo aver sviluppato una stima preliminare “approssimativa”, ha rilevato che il mining di criptovalute rappresentava dallo 0,6% al 2,3% del consumo totale di energia negli Stati Uniti.</p>
<p>Una volta completata, la nuova indagine deve essere approvata dal Dipartimento dell’Energia e sarà inserita nel Registro Federale, avviando un periodo di revisione pubblica di 60 giorni. Successivamente, l’EIA includerà i commenti, presenterà nuovamente i risultati dell’indagine e fornirà ulteriori 30 giorni per la revisione pubblica.</p>
<p>La maggior parte delle persone crede che il sondaggio EIA sia un attacco all’industria delle criptovalute, ma ci sono anche alcuni addetti ai lavori del settore che sostengono il sondaggio EIA e sono preoccupati per l’impatto delle criptovalute sull’ambiente. Lee Blacher, presidente del Texas Blockchain Committee, ha suggerito che l’EIA dovrebbe progettare un’indagine più completa, tenendo conto dell’ascesa di industrie ad alta intensità energetica come l’intelligenza artificiale e il cloud computing. Alcune persone, tra cui l’ex funzionario del Dipartimento dell’Energia Tom Mepps, hanno sottolineato che il mining di Bitcoin può aiutare a stimolare lo sviluppo delle energie rinnovabili e raggiungere accordi di “bilanciamento del carico” con i fornitori di servizi pubblici.</p>
<p><strong>Il programma di staking del token Starknet sarà lanciato sulla mainnet nel quarto trimestre del 2024</strong></p>
<p>Si prevede che Starknet introduca la funzionalità di staking del token nativo nel quarto trimestre del 2024. Lo sviluppatore principale StarkWare ha presentato il Protocollo Migliorato di Starknet (SNIP) per implementare il staking della rete. La proposta SNIP menziona il piano di staking della Fase 1 di StarkWare, che rappresenta un passo importante nella creazione di una comunità e tecnologia di staking, offrendo nuove opportunità per gli utenti e gli sviluppatori. La prima fase del piano di staking adotterà un protocollo di staking su catena senza permessi e la delega di staking.</p>
<p>Se la proposta viene approvata, gli utenti potranno affidarla agli stakers o diventare stakers stessi, e la ricompensa sarà proporzionale all’importo scommesso, in base alle modifiche alla curva di coniazione delle monete proposte rilasciate a febbraio. Prima di prelevare i fondi, ci sarà un periodo di blocco di 21 giorni.</p>
<h2 id="h2-Tendenze20di20mercato20gli20ETF20Bitcoin20spot20continuano20ad20avere20ingressi20netti20e20il20mercato20sta20aspettando20i20dati20CPI20alle20123020UTC501714"><a name="Tendenze di mercato: gli ETF Bitcoin spot continuano ad avere ingressi netti, e il mercato sta aspettando i dati CPI alle 12:30 (UTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: gli ETF Bitcoin spot continuano ad avere ingressi netti, e il mercato sta aspettando i dati CPI alle 12:30 (UTC)</h2><p><strong>BTC</strong><br>Dopo che BTC è schizzato a $59.000, il prezzo di BTC è diminuito ed attualmente si sta consolidando intorno a $57.500. È importante notare che gli ETF spot di Bitcoin continuano ad avere consistenti afflussi netti, il che potrebbe fornire un certo supporto per il mercato.</p>
<p><strong>ETH</strong><br>ETH ha avuto una performance relativamente forte e attualmente si sta consolidando intorno ai $3.100. Le aspettative del mercato per il passaggio degli ETF di ETH stanno gradualmente aumentando, il che potrebbe essere un fattore importante che spinge la forza dei prezzi di Ethereum.</p>
<p><strong>Indicatori di mercato</strong><br>L’indice AHR999: Oggi era a 0,7, indicando che il mercato è adatto per gli investimenti regolari.</p>
<p>Fear and Greed Index: A 29, indicando che il sentiment di mercato è ancora in uno stato di paura. Secondo i dati storici, quando il sentiment di mercato continua ad essere pauroso, il mercato è spesso nella fascia inferiore.</p>
<h3 id="h3-Macroeconomia800168"><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 tutti saliti di oltre l’1%. Il presidente della Federal Reserve, Powell, ha dichiarato che è improbabile che i tassi di interesse scendano a livelli estremamente bassi, ciò ha avuto un certo impatto sul mercato del rischio.</p>
<p>Dati sull’inflazione CPI degli Stati Uniti: Il mercato sta aspettando i dati sull’inflazione CPI di giugno degli Stati Uniti che saranno resi noti stasera alle 12:30 (UTC), che sarà un fattore importante che influenzerà il sentiment e le tendenze di mercato.</p>
<h3 id="h3-Punti20Caldi20del20Mercato154978"><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>Ecosistema Ton:</strong><br>Progetto Meme Dogs: Annuncia un’airdrop a tutti gli utenti di Telegram, con un aumento giornaliero di oltre 1 milione di iscritti sul suo canale di iscrizione. Dogs è un progetto puramente Meme che attualmente non ha giochi o altri bonus dell’applicazione. La sua immagine è progettata basandosi sul cane domestico del fondatore di Telegram, Duroff.</p>
<p><strong>Settore dei meme:</strong><br>PEIEPEI, RATS, MANEKI, PEW, MAGA e altre Meme coins hanno registrato un’impennata, diventando la principale narrativa di questa fase di tendenze di mercato. I progetti Meme spesso attraggono un gran numero di investitori e attenzione in un breve periodo di tempo a causa della loro ampia diffusione e coinvolgimento della comunità.</p>
<p><strong>Ecosistema BTC:</strong><br>STX, SATS e altri progetti hanno sperimentato rimbalzi ipervenduti. Tra questi, SATS servirà come token Gas per Layer2 emesso da Unisat, aggiungendo casi d’uso effettivi, con un aumento del 7 giorni di quasi il 80%.</p>
<h3 id="h3-Sommario910511"><a name="Sommario" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario</h3><p>Il mercato attuale ha mostrato una certa forza guidata da Bitcoin e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, ma il sentimento complessivo è comunque orientato verso la paura. In termini di macroeconomia, la crescita delle azioni statunitensi e l’imminente rilascio dei dati sull’indice dei prezzi al consumo (CPI) degli Stati Uniti avranno un impatto significativo sul mercato. Per quanto riguarda i punti caldi del mercato, Ton Eco e i progetti Meme sono diventati il centro dell’attenzione. Gli investitori devono rimanere cauti nell’attuale ambiente di mercato e concentrarsi sui dati macroeconomici e sui cambiamenti del sentimento di mercato, monitorando anche i progetti con casi d’uso pratici e un forte supporto della comunità.</p>
<h2 id="h2-Macro20I20mercati20azionari20globali20raggiungono20nuovi20massimi20prima20della20pubblicazione20dei20test20sullinflazione543167"><a name="Macro: I mercati azionari globali raggiungono nuovi massimi prima della pubblicazione dei test sull’inflazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: I mercati azionari globali raggiungono nuovi massimi prima della pubblicazione dei test sull’inflazione</h2><p>Il 10 luglio, i listini Nasdaq e S&amp;P 500 hanno chiuso in rialzo, raggiungendo massimi storici, principalmente trainati dalla crescita di Nvidia e altri titoli pesanti di Wall Street.</p>
<p>Questa è la settima volta consecutiva che l’indice Nasdaq ha raggiunto un nuovo massimo di chiusura e la sesta volta consecutiva che l’indice S&amp;P 500 ha raggiunto un nuovo massimo di chiusura. Il discorso del presidente della Federal Reserve, Jerome Powell, ha suscitato aspettative di mercato per un taglio dei tassi a settembre, con l’indice S&amp;P 500 che ha superato per la prima volta i 5.600 punti.</p>
<p>In particolare, i tre principali indici: l’indice S&amp;P 500 è salito dell’1,02%; l’indice Nasdaq è salito dell’1,18%; l’indice Dow Jones è salito dell’1,09%.</p>
<p>Le azioni tecnologiche continuano a performare bene, con Micron Technology in rialzo del 4%, Nvidia del 2,7% e Advanced Micro Devices del 3,9%. Apple è salita del 1,9%, raggiungendo un massimo storico con un valore di mercato di $3,6 trilioni.</p>
<p>I dati sull’inflazione degli Stati Uniti da pubblicare questa settimana includono il Consumer Price Index di giovedì e i rapporti sul Producer Price Index di venerdì. Secondo le osservazioni della Federal Reserve della Chicago Mercantile Exchange, la probabilità di un taglio dei tassi di interesse di 25 punti base da parte della Federal Reserve a settembre dovrebbe aumentare dal 70% di martedì e dal 45% di un mese fa al 74%.</p>
<p>La stagione di presentazione dei risultati finanziari del secondo trimestre inizierà questa settimana e le principali banche pubblicheranno i loro risultati venerdì, il che metterà alla prova se queste ambiziose grandi aziende azionarie possono continuare il loro forte momentum e dimostrare che le loro valutazioni sono ragionevoli.</p>
<p>L’11 luglio, il mercato azionario ha toccato un massimo storico da Tokyo a New York, e i trader stanno aspettando i dati economici degli Stati Uniti, che dovrebbero mostrare un certo alleviamento dell’inflazione e preparare la strada per un taglio dei tassi a settembre.</p>
<p>I bond e il dollaro statunitense rimangono stabili, mentre il tasso di cambio yen/dollaro statunitense rimane debole a 161, avvicinandosi al suo livello più basso degli ultimi decenni.</p>
<p>L’indice azionario più utilizzato della MSCI nella regione Asia-Pacifico, escluso il Giappone, è salito dell’1%, raggiungendo il suo livello più alto in due anni; L’indice Nikkei del Giappone è salito dell’1% a un livello storico di 42426 punti; Il mercato azionario di Taiwan è salito dell’1,25%, raggiungendo un livello storico; L’indice ASX 200 australiano è salito dello 0,89%, vicino a un livello storico.</p>
<p>Il mercato azionario cinese è in linea con il momento del mercato e i dati del PIL verranno pubblicati lunedì. L’indice Hang Seng di Hong Kong è salito dell’1%, mentre le azioni blue chip della terraferma sono aumentate dello 0,4%. Il tasso di cambio dello yuan cinese rispetto al dollaro statunitense è rimasto stabile a 7,2738, riprendendo leggermente dal punto più basso raggiunto mercoledì.</p>
<p>Per quanto riguarda le materie prime, trainate da segnali forti della domanda di benzina negli Stati Uniti, i prezzi del petrolio sono leggermente aumentati. I future del petrolio Brent sono saliti di 35 centesimi, o dello 0,4%, a $85,43 al barile. I future del petrolio greggio americano sono saliti di 36 centesimi, o dello 0,5%, a $82,47 al barile.</p>
<p>L’oro è salito dello 0,2% a $2373 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, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>