Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgbWVyY2F0byDDqCBpbiByaWJhc3NvIG9nZ2k7IGxhIGxlZ2dlIGRlbGwnVUUgY29udHJvIGlsIHJpY2ljbGFnZ2lvIGRpIGRlbmFybyBoYSBpbXBvc3RvIHJlcXVpc2l0aSBzdWwgbWVyY2F0byBkZWxsZSBjcmlwdG92YWx1dGU7IGxhIEZvbmRhemlvbmUgU3RhcmtuZXQgaGEgcmlkaXN0cmlidWl

2024-04-25, 04:30

<p><img src="https://gimg2.gateimg.com/image/article/171401934325.png" alt=""></p>
<h2 id="h2-Riepilogo20cripto20giornaliero20la20legge20dellUE20contro20il20riciclaggio20di20denaro20impone20requisiti20sul20mercato20cripto20Starknet20Foundation20ripropone20gli20airdrop20di20STRK20Il20nuovo20disegno20di20legge20degli20Stati20Uniti20potrebbe20indebolire20linfluenza20delle20stablecoin95510"><a name="Riepilogo cripto giornaliero: la legge dell’UE contro il riciclaggio di denaro impone requisiti sul mercato cripto; Starknet Foundation ripropone gli airdrop di STRK; Il nuovo disegno di legge degli Stati Uniti potrebbe indebolire l’influenza delle stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo cripto giornaliero: la legge dell’UE contro il riciclaggio di denaro impone requisiti sul mercato cripto; Starknet Foundation ripropone gli airdrop di STRK; Il nuovo disegno di legge degli Stati Uniti potrebbe indebolire l’influenza delle stablecoin</h2><p>Prima di tutto, 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 24 aprile i fondi Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (GBTC) hanno continuato a <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> raggiungendo significativamente i 130,4 milioni di dollari. Nel frattempo, l’afflusso di Fidelity Bitcoin spot ETF (FBTC) è stato di 5,6 milioni di dollari e l’afflusso di ARK 21 Shares Bitcoin spot ETF (ARKB) è stato di 4,2 milioni di dollari.</p>
<p>Il Parlamento europeo ha approvato una nuova normativa che richiede alle aziende di criptovalute di condurre una dovuta diligenza per contrastare le attività di riciclaggio di denaro. Questa legge richiede alle società di gestione degli asset cripto di rafforzare i controlli sull’identità dei clienti e segnalare alle autorità le attività sospette. Questa misura avrà un impatto sui fornitori di servizi cripto, inclusi gli scambi cripto centralizzati e alcuni servizi di gioco d’azzardo.</p>
<p>Come già segnalato, la nuova legge avrà un impatto sui fornitori di servizi crittografici (CASPs), come gli scambi crittografici centralizzati, e molte altre istituzioni, inclusi i servizi di gioco d’azzardo.</p>
<p>Patrick Hansen, Direttore della Strategia e delle Politiche dell’UE di Circle, ha dichiarato che il voto era atteso e che il piano di pacchetto sarà ufficialmente approvato dal Consiglio Europeo e implementato in tre anni.</p>
<p>La Fondazione Starknet ha annunciato in un articolo pubblicato sulla piattaforma X che effettueranno il rifacimento delle distribuzioni aeree di STRK per tre tipi di utenti. In particolare, includono:<br>Collezionisti collettivi: Inizialmente, la Fondazione Starknet aveva pianificato di distribuire STRK ai collezionisti collettivi idonei attraverso il protocollo di staking utilizzato dagli utenti. Sebbene molti protocolli di staking non possano completare questa operazione, gli accordi o entità attualmente supportati includono Lido, <a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Rocket Pool</a>, ecc.</p>
<p>Gli utenti di StarkEx erroneamente identificati come utenti di VeVeVe (erroneamente identificati come utenti di un gioco chiamato ‘VeVeVe’ in esecuzione sulla piattaforma Immutable): gli utenti di Immutable identificati come non utenti di VeVeVe nell’elenco di aggiornamento ricevuto dalla fondazione da Immutable potranno richiedere STRK tramite il portale a partire da oggi.</p>
<p>Utenti di VeVeVe: La fondazione è in continuo dialogo con VeVeVe riguardo all’allocazione dei token per determinare come allocare STRK.</p>
<p>Come fondamento del mercato crittografico, le stablecoin rappresentate da USDT hanno sempre ricevuto ampia attenzione. Di recente, i senatori statunitensi Cynthia Lumis e Kirsten Gillibrand hanno proposto una nuova legge sulle stablecoin per regolare il funzionamento delle stablecoin negli Stati Uniti, il che potrebbe influenzare il loro status.</p>
<p>I dati mostrano che <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> (USDT) ha un valore di mercato di 110 miliardi di dollari, rendendolo la terza criptovaluta più grande, mentre USDC di Circle si posiziona al secondo posto con un valore di mercato di 34 miliardi di dollari. Entrambi questi stablecoin sono ancorati al dollaro statunitense.</p>
<p>Standard &amp; Poor’s Global Ratings ha evidenziato in un rapporto mercoledì che la chiarezza dell’ambiente regolamentare degli Stati Uniti potrebbe incoraggiare le istituzioni finanziarie tradizionali a entrare nel mercato delle stablecoin e potenzialmente indebolire la posizione dominante di <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> (USDT) nel mercato.</p>
<p>Il rapporto afferma che entità non statunitensi emettono USDT e, pertanto, non è una stablecoin di pagamento consentita dal disegno di legge proposto. Ciò significa che le entità statunitensi non possono detenere o scambiare USDT, il che potrebbe ridurre la domanda di USDT e aumentare l’emissione di stablecoin negli Stati Uniti. Le attività di trading di USDT sono principalmente situate nei mercati emergenti al di fuori degli Stati Uniti e sono guidate da investitori al dettaglio e da rimesse. Con l’introduzione del disegno di legge sopra citato, la situazione delle stablecoin potrebbe cambiare.</p>
<p>L’analista Andrew O’Neill ha sottolineato: “Le nuove normative potrebbero limitare le istituzioni senza licenza bancaria a emettere fino a $10 miliardi di stablecoin, conferendo così ai bancari un vantaggio competitivo.”</p>
<h2 id="h2-Tendenze20di20mercato20il20mercato2020generalmente20in20calo20e20Meta2020in20ribasso20del201820dopo20lorario20di20chiusura20del20mercato363282"><a name="Tendenze di mercato: il mercato è generalmente in calo e Meta è in ribasso del 18% dopo l’orario di chiusura del mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il mercato è generalmente in calo e Meta è in ribasso del 18% dopo l’orario di chiusura del mercato</h2><p>Dopo due giorni di volatilità, il mercato crittografico è caduto, con BTC che è sceso sotto i $64.000 e le monete contraffatte in generale in calo. Riguardo alla macroeconomia, anche il mercato azionario statunitense ha mostrato volatilità, specialmente dopo che Meta ha rilasciato il suo rapporto finanziario del primo trimestre. A causa di un significativo aumento della spesa in AI, il suo prezzo delle azioni è sceso dell’18% nelle contrattazioni after-hours.</p>
<h3 id="h3-Punti20Caldi20del20Mercato756619"><a name="Punti Caldi del Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato:</h3><p>Il settore delle fan coin ha avuto prestazioni eccezionali: le fan coin come PORTO e LAZIO hanno ottenuto buoni risultati nonostante il generale calo del mercato, in parte grazie alla partecipazione entusiasta del Campionato Europeo. I token dei fan di solito ottengono buoni risultati durante eventi sportivi importanti poiché questi eventi aumentano l’attenzione e le attività di trading dei token correlati.</p>
<p>Progressi nel settore AI+DePin: io.net ha annunciato che farà un airdrop ai suoi utenti, e Whales prevede che il suo mercato di previsione centralizzato on-chain abbia un valore di mercato fino a $4 miliardi. Rispetto a RNDR nello stesso settore (con un valore di mercato di $5 miliardi), questo dimostra l’alto potenziale di crescita e l’interesse degli investitori.</p>
<p>Nuovi sviluppi nel settore delle rune: il prezzo dei token DOG nel settore delle rune è aumentato a causa delle distribuzioni aeree di Rune Stone agli holders, con un valore di mercato di 350 milioni di dollari e un volume di scambi superiore a 100 BTC nel breve termine. Tali attività di solito stimolano l’entusiasmo degli scambi di mercato e le fluttuazioni dei prezzi.</p>
<p>La contro-tendenza Rise of <a href="/price/eos-eos" rel="nofollow noopener noreferrer" target="_blank">EOS</a>: A seguito dell’annuncio delle nuove politiche di economia dei token da parte della Fondazione <a href="/price/eos-eos" target="_blank" class="blog_inner_link">EOS</a> Network, i prezzi di EOS sono aumentati del 15% in controtendenza. La nuova politica prevede misure come la distruzione dell’80% dell’offerta totale futura, la chiusura dell’inflazione, il fissare un tetto di fornitura di 2,1 miliardi di token, un ciclo di dimezzamento di 4 anni e la coniazione di circa 950 milioni di EOS. Queste misure mirano a migliorare la scarsità e il valore di EOS.</p>
<p>Nonostante il mercato generale mostri un trend al ribasso, alcuni settori e token specifici, come le monete dei fans, i concetti AI+DePin e i settori dei rune, hanno mostrato una performance relativamente forte. Le nuove notizie da EOS hanno inoltre portato significativi aumenti di prezzo. Gli investitori dovrebbero continuare a monitorare attentamente i cambiamenti macroeconomici, i report finanziari delle aziende e le dinamiche di sviluppo all’interno di ogni settore per comprendere meglio le tendenze di mercato e prendere decisioni di investimento corrispondenti. Nel frattempo, l’incertezza di mercato suggerisce che gli investitori debbano gestire appropriatamente i rischi.</p>
<h2 id="h2-Macro20La20caduta20delle20azioni20tecnologiche20porta20pressione20al20mercato20Lo20yen20giapponese2020sceso20a20un20minimo20di203420anni20suscitando20discussioni20sulla20direzione20dellintervento20governativo334467"><a name="Macro: La caduta delle azioni tecnologiche porta pressione al mercato; Lo yen giapponese è sceso a un minimo di 34 anni, suscitando discussioni sulla direzione dell’intervento governativo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: La caduta delle azioni tecnologiche porta pressione al mercato; Lo yen giapponese è sceso a un minimo di 34 anni, suscitando discussioni sulla direzione dell’intervento governativo</h2><p>Giovedì, il mercato azionario statunitense ha mostrato tendenze diverse, con l’indice S&amp;P 500 in leggero aumento, l’indice S&amp;P 500 in aumento dello 0,02% a 5.071,63 punti e l’indice Nasdaq Composite in aumento dello 0,10% a 15.712,75. L’indice Dow Jones Industrial Average è sceso dello 0,11% a 38.460,92 punti.</p>
<p>Dei 11 settori nell’indice S&amp;P 500, 7 settori sono saliti, con beni di consumo essenziali, servizi pubblici, beni di consumo non essenziali e azioni immobiliari in testa.</p>
<p>La società mineraria quotata a Londra, Anglo American, ha annunciato giovedì di aver ricevuto una proposta completa di acquisizione delle azioni da parte di BHP.AX. Se l’accordo verrà raggiunto, significherà che la più grande società mineraria quotata al mondo diventerà anche il più grande produttore di rame al mondo.</p>
<p>Completando questa transazione si attiveranno anche ulteriori attività di fusione e acquisizione nell’industria mineraria globale. Poiché l’azienda sta esaminando i suoi asset per aumentare l’esposizione ai metalli considerati cruciali per la transizione energetica, vi è stata una quantità significativa di attività di fusione e acquisizione nell’industria.</p>
<p>In una settimana di ricchi rapporti finanziari, le aziende del settore tecnologico sono diventate il centro dell’attenzione del mercato. Tuttavia, i rapporti finanziari di diverse aziende di primo piano non sono ottimisti. Il prezzo delle azioni di Meta (META.O) è sceso del 15%, e la casa madre di Instagram ha previsto entrate inferiori alle attese e spese in aumento per il trimestre, portando a un peggioramento del sentiment di mercato e innescando una vendita massiccia di azioni tecnologiche statunitensi e azioni correlate alla tecnologia. Alphabet, Microsoft e Intel presenteranno i loro rapporti più tardi giovedì.</p>
<p>Oltre ai profitti delle aziende, gli investitori presteranno attenzione anche ai dati sul PIL del primo trimestre degli Stati Uniti, pubblicati giovedì, e ai dati sulla spesa personale di marzo, pubblicati venerdì. Il mercato prevede una probabilità del 70% di un taglio dei tassi a settembre.</p>
<p>Il calo delle azioni tecnologiche ha influenzato anche i mercati azionari asiatici, con l’indice azionario MSCI Asia Pacific, il più ampiamente utilizzato al di fuori del Giappone, che è sceso dello 0,7%. L’indice giapponese Nikkei è sceso dell’1,3%, il mercato azionario cinese è anch’esso sceso, le azioni blue chip come l’indice CSI 300 sono scese dello 0,3% e l’indice Hang Seng di Hong Kong (.HSI) è sceso dello 0,5%.</p>
<p>Il tasso di cambio yen giapponese/dollaro USA è sceso sotto i 155 dollari per la prima volta dal 1990, suscitando preoccupazioni sull’intervento di Tokyo. Il governatore della Banca del Giappone, Kazuo Ueda, ha dichiarato in un seminario tenutosi a Washington la scorsa settimana che, indipendentemente dalla situazione economica, la Banca del Giappone inizierà alla fine a ridurre il suo bilancio e introdurre questo processo. Tuttavia, Ueda ha sottolineato che la Banca del Giappone non cambierà significativamente il ritmo degli acquisti di obbligazioni per il momento, né utilizzerà le dimensioni degli acquisti di attività come strumento di politica monetaria.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono leggermente diminuiti a causa delle preoccupazioni per un potenziale rallentamento dell’economia statunitense, superando le preoccupazioni per il rischio di conflitti in escalation in Medio Oriente. Il petrolio greggio statunitense è sceso a $82,74 al barile, mentre il petrolio greggio Brent è sceso a $87,99 al barile.</p>
<p>Il prezzo dell’oro spot è salito a $2,320.32 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, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>