Tm90aXppZSBnaW9ybmFsaWVyZSB8IEJUQyBwcmV2aXN0byBkaSBzdXBlcmFyZSBpICQ2OUssIGlsIHNlbnRpbWVudCBkaSBtZXJjYXRvIGNvbnRpbnVhIGFkIGVzc2VyZSBhdmlkbzsgQmlkZW4gc2kgcml0aXJhIGRhbGxhIGNhbXBhZ25hIHByZXNpZGVuemlhbGUsIGNhdXNhbmRvIGlsIGNyb2xsbyBkZWkgdG9rZW4gY29ycmVsYXRp

2024-07-22, 04:00

<p><img src="https://gimg2.gateimg.com/image/article/17216207121_17.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Si20prevede20che20BTC20superer20i206900020e20il20sentiment20del20mercato20crittografico20continua20a20inclinare20verso20lavidit20Biden20si20ritira20dalla20campagna20presidenziale20il20token20BODEN20scende20del204420RollupFinance20annuncia20che20cesser20le20operazioni20Entrano20in20vigore20leggi20severe20in20Corea20del20Sud20riguardo20agli20scambi20di20criptovalute944677"><a name="Crypto Daily Digest: Si prevede che BTC supererà i $69.000, e il sentiment del mercato crittografico continua a inclinare verso l’avidità; Biden si ritira dalla campagna presidenziale, il token BODEN scende del 44%; Rollup.Finance annuncia che cesserà le operazioni; Entrano in vigore leggi severe in Corea del Sud riguardo agli scambi di criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Si prevede che BTC supererà i $69.000, e il sentiment del mercato crittografico continua a inclinare verso l’avidità; Biden si ritira dalla campagna presidenziale, il token BODEN scende del 44%; Rollup.Finance annuncia che cesserà le operazioni; Entrano in vigore leggi severe in Corea del Sud riguardo agli scambi di criptovalute</h2><p>Prima di tutto, analizziamo l’attività di trading del <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Secondo i dati di Farside Investor, il 19 luglio, l’ETF Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot (GBTC) ha registrato un deflusso di capitale di 20,3 milioni di dollari. Nel frattempo, l’iShares Trust Bitcoin Spot ETF (IBIT) ha ricevuto un afflusso di 116,2 milioni di dollari, il Fidelity Bitcoin Spot ETF (FBTC) ha ricevuto un afflusso di 141 milioni di dollari, il VanEck Bitcoin Spot ETF (HODL) ha ricevuto un afflusso di 41,8 milioni di dollari e il Bitwise Bitcoin Spot ETF (BITB) ha ricevuto un afflusso di 44,6 milioni di dollari.</p>
<p>Con il forte rimbalzo dei prezzi dei token mainstream, l’Indice di Paura e Avidità delle criptovalute ha raggiunto il suo livello di “avidità” più alto da oltre un mese. Ciò corrisponde all’opposto scenario della “paura estrema” della scorsa settimana, rappresentando il punto di vista di mercato dei trader ordinari. Alcuni trader credono che BTC sia destinato a superare il suo massimo storico di $69.000.</p>
<p><strong>Joe Biden si ritira dalla campagna presidenziale, il token BODEN scende del 44%</strong></p>
<p>Il presidente degli Stati Uniti Joe Biden ha annunciato che non cercherà la rielezione alle prossime elezioni presidenziali statunitensi del 2024. Nelle ultime settimane, Biden ha dovuto affrontare crescenti pressioni per ritirarsi dalla corsa, con diversi senatori attuali che gli chiedono di farlo e rapporti che suggeriscono che l’ex presidente Barack Obama lo faccia.</p>
<p>La dichiarazione di Biden, rilasciata domenica, ha affermato che dimettersi è nell’interesse del partito e del paese. Ha dichiarato che avrebbe sostenuto la candidatura del vicepresidente Kamala Harris per il Partito Democratico. Con la diffusione di questa notizia, la criptovaluta Meme coin Jeo Boden è crollata del 44%. Nel frattempo, i token di altri potenziali concorrenti sono aumentati significativamente. In particolare, un meme chiamato Kamala Horris è salito del 52%, mentre il meme Gabin Noosum è salito del 115%.</p>
<p>Relativamente parlando, dopo il ritiro dell’avversario del candidato presidenziale repubblicano Donald Trump, il prezzo dei token che portano il suo nome è aumentato. Doland Tremp è il meme più colpito, con un aumento del 24% dal momento in cui è stata diffusa la notizia.</p>
<p>La scarsa performance di Biden nel dibattito dello scorso mese ha suscitato discussioni sulla possibilità di sostituirlo come candidato presidenziale, e da allora ha affrontato una crescente pressione. Secondo ABC News, importanti democratici, tra cui il leader della maggioranza al Senato Chuck Schumer, hanno chiesto il suo ritiro nella scorsa settimana.</p>
<p>Mentre il Partito Democratico si prepara a eleggere il suo candidato alla presidenza alla prossima Convention nazionale democratica a Chicago, non è attualmente chiaro se il partito seguirà l’esempio di Biden e nominerà Harris. Secondo un contratto di fascia alta di Polymarket, la probabilità che la Vice Presidente Harris diventi candidata è dell’81%, mentre la probabilità che un normale candidato ‘altro’ sia del 12%.</p>
<p><strong>Rollup.Finance annuncia che presto cesserà le operazioni</strong></p>
<p>La piattaforma decentralizzata di trading di derivati Rollup Finance ha annunciato che avrebbe cessato le sue operazioni. Il progetto ha dichiarato su X: “Durante i 16 mesi di operatività continua, abbiamo resistito alla tempesta del mercato orso, aumentato il volume di scambi, mantenuto i trader e portato innovazione attraverso partnership. Tuttavia, a causa della mancanza di risorse zkSync e dell’adeguamento al mercato del prodotto, abbiamo rivalutato la nostra posizione e deciso di compiere questo passo.”</p>
<p>Rollup.Finance indica che gli asset dell’utente sono al sicuro, e l’utente ha un mese per liquidare e prelevare i fondi. Gli ordini non chiusi alla scadenza verranno liquidati automaticamente, e gli utenti interessati avranno un altro mese per prelevare i fondi. La piattaforma chiuderà completamente il 21 settembre 2024, e le relative applicazioni non saranno disponibili. Successivamente, l’email ufficiale, l’account Twitter e i canali di supporto della chat Discord verranno interrotti.</p>
<p>Rollup.Finance esprime la sua più profonda gratitudine agli utenti e agli investitori precoci, e dichiara che alcuni membri del team continueranno a lottare per il futuro decentralizzato di DeFi e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p><strong>Le rigide leggi in Corea del Sud relative agli scambi di criptovalute entrano in vigore</strong></p>
<p>Il 19 luglio sono entrati in vigore nuovi regolamenti dell’agenzia di regolamentazione della sicurezza finanziaria della Corea del Sud. Mirano a proteggere gli utenti dall’acquisto e dalla conservazione di asset crittografici tramite i fornitori di servizi di asset virtuali (VASP).</p>
<p>Secondo una dichiarazione rilasciata dalla Commissione per i servizi finanziari (FSC) della Corea del Sud il 17 luglio, VASP deve prendere diverse misure per garantire la sicurezza delle criptovalute degli utenti. Queste includono l’acquisto di assicurazioni per gli asset crittografici degli utenti per prevenire hacker e attacchi maligni, separare gli asset crittografici dei clienti dagli asset degli scambi e conservare in modo sicuro i depositi dei clienti nelle banche.</p>
<p>VASP deve anche mantenere un certo livello di diligenza dovuta per prevenire il riciclaggio di denaro sulla sua piattaforma e deve segnalare qualsiasi transazione sospetta alle autorità di regolamentazione.</p>
<p>Il documento FSC afferma che VASP dovrebbe sempre mantenere un sistema di monitoraggio delle transazioni sospette e segnalare immediatamente le attività di transazione sospette al Servizio di supervisione finanziaria (FSS).</p>
<p>Gli scambi di criptovalute sudcoreani hanno espresso preoccupazioni su queste normative, ritenendo che possano portare alla rimozione di molti token. Il 3 luglio, Cointelegraph ha riportato che come parte della nuova legge sulla protezione degli utenti di criptovalute, 20 scambi di criptovalute sudcoreani valuteranno un totale di 1.333 criptovalute nei prossimi sei mesi. La Digital Asset Exchange Alliance (DAXA) ha dichiarato che c’è ‘poca possibilità che avvenga una cancellazione su larga scala in una sola volta’.</p>
<p>Nel frattempo, il partito al governo della Corea del Sud, il National Power Party, ha ufficialmente proposto di posticipare l’attuazione della politica del paese di tassare i profitti derivanti dal trading di criptovalute. Il partito sottolinea che l’attuale sentimento nei confronti delle criptovalute si sta deteriorando e che tassare rapidamente gli asset virtuali “non è saggio al momento”.</p>
<h2 id="h2-Tendenze20di20mercato12896"><a name="Tendenze di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato</h2><p>BTC ha brevemente superato i 68.000 dollari stamattina, con afflussi di ETF spot che hanno superato i 2 miliardi di dollari nelle ultime due settimane.</p>
<p>ETH ha superato il livello di $3.500 e si prevede che l’ETF di ETH sarà quotato in borsa a partire dal 23 luglio. Alcune comunità ritengono che potrebbe esserci una tendenza ribassista a breve termine dopo l’approvazione dell’ETF di ETH.</p>
<p>SOL è tornato sopra i $180, e il token Meme rimane il settore più impressionante tra gli Altcoin.</p>
<h3 id="h3-Indicatori20di20dati296580"><a name="Indicatori di dati:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Indicatori di dati:</h3><p>Oggi, l’indice AHR999 è a 0,95, il che indica che il mercato ha superato la zona di fondo e sta gradualmente risalendo. L’indice della paura e dell’avidità è 70 e, rispetto alla paura estrema del prezzo del Bitcoin di $53.500, il sentiment del mercato è entrato in uno stato folle in breve tempo.</p>
<p>L’Indice della Paura e della Pavidità è a 70, e rispetto alla paura estrema al prezzo di BTC di $53.500, il sentiment di mercato è entrato in un frenesia in un breve periodo di tempo.</p>
<h3 id="h3-Macroeconomia951886"><a name="Macroeconomia:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia:</h3><p>Azioni statunitensi: la S&amp;P 500 è scesa dell’1,97% la scorsa settimana, il Nasdaq Composite è sceso del 3,65%, e il Dow Jones Industrial Average è salito dello 0,72%. Giganti tecnologici come Microsoft, Google e Apple hanno tutti registrato significativi cali.</p>
<p>Dinamica politica: Biden annuncia il ritiro, la vicepresidente nera Harris diventerà la candidata presidenziale del Partito Democratico e le possibilità di vittoria di Trump su Polymarket sono scese al 63%.</p>
<h3 id="h3-Punti20Caldi20del20Mercato780692"><a name="Punti Caldi del Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato:</h3><p>BTC: La sostanziale crescita di BTC ha superato i 68000 dollari, a soli 8% dal massimo storico, trainando l’intero mercato. La conferenza Bitcoin Nashville di questa settimana si terrà il 27, e il candidato presidenziale americano Trump parteciperà alla conferenza. Inoltre, l’aereo privato dell’uomo più ricco del mondo, Musk, è atterrato anche a Nashville, e ci sono voci di mercato secondo cui Musk potrebbe partecipare anche alla conferenza Bitcoin. L’immagine del profilo dell’account X di Musk è stata sostituita con un’immagine del profilo degli occhi laser. L’ultima volta che ha cambiato la sua immagine del profilo con questa è stata nell’aprile 2019, dopodiché BTC è entrato in una fase di mercato rialzista.</p>
<p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosistema: SOL torna sopra i $180, trainando la forte performance complessiva dell’ecosistema Solana. WEN, POPCAT, MEW e altre monete Meme a tema gatto hanno registrato un forte aumento. POPCAT sta per diventare la prima moneta Meme a tema gatto a superare la soglia di 1 miliardo di dollari di capitalizzazione di mercato, e MEW ha raggiunto un massimo storico nel weekend. Attualmente, il valore di mercato totale delle monete Meme a tema gatto è di 2,6 miliardi di dollari, mentre il valore di mercato totale delle monete Meme a tema cane è di 39,2 miliardi di dollari.</p>
<h3 id="h3-Sommario670639"><a name="Sommario" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario</h3><p>Nel complesso, il sentiment di mercato è passato dalla paura alla frenesia in un breve periodo, principalmente guidato dalla forte crescita delle valute mainstream come BTC e ETH. Dal punto di vista macroeconomico, nonostante la scarsa performance delle azioni tecnologiche, il mercato delle criptovalute sembra essere stato guidato in modo indipendente, soprattutto dalla prossima conferenza su Bitcoin e dalla potenziale partecipazione di Musk. Nel frattempo, le Meme coin nell’ecosistema <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> hanno ottenuto buoni risultati e sono diventate uno dei punti caldi del mercato.</p>
<p>Gli investitori dovrebbero monitorare le prossime importanti conferenze e quotazioni di ETF, che potrebbero avere un impatto significativo sul sentimento del mercato e sull’andamento dei prezzi. Nel frattempo, è necessario prestare attenzione al rischio di ribasso a breve termine di surriscaldamento del mercato.</p>
<h2 id="h2-Macro20Malfunzionamento20tecnico20globale20Wall20Street20chiude20Dopo20luscita20di20Biden20i20mercati20azionari20asiatici20sono20sotto20pressione163637"><a name="Macro: Malfunzionamento tecnico globale, Wall Street chiude; Dopo l’uscita di Biden, i mercati azionari asiatici sono sotto pressione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Malfunzionamento tecnico globale, Wall Street chiude; Dopo l’uscita di Biden, i mercati azionari asiatici sono sotto pressione</h2><p>Il 19 luglio, il mercato azionario degli Stati Uniti ha continuato a diminuire venerdì, poiché l’incertezza di mercato si è intensificata a causa del continuo caos causato dalle fallimenti tecnologici globali. I problemi tecnici della società di sicurezza informatica Crowdstrike hanno causato interruzioni alle operazioni in molteplici settori, tra cui l’aviazione, la banca e la salute, portando al crollo del sistema operativo Windows di Microsoft. Anche se sono state scoperte e risolte alcune vulnerabilità, alcuni servizi sono ancora interessati.</p>
<p>I tre specifici principali indici: il Dow Jones Industrial Average è sceso del 0,93%, l’indice Standard&amp;Poor’s è sceso del 0,71% e l’indice Nasdaq è sceso dell’0,81%.</p>
<p>Dal punto di vista settimanale, sia il Nasdaq che gli indici S&amp;P 500 hanno registrato la loro peggiore performance settimanale da aprile, mentre l’indice Dow Jones non è riuscito a evitare un calo dopo aver raggiunto un massimo storico all’inizio di questa settimana.</p>
<p>Il 22 luglio, i mercati azionari asiatici hanno aperto al ribasso lunedì, poiché la banca centrale della Cina ha tagliato inaspettatamente i tassi di interesse ma non è riuscita a migliorare il sentiment di mercato. Allo stesso tempo, i futures di Wall Street si sono rafforzati dopo che il presidente degli Stati Uniti Joe Biden ha annunciato il suo ritiro dalla corsa. La People’s Bank of China ha abbassato i tassi di interesse a breve termine di dieci punti base per ridurre i costi dei prestiti a lungo termine e i rendimenti dei bond. In precedenza, Pechino ha pubblicato un documento di politica che illustra il suo piano economico.</p>
<p>L’indice azionario MSCI Asia Pacific è diminuito del 1,0%, l’indice Nikkei in Giappone è diminuito dell’1,1%, l’indice di riferimento in Corea del Sud è diminuito del 1,5% e il mercato azionario di Taiwan è diminuito del 2,4%.</p>
<p>Questa settimana saranno pubblicati diversi importanti dati economici e la Federal Reserve pubblicherà il suo altamente atteso indicatore d’inflazione venerdì, concludendo così la settimana di trading. Si prevede che l’indice di spesa per consumi personali core aumenterà dello 0,1% a giugno, con un tasso annuale leggermente in calo al 2,5%. Il mercato si aspetta che questo getti le basi per un taglio dei tassi a settembre, con i prezzi dei futures che indicano una probabilità del 97% di un taglio dei tassi a settembre. Inoltre, ci si aspetta che il tasso di crescita del PIL nel secondo trimestre aumenti dal 1,4% del primo trimestre a un tasso di crescita annuale del 1,9%.</p>
<p>In termini di materie prime, a causa di fattori geopolitici, i prezzi del petrolio sono leggermente aumentati. Non c’è stato alcun progresso sull’accordo di cessate il fuoco a Gaza a causa dei violenti combattimenti tra l’esercito israeliano e i militanti palestinesi a Rafa. Il greggio Brent è salito di 22 centesimi a 82,85 dollari al barile, mentre il greggio statunitense è salito di 36 centesimi a 80,49 dollari al barile.</p>
<p>Secondo un rapporto pubblicato da Invesco, la competizione geopolitica è diventata la preoccupazione più grande per gli investitori, superando persino l’inflazione. Ciò ha suscitato una preferenza per attività rifugio come l’oro. Il prezzo dell’oro si attesta a $2.407 per oncia, vicino al massimo storico di $2.483,60 stabilito 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. Sarà consentito il riposting dell'articolo a condizione che Gate.io venga citato. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>