WmltYmFid2UgbWFha3QgemljaCBrbGFhciB2b29yIGRlIGxhbmNlcmluZyB2YW4gZWVuIGRpZ2l0YWxlIHZhbHV0YSBnZWRla3QgZG9vciBnb3Vk

2023-08-29, 07:59

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>Zimbabwe is klaar om zijn door goud gedekte lokale digitale tokens te lanceren.</p>
<p>ZiG zal een wettig betaalmiddel worden en een waardeopslag.</p>
<p>Individuen en instellingen zullen in staat zijn om GBDT’s te kopen, vast te houden en te verhandelen.</p>
<p>Trefwoorden: door goud gedekte digitale valuta van Zimbabwe, Reserve Bank of Zimbabwe, Zimbabwaanse dollars, door goud gedekte virtuele token, door goud gedekte lokale digitale tokens, Crypto in Zimbabwe</p>
<h2 id="h2-Introductie161637"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Het aantal landen dat centrale bank digitale valuta (CBDC’s) introduceert, neemt toe. In sommige glen, <a href="https://www.gate.io/learn/articles/what-are-central-bank-digital-currencies/363" target="_blank">de CBDC’s</a> worden gedekt door de lokale valuta, de Amerikaanse dollar of kostbare mineralen zoals goud.</p>
<p>Zimbabwe is een van de nieuwste landen die zijn digitale valuta introduceert. In dit artikel bespreken we de mogelijke impact van de door goud gedekte digitale token (GBDT) van Zimbabwe op zijn economie.</p>
<h2 id="h2-Zimbabwe20lanceert20zijn20door20goud20gedekte20digitale20token20GBDT105822"><a name="Zimbabwe lanceert zijn door goud gedekte digitale token (GBDT)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zimbabwe lanceert zijn door goud gedekte digitale token (GBDT)</h2><p>Op 9 augustus kondigde de Reserve Bank of Zimbabwe (RBZ) aan dat het zijn door goud gedekte digitale valuta heeft gelanceerd. Zoals de beschrijving suggereert, wordt de GBDT van Zimbabwe, een vorm van elektronisch geld, gedekt door goudstaven die de centrale bank zal aanhouden.</p>
<p>Tijdens de eerste fase van het project kunnen de GBDT-investeerders hun tokens vasthouden en ze uitwisselen. Echter, in de volgende fase zullen ze in staat zijn om te handelen en ze te gebruiken om betalingen te doen voor goederen en diensten in het land.</p>
<p><a href="https://www.bing.com/ck/a?!&amp;&amp;p=dabe4658507258edJmltdHM9MTY5MzA5NDQwMCZpZ3VpZD0yYzdlZjMzNy1kMWUxLTYwNTMtMjYyOC1lMDE4ZDBjMjYxNTMmaW5zaWQ9NTIwNg&amp;ptn=3&amp;hsh=3&amp;fclid=2c7ef337-d1e1-6053-2628-e018d0c26153&amp;psq=%e2%80%9cHolders+of+physical+gold+coins%2c+at+their+discretion%2c+will+be+able+to+exchange+or+convert%2c+through+the+banking+%e2%80%a6+into+gold-backed+digital+tokens.%e2%80%9d&amp;u=a1aHR0cHM6Ly93d3cuemltYmFid2VzaXR1YXRpb24uY29tL25ld3MvemltYmFid2VzLW5ldy1nb2xkLWJhY2tlZC1kaWdpdGFsLWN1cnJlbmN5LWFsbC15b3UtbmVlZC10by1rbm93Lw&amp;ntb=1" rel="nofollow noopener noreferrer" target="_blank">In een openbare verklaring</a>, zo zei de centrale bank,<br><strong>“Houders van fysieke gouden munten zullen naar eigen goeddunken kunnen inwisselen of converteren, via het banksysteem … in door goud gedekte digitale tokens.”</strong></p>
<p>Op dit moment gebruikt Zimbabwe een veelvalutasysteem waarbij de burgers betalingen kunnen doen met verschillende buitenlandse valuta, waaronder de Amerikaanse dollar, het Britse pond, de Botswaanse Pula en de Zuid-Afrikaanse Rand. Het land heeft echter zijn eigen lokale valuta, de Zimbabwaanse dollar.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1389/how-africans-are-benefiting-from-crypto" target="_blank">Hoe Afrikanen Profiteren Van Crypto</a></p>
<p>Helaas is de Zimbabwaanse dollar een “hete aardappel”, wat betekent dat wanneer mensen hem krijgen, ze deze vaak inwisselen voor populaire buitenlandse valuta zoals de Amerikaanse dollar en de Zuid-Afrikaanse rand. De reden waarom ze de lokale valuta omrekenen naar forex is dat er een hoge inflatie is in het land.</p>
<p>Ondertussen nodigt de regering zowel individuen als instellingen uit om te investeren in de GBDT. Ze kunnen het kopen met Zimbabwaanse dollars of enige belangrijke buitenlandse valuta die in het land circuleert.</p>
<p>In mei introduceerde de RBZ fysieke gouden munten die hielpen bij het verminderen van het aanbod van de Zimbabwaanse dollar en het mogelijk maakten om te waarderen tegen belangrijke valuta’s zoals de Amerikaanse dollar. Tegen juli had het zuidelijk Afrikaanse land GBDT gecreëerd, gesteund door een totaal van 325,02 kg goud en gewaardeerd op ZWD50,5 miljard, ongeveer $139 miljoen waard.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2563" target="_blank">Landen die voorop lopen in de adoptie van blockchain</a></p>
<p>Met deze ontwikkeling sluit Zimbabwe zich aan bij verschillende andere Afrikaanse landen die hun digitale valuta hebben geïntroduceerd, waaronder Ghana en Nigeria. Desalniettemin zijn er veel andere landen op het continent met plannen om hun CBDC’s te lanceren.</p>
<p>Ontdek ook: <a href="https://www.gate.io/price/view/tokenized-gold" target="_blank">Top getokeniseerde-goud Crypto Coins &amp; Tokens op basis van marktkapitalisatie</a></p>
<h2 id="h2-Wat20zijn20goudgedekte20digitale20tokens129684"><a name="Wat zijn goudgedekte digitale tokens?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn goudgedekte digitale tokens?</h2><p>Een op goud gedekte digitale valuta heeft een waarde die gekoppeld is aan een bepaalde hoeveelheid goud. Daarom volgt de waarde de prijs van het goud waaraan het gekoppeld is. In Zimbabwe zullen de op goud gedekte lokale digitale tokens worden gebruikt naast de Zimbabwaanse dollars en andere buitenlandse valuta die als wettig betaalmiddel worden gebruikt.</p>
<p>In feite houdt de Zimbabwaanse regering een bepaalde hoeveelheid goud aan dat haar virtuele tokens ondersteunt. Volgens haar staatsmedia, tegen april <a href="https://www.bloomberg.com/news/articles/2023-04-24/zimbabwe-s-digital-currency-plan-needs-100-million-of-gold#:~:text=State%2Downed%20media%20reported%20earlier,to%2040%20tons%20this%20year." rel="nofollow noopener noreferrer" target="_blank">het land had 350 kg goud in reserves</a>, gewaardeerd op ongeveer $22,80 miljoen. Het heeft echter de bedoeling om GBDT’s te bezitten die worden ondersteund door goudreserves ter waarde van $100 miljoen.</p>
<h2 id="h2-Redenen20waarom20Zimbabwe20goudgedekte20lokale20digitale20tokens20heeft20gentroduceerd834890"><a name="Redenen waarom Zimbabwe goudgedekte lokale digitale tokens heeft geïntroduceerd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Redenen waarom Zimbabwe goudgedekte lokale digitale tokens heeft geïntroduceerd</h2><p>Het belangrijkste doel van de door goud gedekte lokale digitale tokens is om ze te gebruiken als wettig betaalmiddel, voor transacties van persoon naar bedrijf en peer-to-peer. Ook, omdat het gedekt wordt door goud, zal het een waardeopslag worden en zal het in de toekomst zijn CBDC worden.</p>
<p>D <a href="https://miningzimbabwe.com/zim-set-to-introduce-gold-backed-digital-tokens/" rel="nofollow noopener noreferrer" target="_blank">De gouverneur van de RBZ, John Mangudya, zei</a>, “De GBDT’s worden voorgesteld als de basis van de digitale valuta van de centrale bank van het land (CBDC), omdat ZiG in zijn huidige vorm en ontwerp de meeste kenmerken van een CBDC vertoont.”</p>
<p>Hij voegde toe,<br><strong>“De Bank is in een vergevorderd stadium van de voorbereidingen voor de uiteindelijke uitrol van GBDT voor transactiedoeleinden in Fase II van het project onder de code of naam ZiG, wat staat voor Zimbabwe Gold.”</strong></p>
<p>Door de introductie van de door goud gedekte virtuele token streeft de regering van Zimbabwe naar <a href="https://www.sundaymail.co.zw/rbz-introduces-gold-backed-digital-currency" rel="nofollow noopener noreferrer" target="_blank">temmen van inflatie</a> dat is een van de terugkerende economische problemen geweest. Het hoogste inflatieniveau van het land werd geregistreerd in 2008 toen <a href="https://www.cnbc.com/2011/02/14/The-Worst-Hyperinflation-Situations-of-All-Time.html" rel="nofollow noopener noreferrer" target="_blank">het bereikte 79.600.000.000%</a> per maand. In november 2022 heeft Zimbabwe’s <a href="https://www.rbz.co.zw/index.php/research/markets/inflation/29-inflation/1134-consumer-price-index-september-2022" rel="nofollow noopener noreferrer" target="_blank">consumentenprijsindex was 107%</a> terwijl het <a href="https://www.bloomberg.com/news/articles/2023-06-26/zimbabwe-inflation-back-at-three-digits-after-currency-crashes" rel="nofollow noopener noreferrer" target="_blank">inflatiepercentage was 175%</a> in juni van dit jaar.</p>
<h2 id="h2-De20Effectiviteit20van20ZiG909570"><a name="De Effectiviteit van ZiG" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Effectiviteit van ZiG</h2><p>Sommige analisten geloven dat de op goud gebaseerde digitale valuta van Zimbabwe (Zimbabwe Gold) op korte termijn voordelen kan hebben, omdat het waarschijnlijk zal fungeren als een waardeopslag en een beleggingsactivum.</p>
<p>Voor het echter effectief wordt in het controleren van inflatie, moet het vergezeld gaan van gezond macro-economisch beleid. Zo moet het land bijvoorbeeld een strak monetair beleid handhaven dat het verhogen van de rentetarieven en het verhogen van de reservevereisten van banken omvat. Het moet ook een expansief fiscaal beleid handhaven.</p>
<p><a href="https://finance.yahoo.com/news/zimbabwes-gold-backed-digital-token-074638346.html" rel="nofollow noopener noreferrer" target="_blank">Volgens Prosper Chitambara</a>, een econoom, is de oplossing van Zimbabwe voor het probleem van inflatie “het beheersen van de groei van de geldhoeveelheid”, niet de introductie van de GBDTs.</p>
<h2 id="h2-Crypto20in20Zimbabwe839241"><a name="Crypto in Zimbabwe" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto in Zimbabwe</h2><p>Hoewel mensen cryptocurrencies kunnen verhandelen en gebruiken in Zimbabwe, worden ze niet officieel geaccepteerd als betaalmiddel of beleggingsactiva. De positie van de overheid is dat het individuen of instellingen niet heeft toegestaan ​​om cryptocurrencies te gebruiken of crypto-bedrijven op te richten.</p>
<p>Het heeft duidelijk gemaakt dat cryptocurrencies geen wettig betaalmiddel zijn in het land. In een persverklaring van 20 december 2017, <a href="https://www.rbz.co.zw/documents/BLSS/BANK%20SUPERVISION/Press%20Releases%20&amp;%20Speeches/2018/PRESS%20STATEMENT%20ON%20WARNING%20AGAINST%20TRADING%20IN%20CRYPTOCURRENCIES%20%20%20-%2011%20May%202019.pdf" rel="nofollow noopener noreferrer" target="_blank">de overheid zei</a>,<br><strong>De Reserve Bank wil benadrukken dat virtuele valuta’s of cryptocurrencies zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> hebben geen wettig betaalmiddelstatus, omdat ze noch door de Reserve Bank worden uitgegeven, noch door de overheid worden gegarandeerd.</strong></p>
<p>Ze voegde eraan toe: “De Reserve Bank of Zimbabwe heeft geen enkele persoon, entiteit of uitwisseling gemachtigd of gelicentieerd voor de uitgifte, verkoop, aankoop, uitwisseling of investering in virtuele valuta/munten/tokens in Zimbabwe. Uitwisselingen zoals Bitfinance (Private) Limited (Golix) en Styx24 zijn niet gelicentieerd of gereguleerd door de Reserve Bank.”</p>
<p>Uiteindelijk beschermt de wet personen niet die handelen in cryptocurrencies of andere digitale activa. In dit opzicht <a href="https://www.rbz.co.zw/documents/BLSS/BANK%20SUPERVISION/Press%20Releases%20&amp;%20Speeches/2018/PRESS%20STATEMENT%20ON%20WARNING%20AGAINST%20TRADING%20IN%20CRYPTOCURRENCIES%20%20%20-%2011%20May%202019.pdf" rel="nofollow noopener noreferrer" target="_blank">overheid verklaarde</a>, “Voor de duidelijkheid, handelaren en investeerders in welke vorm van cryptocurrency dan ook in Zimbabwe worden niet beschermd door de wet. Virtuele valuta worden verhandeld op ongereguleerde uitwisselingsplatforms.”</p>
<h2 id="h2-Conclusie469678"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Zimbabwe is klaar om zijn door goud gedekte digitale token genaamd ZiG te lanceren, die een wettig betaalmiddel en een waardeopslag zal worden. Individuen en instellingen kunnen het kopen en vasthouden. In de nabije toekomst zullen ze het kunnen verhandelen en gebruiken om betalingen te doen. De overheid van Zimbabwe staat geen investeringen in cryptocurrencies toe, noch staat ze crypto-bedrijven toe.</p>
<h2 id="h2-Veelgestelde20vragen20over20Crypto20in20Zimbabwe155050"><a name="Veelgestelde vragen over Crypto in Zimbabwe" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Crypto in Zimbabwe</h2><h3 id="h3-Is20crypto20toegestaan20in20Zimbabwe884843"><a name="Is crypto toegestaan in Zimbabwe?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is crypto toegestaan in Zimbabwe?</h3><p>De regering van Zimbabwe staat de uitgifte, aankoop, verkoop en handel in cryptocurrencies in het land niet toe. Aangezien er geen wetten zijn die crypto-activiteiten reguleren, handelen mensen op eigen risico in cryptocurrency.</p>
<h3 id="h3-Wat20is20de20door20goud20gedekte20cryptocurrency20van20Zimbabwe944428"><a name="Wat is de door goud gedekte cryptocurrency van Zimbabwe?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de door goud gedekte cryptocurrency van Zimbabwe?</h3><p>Gold backed Zimbabwe cryptocurrency is een digitale valuta die wordt gedekt door goud. Momenteel kunnen mensen de goudgedekte virtuele token genaamd ZiG kopen en vasthouden. In de toekomst zullen ze het echter kunnen gebruiken om betalingen te doen voor goederen en diensten.</p>
<h3 id="h3-Wat20is20de20digitale20valuta20van20Zimbabwe460642"><a name="Wat is de digitale valuta van Zimbabwe?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de digitale valuta van Zimbabwe?</h3><p>Zimbabwaanse digitale valuta is elektronisch geld dat wettig betaalmiddel is en een opslag van waarde. De burgers zullen het gebruiken om goederen en diensten te kopen en erin te investeren, aangezien het een opslag van waarde is.</p>
<h3 id="h3-Heeft20Zimbabwe20het20IMF20getrotseerd20om20voor204020miljoen20aan20goud20gedekte20digitale20tokens20te20verkopen475374"><a name="Heeft Zimbabwe het IMF getrotseerd om voor $40 miljoen aan goud gedekte digitale tokens te verkopen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Heeft Zimbabwe het IMF getrotseerd om voor $40 miljoen aan goud gedekte digitale tokens te verkopen?</h3><p>Zimbabwe heeft het IMF niet getrotseerd toen het zijn met goud gedekte digitale tokens verkocht. In feite heeft het IMF Zimbabwe niet gestopt met het verkopen van zijn digitale tokens. Het heeft het land eenvoudig gewaarschuwd om in plaats daarvan zijn wisselmarkten te liberaliseren.</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 mening van de onderzoeker en vormt geen beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>