RGFpbHkgTmV3cyB8IElsIHJpbGFzY2lvIGRpIERvIEt3b24gcm9tcGUgTFVOQSBvbHRyZSAxIFVTRFQ7IMOIIGluaXppYXRhIGxhIHNlY29uZGEgZmFzZSBkZWxsJ2F0dGl2aXTDoCBkaSBFdGhlckZpIFBvaW50czsgTCdVRSBhcHByb3ZhIGlsIGRpdmlldG8gZGkgdHJhZGluZyBhbm9uaW1vIGRpIGNyaXB0b3ZhbHV0ZQ==

2024-03-25, 04:22

<p><img src="https://gimg2.gateimg.com/image/article/17113405241_17.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Il20rilascio20di20Do20Kwon20ha20permesso20a20LUNA20di20superare20120USDT2020iniziata20la20seconda20fase20dellattivit20EtherFi20points20Commissione20europea20il20trading20anonimo20di20criptovalute20tramite20portafogli20custodiali2020vietato84524"><a name="Crypto Daily Digest: Il rilascio di Do Kwon ha permesso a LUNA di superare 1 USDT; È iniziata la seconda fase dell’attività EtherFi points; Commissione europea: il trading anonimo di criptovalute tramite portafogli custodiali è vietato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Il rilascio di Do Kwon ha permesso a LUNA di superare 1 USDT; È iniziata la seconda fase dell’attività EtherFi points; Commissione europea: il trading anonimo di criptovalute tramite portafogli custodiali è vietato</h2><p>Prima di tutto, 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 22 marzo i fondi GBTC di Grayscale hanno continuato a… <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> aumentando significativamente, raggiungendo i $169,9 milioni; Nel frattempo, l’afflusso di Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) è stato di $18,1 milioni, l’afflusso di Bitwise Bitcoin spot ETF (BITB) è stato di $16,3 milioni e l’afflusso di ARK 21Shares Bitcoin spot ETF (ARKB) è stato di $5,4 milioni.</p>
<p>Secondo Bloomberg, il 23 marzo, <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Il co-fondatore Do Kwon e il CFO Han Chong-Joon verranno rilasciati su cauzione di 400.000 euro mentre la Corte Suprema del Montenegro sta esaminando le richieste di estradizione dagli Stati Uniti e dalla Corea del Sud. Dopo ulteriori considerazioni da parte del tribunale, è possibile deportare Do Kwon in qualsiasi paese. Secondo le autorità montenegrine, Do Kwon sarà rilasciato dal carcere e posto in ‘arresti domiciliari’ durante il ritardo nell’estradizione. Dopo questa notizia, LUNA è salita sopra l’1 USDT in risposta.</p>
<p>Super <a href="/price/sushi-sushi" rel="nofollow noopener noreferrer" target="_blank">Sushi</a> Samurai, un membro del progetto dell’ecosistema Blast, ha pubblicato sulla piattaforma X affermando che il problema di essere hackerati a causa della vulnerabilità del ‘raddoppiamento dei fondi’ è stato risolto. Ha deciso di premiare gli hacker White Hat con una ricompensa ETH del 5%, che il team SSS fornirà loro. I fondi rimanenti saranno trasferiti ai seguenti indirizzi multi-firma sotto il controllo del team SSS. Dopo un’analisi, è stato riscontrato un bug nel contratto del token e trasferire il saldo a se stesso raddoppierà il saldo. I fondi sono al sicuro.</p>
<p>Il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il protocollo di restaking del progetto ether.fi ha annunciato che la seconda stagione dell’attività dei punti, StackRank, inizierà dal 15 marzo al 30 giugno. Gli utenti che fanno staking a lungo termine riceveranno una ricompensa, pari al 5% dell’offerta totale di ETHFI.</p>
<p>L’attività StackRank include otto livelli, che incoraggiano i partecipanti a fare stake a lungo termine. Ogni 100 ore di stake, l’ETH verrà aggiornato di un livello, con un tasso di miglioramento dei punti fedeltà più elevato per ogni livello. Il saldo di stake deve superare 0,1 eETH per essere aggiornato. A partire dal Rango II, gli utenti che partecipano alla prima stagione avranno un intervallo di aumento del livello di 1x a 2x, gli utenti di Ether.Fan NFTT saranno automaticamente aggiornati al Rango III.</p>
<p>Per trattare i nuovi staker in modo equo, il tasso di accumulo dei punti nel secondo trimestre aumenterà di dieci volte. Tutti gli ETH e weETH, che siano detenuti in posizioni DeFi, parteciperanno alle attività di ristaking in modo equo.</p>
<p>La legge dell’UE contro il riciclaggio di denaro ha aggiunto una restrizione sulle criptovalute, vietando qualsiasi valore di scambio di criptovaluta attraverso la custodia di portafogli crittografici. Prima di questo, il Consiglio e il Parlamento europeo hanno temporaneamente concordato di ampliare alcune leggi dell’UE contro il riciclaggio di denaro (AML) e il finanziamento del terrorismo per coprire temporaneamente il mercato delle criptovalute.</p>
<p>Secondo le nuove normative, saranno vietati i pagamenti in contanti anonimi superiori a 3.000 euro nelle transazioni commerciali e i pagamenti in contanti superiori a 10.000 euro saranno vietati del tutto nelle transazioni commerciali. La risposta della comunità cripto alle misure regolamentari dell’UE è inconsistente. Alcune persone ritengono che le nuove leggi antiriciclaggio siano necessarie, mentre altri sono preoccupati che possano violare la privacy e limitare le attività economiche.</p>
<p>Il principio di decentralizzazione della criptovaluta consente a molte reti cripto di operare in un ambiente senza permessi, consentendo a chiunque di creare chiavi private cripto e di accedere in modo anonimo e illimitato al sistema. Pertanto, il grado di limitazione di questa regolamentazione è relativamente evidente.</p>
<p>Daniel “Loddi” Tröster, conduttore del podcast Sound Money Bitcoin, ha sottolineato gli ostacoli pratici e le conseguenze della recente legislazione. Ha delineato l’impatto sulle donazioni e sull’uso più ampio delle criptovalute all’interno dell’UE, esprimendo preoccupazioni circa gli effetti inibitori potenziali di queste regole.</p>
<h2 id="h2-Tendenze20del20mercato20il20mercato20generale20si20riprende20ma2020ancora20in20un20range20volatile725326"><a name="Tendenze del mercato: il mercato generale si riprende ma è ancora in un range volatile" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze del mercato: il mercato generale si riprende ma è ancora in un range volatile</h2><p>Oggi, il mercato delle criptovalute nel complesso mostra una tendenza al rialzo, ma il mercato è ancora in un range volatile. In particolare, gli ETF spot di Bitcoin hanno mostrato deflussi netti per cinque giorni consecutivi. Sebbene Bitcoin abbia superato una volta i massimi storici, gli acquisti di ETF spot si sono gradualmente indeboliti, ma l’uscita si è gradualmente rallentata, indicando che il sentiment di mercato si sta stabilizzando lentamente. Per quanto riguarda la macroeconomia, il mercato azionario statunitense è fluctuato, mentre l’indice del dollaro statunitense ha mostrato segni di ripresa.</p>
<h3 id="h3-Hotspot20di20mercato994540"><a name="Hotspot di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato</h3><p>I token di concetto di Hong Kong sono aumentati:<br>I topic caldi di oggi si concentrano principalmente sull’eccitante conferenza <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> di Hong Kong, con i token della serie di concetto di Hong Kong che mostrano una crescita promettente. ACH, CFX e altri token hanno dimostrato una performance eccezionale, con notizie dalla conferenza di Hong Kong Web3 di aprile. Prima della conferenza di Hong Kong Web3 del 2023, i token di concetto di Hong Kong avevano già mostrato una prestazione impressionante, con ACH, CFX, KEY e altri token che avevano registrato forti aumenti. Ciò indica che gli investitori hanno alte aspettative per la conferenza di Hong Kong Web3 e il mercato ha attivamente seguito le performance dei token correlati.</p>
<p>Il concetto di catena pubblica ha visto una buona crescita:<br>Il concetto di catena pubblica è anche uno dei temi caldi sul mercato, con token come ICP, NEAR e RUNE che mostrano tutti un aumento. In particolare, TON è salito del 25% durante il fine settimana, attirando l’attenzione del mercato. Gli utenti cumulativi di Telegram hanno superato i 800 milioni, mentre gli indirizzi attivi della blockchain Ton sono solo 300.000, indicando che il progetto ha un enorme potenziale sulla base utenti. Influenzato dalla notizia dell’eventuale IPO di Telegram in futuro, le recenti performance della Ton Public Chain sono state anche molto impressionanti, con prezzi raddoppiati nel mese scorso. Ciò dimostra il favore del mercato per i progetti di catene pubbliche con un forte supporto di base e, pertanto, gli investitori favoriscono i token correlati.</p>
<p>Token concetto di bancarotta LUNA in aumento:<br>Un altro argomento caldo è la crescita del token concetto di bancarotta LUNA, che è aumentato di quasi il 50% il 7. La notizia di questa tendenza al rialzo proviene da voci che potrebbe esserci un punto di svolta nel caso DK, che ha attirato l’attenzione del mercato. Sebbene il progresso specifico del caso non sia ancora chiaro, il mercato ha mostrato un atteggiamento positivo verso potenziali buone notizie, spingendo l’aumento dei token LUNA.</p>
<p>Nel complesso, il mercato ha mostrato oggi un modello di ripresa, ma è ancora in un intervallo volatile. Gli investitori dovrebbero rimanere cauti e monitorare attentamente ulteriori tendenze di mercato per adattare le loro strategie di investimento in base alle circostanze effettive. L’entusiasmo della conferenza di Hong Kong Web3, la popolarità del concetto di catena pubblica e la tendenza dei token del concetto di bancarotta sono tutti fattori importanti che richiedono attenzione.</p>
<h2 id="h2-Macro20Aumenta20la20possibilit20di20politiche20accomodanti20e20il20trend20del20mercato20globale20rimane20stabile210276"><a name="Macro: Aumenta la possibilità di politiche accomodanti e il trend del mercato globale rimane stabile" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Aumenta la possibilità di politiche accomodanti e il trend del mercato globale rimane stabile</h2><p>Reuters ha riportato che molti mercati saranno chiusi venerdì a causa della Pasqua e i dati del PCE saranno rilasciati in quella data, quindi una risposta completa dovrà attendere fino alla prossima settimana. Il presidente della Federal Reserve, Jerome Powell, è apparso sufficientemente accomodante la scorsa settimana, lasciando intendere politiche flessibili a giugno.</p>
<p>Powell parteciperà alla discussione presieduta dell’incontro di politica di venerdì, e i direttori della Federal Reserve Lisa Cook e Christopher Waller parteciperanno anche questa settimana. Secondo lo strumento FedWatch di CME, i trader ritengono che la probabilità del primo taglio dei tassi di interesse a giugno sia di circa il 71%, rispetto al 56% all’inizio di questa settimana.</p>
<p>L’aspettativa di un calo dei costi di prestito globali è positiva per il mercato azionario, con l’indice Nikkei in calo e i futures dell’indice S&amp;P 500 rimasti invariati. L’indice S&amp;P 500 è aumentato di quasi il 10% finora quest’anno. Lunedì, il trading dei futures dell’indice S&amp;P 500 e dei futures NASDAQ è rimasto sostanzialmente invariato. Il 22 marzo, l’indice NASDAQ e l’indice dei semiconduttori (.SOX) hanno chiuso leggermente in rialzo, e a causa del prosieguo <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> riguardo all’intelligenza artificiale, anche l’indice del settore dei semiconduttori è aumentato significativamente questa settimana. L’indice Dow Jones ha chiuso in ribasso nella giornata.</p>
<p>In termini di valuta, lunedì il dollaro statunitense è leggermente diminuito rispetto allo yen giapponese a 151,23 yen, e la scorsa settimana è aumentato del 1,6%, raggiungendo un picco di 151,86 yen.</p>
<p>Il mercato è cauto nel testare il livello di 152,00, poiché questo livello ha causato in precedenza un intervento giapponese. In effetti, il Chief Monetary Officer del Giappone ha avvertito lunedì che la debolezza attuale dello yen non riflette i fondamentali e che un’eccessiva volatilità non è gradita. Anche se la Banca del Giappone abbandona la sua politica super-larga, non può indebolire il dollaro statunitense, poiché gli investitori credono che questo non sia l’inizio di una serie di rialzi dei tassi di interesse.</p>
<p>In termini di materie prime, i prezzi del petrolio sono aumentati nelle prime negoziazioni asiatiche di lunedì a causa delle preoccupazioni di mercato che i crescenti conflitti tra Medio Oriente, Russia e Ucraina potrebbero portare a un restringimento dell’offerta globale, mentre la riduzione del numero di piattaforme di trivellazione negli Stati Uniti ha aggiunto pressione all’aumento dei prezzi del petrolio.</p>
<p>I futures sul greggio Brent sono saliti di 24 centesimi a 85,67 dollari al barile. I futures sul greggio statunitense sono saliti di 25 centesimi a 80,88 dollari al barile. Entrambi i benchmark hanno mostrato una variazione inferiore all’1% rispetto alla settimana precedente.</p>
<p>Dopo aver raggiunto un massimo storico di $2.217,79 la settimana scorsa, i prezzi dell’oro sono leggermente aumentati a $2.174 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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>