VHJ1bXAncyBDcnlwdG8gRW5kb3JzZW1lbnQgem9yZ3Qgdm9vciBNZW1lY29pbiBGcmVuenkgZW4gaGVyc2NoaWt0IGhldCBwb2xpdGlla2UgZm9uZHNlbndlcnZpbmdzbGFuZHNjaGFw

2024-05-22, 03:35

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR670511"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Donald Trump, de voormalige president van de Verenigde Staten, heeft beloofd de groei van de cryptocurrency-sector te ondersteunen als hij herkozen wordt.</p>
<p>Na de goedkeuring van cryptocurrency door Trump steeg de cumulatieve marktkapitalisatie van de top 50 memecoins met meer dan 10%.</p>
<p>VanEck heeft een memecoin-index gelanceerd die de prijzen volgt van toonaangevende memecoins, waaronder DOGE en SHIB.</p>
<h2 id="h2-Introductie923506"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Er is een grote kans dat sommige mensen die eerder een hekel hadden aan cryptocurrencies, na verloop van tijd van gedachten veranderen. Dit lijkt het g te zijn bij Donald Trump, de voormalige president van de Verenigde Staten. Tijdens zijn ambtstermijn had Trump een hekel aan cryptocurrencies. Nu gelooft hij echter in verschillende digitale valuta’s, waaronder niet-vervangbare tokens en de vervangbare varianten.</p>
<p>Deze analyse bekijkt de steun van Trump voor cryptocurrencies en zijn belofte om pro-crypto beleid te bevorderen als hij voor de tweede keer tot president wordt gekozen.</p>
<h2 id="h2-Donald20Trumps20Openbare20Endorsements20van20Cryptocurrency897354"><a name="Donald Trump’s Openbare Endorsements van Cryptocurrency" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Donald Trump’s Openbare Endorsements van Cryptocurrency</h2><p>Donald Trump, een van de Amerikaanse presidentskandidaten, verraste veel Amerikanen door zijn openlijke steun aan digitale activa, waaronder cryptocurrencies en niet-fungibele tokens (NFT’s). Tijdens een speciaal georganiseerd evenement in zijn Mar-a-Lago resort in Palm Beach, Florida, beloofde Trump een einde te maken aan de vijandigheid van de VS jegens cryptocurrencies, als hij gekozen wordt als de volgende president van de VS.</p>
<p>Trump zei ook dat hij cryptocurrency donaties verwelkomt voor zijn campagnefinanciering. Door cryptocurrency te accepteren als onderdeel van zijn politieke fondsenwerving heeft Trump persoonlijk hun gebruik aangenomen. Over het algemeen laat zijn nieuwe houding ten opzichte van cryptocurrencies een sterke mindset verandering zien. Dit komt doordat Trump in sommige van zijn eerdere toespraken cryptocurrencies bekritiseerde omdat ze instabiel zijn en worden gebruikt voor illegale activiteiten zoals drugshandel. Hier zijn Trump’s tweets terwijl hij nog in functie was tijdens zijn eerste termijn.<br><img src="https://gimg2.gateimg.com/image/article/17163484101.jpg" alt=""><br>Bron: X.com</p>
<p>In zijn toespraak op het Trump Cards NFT Gala, gehouden in het Mar-a-Lago resort in Palm Beach, beloofde hij echter een einde te maken aan het anti-crypto beleid van de Verenigde Staten dat de regering-Biden heeft aangenomen. Tijdens een gesprek met een groep van zijn NFT-kopers zei Trump: ‘Ik vind het goed. Als crypto uit de VS vertrekt vanwege vijandigheid jegens crypto… nou, dan stoppen we het. Dat willen we niet. ‘Als we het gaan omarmen, moeten we ze hier laten zijn.’</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/blog_detail/4135/as-the-us-presidential-election-approaches-is-trump-meme-becoming-a-best-loved-meme" target="_blank">Wordt Trump MEME een geliefde MEME?</a></p>
<p>Trump zei ook dat veel leden van de Biden-regering tegen cryptocurrencies zijn. In <a href="https://twitter.com/frankdegods/status/1788359051031761269" rel="nofollow noopener noreferrer" target="_blank">in een recente toespraak zei hij</a>, “Gensler is er sterk tegen, de Democraten zijn er sterk tegen. En ik zeg dit, veel mensen zijn er zeer voorstander van. Daar ben ik het mee eens. Als je voorstander bent van crypto, stem dan op Trump. Zij zijn er tegen. Biden weet zelfs niet wat het is. Hij heeft geen idee.”</p>
<p>Op basis van Trump’s recente toespraak hebben sommige cryptoliefhebbers opgeroepen om te stemmen voor Trump. Bijvoorbeeld, <a href="https://e.email.forbes.com/c2/869:663bc63ad963c01dcb03f7b2:ot:5e33380926f096d31d28295d:1/d7f718ed?jwtH=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9&amp;jwtP=eyJpYXQiOjE3MTUyNTQxMTYsImNkIjoiLmVtYWlsLmZvcmJlcy5jb20iLCJjZSI6ODY0MDAsInRrIjoiZm9yYmVzLWxpdmUiLCJtdGxJRCI6IjY2M2NiMWY3NWNlNDQwNDM5ZjAwZTE1ZCIsImxpbmtVcmwiOiJodHRwczpcL1wvdHdpdHRlci5jb21cL3R3b2JpdGlkaW90XC9zdGF0dXNcLzE3ODgzODk3NTQ1MDI4NTY3MDc_dXRtX3NvdXJjZT1uZXdzbGV0dGVyJnV0bV9tZWRpdW09ZW1haWwmdXRtX2NhbXBhaWduPWNyeXB0b2NvZGV4JmNkbGNpZD01ZTMzMzgwOTI2ZjA5NmQzMWQyODI5NWQifQ&amp;jwtS=F1Jq3yZ4eKIJt22n23xG2KJIfdnBeSxzEP0lqvz6st4" rel="nofollow noopener noreferrer" target="_blank">Kevin Svenson zei</a> Als je politieke vooroordelen even opzij zet en gewoon beseft dat de meest waarschijnlijke kandidaat om de presidentsverkiezing te winnen net heeft aangekondigd dat hij voor het eerst positief staat tegenover cryptovaluta. Het maakt niet uit wat je mening is. Dit is bullish nieuws.</p>
<p>Ryan Selkis, de CEO van Messari, een cryptodata bedrijf, deelde soortgelijke sentimenten. Hij <a href="https://twitter.com/twobitidiot/status/1788389754502856707" rel="nofollow noopener noreferrer" target="_blank">schreef</a> Ik had niet verwacht dat ik vanavond in Mar-a-Lago zou zijn, maar president Trump sprak zeer positief over crypto … Strijd voor crypto. Steun president Trump.</p>
<p>Ook bekritiseerde Trump de huidige Amerikaanse regering voor het gebrek aan uitgebreide kennis over cryptocurrency, wat hen heeft gedwongen om beperkende maatregelen te nemen tegen digitale activa. Tijdens een interview met CNBC vorige maand zei Trump dat hij bij herverkiezing geen regelgevende onderdrukking zal handhaven op digitale activa zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2450/donald-trump-trading-card-volume-pumps-resultant-criminal-indictment" target="_blank">Donald Trump Trading Card Volume stijgt als gevolg van strafrechtelijke aanklacht</a></p>
<p>Evenzo is Kristin Smith, CEO van de Blockchain Association, een lobbygroep voor de crypto-industrie, hoopvol dat de toespraak van Trump een langdurige impact zal hebben op de verkiezingscampagnes van de VS dit jaar. <a href="https://twitter.com/BlockchainAssn/status/1788963540562260350" rel="nofollow noopener noreferrer" target="_blank">Hij zei</a>“De opmerkingen van president Trump geven aan dat er een verschuiving plaatsvindt in de belangrijkheid van digitale activa in deze verkiezingscyclus.”</p>
<p>Zoals per een <a href="https://cryptoadventure.com/bitcoin-bulls-anticipate-trump-victory-standard-chartered-predicts-150k-btc/" rel="nofollow noopener noreferrer" target="_blank">Cryptoadventure publicatie</a>, volgens een recent rapport van Standard Chartered Bank wil de cryptomarkt Trump omdat er een dreigende fiscale dominantie is als de huidige regering doorgaat. Als de Federal Reserve echter overheidschulden monetiseert, zullen veel mensen kiezen voor cryptocurrencies. Het rapport verduidelijkte ook dat als Trump herkozen wordt als president, dit het enthousiasme voor <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> kan aanwakkeren, wat gevolgd kan worden door een sterke stijging van de cryptoprijzen.</p>
<p>De woorden van Trump zijn niet alleen goed nieuws voor de Amerikaanse crypto-enthousiastelingen, maar ook voor alle crypto-liefhebbers over de hele wereld. Het heeft een positieve sfeer in de cryptocurrency-markt gebracht en vertrouwen gecreëerd onder de crypto-gemeenschap. Tenminste, dat brengt de gedachten van crypto-investeerders af van de huidige Amerikaanse aanpak van cryptocurrencies.</p>
<p>Sinds 2022 is de Biden regering actief bezig met het aanpakken van crypto-activiteiten in het land. Tot nu toe is het betrokken bij verschillende juridische gevechten met toonaangevende crypto-bedrijven zoals Ripple Labs, Binance Exchange, Coinbase, Gemini Exchange en anderen. Als gevolg hiervan geloven sommige experts dat de huidige regering van de Verenigde Staten af wil van cryptocurrencies. De reden hiervoor is dat sommige wetgevers zelfs hebben opgeroepen tot het verbieden van cryptocurrencies.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/post/NewsBTC/status/4936842" target="_blank">Biden-Gerelateerde Memecoin Stunt Markten Met 5000% Stijging</a></p>
<p>Desalniettemin is het nog onduidelijk of Trumps recente retoriek over digitale activa het aantal stemmen dat hij ontvangt aanzienlijk kan verhogen. Naast cryptocurrencies sprak Trump ook zeer positief over niet-vervangbare tokens waarin hij ook veel heeft geïnvesteerd. Sterker nog, zijn Mar-a-Lago-resort in Palm Beach werd georganiseerd voor investeerders die zijn NFT’s hebben gekocht, zoals de Trump Digital Trading Cards (TRUMP).</p>
<h2 id="h2-De20Crypto20Endorsement20van20Donald20Trump20benvloedt20de20heropleving20van20Memecoin218496"><a name="De Crypto Endorsement van Donald Trump beïnvloedt de heropleving van Memecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Crypto Endorsement van Donald Trump beïnvloedt de heropleving van Memecoin</h2><p>De goedkeuring van digitale activa door Donald Trump heeft al geleid tot een opleving van memecoins. Sterker nog, binnen een week na zijn toespraak steeg de gezamenlijke marktkapitalisatie van de top 50 memecoins met meer dan 10%.</p>
<p>De best presterende munten waren MAGA Coin ($TRUMP), Turbo Toad Token ($TURBO), Ponkesol ($PONKE) en Myro ($MYRO), waarvan de waarden met tussen de 9% en 50% stegen binnen een periode van 24 uur na de toespraak van Trump. Zo’n prijsstijging geeft eenvoudigweg aan dat de retoriek van Trump over digitale activa mogelijk de dynamiek van de memecoin-markt kan veranderen, tenminste op korte termijn. Dat geeft ook aan dat positieve cryptobeleid kan leiden tot een robuuste markt voor digitale activa.</p>
<p>Santiment, een marktinformatieplatform, schreef de stijging van de memecoinprijs toe aan de recente toespraak van Trump. <a href="https://twitter.com/santimentfeed/status/1788750340730605709" rel="nofollow noopener noreferrer" target="_blank">geplaatst</a>: “Een groot deel van de toeschrijving aan deze laatste memecoin-stijgingen gaat naar Donald Trump en zijn pro-crypto-goedkeuringen.”</p>
<p>Wat ook belangrijk is om op te merken, is dat <a href="https://www.gate.io/how-to-buy/maga-trump &quot;MAGA (Make America Great Again" rel="nofollow noopener noreferrer" target="_blank">MAGA (Make America Great Again) memecoin</a> De ‘memecoin’ (een cryptomunt geïnspireerd door Trump’s politieke slogans) was een van de best presterende cryptovaluta gedurende die periode, aangezien de prijs met ongeveer 80% steeg. Donal Tremp (TREMP), nog een politiek thematische memecoin, boekte ook een grote winst. Santiment reageerde positief op deze ontwikkeling, zoals blijkt uit de volgende afbeelding.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/learn/articles/understanding--web3-banking-protocol-in-one-article-fiat24/2161" target="_blank">De</a><img src="https://gimg2.gateimg.com/image/article/17163486812.jpg" alt=""><br>Bron: x.com</p>
<h2 id="h2-Trump20vs20Biden20De20Crypto20Sentiment20Battle817892"><a name="Trump vs. Biden: De Crypto Sentiment Battle" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Trump vs. Biden: De Crypto Sentiment Battle</h2><p>Donald Trump heeft mogelijk beperkte kennis over cryptocurrencies, maar hij heeft zichzelf gepositioneerd als een kampioen in de sector. Sterker nog, Trump heeft betreurd dat veel crypto-bedrijven de Verenigde Staten verlaten voor andere landen met crypto-vriendelijke regelgeving. Als gevolg daarvan verzekerde hij de aanwezigen tijdens zijn bijeenkomst in zijn huis in Florida dat hij crypto-bedrijven zou stoppen om het land te verlaten door pro-crypto maatregelen in te voeren.</p>
<p>Hierover, <a href="https://www.kitco.com/news/article/2024-05-09/battle-lines-drawn-trump-advocates-crypto-while-biden-looks-regulate" rel="nofollow noopener noreferrer" target="_blank">Kitcoin citeerde Trump als zeggende</a>“Crypto verlaat de VS vanwege vijandigheid jegens crypto. We zullen het stoppen omdat ik dat niet wil - als we het omarmen, moeten we ze hier laten zijn.”</p>
<p>Daarentegen heeft de regering tijdens Biden’s ambtstermijn vele beperkende maatregelen ingevoerd met betrekking tot crypto-activiteiten en heeft zij hard opgetreden tegen toonaangevende crypto-bedrijven. Zo keurde zijn regering bijvoorbeeld in maart een voorstel goed om een accijns van 30% in te voeren op de kosten van elektriciteit die wordt gebruikt voor Bitcoin-mining.</p>
<p>Naar aanleiding van deze ontwikkeling beloofde de Republikeinse senator uit Wyoming, Cynthia Lummis, om tegen deze ontwikkeling te vechten. <a href="https://twitter.com/SenLummis/status/1661803569341759495" rel="nofollow noopener noreferrer" target="_blank">Ze zei</a> Een voorgestelde bestraffende belasting van 30% op het mijnen van digitale activa zou elke voet aan de grond die de industrie heeft in Amerika vernietigen. Ik zal niet toestaan dat president Biden de digitale activa-industrie uitroeit door middel van belastingen.</p>
<p>Robert F. Kennedy Jr, onafhankelijke presidentskandidaat, voelde zich geagiteerd door de houding van de regering-Biden om de belasting in te voeren. Hij <a href="https://twitter.com/RobertKennedyJr/status/1653808786577010697" rel="nofollow noopener noreferrer" target="_blank">getweet</a>‘Cryptocurrencies, geleid door bitcoin, samen met andere cryptotechnologieën, zijn een belangrijke innovatiemotor. Het is een fout voor de Amerikaanse overheid om de sector te belemmeren en innovatie elders te stimuleren. Bidens voorgestelde 30% belasting op cryptocurrency mining is een slecht idee.’ Dergelijke opvattingen tonen aan dat Biden niet zo progressief is als Trump wat betreft digitale activa.</p>
<p>Geoffrey Kendrick, digitale activa-onderzoeker bij Standard Chartered, heeft gereageerd op de standpunten van Trump en Biden ten opzichte van cryptocurrencies. Hij <a href="https://www.kitco.com/news/article/2024-05-09/battle-lines-drawn-trump-advocates-crypto-while-biden-looks-regulate" rel="nofollow noopener noreferrer" target="_blank">zei</a>“Hoewel ambtenaren in de regering-Biden een relatief harde lijn hebben ingenomen ten aanzien van digitale activa, zei Trump in een interview in maart dat hij, als hij gekozen werd, geen hard optreden zou toepassen tegen Bitcoin of andere digitale activa.”</p>
<p>Hij vervolgde: “We denken dat een tweede regering-Trump over het algemeen positief zou zijn via een meer ondersteunende regelgeving. In een scenario van Amerikaanse fiscale dominantie denken we dat Bitcoin een goede bescherming zou bieden tegen de-dollarisatie en afnemend vertrouwen in de Amerikaanse schatkistmarkt.”</p>
<p>Tijdens zijn eerste ambtstermijn nam Trump een laissez-faire benadering aan. Zo’n hands-off benadering hielp de cryptosector in de Verenigde Staten te groeien. Zijn beleid van deregulering en belastingverlagingen die investeringen ondersteunden, bevorderde ook de groei van de digitale sector.</p>
<p>Daarentegen heeft de Biden-regering zich gericht op het reguleren van de crypto-sector. Hoewel wetgeving noodzakelijk is voor de stabiliteit van de sector en consumentenbescherming, remt overregulering innovatie af.</p>
<h2 id="h2-Institutioneel20Omarmen20De20MarketVector20Meme20Coin20Index389728"><a name="Institutioneel Omarmen: De MarketVector Meme Coin Index" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Institutioneel Omarmen: De MarketVector Meme Coin Index</h2><p>Op dit moment is er een stijging van institutionele investeringen in cryptocurrencies. Als voorbeeld heeft VanEck, een in New York gevestigde vermogensbeheerder die bekend staat om de lancering van een spot bitcoin ETF in januari, een MarketVector Meme Coin Index (memecoin) geïntroduceerd. De memecoin-index van VanEck volgt de waarde van toonaangevende memecoins. <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Dogecoin (DOGE)](https://www.gate.io/blog_detail/265/sg93ifrviej1esbeb2dly29pbibpbibhyxrllmlvihwgqnv5iervz2u “Dogecoin (DOGE)”) en [Shiba Inu</a> (SHIB). Zo’n index geeft beleggers de kans om op een gestructureerde manier te investeren in de memecoin-sector, die hoog risico maar ook hoge beloning met zich meebrengt.</p>
<h2 id="h2-Conclusie719022"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Trump’s positieve retoriek over cryptocurrency leidde tot een stijging van de prijzen van de top 50 memecoins. Het plaatste hem ook als een pro-crypto presidentskandidaat voor de verkiezingen van dit jaar in de Verenigde Staten. Als gevolg van zijn recente toespraak hebben verschillende prominente toezichthouders en leiders van crypto-bedrijven Trump’s nieuwe standpunt over digitale activa toegejuicht. Ondertussen heeft VanEck, een in New York gevestigde vermogensbeheerder, zijn memecoin-index gelanceerd, wat wijst op de grotere erkenning van memecoins dan voorheen.</p>
<div class="blog-details-info"><br><div>Auteur:<em> Mashell C.</em>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen investeringssuggesties.<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 genoemd. In alle glen zal juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>