Tm90aXppZSBxdW90aWRpYW5lIHwgRGl2ZXJzaSBkaXJpZ2VudGkgZGkgYXppZW5kZSB0ZWNub2xvZ2ljaGUgc2kgc29ubyB1bml0aSBhIFdMRDsgQURBIGhhIGFnZ2lvcm5hdG8gZ2xpIGluZGljYXRvcmkgZGkgY29uZm9ybWl0w6AgTWlDQTsgQmxhc3QgaGEgZW1lc3NvIGxhIHNlY29uZGEgZmFzZSBkZWxsZSBub3JtYXRpdmUgc3VnbGk

2024-07-03, 03:31

<p><img src="https://gimg2.gateimg.com/image/article/17199773311_4.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Diversi20dirigenti20delle20grandi20aziende20tecnologiche20si20sono20uniti20a20Worldcoin20Cardano20ha20aggiornato20in20anticipo20gli20indicatori20di20conformit20MiCA20Blast20annuncia20la20seconda20fase20delle20normative20sullairdrop20e20distribuisce201020miliardi20di20BLAST798624"><a name="Crypto Daily Digest: Diversi dirigenti delle grandi aziende tecnologiche si sono uniti a Worldcoin; Cardano ha aggiornato in anticipo gli indicatori di conformità MiCA; Blast annuncia la seconda fase delle normative sull’airdrop e distribuisce 10 miliardi di BLAST" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Diversi dirigenti delle grandi aziende tecnologiche si sono uniti a Worldcoin; <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> ha aggiornato in anticipo gli indicatori di conformità MiCA; Blast annuncia la seconda fase delle normative sull’airdrop e distribuisce 10 miliardi di BLAST</h2><p>In primo luogo, esaminiamo le attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Secondo i dati degli investitori di Farside, il 6 marzo gli ETF spot Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (GBTC) hanno registrato deflussi di 32,4 milioni di dollari. Nel frattempo, Fidelity Bitcoin spot ETF (FBTC) ha registrato un ingresso di 5,4 milioni di dollari, Bitwise Bitcoin spot ETF (BITB) ha registrato deflussi di 6,8 milioni di dollari e ARK 21Shares Bitcoin spot ETF (ARKB) ha registrato un ingresso di 2,5 milioni di dollari.</p>
<p><strong>Diversi dirigenti delle grandi aziende tecnologiche si sono uniti al progetto Worldcoin di Sam Altman</strong><br>Sam Altman, CEO di OpenAI, co-fondatore di Worldcoin e Tools for Humanity, è un contributore principale del progetto di crittografia con scansione dell’occhio Worldcoin. L’azienda ha recentemente annunciato di aver nominato quattro ex dirigenti di Apple, Google, Meta, Tesla e X nel suo team.</p>
<p>La situazione specifica è la seguente:</p>
<p>Rich Heley: Ex dirigenti di Apple, Meta e Tesla, che ricoprono il ruolo di Chief Equipment Officer, responsabile della progettazione, delle prestazioni e dell’accessibilità di Orb. Orb è un dispositivo hardware sviluppato da Tools for Humanity per la scansione dell’iride di Worldcoin.</p>
<p>Damien Kieran: Ex Chief Privacy Officer di X, attualmente Chief Privacy Officer di Tools for Humanity. Il suo compito è collaborare con funzionari globali della privacy dei dati e agenzie regolatorie per sviluppare nuovi standard di settore per la conformità e la protezione della privacy.</p>
<p>Adrian Ludwig: Ex direttore della sicurezza di Google Android e responsabile della sicurezza delle informazioni all’interno e all’esterno di Tools for Humanity.</p>
<p>Ajay Patel: ex capo squadra per Google Payments e attuale Direttore Global ID, responsabile della guida della sua strategia di marketing, delle partnership pubblico-private e dell’esperienza complessiva dell’utente.</p>
<p>Worldcoin mira a utilizzare il suo sistema di identità digitale, World ID, per convalidare l’unicità individuale attraverso dati biometrici e creare una valuta digitale globale distribuita equamente a tutti. Tools for Humanity ritiene che nell’era dell’intelligenza artificiale, aumentare la necessità di tale “prova di umanità” sia particolarmente importante. L’aggiunta di nuovi dipendenti mira a contribuire a affrontare le sfide della privacy e della sicurezza e a “costruire tecnologie per stabilire un sistema economico più giusto.”</p>
<p>Dalla sua lancio lo scorso anno, Worldcoin ha affrontato sfide normative in diversi paesi. Worldcoin si basa su OP Mainnet e ha pianificato di passare al suo <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Layer 2 blockchain quest’estate.</p>
<p><strong><a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> metriche di conformità MiCA aggiornate in anticipo</strong><br>La Fondazione Cardano ha collaborato con il Crypto Carbon Rating Institute (CCRI) per rilasciare indicatori di sostenibilità che rispettano gli standard di MiCA, puntando a mettere Cardano all’avanguardia della regolamentazione, con un focus sull’efficienza energetica e trasparenza. Questo rapporto è stato rilasciato il 2 luglio e è conforme al requisito di MiCA per gli emittenti e i fornitori di servizi crittografici di divulgare indicatori di sostenibilità. Secondo la Fondazione Cardano, collabora con CCRI per garantire la qualità dei metodi di monitoraggio della blockchain e di raccolta dati.</p>
<p>Il rapporto sottolinea che Cardano opera utilizzando un protocollo di consenso più efficiente dal punto di vista energetico e consuma molta meno elettricità rispetto al protocollo Proof of Work. Fornisce il consumo annuale totale di elettricità e l’impronta di carbonio della rete Cardano, nonché la domanda marginale di elettricità per transazione al secondo. Il rapporto fornisce inoltre indicatori di sostenibilità che sono conformi agli standard tecnici regolamentari preliminari dell’Autorità europea degli strumenti finanziari e dei mercati.</p>
<p>Frederik Gregor, CEO della Fondazione Cardano, ha affermato che sviluppando indicatori di sostenibilità conformi agli standard MiCA, la fondazione mira a garantire la conformità alle prossime normative dell’UE stabilendo nel contempo un punto di riferimento per l’industria crittografica. Ha sottolineato: “Con l’attuazione parziale delle normative MiCA, l’industria si trova attualmente in un conto alla rovescia di sei mesi per l’attuazione dei principali requisiti vincolanti ESG.”</p>
<p>Questi sforzi sono cruciali per costruire fiducia con le agenzie regolatorie, gli investitori e gli utenti, spianando la strada per una più ampia adozione della tecnologia blockchain in modo sostenibile.</p>
<p><strong>Blast annuncia le regole di assegnazione dei punti per la seconda fase dell’airdrop, che distribuirà 10 miliardi di BLAST</strong><br>Blast ha recentemente pubblicato le regole di assegnazione dei punti per la seconda fase degli airdrop. Nella seconda fase, Blast distribuirà 10 miliardi di airdrop di BLAST, di cui il 50% sarà assegnato a punti regolari (Point). Gli utenti possono guadagnare punti tenendo ETH, WETH, USDB e BLAST, e il tasso di accumulo di punti per ogni asset è lo stesso.</p>
<p>Un ulteriore 50% delle azioni sarà allocato ai punti oro (Gold). Dapp può guadagnare Gold e distribuirlo agli utenti in base al suo appeal sul sito web principale di Blast e alle future competizioni Big Bang. L’assegnazione di Gold verrà effettuata nella prima settimana di ogni mese e la prima emissione sarà annunciata l’8 luglio.</p>
<p>Inoltre, gli utenti che hanno installato l’app Blast riceveranno un “Biglietto d’Oro” in base ai loro saldi ETH, WETH, USDB e BLAST. I Biglietti d’Oro permettono agli utenti di guadagnare più punti e oro.</p>
<p>I meccanismi come Jackpot, moltiplicatore di punti e invito a restituire i punti che esistono nella prima fase continueranno ad esistere. Tuttavia, gli inviti nella seconda fase saranno calcolati indipendentemente.</p>
<h2 id="h2-Tendenze20di20mercato172334"><a name="Tendenze di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato</h2><p>BTC è sceso sotto i $62.000, con un debole rimbalzo. Gli ETF spot di Bitcoin hanno registrato deflussi netti e il governo tedesco continua a vendere BTC.</p>
<p>ETH è sceso sotto i $3.400, indicando un povero sentiment di mercato.</p>
<p>SOL è salito contro la tendenza e ha superato i 150 dollari, mostrando una forte performance.</p>
<p>Le altcoin sono generalmente in calo e il sentimento di mercato complessivo è relativamente basso.</p>
<h3 id="h3-Macroeconomia490388"><a name="Macroeconomia:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia:</h3><p>I tre principali indici azionari statunitensi hanno chiuso in rialzo collettivamente, indicando un buon sentiment di mercato.</p>
<p>Tesla ha raggiunto la sua serie più lunga di giornate positive dallo scorso luglio, con una performance impressionante.</p>
<h3 id="h3-Punti20caldi20del20mercato337023"><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>Catena Pubblica <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> (SOL):</strong><br>SOL è salito contro la tendenza: <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> si è comportato molto bene, superando i $150. Il nuovo modulo Blinks e le aspettative degli ETF lanciate la scorsa settimana hanno reso ancora più eccezionale la performance di Solana.</p>
<p>Progetti ecosistemici come RAY, MOBILE, POPCAT, BILLY, ecc. hanno registrato un aumento significativo.</p>
<p><strong>Public Chain Ton (TON):</strong><br>TON ha continuato a salire: TON ha superato la soglia di 8 dollari, a un passo dall’alto precedente.</p>
<p>Mini giochi dell’ecosistema: i mini giochi sulla catena Ton continuano ad essere popolari, attirando considerevole attenzione di mercato.</p>
<p><strong>Protocollo di restaking “Pendle Finance (PENDLE)”:</strong><br>Il business di ristaking di Pendle sta maturando gradualmente e sta dando i suoi frutti, con una significativa diminuzione del TVL e un dimezzamento della sua posizione più alta. PENDLE è precipitato di quasi il 25% nel giro di un giorno.</p>
<p>Il calo dei prezzi di Bitcoin e <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> riflette l’incertezza del mercato e le preoccupazioni sul mercato generale. Il deflusso netto degli ETF di Bitcoin spot e la continua vendita da parte del governo tedesco hanno intensificato il sentimento negativo sul mercato. Nel breve termine, BTC e ETH potrebbero continuare ad affrontare pressioni.</p>
<p>Attualmente il mercato mostra una significativa differenziazione, con le valute mainstream come BTC e ETH che stanno performando debolmente. Nel frattempo, i progetti di public chain come Solana e Ton stanno salendo contro la tendenza. I cambiamenti nell’ambiente macroeconomico e la rotazione dei punti caldi del mercato continueranno ad influenzare significativamente il mercato delle criptovalute. Gli investitori devono rimanere vigili, concentrarsi sulle tendenze di mercato e regolare tempestivamente le loro strategie di investimento.</p>
<h2 id="h2-Macro20guidato20da20altre20grandi20azioni20come20Tesla20lindice20di20Wall20Street20ha20chiuso20in20rialzo20i20mercati20azionari20asiatici20sono20saliti20a20causa20dei20previsti20tagli20dei20tassi20di20interesse20e20lo20yen20giapponese2020rimasto20vicino20a20un20minimo20di203820anni929217"><a name="Macro: guidato da altre grandi azioni come Tesla, l’indice di Wall Street ha chiuso in rialzo, i mercati azionari asiatici sono saliti a causa dei previsti tagli dei tassi di interesse, e lo yen giapponese è rimasto vicino a un minimo di 38 anni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: guidato da altre grandi azioni come Tesla, l’indice di Wall Street ha chiuso in rialzo, i mercati azionari asiatici sono saliti a causa dei previsti tagli dei tassi di interesse, e lo yen giapponese è rimasto vicino a un minimo di 38 anni</h2><p>Il 2 luglio, a causa dell’aumento del prezzo delle azioni di Tesla e dello slancio delle grandi azioni in crescita, gli indici principali di Wall Street hanno chiuso in rialzo martedì. Tuttavia, il volume degli scambi è stato relativamente basso prima delle vacanze del 4 luglio e dell’attesissima pubblicazione dei dati sull’occupazione non agricola di giugno venerdì.</p>
<p>In particolare, i tre principali indici: l’indice Dow Jones è salito dello 0,41%, l’indice Standard &amp; Poor’s è salito dello 0,62%, e l’indice Nasdaq è salito dello 0,84%.</p>
<p>Tra le principali azioni, il leader dei chip AI Nvidia è sceso dell’1,3% tra le principali azioni, mentre le altre azioni dei chip hanno avuto performance diverse. Apple è salita dell’1,6%, mentre anche Amazon e Alphabet sono salite. Allo stesso tempo, il rendimento dei titoli di stato statunitensi è sceso su tutta la linea.</p>
<p>Secondo i dati del dipartimento del lavoro del Bureau of Labor Statistics degli Stati Uniti, il numero di posti vacanti (una misura della domanda di lavoro) è aumentato di 221.000 nell’ultimo giorno di maggio, raggiungendo 8,14 milioni. I dati di aprile sono stati rivisti al ribasso, mostrando un conteggio delle vacanze pari a 7,919 milioni, invece dei precedenti 8,059 milioni. Gli economisti intervistati da Reuters stimavano che ci fossero 7,91 milioni di posti vacanti nel mese di maggio.</p>
<p>Dopo una significativa diminuzione delle offerte di lavoro nei primi due mesi, il numero delle offerte di lavoro è aumentato a maggio, ma questa tendenza è in linea con il miglioramento delle condizioni del mercato del lavoro, il che potrebbe spianare la strada alla Federal Reserve per tagliare i tassi di interesse quest’anno.</p>
<p>Il 3 luglio, i mercati azionari asiatici sono saliti mercoledì dopo un inizio deludente della stagione lunedì e un calo dello 0,5% martedì. Questo aumento è stato dovuto alla forte performance dei mercati azionari statunitensi e globali trainati dalle azioni tecnologiche e dal calo del rendimento dei titoli di Stato statunitensi. Le osservazioni del presidente della Federal Reserve, Jerome Powell, hanno rafforzato le aspettative di mercato per il prossimo taglio dei tassi di interesse negli Stati Uniti. Lo yen è rimasto vicino al suo livello più basso dal 1986, rendendo i trader cauti riguardo a possibili interventi da parte del Giappone.</p>
<p>Si tratta di un contesto globale positivo che gli investitori del mercato azionario asiatico stanno aspettando, anche se questa situazione potrebbe essere influenzata da una serie di rapporti PMI del settore dei servizi pubblicati da diversi paesi asiatici, tra cui Cina, Giappone e altri.</p>
<p>In termini di indici, l’indice azionario MSCI Asia Pacific è salito dello 0,26%, mentre l’indice Nikkei in Giappone è salito dello 0,49%, avvicinandosi a un massimo storico raggiunto a marzo. Il mercato azionario cinese è sceso nella sessione di trading iniziale, con l’indice blue chip Shanghai e Shenzhen 300 che è sceso dello 0,27%. L’indice Hang Seng di Hong Kong è salito dello 0,3%.</p>
<p>I dati mostrano che a causa del rallentamento della crescita dei nuovi ordini, il tasso di espansione dell’attività del settore dei servizi in Cina a giugno è stato il più lento degli ultimi otto mesi e la fiducia è scesa ai minimi degli ultimi quattro anni, indicando la necessità di ulteriori misure di stimolo economico.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono aumentati a causa dei dati dell’industria negli Stati Uniti, che hanno aumentato le speranze di una domanda solida di carburante durante la stagione estiva di punta. I futures del greggio Brent sono saliti dello 0,44% a $86,62 al barile, mentre i futures del greggio West Texas Intermediate negli Stati Uniti sono saliti dello 0,41% a $83,15 al barile.</p>
<p>Il prezzo dell’oro è rimasto invariato mercoledì mentre gli investitori attendevano i verbali dell’ultima riunione di politica della Federal Reserve per trovare nuovi indizi su quando la banca centrale degli Stati Uniti inizierà a tagliare i tassi di interesse. L’oro spot è rimasto pressoché invariato a $2,329.66 per oncia. I futures sull’oro statunitense sono saliti dello 0,2% a $2,338.70.</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 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>