Tm90aXppZSBxdW90aWRpYW5lIHwgSGFja2VyIGhhIGNsaWNjYXRvIGFjY2lkZW50YWxtZW50ZSBzdSB1biBzaXRvIGRpIHBoaXNoaW5nIGUgc29ubyBzdGF0aSBydWJhdGkgMi45MzAgRVRILCBUZXRoZXIgaGEgYXVtZW50YXRvIGxlIHN1ZSByaXNlcnZlIGRpIDguODg4IEJUQw==

2025-04-01, 03:11

<p><img src="https://gimg2.gateimg.com/image/article/17434768404.1.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Hacker20ha20cliccato20accidentalmente20su20un20sito20di20phishing20risultando20nel20furto20di20293020ETH20e20Tether20ha20aumentato20le20sue20riserve20di20888820BTC224962"><a name="Crypto Daily Digest: Hacker ha cliccato accidentalmente su un sito di phishing, risultando nel furto di 2.930 ETH, e Tether ha aumentato le sue riserve di 8.888 BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Hacker ha cliccato accidentalmente su un sito di phishing, risultando nel furto di 2.930 ETH, e <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> ha aumentato le sue riserve di 8.888 BTC</h2><p>Secondo i dati degli investitori di Farside, il totale deflusso netto di US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF spot ieri ammontavano a $75.7 milioni, di cui BTCW ha avuto un deflusso netto di $32.6 milioni e ARKB ha avuto un deflusso netto di $23.2 milioni. I dati di BlackRock non sono ancora stati aggiornati.</p>
<p>Ieri, il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> l’ingresso dell’ETF spot è stato di $6.4 milioni, di cui Fidelity FETH ha avuto un deflusso netto di $6.4 milioni. I dati di BlackRock non sono ancora stati aggiornati.</p>
<p><strong>Lo hacker di zkLend ha cliccato accidentalmente su un sito di phishing, causando il furto di 2.930 ETH</strong></p>
<p>Il 1 aprile, secondo il monitoraggio del fondatore di SlowMist Yu Xian, un hacker di zkLend ha cliccato accidentalmente su un sito di phishing, risultando nel furto di 2.930 ETH. L’hacker ha inviato un messaggio on-chain a zkLend dicendo: “Ciao, volevo trasferire fondi a Tornado Cash, ma ho usato per errore un sito di phishing e ho perso tutti i miei fondi. Sono devastato. Mi scuso profondamente per la confusione e le perdite causate. Tutti i 2930 ETH sono stati prelevati dagli operatori di questo sito. Non ho più monete. Vi prego di rivolgere la vostra attenzione a quegli operatori del sito per vedere se potete recuperare parte dei fondi.”</p>
<p><strong>OOGA ha annunciato l’economia dei token, il drop aereo rappresenta il 10%</strong></p>
<p>L’ecosistema di trading di aggregazione Berachain ha annunciato il modello economico del token Ooga Booga. L’allocazione del team rappresenta il 18%, che è bloccata per 6 mesi e poi sbloccata linearmente in 24 mesi; l’allocazione degli investitori rappresenta il 19,15%, senza blocco e sblocco lineare in 24 mesi; l’allocazione dell’airdrop rappresenta il 10%, e il 100% è sbloccato al TGE.</p>
<p><strong><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> ha aumentato le sue disponibilità di 8.888 BTC, diventando il sesto indirizzo con il maggior numero di BTC in possesso</strong></p>
<p>Il 1 aprile, secondo Ember Monitoring, <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> ha nuovamente aumentato le sue disponibilità di 8.888 BTC (735 milioni di dollari) nel primo trimestre di quest’anno: Tether ha annunciato nel maggio 2023 che utilizzerà regolarmente il 15% dei profitti dell’azienda per acquistare <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> al fine di potenziare le sue riserve. Tether detiene attualmente un totale di 92.647 BTC (7,64 miliardi di dollari), diventando il sesto più grande indirizzo del portafoglio BTC, con un costo complessivo di acquisto di BTC di circa 41.147 dollari.</p>
<p><strong>Vitalik ha venduto DHN e LEDOG</strong></p>
<p>Il 1 aprile, secondo il monitoraggio di Onchain Lens, 4 ore fa, il co-fondatore di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Vitalik Buterin ha liquidato i suoi 5.000 DHN e li ha scambiati per 93.655 USDC, e ha anche venduto 2 trilioni di LEDOG in cambio di 16.569 USDC.</p>
<h2 id="h2-Tendenze20di20mercato20Strategy20ha20acquistato20altri202204820BTC20e20i20token20GT20hanno20mostrato20una20relativa20forza648154"><a name="Tendenze di mercato: Strategy ha acquistato altri 22.048 BTC e i token GT hanno mostrato una relativa forza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: Strategy ha acquistato altri 22.048 BTC e i token GT hanno mostrato una relativa forza</h2><h3 id="h3-Punti20Caldi20del20Mercato961774"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>Secondo il monitoraggio di Glassnode, il gruppo di persone che ha tenuto <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> per 3 a 6 mesi e sta per diventare detentori a lungo termine ha visto un aumento significativo dei profitti detenuti. Inoltre, l’attività di trading di monete per detentori da 3 a 6 mesi è al suo livello più basso da giugno 2021, e le nuove balene entrate stanno ancora mantenendo posizioni anziché vendere.</p>
<p>La Strategia ha acquistato altri 22.048 BTC a un prezzo di circa $1.92 miliardi, con un prezzo medio di circa $86.969. Al 30 marzo 2025, detiene 528.185 BTC con un valore totale di circa $35.63 miliardi e un prezzo medio di circa $67.458.</p>
<h3 id="h3-Coin20Mainstream919108"><a name="Coin Mainstream" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Coin Mainstream</h3><p>All’indomani dell’annuncio della politica tariffaria degli Stati Uniti, il Bitcoin ha iniziato a oscillare intorno ai $83.000, con un limite superiore di $84.000 e un limite inferiore di $81.500. Al momento della stampa, il Bitcoin è stato quotato a $82.863, in aumento del 1,57% in 24 ore.</p>
<p>Il prezzo attuale di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> è sceso al punto più basso all’inizio di marzo, formando un forte supporto dei prezzi a $1,750. Al momento della stampa, Ethereum è quotato a $1,830, in aumento del 1.13% nelle ultime 24 ore.</p>
<p>I prezzi delle altcoin non hanno fluttuato molto nel complesso, con la maggior parte dei settori che hanno registrato un aumento o una diminuzione del 24 ore inferiore all’1%. SOL ha oscillato intorno a $125, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> fluttuava intorno ai $600, e i token GT hanno avuto una performance relativamente forte in questa fase delle condizioni di mercato, attualmente quotati a $22.45.</p>
<h2 id="h2-Macro20News20Le20ultime20misure20tariffarie20saranno20annunciate20mercoled20e20il20Nasdaq20ha20registrato20il20pi20grande20calo20trimestrale20in20quasi20tre20anni191089"><a name="Macro News: Le ultime misure tariffarie saranno annunciate mercoledì, e il Nasdaq ha registrato il più grande calo trimestrale in quasi tre anni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro News: Le ultime misure tariffarie saranno annunciate mercoledì, e il Nasdaq ha registrato il più grande calo trimestrale in quasi tre anni</h2><p>Il 1 aprile, il segretario del Tesoro statunitense Scott Bessent ha detto che Trump annuncerà misure tariffarie corrispondenti alle 15:00 di mercoledì (3:00 del mattino ora di Pechino il giorno successivo). Attualmente, il mercato globale continua a concentrarsi su questo evento. A quel tempo, il mercato finanziario potrebbe registrare maggiori fluttuazioni. Si prega gli investitori di fare piani.</p>
<p>Il dollaro è rimasto stabile dopo un primo trimestre difficile poiché gli investitori hanno seguito da vicino le tariffe reciproche previste da annunciare dal presidente statunitense Donald Trump mercoledì. L’euro è salito del 4,5% contro il dollaro nel primo trimestre, il suo miglior trimestre da fine 2022, mentre lo yen è salito di quasi il 5% in previsione che la Banca del Giappone alzerà ulteriormente i tassi di interesse.</p>
<p>Le azioni statunitensi hanno ripreso dopo un forte calo, con lo S&amp;P 500 in rialzo dello 0,55%. Era sceso a un nuovo minimo da settembre dell’anno scorso, e era sceso di quasi il 10% rispetto al massimo di febbraio. Lo S&amp;P e il Nasdaq hanno registrato il più grande calo trimestrale da quasi tre anni. Tesla è scesa di quasi l’8% durante la giornata e ha chiuso in ribasso di quasi il 2%. È scesa di quasi il 36% nel primo trimestre. Nvidia è scesa per cinque giorni consecutivi e è scesa di quasi il 20% per l’intero trimestre.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Rooick Z.</strong>, Ricercatore di Gate.io<br><div>Translator:Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni oculate.<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>