Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgQml0Y29pbiBzYWxlIHN1bGwnb3R0aW1pc21vIGRlZ2xpIEVURiBzdGF0dW5pdGVuc2ksIGlsIFN1ZGFmcmljYSBzdHJpbmdlIGxlIHJlZ29sZSBzdWkgY3JpcHRvdmFsdXRlOyBMZSBhemlvbmkgZ2xvYmFsaSBzb25vIGNvbnRlbnV0ZSBkdXJhbnRlIGxlIGZlc3Rpdml0w6Agc3RhdHVuaXRlbnN

2023-07-05, 02:10

<p><img src="https://gimg2.gateimg.com/image/article/16885227280705.jpg" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20i20tori20del20Bitcoin20guidano20limpennata20del20mercato20in20vista20del20420luglio20il20Sudafrica20richieder20licenze20per20gli20exchange20di20criptovalute244713"><a name="Riepilogo giornaliero delle criptovalute: i tori del Bitcoin guidano l’impennata del mercato in vista del 4 luglio, il Sudafrica richiederà licenze per gli exchange di criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: i tori del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> guidano l’impennata del mercato in vista del 4 luglio, il Sudafrica richiederà licenze per gli exchange di criptovalute</h2><p>Gli investitori di Bitcoin (BTC) hanno approfittato della scarsa liquidità di mercato in vista della festa del 4 luglio, spingendo il prezzo della criptovaluta a nuovi massimi per l’anno. Lunedì, Bitcoin è salito dell’1,8%, raggiungendo i 31.159 dollari, appena sotto il massimo annuo di 31.410 dollari, anche se martedì è tornato a 30.768 dollari, rappresentando una diminuzione del 1,3%.</p>
<p><strong>Questo aumento è guidato da un rinnovato <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> circa la potenziale approvazione di un fondo negoziato in borsa (ETF) di Bitcoin negli Stati Uniti.</strong> BlackRock ha recentemente presentato documentazione presso la Securities and Exchange Commission (SEC), aggiungendo nuovi dettagli alla sua proposta ETF. Il sentiment di mercato rimane rialzista, con significativi guadagni osservati in aziende legate alle criptovalute come Coinbase e MicroStrategy.</p>
<p><strong>In contrasto con la crescente domanda, l’offerta di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e l’ether (ETH) sugli scambi di criptovalute ha registrato un calo a giugno.</strong> Questo calo è principalmente attribuito alle pressioni regolamentari e alle preoccupazioni per la sicurezza, che spingono gli investitori a preferire la custodia autonoma dei loro asset digitali.</p>
<p>Secondo un rapporto di Goldman Sachs,<br><strong>La fornitura di bitcoin è diminuita del 4%,</strong> raggiungendo il suo livello più basso da novembre 2020. Allo stesso modo,<br><strong>il fornitura di ether è scivolato del 5,8%,</strong> raggiungendo livelli non visti dal maggio 2018. Queste tendenze riflettono la preferenza degli investitori per mantenere i propri asset in modo sicuro, nonché il passaggio al deposito di ether anziché tenerlo passivamente sugli scambi.</p>
<p>I minatori di Bitcoin stanno capitalizzando l’attuale impennata dei prezzi vendendo le loro riserve di criptovaluta. La newsletter di Grayscale di giugno ha evidenziato che la percentuale dei ricavi dei minatori inviati agli exchange ha raggiunto livelli record nelle ultime settimane. Con un rialzo dell’80% del valore di Bitcoin quest’anno, i minatori stanno approfittando delle favorevoli condizioni di mercato.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688523019Untitled 0705 1.png" alt=""><br>Il ricavato del minatore inviato agli scambi ha raggiunto un massimo storico in 3 anni - Dati per Glassnode</p>
<p>Tuttavia, alcuni minatori, specialmente quelli in Texas, Stati Uniti, hanno affrontato sfide a causa di aumenti dei costi energetici e interruzioni durante il calore <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Onde</a>. Inoltre,<br><strong>L’imminente evento di halving nel 2024, che riduce le ricompense per il mining, aggiunge ulteriore pressione alle loro operazioni.</strong></p>
<p>Nel frattempo, Cameron Winklevoss, co-fondatore dell’exchange di criptovalute Gemini, ha presentato una “offerta finale” nelle trattative per la ristrutturazione del debito con Genesis, una società di asset digitali in bancarotta di proprietà di Digital Currency Group (DCG). Winklevoss ha espresso frustrazione per i ritardi di DCG nel rimborsare i creditori di Genesis, compresi i clienti del programma Earn di Gemini, e per il mancato pagamento di 630 milioni di dollari. Winklevoss ha pubblicato una “Lettera aperta a Barry Silbert” su Twitter, delineando un piano per 1,5 miliardi di dollari in pagamenti di tolleranza e nuovi prestiti denominati in dollari, bitcoin ed ether.<br><strong>Il mancato accettazione dell’accordo entro la scadenza del 6 luglio potrebbe comportare cause legali contro DCG e Silbert personalmente, nonché potenziali piani di default e di ripagamento del debito non consensuali.</strong></p>
<p>In un’altra sviluppo correlato, l’Autorità di condotta del settore finanziario del Sudafrica (FSCA) ha annunciato che gli scambi di criptovaluta nel paese devono ottenere le licenze entro la fine del 2023. La FSCA ha già ricevuto circa 20 domande di licenza dall’apertura delle presentazioni, con altre attese entro il termine del 30 novembre. La mancata operatività con una licenza oltre il termine potrebbe portare ad azioni di applicazione della legge, comprese multe o chiusure.</p>
<h2 id="h2-Bitcoin20BTC2030807200132020Outlook20Neutrale291710"><a name="Bitcoin (BTC) $30,807 (+0.13%) - Outlook Neutrale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC) $30,807 (+0.13%) - Outlook Neutrale</h2><p><img src="https://gimg2.gateimg.com/image/article/1688522951Untitled 0705 2.png" alt=""></p>
<p><img src="https://gimg2.gateimg.com/image/article/1688522966Untitled 0705 3.png" alt=""></p>
<p>Come accennato in precedenza questa settimana, c’è stata una struttura di distribuzione che è fallita il 30 giugno entro un arco di tempo di quattro ore. Questo è stato seguito da una struttura di accumulazione che necessitava di ulteriori osservazioni. A partire da mercoledì, la potenziale struttura di accumulazione è ora entrata nella fase di Uptrust Action (UA). Ciò suggerisce che il prossimo movimento previsto, man mano che la domanda diminuisce e il volume diminuisce, è un retest della zona di Selling Climax (SC) tra 30070-29680. Lo scopo di questo retest è stabilire la fase di Secondary Test come un segno di debolezza (stSOW), seguito da ulteriore accumulazione da parte degli Smart Money. È importante notare che il prezzo del BTC potrebbe scendere fino a 29300, che è un livello mensile significativo.</p>
<p><strong>Panoramica:</strong></p>
<ul>
<li><strong><em>Zona di supporto giornaliero più vicina: 30025 - 29475</em></strong></li><li><strong><em>Zona di resistenza giornaliera più vicina: 30690 - 31015</em></strong></li><li><strong><em>Livello chiave: 29300 (Massimo mensile di dicembre 2020)</em></strong></li></ul>
<p><strong>Zone di resistenza quotidiane</strong></p>
<ol>
<li>30690 - 31015</li><li>31530 - 32255</li><li>33100 - 33600</li></ol>
<p><strong>Zone di supporto quotidiano</strong></p>
<ol>
<li>30025 - 29475</li><li>29095 - 28420</li><li>27970 - 27265</li></ol>
<h2 id="h2-Macro20Pausa20festiva20negli20Stati20Uniti20immobili20europei20in20crescita20azioni20asiatiche20con20scambi20contenuti904718"><a name="Macro: Pausa festiva negli Stati Uniti, immobili europei in crescita, azioni asiatiche con scambi contenuti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Pausa festiva negli Stati Uniti, immobili europei in crescita, azioni asiatiche con scambi contenuti</h2><p>Quando gli Stati Uniti sono entrati nella stagione delle vacanze, l’attenzione del mondo si è spostata su Europa e Asia. Il trading nei mercati azionari globali è stato contenuto a causa delle festività del Giorno dell’Indipendenza negli Stati Uniti.</p>
<p>Le azioni immobiliari hanno guidato i guadagni in Europa, con ottime performance di aziende come Castellum AB e Warehouses de Pauw CVA. Anche l’interesse degli investitori è stato stimolato dall’attività di deal, poiché OMV AG con sede a Vienna ha registrato un significativo aumento a seguito di notizie su trattative con Abu Dhabi per stabilire un’azienda chimica e plastica del valore di oltre 30 miliardi di dollari. Tuttavia, le azioni di Casino Guichard-Perrachon SA sono state temporaneamente sospese dopo aver ricevuto offerte dal miliardario ceco Daniel Kretinsky e da un gruppo guidato dal miliardario delle telecomunicazioni Xavier Neil.</p>
<p>In mezzo al sentimento positivo di mercato, le preoccupazioni riguardanti tassi di interesse più alti e un contesto economico impegnativo hanno suscitato cautela tra gli investitori.<br><strong>Gli strategist di Citigroup Inc. e Goldman Sachs Group Inc. hanno messo in guardia sui rischi per le azioni statunitensi, citando una posizione estesa e l’eventuale impatto dell’aumento dei tassi d’interesse.</strong> Questi fattori hanno portato a un approccio più misurato tra i partecipanti al mercato.</p>
<p>Nel settore dell’energia, il Brent si è scambiato vicino a $76 al barile mentre i trader valutavano gli effetti dei tagli alla produzione. L’Arabia Saudita ha confermato la sua intenzione di estendere una riduzione unilaterale dell’offerta di 1 milione di barili al giorno fino ad agosto, come ampiamente previsto dai trader. La Russia ha annunciato anche una riduzione delle esportazioni, mentre l’Algeria ha pianificato tagli più modesti.</p>
<p><strong>Nei mercati asiatici, i future indicano un’apertura al ribasso a seguito della festività statunitense, portando a una negoziazione contenuta.</strong> Le principali valute sono rimaste relativamente stabili. Gli investitori in Asia osserveranno attentamente l’indice dei direttori degli acquisti di Caixin in Cina per avere informazioni sulla salute della seconda economia mondiale. Il mercato azionario cinese ha registrato una performance inferiore rispetto agli indici globali e regionali quest’anno, e la sua valuta ha subito una pressione al ribasso.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688522979Untitled 0705 4.png" alt=""></p>
<p>Guardando avanti,<br><strong>i partecipanti al mercato attendono con ansia il rapporto sugli occupati non agricoli degli Stati Uniti, che fornirà importanti indicazioni sulla traiettoria della politica monetaria.</strong> Questo rapporto, programmato per essere rilasciato venerdì, sarà un evento significativo per i mercati e potrebbe ulteriormente plasmare il sentiment degli investitori.</p>
<div class="blog-details-info"><br><div>Autore: Peter L., Ricercatore di Gate.io<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 ripostaggio dell'articolo 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>