UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIzIHwgTWVyY2F0byBjb21wbGVzc2l2byBpbiByaWJhc3Nv

<p><img src="https://gimg2.gateimg.com/image/article/1741917881weeklyweb3research.webp" alt=""></p>
<h2 id="h2-Panoramica20settimanale20delle20tendenze809174"><a name="Panoramica settimanale delle tendenze" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica settimanale delle tendenze</h2><p>L’economia macroeconomica e il vertice della Casa Bianca hanno influenzato il complessivo <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato criptovalute</a>, che ha aperto in alto e è terminato in basso questa settimana, mostrando un trend al ribasso relativamente evidente. I fattori esterni di notizie erano complicati, il che ha diluito l’effetto positivo dell’annuncio di Trump della riserva di guerra criptata della settimana scorsa e ha portato effetti avversi al <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a>, in particolare le altcoin. Anche se il mercato nel complesso è stato in ribasso per la maggior parte del tempo di recente, le prestazioni delle principali criptovalute sono comunque relativamente resilienti e non c’è stato un declino su larga scala come per le altcoin.</p>
<p>In generale, la tendenza di mercato è stata principalmente volatile e al ribasso per la maggior parte della settimana, e il valore complessivo del mercato è diminuito anche. Il sentiment di mercato è rimasto intorno al 20 per una settimana. Vicino all’ora di chiusura della settimana, la maggior parte delle principali criptovalute ha mantenuto un continuo lieve calo e non vi è alcun segno di ripresa nel mercato complessivo.</p>
<p>La maggior parte delle criptovalute principali ha mostrato un trend al ribasso questa settimana, principalmente con continui declini a breve termine. Al momento, la possibilità di ripresa del mercato nel breve termine è bassa e è fortemente influenzata dall’economia macro. Allo stesso tempo, i cambiamenti nei fattori di politica esterna sono più critici per le variazioni di mercato.</p>
<p>Questa settimana, il prezzo del BTC è sceso significativamente ed è ora nell’intervallo di $80,600 di nuovo. C’è ancora il rischio di ulteriori cali. Se scende sotto il prezzo chiave di $75,000, c’è la probabilità di un calo compensativo, che porterà a liquidazioni su larga scala. Il punto più basso del BTC è intorno a $76,000 e quello più alto è intorno a $84,000.</p>
<p>Il trend del prezzo dell’ETH è simile a quello del BTC, con un declino relativamente più ampio. Il punto più alto della settimana era intorno a $2,142 e il punto più basso era intorno a $1,792. I trend dei prezzi delle principali criptovalute hanno mostrato principalmente un trend continuo al ribasso, e il mercato lento si è intensificato. Il valore di mercato complessivo del <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato crittografico</a> è sceso significativamente, raggiungendo circa $2.63 trilioni, un calo del 1.53% in 24 ore.</p>
<p>Il calo generale del mercato delle criptovalute questa settimana si è intensificato rispetto alla settimana scorsa, e il sentiment depresso è diventato più serio a causa delle notizie. Il prezzo attuale del BTC si aggira intorno a $80,500, mentre il prezzo attuale dell’ETH si mantiene intorno a $1,800.</p>
<p>Il mercato delle criptovalute è in un trend al ribasso questa settimana e le principali monete mancano di segnali di rialzo efficaci. La top coin con il maggior aumento è TIA, ma l’incremento effettivo è ancora limitato, raggiungendo circa l’8,13% in una settimana, il che manca di significato di riferimento pratico.</p>
<p>Il mercato delle criptovalute è previsto che esperimenterà piccole oscillazioni questo fine settimana, con un’alta probabilità di ulteriore declino.</p>
<h2 id="h2-Mercato20delle20criptovalute273920"><a name="Mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato delle criptovalute</h2><p>🔥Secondo i dati di Alternative.me, l’indice di panico e avidità delle criptovalute è sceso a 20 lunedì, passando da panico a panico estremo, e questo sentimento è continuato fino alla chiusura della settimana.</p>
<p>🔥The U.S. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il mercato degli spot ETF ha registrato deflussi per quattro settimane consecutive. Secondo Farside Investors, i maggiori deflussi settimanali dagli ETF nella settimana che è terminata il 7 marzo includevano: Fidelity Smart Origin <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il fondo (FBTC) ha avuto un deflusso netto di $201 milioni, che è stato il sesto consecutivo di deflussi settimanali.</p>
<p>🔥Secondo Cointelegraph, Iliya Kalchev, analista di Dispatch presso la piattaforma di investimento in asset digitali <a href="/price/nexo-nexo" rel="nofollow noopener noreferrer" target="_blank">Nexo</a>, ha detto che <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> i prezzi continueranno a essere sotto pressione dagli sviluppi macroeconomici e dalle questioni commerciali globali. La prossima settimana, tutti gli occhi saranno puntati sui principali eventi economici negli Stati Uniti, tra cui l’Indice dei Prezzi al Consumo, che ci si aspetta segni un rallentamento dell’inflazione. Il rapporto sulle vacanze di lavoro sarà un indicatore chiave della forza del mercato del lavoro e del potenziale per tassi di interesse più bassi.</p>
<p>Il CEO di 🔥First Digital ha affermato che la priorità degli Stati Uniti per <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> come riserva consolidi il suo status di oro digitale e stabilisca un precedente per accelerare lo sviluppo di quadri normativi e promuovere l’adozione istituzionale a livello mondiale.</p>
<p>🔥I dati on-chain mostrano che il 10 marzo il governo salvadoregno ha aumentato il proprio portafoglio di 5 BTC (415.000 dollari) e ora il suo totale raggiunge 6.111 BTC, del valore di 492,5 milioni di dollari.</p>
<p>🔥Julio Moreno, capo della ricerca presso CryptoQuant, ha scritto sull’X platform del perché il prezzo del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> sia diminuito. In poche parole, la crescita della domanda di Bitcoin spot si sta riducendo, mentre le posizioni corte del Bitcoin dominano il mercato dei futures.</p>
<p>🔥Secondo Cointelegraph, il progetto di criptovaluta della famiglia Trump WLFI ha annunciato in precedenza una partnership con Sui Network e pianifica di includere i token SUI nella sua riserva strategica di token “Macro Strategy”.</p>
<p>🔥Secondo Crypto.news, i dati di CryptoSlam mostrano che il volume delle transazioni NFT è cresciuto fino a $121.5 milioni questa settimana, un aumento del 15.27% rispetto alla settimana precedente.</p>
<p>🔥Secondo News.Bitcoin, il valore di mercato complessivo delle stablecoin è aumentato di $7.7 miliardi a febbraio, evidenziando la crescente domanda di “dollari digitali” nel mercato crittografico. La situazione principale del mercato delle stablecoin a febbraio è stata: il valore di mercato di USDS è aumentato del 64%; il valore di mercato di PYUSD è aumentato del 49%; il valore di mercato di USDT ha raggiunto circa $143 miliardi (un aumento di $2.5 miliardi solo a febbraio); il valore di mercato di USDC è aumentato del 7%.</p>
<p>🔥Secondo DL News, il direttore degli investimenti di Bitwise, Matt Hougan, ha dichiarato in una nota di investimento questa settimana che Trump ha cambiato le regole del gioco nel mercato crittografico. Stabilire una riserva crittografica strategica negli Stati Uniti scatenerà un effetto domino e sarà considerato il primo colpo in una corsa agli armamenti di Bitcoin. Honduras, Messico o Guatemala stanno osservando le strategie di Bitcoin degli Stati Uniti e di El Salvador. Tutti i paesi potrebbero promuovere Bitcoin affinché diventi un importante asset monetario globale.</p>
<p>🔥Il partner di eGirl Capital, Degen Spartan, ha condiviso le sue opinioni sui social media, citando la classificazione dell’esperto di investimenti Charles D. Ellis, che considera l’investimento moderno come un “gioco da perdenti”, dove la vittoria dipende dal commettere meno errori.</p>
<p>🔥L’analista DeFi Adaora Favour Nwankwo ha scritto sulla piattaforma X: la tendenza del prezzo del Bitcoin è strettamente correlata agli indicatori economici degli Stati Uniti. La seguente è uno scenario possibile: Se si verifica una recessione, il potenziale calo massimo del Bitcoin è di circa $50.000; se non c’è una recessione, ci si aspetta che il prezzo minimo sia compreso tra $70.000 e $75.000.</p>
<p>🔥Secondo Walter Bloomberg, l’analista di Deutsche Bank Marion Laboure ha detto che la volatilità delle criptovalute potrebbe rimanere alta in assenza di dettagli chiari sul piano di riserva di Bitcoin di Trump.</p>
<p>🔥Michael Saylor, fondatore di Strategy, ha suggerito che il governo degli Stati Uniti acquisisca il 25% dell’offerta totale di Bitcoin entro il 2035 per stabilire una riserva strategica di Bitcoin.<br>BTC Inc. CEO David Bailey, uno dei dozzine di insider invitati al recente summit crittografico di Trump, ha suggerito sui social media che le due idee del presidente potrebbero essere combinate per aumentare le riserve di criptovalute senza spendere un centesimo.</p>
<p>🔥L’analista ha sottolineato che la Fed si trova ora di fronte a un ambiente politico difficile. Se da un lato la debolezza della crescita dell’occupazione supporta il caso per i tagli ai tassi, le preoccupazioni per l’inflazione persistente - specialmente quelle derivanti da vincoli del lato dell’offerta e incertezze geopolitiche - potrebbero spingere la Fed ad agire con cautela, e l’ambiente incerto potrebbe mettere pressione sull’industria crittografica.</p>
<p>I prezzi delle criptovalute hanno continuato a diminuire lunedì, a causa delle crescenti tensioni nella guerra dei dazi e delle aspettative di ulteriori tagli dei tassi di interesse da parte della Federal Reserve che hanno annullato l’effetto positivo di una serie di dichiarazioni a favore delle criptovalute del Presidente degli Stati Uniti Donald Trump della scorsa settimana, secondo quanto riportato da Bloomberg.</p>
<p>🔥Secondo Decrypt, Geoff Kendrick, responsabile globale della ricerca sugli asset digitali presso Standard Chartered, ha suggerito che il governo degli Stati Uniti potrebbe acquistare Bitcoin in diversi modi neutri dal punto di vista di bilancio durante l’attuazione dell’ultimo decreto del Presidente Trump.</p>
<p>L’analista di CoinDesk James Van Straten ha scritto che da quando il Presidente Trump ha preso ufficio il 20 gennaio, il prezzo del Bitcoin è sceso da $109.000 a $80.000, diventando un tipico evento di “vendi sulla notizia”. Questo ritiro è continuato dall’Asset Summit digitale di venerdì. Anche se il trend dei prezzi potrebbe indicare una tendenza ribassista a breve termine, i sostenitori del Bitcoin potrebbero vederlo come un catalizzatore positivo a lungo termine perché il governo degli Stati Uniti è passato dall’atteggiamento ostile dell’amministrazione precedente a una posizione più amichevole.</p>
<p>🔥Secondo The Block, le commissioni totali generate dalle <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> la scorsa settimana la rete è stata di soli 53.800 SOL, il livello più basso dal settembre 2024 e un calo del 10% rispetto alla settimana precedente.</p>
<p>🔥Singapore Exchange Ltd. plans to launch Bitcoin perpetual futures, Bloomberg reported, a move by traditional exchanges to move deeper into the crypto derivatives market.</p>
<p>🔥Geoff Kendrick, capo della ricerca sugli asset digitali presso la Standard Chartered Bank, ha dichiarato che le recenti fluttuazioni di prezzo di Bitcoin sono coerenti con le prestazioni di asset rischiosi come le “Big Seven U.S. Stocks” piuttosto che con un problema legato alla criptovaluta stessa.</p>
<p>🔥L’analista di ricerca 10X Markus Thielen ha detto: Ora non è il momento di comprare durante i cali perché BTC potrebbe scendere fino alla fascia dei $73,000.</p>
<p>🔥Secondo Nate Geraci, presidente di The ETF Store, Franklin Templeton, che gestisce più di $1.5 trilioni di asset, si è ufficialmente unito a Gate <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Concorrenza ETF.</p>
<p>🔥Secondo lo sviluppatore di ckpool Dr-ck, un minatore ha minato con successo il blocco Bitcoin 887212 su solo.ckpool.org utilizzando un minatore Bitaxe da 480GH con solo 3.3TH di hashrate.</p>
<p>🔥Secondo The Block, StarkWare ha annunciato di aver istituito una “riserva strategica di Bitcoin” e deterrà un importo crescente di fondi nel suo tesoro sotto forma di BTC.</p>
<p>🔥Secondo The Block, Pierre Gramegna, presidente del Meccanismo di stabilità europeo (ESM), ha dichiarato in conferenza stampa dopo la riunione dell’Eurogruppo di lunedì che il supporto del governo degli Stati Uniti sotto la guida del Presidente Trump alle criptovalute potrebbe minare l’autonomia monetaria dell’Europa.</p>
<p>🔥 Clearstream, il braccio di compensazione di Deutsche Börse, ha annunciato che fornirà servizi di regolamento e custodia crittografici ai clienti istituzionali entro la fine di quest’anno.</p>
<p>🔥Arthur Hayes ha twittato che Bitcoin (BTC) è un globale 24⁄7mercato, con transazioni illimitate, non può essere emesso in eccesso, il fallimento significa bancarotta o liquidazione, e le finanze di nessun paese dipendono dall’aumento del BTC.</p>
<p>🔥Secondo Decrypt, le autorità californiane hanno intensificato la loro azione contro le frodi nel settore delle criptovalute, chiudendo 26 siti web fraudolenti e rivelando che i consumatori hanno perso più di $4.6 milioni nel 2024.</p>
<p>🔥Secondo CoinDesk, il recente calo del mercato delle criptovalute ha causato la perdita del suo primato della scommessa opzioni Bitcoin da $120.000, una volta popolare, ed è stata sostituita da una chiamata opzione da $100.000, indicando che i trader stanno rivalutando le loro aspettative rialziste.</p>
<p>🔥Come riportato da Cointelegraph, le ultime tariffe di rappresaglia dell’UE hanno aumentato l’incertezza macroeconomica, spingendo gli analisti crittografici a prevedere che <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo Bitcoin</a> la volatilità aumenterà e potrebbe scendere al di sotto del livello chiave di supporto di $75.000.</p>
<p>🔥Secondo The Block, i termini legati alla blockchain nei documenti della Securities and Exchange Commission (SEC) degli Stati Uniti hanno raggiunto un livello record a febbraio, con il database EDGAR che registra più di 5.000 menzioni correlate, mostrando un continuo trend al rialzo dal 2023.</p>
<p>🔥 Secondo Decrypt, il team di ricerca di Socket ha scoperto in un nuovo attacco che il gruppo di hacker nordcoreano Lazarus era collegato a sei nuovi pacchetti npm dannosi che hanno cercato di installare backdoor per rubare le credenziali dell’utente.</p>
<p>🔥Stark Bank SA, una banca online brasiliana sostenuta da Bezos Expeditions, si sta posizionando come il fornitore di servizi bancari preferito per le startup criptate del paese, scommettendo che quest’area, esclusa dai tradizionali prestatori, favorirà la crescita, secondo Bloomberg.</p>
<p>🔥La rappresentante del Massachusetts Kate Lipper-Garabedian ha presentato un disegno di legge che propone la creazione di un comitato speciale composto da membri della legislatura statale per indagare sulle questioni legate alla blockchain e alle criptovalute.</p>
<p>🔥Hyperliquid ha pubblicato sulla piattaforma X: Riguardo ai commenti e alle domande riguardanti il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> posizione lunga dell’utente 0xf3f4, con la presente precisiamo: non c’è stata nessuna sfruttamento di vulnerabilità del protocollo o attacco hacker. L’utente aveva profitto e perdita non realizzati (PNL), e poi ha prelevato contanti, causando il calo del suo margine e la chiusura forzata della sua posizione.</p>
<p>🔥La giornalista di Fox Business News, Eleanor Terrett, ha pubblicato sulla piattaforma X che due fonti affidabili hanno rivelato che la causa tra la Securities and Exchange Commission (SEC) degli Stati Uniti e Ripple sta volgendo al termine e potrebbe concludersi presto.</p>
<p>🔥Secondo Cryptonews, l’Autorità olandese per i mercati finanziari (AFM) ha multato la piattaforma online di trading di criptovalute e azioni BUX con 1,6 milioni di euro per aver violato le normative del settore attirando nuovi clienti attraverso influencer finanziari e programmi di referral.</p>
<p>🔥Secondo il sito ufficiale, il 99,2% delle 5% azioni aggiuntive (5 miliardi di token) del progetto criptato di Trump WLFI è stato venduto. Secondo le notizie precedenti, il prezzo della fornitura aggiuntiva del 5% del progetto criptato di Trump WLFI è salito a $0.05, mentre il prezzo della precedente tornata era solo $0.015.</p>
<p>🔥Santiment ha pubblicato sulla piattaforma X che il volume complessivo degli scambi del mercato delle criptovalute è continuato a diminuire dal picco del volume degli scambi del 27 febbraio (quando i trader hanno comprato in modo ottimistico durante i ribassi). Dopo ulteriori cali nelle ultime due settimane, il comportamento dei trader ha mostrato stanchezza, disperazione e cedimento. Quando il volume degli scambi delle principali criptovalute continua a diminuire, anche durante una piccola ripresa dei prezzi, di solito significa che l’entusiasmo dei trader si è indebolito.</p>
<h2 id="h2-Regulatory20amp20Macro20Policies814772"><a name="Regulatory &amp; Macro Policies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regulatory &amp; Macro Policies</h2><p>🔥Il tanto atteso Vertice criptato della Casa Bianca è concluso, ma i risultati hanno deluso i trader di criptovalute e non sono riusciti a innescare il mercato caldo previsto dal mercato. Rispetto a Bitcoin, le altcoin come Ripple, <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> e SOL sono crollati bruscamente. I risultati del vertice sono stati relativamente deludenti, con solo un impegno a sviluppare un quadro legislativo per le stablecoin entro agosto e garanzie di misure regolamentari più distese. Queste misure non sono riuscite a accendere il sentiment di mercato come previsto.</p>
<p>🔥Secondo Cointelegraph, il Senato dello Utah ha approvato il disegno di legge HB230 “Modifica sull’Innovazione Blockchain e Digitale”, ma ha eliminato la clausola che originariamente consentiva al tesoro dello stato di investire in Bitcoin. Il disegno di legge è stato approvato con un voto di 19-7-3 e sarà presentato al governatore Spencer Cox per essere firmato in legge.</p>
<p>Il presidente statunitense Trump ha firmato un ordine esecutivo per istituire una riserva strategica di Bitcoin e una riserva separata di asset digitali. A tal proposito, Zach Pandl, responsabile della ricerca presso Grayscale Investments, ritiene che Bitcoin non abbia bisogno delle riserve strategiche degli Stati Uniti per apprezzarsi ulteriormente quest’anno. Si aspetta che, con l’aumento del tasso di adozione, il prezzo di Bitcoin continuerà a salire. Allo stesso tempo, Bitcoin inizierà a svolgere un ruolo come mezzo di conservazione del valore quest’anno, soprattutto in mezzo alle preoccupazioni che la politica tariffaria di Trump possa far aumentare nuovamente l’inflazione.</p>
<p>🔥Secondo Bitcoin.com, il disegno di legge SB 21 precedentemente approvato dal Senato del Texas è attualmente in attesa di approvazione da parte della Camera dei Rappresentanti. Il disegno di legge SB 21 stabilisce che verrà creato un fondo gestito dal governo statale per detenere Bitcoin e altre criptovalute.</p>
<p>🔥Secondo Cointelegraph, il Dipartimento degli Alloggi e dello Sviluppo Urbano degli Stati Uniti (HUD) sta considerando di sperimentare blockchain e stablecoin in alcune delle sue funzioni.</p>
<p>🔥Secondo CoinDesk, il regolatore finanziario della Thailandia, la Commissione per i Valori Mobiliari e lo Scambio (SEC), sta ampliando la sua lista di criptovalute approvate per includere due importanti stablecoin, l’USDT di <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> e l’USDC di Circle, come coppie di trading su scambi di asset digitali.</p>
<p>🔥Secondo Bitcoin.com News, le Isole Cayman hanno aggiornato il loro quadro normativo criptato e formulato nuove normative per il rilascio di licenze, che entreranno in vigore il 1 aprile 2025. Secondo il Regolamento del 2025 sugli Attività Virtuali (Fornitori di Servizi) (Modifica), tutte le entità che forniscono servizi di custodia di attività virtuali e piattaforme di trading dovranno ottenere una licenza rilasciata dall’Autorità Monetaria delle Isole Cayman (CIMA). I fornitori di servizi di attività virtuali esistenti (VASP) devono presentare una domanda di licenza entro 90 giorni dalla data di entrata in vigore.</p>
<p>🔥 Secondo CoinDesk, El Salvador ha raggiunto un accordo di cooperazione con il Paraguay sulla regolamentazione delle criptovalute. Questo è il secondo accordo internazionale sulla regolamentazione delle criptovalute firmato dal paese in tre mesi, e un accordo simile è stato raggiunto con l’Argentina.</p>
<p>I documenti della SEC degli Stati Uniti mostrano che la Securities and Exchange Commission degli Stati Uniti (SEC) ha rinviato l’approvazione di diverse domande di ETF spot criptovalutari, compreso Grayscale Spot <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> (ADA) ETF, Canary Spot <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> ETF, Canary Spot <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ETF, Spot Canary <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> ETF e Spot VanEck <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ETF.</p>
<p>🔥Secondo IBTimes, la Securities and Exchange Commission degli Stati Uniti (SEC) valuterà una proposta per determinare la definizione di “exchange” al fine di stabilire se la definizione possa essere modificata per escludere entità o aziende che consentono il trading di criptovalute, segnando un’altra svolta nella nuova strategia della SEC per affrontare criptovalute e asset digitali.</p>
<p>🔥Secondo Cointelegraph, la senatrice statunitense Cynthia Lummis ha presentato nuovamente il Bitcoin Act (Boosting Innovation, Technology, and Competitiveness through Optimized Investment Nationwide Act of 2025) al 119° Congresso. Il disegno di legge permetterà al governo degli Stati Uniti di detenere più di 1 milione di bitcoins.</p>
<p>🔥Secondo The Block, l’autorità di regolamentazione finanziaria della Corea del Sud ha annunciato mercoledì che prevede di rilasciare linee guida complete per gli investimenti crittografici istituzionali nel terzo trimestre.</p>
<p>🔥Secondo l’annuncio ufficiale, la Banca Centrale della Russia, in conformità con le istruzioni del Presidente russo, ha presentato al governo una proposta sulla regolamentazione degli investimenti criptati per la discussione. La proposta suggerisce di consentire a un gruppo limitato di investitori russi di comprare e vendere criptovalute.</p>
<p>🔥Le autorità indiane hanno recentemente arrestato Aleksej Bešciokov, il co-fondatore dello scambiador criptato sanzionato Garantex, che ha elaborato più di $60 miliardi in flussi di capitale illeciti dal suo istituzione nel 2019.</p>
<p>🔥La Securities and Exchange Commission (SEC) degli Stati Uniti ha rinviato la sua decisione su diverse domande di spot crypto ETF, tra cui <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> (SOL), <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> (DOGE), e <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> (LTC).</p>
<h2 id="h2-Evidenziazioni20del20mercato20delle20criptovalute932639"><a name="Evidenziazioni del mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Evidenziazioni del mercato delle criptovalute</h2><p>⭐️La scorsa settimana, il declino del mercato delle criptovalute si è ulteriormente intensificato. Impattati dalla macroeconomia e dal vertice della Casa Bianca, fattori esterni come il mercato azionario statunitense hanno continuato a cadere anche nella scorsa settimana, il che ha influito sul mercato delle criptovalute e ha causato un ulteriore calo complessivo del mercato. La maggior parte delle criptovalute principali ha mostrato un trend al ribasso continuo nella scorsa settimana. Complessivamente, la possibilità di un rapido recupero del mercato nel breve termine è bassa nel prossimo futuro e si prospetta ancora un trend al ribasso per il futuro.</p>
<p>⭐️Questa settimana, l’aumento del TIA nel mercato delle criptovalute si è classificato al primo posto tra le monete tradizionali, ma in realtà l’aumento della moneta non ha raggiunto un livello elevato. L’aumento effettivo delle monete tradizionali è stato di circa l’8%. Dopo il calo di inizio settimana, lo slancio di ripresa a breve termine della moneta non è stato forte. Il prezzo attuale è rimasto intorno ai 3,4 dollari. Ha mostrato una tendenza di fluttuazione continua relativamente evidente e c’è ancora una certa tendenza al ribasso.<br><img src="https://gimg2.gateimg.com/image/article/17419182701.jpeg" alt=""></p>
<h2 id="h2-BTC20amp20ETH20Prestazioni20Settimanali531934"><a name="BTC &amp; ETH Prestazioni Settimanali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC &amp; ETH Prestazioni Settimanali</h2><h3 id="h3-Bitcoin20BTC391629"><a name="Bitcoin (BTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC)</h3><p><img src="https://gimg2.gateimg.com/image/article/17419182912.jpeg" alt=""><br>(Dati Cortesia Di TradingView)</p>
<p>Questa settimana, il prezzo del BTC è stato in continuo calo dall’apertura. Poiché il vertice della Casa Bianca non ha portato l’effetto atteso, il mercato è sceso di conseguenza. Inoltre, il calo del mercato azionario statunitense ha reso il calo del prezzo del BTC più evidente. Tuttavia, questo calo ha avuto un impatto complessivo sul mercato, ma il prezzo del BTC è relativamente forte. Il suo prezzo non è sceso al di sotto del prezzo chiave di $75.000, e c’è stata una leggera ripresa in seguito. Il prezzo del BTC è tornato di nuovo sopra gli $80.000, ma c’è comunque la possibilità di ulteriori cali. Le performance successive dei prezzi del BTC dipendono dai cambiamenti generali del trend di mercato, dai fattori macroeconomici e politici.</p>
<h3 id="h3-Ethereum20ETH461396"><a name="Ethereum (ETH)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum (ETH)</h3><p><img src="https://gimg2.gateimg.com/image/article/17419183263.jpeg" alt=""><br>(Dati Cortesia Di TradingView)</p>
<p>Il trend dei prezzi dell’ETH di questa settimana è simile a quello del BTC, che è anche fortemente influenzato da fattori esterni di notizie. Tuttavia, le prestazioni dei prezzi non sono così forti come per il BTC. Dopo il rapido calo dei prezzi, non c’è un recupero evidente, e sostanzialmente oscilla nell’intervallo di $1,800-$1,900. Il prezzo dell’ETH si attesta intorno a $1,850, e continua a salire e scendere in un piccolo range. Il punto più alto del prezzo dell’ETH nella settimana è di circa $2,200 durante il periodo di apertura. Si prevede che ci sarà una nuova fase di fluttuazioni dei prezzi durante il fine settimana, e la probabilità di ulteriori ribassi è relativamente alta.</p>
<h2 id="h2-Tendenza20del20Progetto20Web3896665"><a name="Tendenza del Progetto Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenza del Progetto Web3</h2><p>Questa settimana, il valore di mercato totale dei sette tipi di progetti è diminuito in generale. Il trend al ribasso della maggior parte dei settori si è ulteriormente intensificato e sono più comuni forti cali. Il mercato nel complesso è stato fortemente influenzato dai fattori di novità e dall’economia macro recentemente, ed è probabile che continui a diminuire nel breve termine.</p>
<table>
<thead>
<tr>
<th>Categoria del progetto</th>
<th>Variazione a 7 giorni</th>
<th>Top 3 Guadagni</th>
<th>Commento</th>
</tr>
</thead>
<tbody>
<tr>
<td>Layer 1</td>
<td>-11.9%</td>
<td>KTA,SOUL,ZTH</td>
<td>Il valore di mercato totale del settore Layer 1 è diminuito bruscamente. La distribuzione della crescita delle principali monete è stata relativamente simile, mantenendo una distribuzione dinamica intorno al 50%, e la maggior parte dei progetti nel settore erano in tendenza al ribasso.</td>
</tr>
<tr>
<td>Layer 2</td>
<td>-13.9%</td>
<td>LAI, OPAI, ISLM</td>
<td>Il segmento Layer 2 ha continuato a declinare e il declino si è ulteriormente intensificato. Tra le principali criptovalute in aumento, LAI ha ottenuto il miglior rendimento, con un forte incremento per due settimane consecutive. Le altre criptovalute hanno registrato incrementi minori e il mercato complessivo ha mantenuto un trend al ribasso.</td>
</tr>
<tr>
<td>DeFi</td>
<td>-15.0%</td>
<td>DEPAY, PRISMA, TERMINAL</td>
<td>Il valore di mercato totale del settore DeFi è diminuito significativamente ed è in un trend continuo al ribasso complessivamente. Anche i guadagni delle migliori criptovalute sono relativamente limitati.</td>
</tr>
<tr>
<td>NFT</td>
<td>-17.3%</td>
<td>XED,$RAINI,RMV</td>
<td>Il valore totale del mercato degli NFT ha subito un significativo calo. Le principali criptovalute in aumento erano principalmente criptovalute non mainstream e la distribuzione dei guadagni era estremamente disomogenea.</td>
</tr>
<tr>
<td>MEME</td>
<td>-18.6%</td>
<td>ANTI,CATEX,FOFAR</td>
<td>Il trend al ribasso della traccia della criptovaluta MEME si è ulteriormente intensificato, ma l’incremento delle prime criptovalute in aumento ha comunque raggiunto il 1000%. Tuttavia, la situazione generale di mercato è che la maggior parte delle criptovalute è in un trend al ribasso.</td>
</tr>
<tr>
<td>Staking Liquido</td>
<td>-17.2%</td>
<td>PRISMA, STSOMM, OS</td>
<td>Il trend al ribasso di questo settore si è intensificato e la crescita delle principali criptovalute si è concentrata in singole monete, che sono state fortemente influenzate dai trend delle criptovalute principali.</td>
</tr>
<tr>
<td>AI</td>
<td>-18.6%</td>
<td>LAI,VNTR,TERMINAL</td>
<td>Il tracciato AI ha mantenuto un forte calo, e i guadagni delle principali monete sono rimasti moderati. Il tracciato complessivo è stato influenzato di recente dalle fluttuazioni di mercato, e il recente trend lento continua.</td>
</tr>
</tbody>
</table>
<div class="blog-details-info"><br><div>Autore:<strong>Charles T.</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. 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. Il ri-pubblicare dell'articolo sarà permesso a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>