RGUgZG9sbGFyIGRhYWx0OiBkZSBkb2xsYXIga2FuIGFhbiBrcmFjaHQgdmVybGllemVuIG51IENoaW5hIGVuIFJ1c2xhbmQgb3ZlcnN0YXBwZW4gbmFhciBlZW4gbmlldXdlIHZhbHV0YWJsb2M=

2023-04-18, 03:24

<p><img src="https://gimg2.gateimg.com/blog/1679447253500249423shendu.jpeg" alt=""></p>
<h2 id="h2-TL20DR386937"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De dominantie van de Amerikaanse dollar staat onder druk vanwege de mogelijkheid van een door BRICS voorgestelde wereldwijde reservuta.</p>
<p>Het bevriezen van de reserve van Rusland ter waarde van ongeveer $300 miljard en het verwijderen van Russische banken uit SWIFT heeft veel landen gedwongen op zoek te gaan naar een nieuwe wereldwijde valuta.</p>
<p>Verschillende landen hebben hun lokale valuta aangenomen bij het uitvoeren van bilaterale handel in plaats van te vertrouwen op de Amerikaanse dollar.</p>
<p>De USD-voorspellingen tonen een afname van zijn dominantie over de komende jaren.</p>
<h2 id="h2-Introductie226494"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De Amerikaanse dollar is sinds het einde van de Tweede Wereldoorlog de dominante internationale valuta geweest. Nu, een jaar na het uitbreken van de oorlog in Oekraïne, hebben verschillende landen een podium opgezet om andere valuta’s dan de Amerikaanse dollar te verkennen. Vandaag onderzoeken we valuta’s die kunnen concurreren met de Amerikaanse dollar, zoals de Chinese Yuan.</p>
<h2 id="h2-Verzwakking20van20de20wereldwijde20hegemonie20van20de20dollar831054"><a name="Verzwakking van de wereldwijde hegemonie van de dollar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verzwakking van de wereldwijde hegemonie van de dollar</h2><p>Aan het begin van deze eeuw bestond 75% van de mondiale valutareserves uit de Amerikaanse dollar. Volgens het Internationaal Monetair Fonds is dat percentage gedaald tot 59% en het zal naar verwachting blijven dalen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16817880351191681788002_.pic_hd.jpg" alt=""><br>Amerikaanse dollar - Africom</p>
<p>Het momentum om de afhankelijkheid van de Amerikaanse dollar te verminderen is toegenomen na de opgelegde sancties aan Rusland <a href="https://www.gate.io/blog_detail/1020/Ukraine--Crypto--And-War--A-Bittersweet-Experience" target="_blank">na de invasie van Oekraïne in 2022</a> Als onderdeel van de economische sancties hebben westerse regeringen meer dan $300 miljard aan buitenlandse valutareserves van Rusland bevroren. De regering van de Verenigde Staten heeft ook Russische banken uit het internationale betalingssysteem SWIFT verbannen.</p>
<p>Veel landen, niet alleen Rusland en China, hebben veroordeeld wat zij de bewapening van de Amerikaanse dollar noemen. Commentaar op de huidige stand van zaken met betrekking tot het internationale financiële systeem Jason Hollands, algemeen directeur van het beleggingsplatform Bestinvest zei: “Landen die bereid zijn om met Rusland te blijven handelen, zoals India en China, zijn begonnen dat te doen in roepies en yuan in plaats daarvan, wat heeft geleid tot gesprekken over de de-dollarisatie van de internationale handelsorde.”</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/673/Ukraine-Receives-Crypto-Donations-Amid-War-with-Russia" target="_blank">Oekraïne ontvangt cryptodonaties te midden van oorlog met Rusland</a></p>
<p>Verschillende andere landen zijn bilaterale overeenkomsten aangegaan die hen in staat stellen om hun lokale valuta te gebruiken bij de handel in goederen en diensten. Brazilië en China hebben bijvoorbeeld afgesproken om hun valuta te gebruiken bij de handel met elkaar in plaats van te vertrouwen op de Amerikaanse dollar zoals ze vroeger deden.</p>
<p>Dergelijke stappen zullen waarschijnlijk de mondiale hegemonie van de dollar als reservemunt verzwakken. De heer Hollands voegde eraan toe: ‘De dollar staat echter zwakker met stappen van China, Rusland, Saudi-Arabië en Iran om weg te stappen van het prijzen en verhandelen van energie in Amerikaanse dollars’.</p>
<p>Helaas komt deze ontwikkeling in de nasleep van het instorten van verschillende Amerikaanse banken zoals Silvergate, <a href="https://www.gate.io/blog_detail/2303/svb-crash-caused-the-butterfly-effect-in-the-crypto-market-what-should-investors-do" target="_blank">Silicon Valley Bank</a> en Signature Banks. Hoewel de belangrijkste oorzaak van het instorten van deze banken financieel wanbeheer is, heeft de voortdurende stijging van de Federal Funds-rente in 2022 bijgedragen aan hun financiële problemen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2397/crashing-banks-push-crypto-towards-a-bull-market" target="_blank">Instortende banken duwen Crypto richting een stierenmarkt</a></p>
<h2 id="h2-China20en20Rusland20bouwen20een20alternatieve20valutablok295549"><a name="China en Rusland bouwen een alternatieve valuta-blok" class="reference-link"></a><span class="header-link octicon octicon-link"></span>China en Rusland bouwen een alternatieve valuta-blok</h2><p>Waarschijnlijk de grootste bedreiging voor de wereldwijde hegemonie van de Amerikaanse dollar is de oprichting van een alternatief valutablok genaamd BRICS door Rusland en China. Volgens de adjunct-directeur van de afdeling Buitenlands Beleid Planning van het Russische Ministerie van Buitenlandse Zaken, Pavel Knyazev, <a href="https://www.silkroadbriefing.com/news/2022/10/04/brics-working-to-develop-a-new-reserve-currency/#:~:text=The%20new%20currency%20will%20be,and%20the%20South%20African%20Rand." rel="nofollow noopener noreferrer" target="_blank">Alternatief voor reservuta van BRICs</a> zal gebaseerd zijn op de nationale valuta’s van zijn lidstaten, waaronder momenteel Rusland, Zuid-Afrika, India en China.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16817881711201681788015_.pic.jpg" alt=""><br>Lidstaten van BRICS - Russiabriefing</p>
<p>De voorgestelde mandje van valuta bestaat uit de Chinese RMB Yuan, de Russische Roebel, de Zuid-Afrikaanse Rand, de Indiase Roepie en de Braziliaanse Real. Knyazev voegde toe: “De mogelijkheid en vooruitzichten van het opzetten van een gemeenschappelijke munteenheid op basis van een mandje van valuta van de BRICS-landen wordt besproken.”</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2432/depegging-bank-runs-and-unstablecoins" target="_blank">Depegging, Bank Runs en Unstablecoins</a></p>
<p>De historische statistieken geven aan dat de Amerikaanse dollar is gedaald ten opzichte van de Braziliaanse Real en de Russische valuta. Aan de andere kant is de EURO gedaald ten opzichte van alle valuta van de BRICS-landen. De BRICS-landen hebben gezegd dat ze een mandje van valuta creëren dat zal concurreren tegen het westerse financiële stelsel.</p>
<p>Bovendien hebben de verschillende lidstaten van BRICS het gebruik van hun lokale valuta’s verhoogd bij het uitvoeren van hun bilaterale handel.</p>
<h2 id="h2-De20Russische20economie20en20het20gebruik20van20de20Yuan105962"><a name="De Russische economie en het gebruik van de Yuan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Russische economie en het gebruik van de Yuan</h2><p>Sinds het uitbreken van de oorlog in Oekraïne gebruikt Rusland steeds meer de Chinese yuan. De Russische energie-exporteurs worden voornamelijk betaald in de Chinese yuan. Bovendien maakt het soevereine fonds van Rusland, een bron van financiering om haar oorlogsuitgaven te ondersteunen, gebruik van yuan.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/848/daily-flash-russia-may-use-cryptocurrency-in-foreign-trade-since-2022-the-global-nft-trading-volume-has-increased-by-more-than-200" target="_blank">Rusland kan cryptocurrency gebruiken in buitenlandse handel</a></p>
<p>Veel bedrijven in Rusland lenen ook de Yuan terwijl huishoudens hun spaargeld in de Yuan beleggen, ook wel renminbi genoemd. Interessant is dat de Chinese valuta in Rusland de banden tussen de twee landen versterkt. Rusland begon zijn afhankelijkheid van de Amerikaanse dollar te verminderen na de annexatie van de Krim in 2014.</p>
<h2 id="h2-Landen20die20zich20distantiren20van20de20Amerikaanse20dollar37921"><a name="Landen die zich distantiëren van de Amerikaanse dollar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Landen die zich distantiëren van de Amerikaanse dollar</h2><p>Rusland is niet het enige land dat hard werkt aan het creëren van een nieuwe wereldreservemunt.</p>
<h3 id="h3-Brazili20en20China128622"><a name="Brazilië en China" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Brazilië en China</h3><p>Brazilië en China hebben afgesproken om het gebruik van hun lokale valuta te verhogen bij de handel tussen henzelf. Dit helpt om de Amerikaanse dollar te omzeilen, die ze in het verleden gebruikten om de meeste van hun handelsactiviteiten af te wikkelen. Dit zal helpen om de kosten te verlagen, de investeringen tussen de twee landen te bevorderen en de bilaterale handel te bevorderen. Opmerkelijk is dat China de grootste handelspartner van Brazilië is, met een bilaterale handel ter waarde van meer dan $150,5 miljard per jaar.</p>
<h3 id="h3-SaudiArabi20is20van20plan20om20de20Amerikaanse20dollar20te20laten20vallen459474"><a name="Saudi-Arabië is van plan om de Amerikaanse dollar te laten vallen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Saudi-Arabië is van plan om de Amerikaanse dollar te laten vallen</h3><p>Saudi-Arabië heeft gedreigd zijn olie in andere valuta dan de Amerikaanse dollar te verkopen als de VS een wetsvoorstel aanneemt dat OPEC blootstelt aan antitrustrechtszaken. Saudi-Arabië is de 10e grootste olieproducent en concurreert met landen als China en de Verenigde Staten. Op dit moment is de olie genoteerd in Amerikaanse dollars.</p>
<p>Lees ook: <a href="https://www.gate.io/uk/bitwiki/detail/886" target="_blank">Het Indiase parlement heeft wetgeving inzake cryptobelasting goedgekeurd</a></p>
<p>Het heeft ook gedreigd om zijn investering in de Verenigde Staten te liquideren, die meer dan $1 biljoen waard is. India en Maleisië hebben ook afgesproken om de Indiase roepie te gebruiken bij de handel tussen hen.</p>
<h2 id="h2-Conclusie984129"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De huidige wereldwijde ontwikkeling laat zien dat de dominantie van de Amerikaanse dollar waarschijnlijk zal afnemen als gevolg van verschillende financiële initiatieven van andere landen. BRICS heeft tot doel zijn wereldreservemunt te introduceren. Aangezien veel landen de Chinese Yuan adopteren, is het waarschijnlijk de nieuwe wereldvaluta te worden.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel wordt toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>