Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgbWVyY2F0byBkZWxsZSBjcmlwdG92YWx1dGUgw6ggZ2VuZXJhbG1lbnRlIGluIGNhbG87IElsIENFTyBkaSBDdXJ2ZSBoYSBjaGlhcml0byBpIGZyYWludGVuZGltZW50aSByaWd1YXJkYW50aSBsJ2luY2lkZW50ZSBkaSBoYWNraW5nIGRpIFV3VSBMZW5kIGUgbGEgYnJ1Y2lhdHVyYSBkaSBDUlY

2024-06-17, 04:21

<p><img src="https://gimg2.gateimg.com/image/article/17185979301_12.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Il20CEO20di20Curve20ha20chiarito20i20malintesi20sullincidente20di20hacking20di20UwU20Lend20e20sulla20bruciatura20di20CRV20Notcoin20ha20annunciato20la20fine20della20richiesta20di20airdrop20APE20MANTA20e20altri20token20riceveranno20sblocchi20consistenti20la20prossima20settimana912159"><a name="Crypto Daily Digest: Il CEO di Curve ha chiarito i malintesi sull’incidente di hacking di UwU Lend e sulla bruciatura di CRV; Notcoin ha annunciato la fine della richiesta di airdrop; APE, MANTA e altri token riceveranno sblocchi consistenti la prossima settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Il CEO di Curve ha chiarito i malintesi sull’incidente di hacking di UwU Lend e sulla bruciatura di CRV; Notcoin ha annunciato la fine della richiesta di airdrop; APE, MANTA e altri token riceveranno sblocchi consistenti la prossima settimana</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 di Farside Investor, il 14 giugno gli ETF spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> di Grayscale (GBTC) hanno continuato a registrare deflussi di fondi pari a $52,3 milioni. Nel frattempo, Fidelity Bitcoin spot ETF (FBTC) ha registrato un afflusso di $80,1 milioni, Bitwise Bitcoin spot ETF (BITB) di $29 milioni, ARK 21Shares Bitcoin spot ETF (ARKB) di $49 milioni, e iShares Trust Bitcoin spot ETF (IBIT) di $1,5 milioni di afflusso netto.</p>
<p><strong>Il CEO di Curve ha chiarito i fraintendimenti riguardo all’incidente di hacking di UwU Lend e alla bruciatura di CRV</strong><br>Michael Egorov, fondatore e CEO di Curve Finance (CRV), ha chiarito l’incidente di hacking recente di UwU Lend. Ha sottolineato che l’incidente non ha coinvolto alcuna falla in Curve Finance.</p>
<p>Il lunedì, una vulnerabilità in UwU Lend ha liquidato automaticamente il prestito di 100 milioni di dollari di Egorov da più accordi, facendo scendere il prezzo dei token CRV fino al 30%. Egorov ha spiegato: ‘Questa non è una vulnerabilità di Curve. È una vulnerabilità di UwU Lend, un singolo progetto’. Ha suggerito a UwU Lend di ‘rivedere tutti i contratti e lavorare con eccellenti revisori di sicurezza’ per recuperare le perdite.</p>
<p>Per le misure di compensazione successive a questo incidente, ha proposto di bruciare il 10% dei token CRV in circolazione per ripristinare i prezzi dei token ai livelli precedenti all’incidente.</p>
<p><strong>Notcoin ha annunciato la fine della richiesta dell’airdrop, e i token non richiesti saranno utilizzati per lo sviluppo futuro o per il bruciamento</strong><br>Il progetto di gioco Telegram Notcoin ha annunciato sulla piattaforma X che la richiesta di airdrop è terminata. La maggior parte dei token airdrop è stata distribuita e i token non richiesti saranno utilizzati per lo sviluppo futuro. Alcuni saranno bruciati.</p>
<p>Notcoin ($NOT) è un token guidato dalla comunità che è un gioco basato su Telegram che utilizza un meccanismo di mining “clicca-per-guadagnare” per coinvolgere gli utenti nell’ecosistema <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> attraverso interazioni coinvolgenti.</p>
<p>Inizialmente, gli utenti possono registrarsi e “cliccare” sull’immagine della moneta per ricevere premi di gioco, e completando varie missioni e compiti possono anche guadagnare premi e ricompense aggiuntive. Questo gioco si è sviluppato rapidamente, seguito dalla nascita dei token Notcoin e dagli utenti che ricevono airdrop. Il gioco presenta un sistema di valutazione con livelli di bronzo, argento, oro e platino, che consente agli utenti attivi di ricevere più premi. In precedenza, il saldo di Notcoin veniva anche puntato, ottenendo un livello di aggiornamento e premi aumentati.</p>
<p>Al momento, Notcoin ha 11,5 milioni di detentori. Ci saranno premi aggiuntivi per i giocatori che hanno raggiunto i livelli di staking Oro e Platino.</p>
<p><strong>Evento di sblocco dei token di rilievo della prossima settimana:</strong> <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a>(APE): <a href="/price/apecoin-ape" target="_blank" class="blog_inner_link">ApeCoin</a> è il token nativo dell’ecosistema Ape di Yuga Labs, che copre la popolare serie di NFT Bored Ape Yacht Club (BAYC). Il 17 giugno, il progetto sbloccherà oltre 15 milioni di token e li distribuirà al tesoro, ai fondatori, al team e ai contributori. Di solito, dopo lo sblocco di molti token, il prezzo di APE scenderà. Tuttavia, il calo potrebbe non essere significativo a causa dell’interesse rinnovato per i token non fungibili come BAYC.</p>
<p>Data di sblocco: 17 giugno<br>Quantità di token sbloccati: 15,6 milioni di APE<br>Circolazione attuale: 627,8 milioni di APE</p>
<p>Manta Network (MANTA): Manta Network è una blockchain modulare che utilizza la tecnologia zk-SNARK per fornire protezione della privacy per le applicazioni DeFi, consentendo transazioni e interazioni private. Manta Network è composto da due reti: Manta Pacific (è un ecosistema L2 modulare adatto per le applicazioni ZK native EVM e dApps) e Manta Atlantic (è la blockchain L1 più veloce su <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> e fornisce funzionalità zkSBT). Il 18 giugno, la circolazione di MANTA aumenterà di 6,67 milioni, e questi nuovi token sbloccati saranno distribuiti ai partecipanti per la vendita pubblica.</p>
<p>-Data di sblocco: 18 giugno<br>-Quantità di token sbloccati: 6,67 milioni di MANTA<br>-Sofferenza circolante attuale: 325,3 milioni di MANTA</p>
<p>Pixels (PIXEL): Pixels è un gioco multiplayer basato sulla blockchain Ronin, che utilizza i token PIXEL come monete di gioco e strumenti di governance della comunità. I detentori di PIXEL possono creare NFT, acquistare oggetti e pass VIP, unirsi alle gilde e votare lo sviluppo del progetto. Il 19 giugno saranno sbloccati 54,38 milioni di token PIXEL e assegnati a consulenti, fondi del progetto e premi dell’ecosistema.</p>
<ul>
<li>Data di sblocco: 19 giugno</li><li>Quantità di token sbloccata: 54,38 milioni di PIXEL</li><li>Circolazione attuale: 771 milioni di PIXEL</li></ul>
<p>Space ID: Space ID è un protocollo di identità decentralizzato universale che collega persone, beni e dApp su diverse blockchain. Consente agli utenti di utilizzare un singolo nome di dominio per rappresentare le proprie identità in diverse applicazioni e reti. Il 22 giugno, il progetto sbloccherà 78,5 milioni di token ID e li assegnerà alla Fondazione Space ID e ai partecipanti a più round di vendita.</p>
<p>-Data di sblocco: 22 giugno<br>-Quantità di token sbloccati: 78,5 milioni di ID<br>-Circolazione attuale: 430 milioni di ID</p>
<p>Inoltre, altri token che verranno presto sbloccati includono Nym (NYM), <a href="/price/kadena-kda" rel="nofollow noopener noreferrer" target="_blank">Kadena</a> (KDA), Euler (EUL) e Pendle (PENDLE), con un valore totale di oltre $170 milioni.</p>
<h2 id="h2-Tendenze20di20mercato20Il20mercato2020in20generale20in20calo20e20le20prestazioni20di20MAGA20sono20impressionanti83268"><a name="Tendenze di mercato: Il mercato è in generale in calo e le prestazioni di MAGA sono impressionanti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: Il mercato è in generale in calo e le prestazioni di MAGA sono impressionanti</h2><p>BTC si sta attualmente consolidando al di sotto dei $67.000, indicando che il mercato potrebbe essere in attesa di nuovi catalizzatori.</p>
<p>ETH è sceso sotto i $3.500, segnalando un debole sentimento di mercato. Si prevede che l’ETF di ETH passi questa estate, il che potrebbe diventare un importante fattore positivo e merita attenzione.</p>
<p>Altcoin: La maggior parte dei prezzi delle altcoin è tornata ai livelli precedenti alla pubblicazione dei dati sull’IPC, indicando un sentimento di mercato cauto.</p>
<h3 id="h3-Macroeconomia780840"><a name="Macroeconomia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia</h3><p>Volatilità del mercato azionario statunitense: Sebbene la diminuzione dei dati PPI sia un piccolo elemento positivo, non ha avuto un impatto significativo sul mercato. Gli investitori dovrebbero continuare a monitorare i dati CPI e le tendenze di politica della Federal Reserve, poiché questi fattori hanno un impatto più significativo sul mercato.</p>
<h3 id="h3-Punti20Caldi20del20Mercato139022"><a name="Punti Caldi del Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato:</h3><p>CRV: Il fondatore ha scommesso oltre 100 milioni di dollari nelle spedizioni CRV, causando insoddisfazione nella comunità e determinando una diminuzione del prezzo del 40% nel breve termine. Nonostante abbia pagato la maggior parte dei suoi debiti on-chain, il prezzo non è rimbalzato significativamente, indicando una mancanza di fiducia nel mercato.</p>
<p>Settore meme: il MAGA è salito di oltre il 20% durante la giornata, probabilmente a causa del 14 giugno che è il compleanno di Trump, e il mercato ha colto l’occasione per pubblicizzarsi. Potrebbe continuare a salire a breve termine, ma la volatilità è elevata.</p>
<p>TON Eco: TON è salito del 10% durante la giornata, raggiungendo un nuovo massimo storico. Il TVL dell’ecosistema ha superato i 550 milioni di dollari, raggiungendo anche un massimo storico, dimostrando una forte domanda di mercato. Attualmente TON si comporta in modo positivo ed è adatto per il mantenimento a medio-lungo termine, ma è importante prestare attenzione ai cambiamenti nel sentimento di mercato.</p>
<p>Il sentimento attuale del mercato è piuttosto complesso, con BTC ed ETH in fasce di prezzo chiave e le prestazioni delle Altcoins differenziate. I dati macroeconomici come l’IPC e le politiche della Federal Reserve rimangono fattori influenti chiave. Per quanto riguarda argomenti caldi, il settore delle Meme coin presenta significative fluttuazioni ed è adatto per il trading a breve termine; TON si comporta bene ed è adatto per il possesso a medio e lungo termine. Gli investitori dovrebbero effettuare adeguamenti flessibili in base alle proprie preferenze di rischio e ai cambiamenti di mercato.</p>
<h2 id="h2-Macro20Le20azioni20tecnologiche20hanno20guidato20i20guadagni20con20il20Nasdaq20che20ha20raggiunto20chiusure20consecutive20al20massimo20Il20mercato20asiatico20si20sta20indebolendo20in20generale807455"><a name="Macro: Le azioni tecnologiche hanno guidato i guadagni, con il Nasdaq che ha raggiunto chiusure consecutive al massimo; Il mercato asiatico si sta indebolendo in generale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Le azioni tecnologiche hanno guidato i guadagni, con il Nasdaq che ha raggiunto chiusure consecutive al massimo; Il mercato asiatico si sta indebolendo in generale</h2><p>Il 14 giugno, l’indice Nasdaq ha raggiunto un nuovo massimo di chiusura per il quinto giorno consecutivo di negoziazione, trainato dalla crescita di Adobe e altre azioni tecnologiche, mentre l’indice S&amp;P 500 e l’indice Dow Jones sono leggermente diminuiti.</p>
<p>L’indice S&amp;P 500 ha concluso la sua serie di quattro giorni consecutivi di nuovi massimi di chiusura, ma è comunque salito di oltre l’1% questa settimana. Il settore tecnologico è salito dello 0,5%, raggiungendo un nuovo massimo di chiusura. Il settore dei servizi di comunicazione è salito dello 0,6%, guidando i guadagni tra i vari settori. Per quanto riguarda gli indici specifici, l’indice Dow Jones è sceso dello 0,2%, l’indice S&amp;P 500 è sceso dello 0,04% e l’indice Nasdaq è salito dello 0,1%.</p>
<p>I responsabili della Fed hanno ridotto le loro aspettative di tre tagli dei tassi di interesse quest’anno a uno mercoledì. Tuttavia, un rapporto pubblicato venerdì ha mostrato che il valore iniziale dell’Indice di fiducia dei consumatori dell’Università del Michigan per giugno è sceso a 65,6, molto al di sotto delle aspettative. I dati CPI mostrano anche un raffreddamento dell’inflazione, il che potrebbe portare a tagli dei tassi di interesse.</p>
<p>Il 17 giugno, i mercati azionari asiatici si sono generalmente indeboliti, i dati economici della Cina sono stati altalenanti e l’incertezza politica in Europa ha indebolito l’appetito per il rischio degli investitori, indebolendo l’euro.</p>
<p>Le azioni blue chip della Cina sono scese dello 0,2%. Anche se le vendite al dettaglio sono aumentate del 3,7% a maggio, superando le aspettative, la produzione industriale e gli investimenti nelle attività fisse hanno entrambi avuto prestazioni scadenti. I dati mostrano che i prezzi delle case sono scesi più rapidamente in un decennio a maggio, mettendo in evidenza la continua pressione sull’industria immobiliare. L’indice Nikkei in Giappone è sceso dell’1,7%, e gli investitori devono aspettare sei settimane per conoscere i dettagli delle prossime misure di stretta della Banca del Giappone.</p>
<p>Questa settimana si prevede che le banche centrali di Australia, Norvegia e Regno Unito manterranno invariati i tassi di interesse durante la riunione, ma a causa della recente forza del franco svizzero, la banca centrale svizzera potrebbe allentare i tassi di interesse.</p>
<p>L’incertezza politica in Francia ha portato l’euro a cadere a un minimo di quattro mesi di 0,9505 contro il franco svizzero venerdì, aumentando la possibilità di un taglio del tasso del 75% nel mercato. Il tasso di cambio euro/dollaro USA è rimasto a $1,0698, raggiungendo un minimo di sei settimane di $1,06678 la scorsa settimana. Il dollaro USA/yen si è leggermente rafforzato a 157,52 yen dopo aver superato i 158,00 yen in un momento a causa dell’annuncio della Banca del Giappone dello scorso venerdì che avrebbe iniziato a ridurre gli acquisti di obbligazioni.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono leggermente diminuiti dopo un aumento del 4% la settimana scorsa a causa delle aspettative di una domanda più forte durante la stagione di massimo traffico negli Stati Uniti. I prezzi del greggio Brent sono scesi di 17 centesimi a $82.45 al barile, mentre i prezzi del greggio statunitense sono scesi di 18 centesimi a $78.27 al barile.</p>
<p>Il prezzo dell’oro è rimasto a $2,325 per oncia, recuperando l’1,7% la scorsa settimana.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Glassa</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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>