SXMgQml0Y29pbiBFZW4gR29lZGUgS2V1emUgQmlqIFZvb3J0ZHVyZW5kZSBJbmZsYXRpZT8=

2023-03-23, 07:14

<p><img src="https://gimg2.gateimg.com/image/article/1679564895post.jpeg" alt=""></p>
<p>In dit dilemma heeft de Federal Reserve (Fed) gekozen voor het pad van ‘inflatie onderdrukken’. Vanochtend kondigde de Fed een verhoging van 25 basispunten aan in het referentiepercentage voor de federale fondsen, tot een streefreeks van 4,75% tot 5%. Voorzitter Powell van de Fed gaf aan dat renteverhogingen ten einde zijn gekomen en dit jaar mogelijk slechts eenmaal zullen worden verhoogd, maar ‘we zullen geen renteverlaging zien’. Na het nieuws daalden regionale banken zoals de First Republic Bank tijdens de sessie en de drie belangrijkste aandelenindexen namen al hun dagelijkse winsten terug en keerden ze om. Bij het sluiten daalde Bank of America en Wells Fargo met 3,3%, JPMorgan Chase met ongeveer 2,6% en Goldman Sachs met 1,1%. De huidige situatie weerspiegelt de geleidelijke toename van de kans op een recessie in de Verenigde Staten en de onzekere richting van de markt. Het geld dat terug had moeten vloeien, kan in goud, cryptocurrencies of andere landen zijn gestroomd.</p>
<h2 id="h2-Is20Hyperinflation20Ver20Van20Ons747901"><a name="Is Hyperinflation Ver Van Ons?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Hyperinflation Ver Van Ons?</h2><p>Wanneer de hoeveelheid valuta die door een land wordt uitgegeven groter is dan de hoeveelheid valuta in omloop, zal dit leiden tot prijsstijgingen, valutaduatie en inflatie. In feite is het aantal valuta’s over de hele wereld toegenomen sinds het moment dat er een “fiatvaluta” was. Omdat landen matig valuta over-uitgeven om consumentengedrag te stimuleren en zo economische groei te bevorderen. Dit is een goedaardige inflatie.</p>
<p>Hyperinflatie is een toestand van ongebreidelde inflatie, waarbij de prijzen snel stijgen en valuta aan waarde verliezen. Volgens Wikipedia wordt hyperinflatie over het algemeen gedefinieerd als een maandelijkse inflatie van 50% of meer, terwijl de meeste economen geloven dat ‘een inflatiecyclus zonder enige gebalanceerde trend’ hyperinflatie is.</p>
<p>Tijdens de Eerste Wereldoorlog, toen Duitsland verslagen was, konden de autoriteiten en regeringen de financiële kosten van het ondertekende herstelverdrag niet betalen en moesten ze ervoor kiezen om een grote hoeveelheid valuta uit te geven. In 1923 gaven de autoriteiten en de regering ongeveer 50 biljoen mark uit (voorheen Duitse fiatvaluta), waardoor Duitsland in de afgrond van hyperinflatie terechtkwam. In 1914 was de wisselkoers tussen de dollar en de mark slechts 1:4. In november 1923 steeg de wisselkoers tussen de dollar en de mark naar 1:4,2 biljoen mark, en een brood zou toen 20 miljoen mark kosten.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167955535011.png" alt=""><br>Het gebruik van bundels Mark als speelgoed is veel goedkoper dan het kopen van speelgoed - Netwerk</p>
<p>Er is ook Venezuela, dat ooit door het Internationaal Monetair Fonds werd voorspeld een inflatiepercentage van 1.000.000% te hebben. In december 2021 bereikte het inflatiepercentage van het land 686%, en meer dan 3 miljoen Venezolanen ontvluchtten het land. Hyperinflatie leidde niet alleen tot de ineenstorting van het financiële systeem van het land, maar ook tot een humanitaire crisis.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167955539222.png" alt=""><br>In augustus 2018 konden 2.600.000 Bolivars een rol toiletpapier kopen - Reuters</p>
<h2 id="h2-The20Pandoras20Magic20Box20wordt20geopend20en20laat20de20Verenigde20Staten20in20een20dilemma20achter240385"><a name="The “Pandora’s Magic Box” wordt geopend en laat de Verenigde Staten in een dilemma achter" class="reference-link"></a><span class="header-link octicon octicon-link"></span>The “Pandora’s Magic Box” wordt geopend en laat de Verenigde Staten in een dilemma achter</h2><p>In maart 2021 werd de “reddingswet” van de Amerikaanse president Biden ter waarde van 1,9 biljoen dollar aangenomen in de Senaat, met als inhoud de verdeling van 1.400 dollar per in aanmerking komende Amerikaanse burger. De enorme stijging van het rendement op Amerikaanse 10-jaars staatsobligaties is grotendeels te wijten aan de impact van de reddingswet.</p>
<p>Al snel begon er een economische boom. Of je nu rijk of arm was, iedereen had een cheque om te consumeren. Als gevolg daarvan stroomde er een groot aantal deposito’s de banken binnen. Wanneer sommige regionale banken zo’n groot bedrag aan deposito’s kregen, zouden ze deze deposito’s gebruiken om uit te lenen en hun inkomen te verhogen door bepaalde kredietrisico’s aan te nemen (niet-terugbetaling door leners wordt kredietrisico genoemd). Over het algemeen vermijden de meeste banken kredietrisico, maar ze willen hun inkomsten vergroten. Daarom kiezen ze ervoor om geld te lenen van verschillende Amerikaanse overheidsinstanties om het risico te beperken en de rente-inkomsten te verhogen door obligaties met langere looptijden te kopen.</p>
<p>In maart 2022 bleef de inflatiesituatie in de Verenigde Staten onverminderd voortduren. De Fed verhoogde de rentetarieven van 0% naar 4,58% en zal naar verwachting dit jaar de rentetarieven verhogen naar 5,5%. De stap van de renteverhogingen door de Fed leidde tot een scherpe waardedaling van de Amerikaanse schatkistpapieren en door regionale banken (zoals Silicon Valley Bank) gekochte residentiële hypotheekgedekte effecten, waardoor banken begonnen geld te verliezen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167955542333.png" alt=""><br>Sinds 2022 heeft de Fed de rente verhoogd naar 4,58% - ycharts</p>
<p>Bedrijven die lenen van banken kunnen de stijgende rentetarieven niet veroorloven, dus moeten ze aanzienlijk inkrimpen. Ondertussen kunnen ondernemingen alleen geld opnemen van bankrekeningen om de bedrijfsvoering te handhaven, omdat het moeilijk is om investeringen van investeerders te verkrijgen, wat heeft geleid tot een liquiditeitscrisis bij banken. Uiteindelijk stapelden de liquiditeitscrisis zich op met verliezen, en het resultaat was de opeenvolgende faillissementen die we enige tijd geleden hebben gezien.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167955545344.png" alt=""><br>De verkrapping van de Fed is de snelste ooit - NDR</p>
<p>Het monetaire en fiscale beleid van de VS heeft de afgelopen twee jaar een grote hoeveelheid hot money op de markt gebracht. Nu is de “Pandora’s Magic Box” geopend. Aan de ene kant kunnen de rentetarieven niet worden stopgezet vanwege de noodzaak om de inflatie te beteugelen en de waarde van de Amerikaanse dollar te behouden; Aan de andere kant gaan de renteverhogingen door, waardoor er mogelijk meer bankfaillissementen, marktschokken en de financiële crisis opnieuw kunnen ontstaan. Zoals Satoshi Nakamoto schreef in de verklaring over het Genesis-blok: “Op 3 januari 2009 stond de minister van Financiën op het punt de tweede ronde van noodhulp voor banken uit te voeren.” Centrale instellingen manipuleerden de uitgifte van valuta om valse welvaart te creëren. Op de dag dat de zeepbel te groot was, zou de economie uiteindelijk een “harde landing” doormaken. De prijs van een “harde landing” is het rustige leven dat mensen zouden moeten hebben.</p>
<h2 id="h2-Is202020Bitcoin2020Een20goede20keuze370354"><a name="Is   Bitcoin  Een goede keuze?" 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> Een goede keuze?</h2><p>Vanuit het perspectief van diversiteit van activa, of we nu te maken hebben met “ <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>“” of “Bitmine” of andere opkomende activa met verschillende namen vandaag de dag, het verspreiden van ons investeringsprincipe over verschillende activa is een effectieve manier om het risico te verminderen. Hier richten we ons op de unieke kenmerken van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Laten we eerst proberen om een dag voor te stellen zonder <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> in de toekomst:</p>
<ol>
<li><p>Je werd om 7 uur wakker gemaakt door de wekker. Vandaag is de dag van de huurbetaling, maar je kunt niet begrijpen waarom de huur elk jaar stijgt, terwijl je salaris nooit is toegenomen.</p>
</li><li><p>Na je ochtendroutine ga je naar de koffieshop om een kopje koffie te kopen. Op dit punt is de prijs van koffie al in de driecijferige getallen, en je twijfelt. Als je dit kopje koffie drinkt, zal je lunchbudget gehalveerd worden.</p>
</li><li><p>Je zet je computer aan op het werk en zoekt op Google naar ‘Hoe te investeren en geld te beheren?’ en ‘Waarom stijgen de prijzen?’ Je merkt dat de zoekresultaten vol zitten met mensen die dezelfde twijfels hebben als jij, maar weinig mensen geven antwoord. Over het algemeen controleren gecentraliseerde instellingen de uitgifte van valuta en ‘zij’ zullen dat ook doen.</p>
</li></ol>
<p>Is er een diep gevoel van machteloosheid? Fiat valuta is als een onzichtbare touw dat mensen aan de orde bindt, en je hebt geen andere keuze dan te gehoorzamen, omdat er geen andere keuze is.</p>
<p>Op dit punt, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> verscheen. Het opduiken van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> heeft het besturingssysteem van deze samenleving niet veranderd, maar je hebt een keuze. Je kunt afkomen van de manipulatie van gecentraliseerde instellingen, omdat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> is niet wat zij bepalen, maar wat iedereen op de markt bepaalt.</p>
<p>Naast vrij van gecentraliseerde institutionele manipulatie te zijn, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is een relatief onafhankelijke markt en een voorkeurskeuze voor alle ‘besluiteloze’ investeerders, wat ook een van de kenmerken van risico-aversie is. Neem de huidige marktsituatie als voorbeeld (de rentebeslissing van de Fed op 22 maart is nog niet bekendgemaakt), op dit moment zijn de verwachtingen van investeerders over een renteverhoging van de Fed in een staat van havikachtige of duifachtige ambiguïteit, en wedden aan beide kanten brengt een hoog risico met zich mee. Net als bij dobbelstenen, zijn de dobbelstenen in een roterende staat en niemand weet of het uiteindelijke resultaat groot of klein is. In deze staat zijn investeerders meer geneigd te investeren in relatief onafhankelijke markten, zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Zal een centrale bank digitale valuta een betere keuze zijn?<br>Volgens de Atlantic Council CBDC Tracker zijn er momenteel 119 landen die de centrale bank digitale valuta (CBDC) verkennen of introduceren, met uitzondering van twee landen die expliciet CBDC-projecten hebben geannuleerd (Ecuador en Senegal). Onder hen is de regio Azië-Pacific de meest welvarende regio, met landen als China, Singapore, Japan, Zuid-Korea, Australië en Rusland allemaal in de pilotfase.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167955582766.png" alt=""><br>Bron: Atlantic Council CBDC Tracker</p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Analist Josef Tětek gelooft dat CBDC een reeks kenmerken heeft die interessant zijn voor autoritarisme, met name het verstrekken van uitgevers met directe controle over nationale digitale valuta’s, waardoor uitgevers willekeurig negatieve rentetarieven kunnen opleggen en zelfs rechtstreeks belastingen kunnen heffen op mensen hun rekeningen. Ondertussen kan CBDC ook dienen als een instrument voor het monitoren en censureren van mensen, en heersers kunnen gemakkelijk de fondsen van mensen bevriezen die het niet eens zijn totdat ze zich gedragen op een manier die voldoet aan de verwachtingen van de heersers.</p>
<h2 id="h2-Om20samen20te20vatten918694"><a name="Om samen te vatten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Om samen te vatten</h2><p><em>“Wanneer we dagelijks onder enorme druk staan ​​om fiatvaluta te verkrijgen, is de valuta nog steeds aan het depreciëren.” - Michael Saylor</em></p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> maakt nooit geld, maar biedt eerder keuzemogelijkheden.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Jill Ma</strong>, Gate.io Onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>