Qml0Y29pbiDDqCB1bmEgYnVvbmEgc2NlbHRhIGluIGNhc28gZGkgaW5mbGF6aW9uZSBwZXJlbm5lPw==

2023-03-23, 07:14

<p><img src="https://gimg2.gateimg.com/image/article/1679564895post.jpeg" alt=""></p>
<p>In questo dilemma, la Federal Reserve (Fed) ha scelto la strada della “soppressione dell’inflazione”. Stamattina la Fed ha annunciato un aumento di 25 punti base nel tasso di interesse di riferimento dei fondi federali a un intervallo di target del 4,75% al 5%. Il presidente della Fed, Powell, ha lasciato intendere che gli aumenti dei tassi di interesse sono giunti al termine e potrebbero essere alzati solo una volta quest’anno, ma “non vedremo un taglio dei tassi”. Dopo la diffusione della notizia, banche regionali come la First Republic Bank sono crollate durante la sessione, e i tre principali indici azionari hanno ripreso tutti i loro guadagni giornalieri e li hanno ribaltati. Al momento della chiusura, Bank of America e Wells Fargo sono scese del 3,3%, JPMorgan Chase è scesa di circa il 2,6%, e Goldman Sachs è scesa dell’1,1%. La situazione attuale riflette l’aumento graduale della probabilità di una recessione negli Stati Uniti e l’incerta direzione del mercato. I fondi che avrebbero dovuto tornare potrebbero essere affluiti nell’oro, nelle criptovalute o in altri paesi.</p>
<h2 id="h2-Liperinflazione2020lontana20da20noi531343"><a name="L’iperinflazione è lontana da noi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’iperinflazione è lontana da noi?</h2><p>Quando la quantità di valuta emessa da un paese è superiore alla quantità di valuta in circolazione, ciò porterà ad aumenti dei prezzi, svalutazione della valuta e inflazione. In realtà, il numero di valute in tutto il mondo è aumentato fin dal momento in cui c’è stata una “valuta fiat”. Poiché per promuovere la crescita economica, i paesi emettono moderatamente valuta in eccesso per stimolare il comportamento dei consumatori. Questa è un’infrazione benigna.</p>
<p>L’iperinflazione è uno stato di inflazione incontrollata, con prezzi che aumentano rapidamente e valute che perdono valore. Secondo Wikipedia, l’iperinflazione è generalmente definita come un tasso di inflazione mensile del 50% o più, mentre la maggior parte degli economisti ritiene che “un ciclo di inflazione senza alcuna tendenza equilibrata” sia iperinflazione.</p>
<p>Durante la Prima Guerra Mondiale, quando la Germania fu sconfitta, le autorità e i governi non furono in grado di sostenere le spese finanziarie del trattato di riparazione firmato e dovettero scegliere di emettere una grande quantità di valuta. Nel 1923, le autorità e il governo emisero circa 50 trilioni di marchi (la precedente valuta fiat tedesca), facendo precipitare la Germania nell’abisso dell’iperinflazione. Nel 1914, il tasso di cambio tra il dollaro e il marco era solo di 1:4. Nel novembre 1923, il tasso di cambio tra il dollaro e il marco schizzò a 1:4,2 trilioni di marchi, e un singolo pezzo di pane costava allora 20 milioni di marchi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167955535011.png" alt=""><br>Utilizzare fasci di Mark come giocattolo è molto più conveniente che comprare un giocattolo - Network</p>
<p>C’è anche il Venezuela, che una volta è stato previsto dal Fondo Monetario Internazionale di avere un tasso di inflazione del 1.000.000%. Nel dicembre 2021, il tasso di inflazione del paese ha raggiunto il 686%, e più di 3 milioni di venezuelani hanno lasciato il paese. L’iperinflazione non solo ha portato al collasso del sistema finanziario del paese, ma ha anche causato una crisi umanitaria.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167955539222.png" alt=""><br>Nel agosto 2018, 2.600.000 bolivari sono stati in grado di acquistare un rotolo di carta igienica - Reuters</p>
<h2 id="h2-La20Scatola20Magica20di20Pandora20si20apre20lasciando20gli20Stati20Uniti20in20un20dilemma137776"><a name="La “Scatola Magica di Pandora” si apre, lasciando gli Stati Uniti in un dilemma" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La “Scatola Magica di Pandora” si apre, lasciando gli Stati Uniti in un dilemma</h2><p>Nel marzo 2021, il “piano di salvataggio” del Presidente degli Stati Uniti Biden da 1,9 trilioni di dollari è stato approvato nel Senato, con il contenuto di distribuire $1.400 per ogni cittadino americano idoneo. L’aumento enorme del rendimento dei bond del tesoro decennale USA è in gran parte dovuto all’impatto del piano di salvataggio.</p>
<p>Presto, iniziò un boom economico. Ricchi o poveri, tutti avevano un assegno da consumare. Di conseguenza, un gran numero di depositi affluì nelle banche. Quando alcune banche regionali ottennero un così grande quantità di depositi, avrebbero utilizzato questi depositi per concedere prestiti e aumentare i loro guadagni assumendo certi rischi di credito (il non rimborso da parte dei debitori è chiamato rischio di credito). In generale, la maggior parte delle banche evita il rischio di credito, ma desidera ampliare i propri guadagni. Pertanto, scelgono di prendere in prestito denaro da vari dipartimenti del governo degli Stati Uniti per limitare il rischio e aumentare il reddito degli interessi acquistando obbligazioni con scadenze più lunghe.</p>
<p>A marzo 2022, la situazione dell’inflazione negli Stati Uniti è rimasta incontrollata. La Fed ha aumentato i tassi di interesse dallo 0% al 4,58%, ed è previsto che li alzerà al 5,5% quest’anno. L’aumento dei tassi di interesse della Fed ha portato a una forte svalutazione dei titoli del tesoro americani e dei titoli garantiti da mutui residenziali acquistati dalle banche regionali (come la Silicon Valley Bank), e le banche hanno cominciato a perdere denaro.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167955542333.png" alt=""><br>Dal 2022, la Fed ha aumentato i tassi di interesse al 4,58% - ycharts</p>
<p>Le aziende che prendono in prestito dalle banche non possono permettersi un aumento dei tassi di interesse, quindi devono licenziare in modo significativo. Nel frattempo, poiché è difficile ottenere investimenti dagli investitori, le imprese possono prelevare denaro dai conti bancari solo per mantenere le operazioni, il che ha portato a una crisi di liquidità nelle banche. Alla fine, la crisi di liquidità si è sovrapposta alle perdite, e il risultato sono stati i successivi fallimenti a cui abbiamo assistito qualche tempo fa.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167955545344.png" alt=""><br>Il ciclo di restrizione della Fed è il più rapido mai registrato - NDR</p>
<p>Negli ultimi due anni, le politiche monetarie e fiscali degli Stati Uniti hanno immesso sul mercato una grande quantità di denaro caldo. Ora, il “Vaso Magico di Pandora” è stato aperto. Da un lato, i tassi di interesse non possono essere fermati a causa della necessità di frenare l’inflazione e preservare il valore del dollaro USA; D’altra parte, i rialzi dei tassi di interesse continuano, il che potrebbe causare ulteriori fallimenti bancari, shock di mercato e la crisi finanziaria di nuovo. Come ha scritto Satoshi Nakamoto nella dichiarazione sul blocco Genesis: “Il 3 gennaio 2009, il Cancelliere dello Scacchiere era sul punto di attuare il secondo round di assistenza bancaria di emergenza”. Le istituzioni centrali hanno manipolato l’emissione di valuta per creare una falsa prosperità. Il giorno in cui la bolla era troppo grande, l’economia avrebbe incontrato un “atterraggio duro”. Il prezzo di un “atterraggio duro” è la vita tranquilla che le persone dovrebbero avere.</p>
<h2 id="h2-Is202020Bitcoin2020Una20buona20scelta649977"><a name="Is   Bitcoin  Una buona scelta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Una buona scelta?</h2><p>Dal punto di vista della diversità degli asset, se ci troviamo di fronte “ <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>“ o “Bitmine” o altri asset emergenti con vari nomi oggi, disperdere il nostro capitale di investimento tra diversi asset è un modo efficace per ridurre il rischio. Qui ci concentriamo sulle caratteristiche uniche di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Prima, cerchiamo di immaginare una giornata senza <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> in futuro:</p>
<p>1.Sei stato svegliato dall’allarme alle 7 in punto. Oggi è il giorno del pagamento dell’affitto, ma non riesci a capire perché l’affitto sia aumentato di anno in anno, mentre il tuo stipendio non è mai aumentato.</p>
<ol>
<li><p>Dopo la tua routine mattutina, vai al bar per comprare una tazza di caffè. A questo punto, il prezzo del caffè è già a tre cifre, e sei indeciso. Se bevi questa tazza di caffè, il tuo budget per il pranzo sarà dimezzato.</p>
</li><li><p>Accendi il tuo computer al lavoro e cerchi su Google ‘Come investire e gestire il denaro?’ e ‘Perché i prezzi stanno salendo?’ Trovi che i risultati della ricerca sono pieni di persone che hanno gli stessi dubbi come te, ma poche persone rispondono. In generale, istituzioni centralizzate controllano l’emissione della valuta, e ‘loro’ faranno altrettanto.</p>
</li></ol>
<p>Esiste un profondo senso di impotenza? La valuta fiat è come una corda invisibile che lega le persone all’ordine e non hai altra scelta se non quella di conformarti, perché non c’è altra scelta.</p>
<p>A questo punto, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è apparso. L’emergere di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> non ha cambiato il sistema operativo di questa società, ma hai una scelta. Puoi liberarti dalla manipolazione delle istituzioni centralizzate, perché <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> non è ciò che loro determinano, ma ciò che tutti nel mercato determinano.</p>
<p>Oltre a essere libero dalla manipolazione istituzionale centralizzata, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è un mercato relativamente indipendente e una opzione preferita per tutti gli investitori “indecisi”, che è anche una delle sue caratteristiche di avversione al rischio. Prendendo come esempio la situazione attuale del mercato (la risoluzione sui tassi di interesse della Fed del 22 marzo non è ancora stata resa nota), in questo momento, le aspettative degli investitori sull’aumento dei tassi di interesse della Fed sono caratterizzate da un’incertezza hawkish o dovish, e scommettere su uno dei due lati comporta un alto rischio. Proprio come lanciare i dadi, i dadi sono in uno stato di rotazione e nessuno sa se il risultato finale sarà alto o basso. In questo stato, gli investitori sono più inclini a investire in mercati relativamente indipendenti, come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<h2 id="h2-Sar20una20valuta20digitale20della20banca20centrale20una20scelta20migliore243009"><a name="Sarà una valuta digitale della banca centrale una scelta migliore?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sarà una valuta digitale della banca centrale una scelta migliore?</h2><p>Secondo l’Atlantic Council CBDC Tracker, ad eccezione di due paesi che hanno esplicitamente cancellato i progetti CBDC (Ecuador e Senegal), attualmente ci sono 119 paesi che stanno esplorando o introducendo la valuta digitale della banca centrale (CBDC). Tra di loro, la regione Asia-Pacifico è la regione più prospera, con paesi come Cina, Singapore, Giappone, Corea del Sud, Australia e Russia tutti nello stadio pilota.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167955582766.png" alt=""><br>Origine: Atlantic Council CBDC Tracker</p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L’analista Josef Tětek ritiene che le CBDC abbiano una serie di caratteristiche che interessano all’autoritarismo, in particolare fornendo agli emittenti un controllo diretto sulle valute nazionali digitali, il che consente agli emittenti di imporre arbitrariamente tassi di interesse negativi e persino tassare direttamente i conti delle persone. Nel frattempo, le CBDC possono anche fungere da strumento per monitorare e censurare le persone, e i governanti possono facilmente congelare i fondi delle persone dissenzienti fino a quando non agiscono in modo che soddisfi le aspettative dei governanti.</p>
<h2 id="h2-Per20riassumere347118"><a name="Per riassumere" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Per riassumere</h2><p><em>Quando siamo sotto una pressione enorme per ottenere valuta legale ogni giorno, la valuta si sta comunque svalutando.</em></p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> non crea mai denaro, ma crea invece opportunità di scelta.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Jill Ma</strong>, 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 riutilizzo dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>