Tm90aXppZSBnaW9ybmFsaWVyZSB8IExhIGRlY2lzaW9uZSBkZWxsYSBGZWQgaW5jb21iZSBtZW50cmUgQml0Y29pbiDDqCByaW1hc3RvIHN0YWJpbGUgbm9ub3N0YW50ZSBpIHRhc3NpIGRpIGZpbmFuemlhbWVudG8gbmVnYXRpdmksIEZyYXggdGVybWluYSBsJ2VzcGVyaW1lbnRvIGRpIHN0YWJsZWNvaW4gYWxnb3JpdG1pY28=

2023-03-07, 02:09

<p><img src="https://gimg2.gateimg.com/image/article/16781548700307.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest202020Bitcoin2020Mantiene20la20stabilit20nonostante20i20tassi20di20finanziamento20negativi20la20decisione20della20Fed20determiner20il20futuro20del20mercato588767"><a name="Crypto Daily Digest:   Bitcoin  Mantiene la stabilità nonostante i tassi di finanziamento negativi, la decisione della Fed determinerà il futuro del mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Mantiene la stabilità nonostante i tassi di finanziamento negativi, la decisione della Fed determinerà il futuro del mercato</h2><p>Buongiorno, trader! Affrontiamo questo martedì implacabilmente e ne facciamo il massimo! 🚀</p>
<p>Il recente rally del mercato azionario non è riuscito a sostenersi a causa dei rischi economici e della pressione derivante dall’aumento dei rendimenti del Tesoro. Anche se i fattori tecnici potrebbero fornire un certo supporto nel breve termine, i fondamentali continuano a deteriorarsi. Lo spread tra il debito societario denominato in dollari con rating BBB e gli utili disponibili sull’S&amp;P 500 è ora superiore a zero, segnalando cautela su come possano evolversi gli asset finanziari globali e l’economia. La prossima decisione della Federal Reserve e quattro eventi principali determineranno se la ripresa del 2023 nei titoli azionari sarà bloccata o inizierà a correre di nuovo dopo una flessione a febbraio.</p>
<p>Si prevede un’apertura contenuta dei mercati azionari asiatici a seguito di una debole sessione di trading a Wall Street. Le azioni australiane hanno aperto in ribasso, mentre i futures sull’indice giapponese sono leggermente al ribasso. I futures di Hong Kong hanno registrato un modesto guadagno, nonostante un calo del 1,7% in un indice delle azioni cinesi negoziate negli Stati Uniti. Si prevede che la Reserve Bank of Australia aumenterà il suo tasso di interesse di un altro quarto di punto al 3,60%, prima di raggiungere il picco del 3,85% in aprile. In seguito, il presidente della Fed Jerome Powell inizierà due giorni di testimonianza davanti alle commissioni del Senato e della Camera dei rappresentanti.</p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ed Ether hanno iniziato la settimana scambiando all’interno di un range stretto con poca convinzione in qualsiasi direzione, come riflessi in bassi volumi di scambio. Il sentiment negativo continua a gravare sui mercati a seguito del crollo della base patrimoniale di Silvergate Bank, ma gli investitori stanno rivalutando il rischio invece di abbandonare i mercati. L’attività on-chain implica che la domanda persiste ancora all’interno dello spazio cripto, con <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il volume di trasferimento (BTV) aumenta del 79% anno su anno. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> è salito a un picco di oltre $22.500 lunedì, ma poi è leggermente diminuito e è rimasto in un range stretto da giovedì. Le tassi di finanziamento di BTC ed ETH sono diventati negativi la scorsa settimana, il che è un segnale di sentiment di mercato pessimistico. Tuttavia, la chiusura di Silvergate Exchange Network non ha avuto un impatto significativo sul prezzo di BTC.</p>
<p>Nel frattempo, secondo un rapporto della società di ricerca di mercato Kaiko, ci si aspetta che la decisione di Silvergate Capital di chiudere il suo servizio di regolamento istantaneo aumenti l’importanza delle stablecoin e dei loro emittenti nel trading di criptovalute. Queste stablecoin, come <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Cavezza</a> Le USDT di ‘s e gli USDC di Circle hanno preso il posto delle valute fiat emesse dal governo, come il dollaro statunitense, come pilastro dei mercati crittografici. Il rapporto evidenzia anche il declino del ruolo del dollaro statunitense nel trading crittografico, con i trader che ora scelgono di trasferire fondi agli emittenti di stablecoin per ottenere stablecoin e depositarli sugli scambi. Tuttavia, il rapporto avverte anche che questa spostamento concentra il rischio poiché gli emittenti di stablecoin necessitano ancora di accesso a una banca crittografica.</p>
<h2 id="h2-Argomento20del20giorno202020Frax2020Termina20lesperimento20con20gli20stablecoin20algoritmici896347"><a name="Argomento del giorno:   Frax  Termina l’esperimento con gli stablecoin algoritmici" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Argomento del giorno: <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> Termina l’esperimento con gli stablecoin algoritmici</h2><p><a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a>, una piattaforma di stablecoin decentralizzata, ha preso una decisione significativa di garantire il suo stablecoin FEI con equivalenti in USD, ponendo fine all’esperimento con le stablecoin algoritmiche. Questa mossa ha il potenziale per aumentare la fiducia e la fiducia nelle stablecoin, portando a una maggiore adozione delle applicazioni DeFi. Una stablecoin completamente garantita può anche contribuire a ridurre i rischi per gli investitori mitigando il depegging e la perdita di valore.</p>
<p>Tuttavia, il fallimento delle stablecoin algoritmiche come UST e delle stablecoin sovraccaricate come MIM ha creato una perdita di fiducia nelle stablecoin decentralizzate. Le stablecoin decentralizzate rappresentano solo una piccola percentuale della fornitura totale di stablecoin e i volumi di trasferimento sono diminuiti dal Q3 del 2022, indicando sfide nel guadagnare quote di mercato. Inoltre, i rischi regolamentari, come evidenziato da una recente sentenza della corte in Inghilterra che ha colpito MakerDAO, rimangono una preoccupazione.</p>
<p>Mentre <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> La decisione di di sostenere completamente la sua stablecoin ha implicazioni positive, tuttavia ci sono potenziali sfide da considerare, come ricostruire la fiducia nelle stablecoin decentralizzate e navigare i rischi regolatori.</p>
<h2 id="h2-Frax20Share2020FXS209684200912020Prospettiva20neutra150706"><a name="Frax Share  (FXS) $9.684 (+0.91%) - Prospettiva neutra" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/frax-share-fxs" rel="nofollow noopener noreferrer" target="_blank">Frax Share</a> (FXS) $9.684 (+0.91%) - Prospettiva neutra</h2><p><strong>Panoramica:</strong></p>
<ul>
<li><strong><em>Zona di supporto giornaliero più vicina: 9.392 - 9.020</em></strong></li><li><strong><em>Zona di resistenza giornaliera più vicina: 9,942 - 10,567</em></strong></li><li><strong><em>Livello chiave: 9.392 (Chiusura mensile di maggio 2021)</em></strong></li></ul>
<p><img src="https://gimg2.gateimg.com/image/article/1678154930Untitled0307.png" alt=""></p>
<p>Nonostante abbia registrato un calo di quasi il 20% tra giovedì scorso e domenica, FXS ha dimostrato resilienza mantenendosi sopra il livello mensile di 9,392. Tuttavia, il suo attuale livello di prezzo si avvicina alla parte inferiore della zona d’oro estesa di Fibonacci settimanale, che va da 9,020 a 11,865 ed è stata una zona di consolidamento fondamentale dal breakout del 19 gennaio. Se FXS scende al di sotto del suo attuale livello di prezzo, probabilmente punterà al livello settimanale di 8,160. In alternativa, se FXS risale dal suo attuale livello di prezzo, dovrà affrontare un ostacolo significativo nella zona d’oro giornaliera di Fibonacci, che va da 10,567 a 11,191, e ciò contribuirà a determinare se il recupero è una trappola per i tori.</p>
<p><strong>Zone di resistenza quotidiane</strong></p>
<ol>
<li>9.942 - 10.567</li><li>10.879 - 11.191</li><li>11.865 - 13.210</li></ol>
<p><strong>Zone di supporto giornaliere</strong></p>
<ol>
<li>9.392 - 9.020</li><li>8.309 - 7.925</li><li>7.611 - 7.263</li></ol>
<div class="blog-details-info"><br><div>Autore: <strong> Peter L. </strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Il riposting dell'articolo sarà consentito a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>