RXhjbHVzaWV2ZSBhbmFseXNlIHZhbiBkZSBXTEZJIEhvbGRpbmdzIGVuIGludmVzdGVyaW5nc3N0cmF0ZWdpZSB2YW4gZGUgZmFtaWxpZSBUcnVtcA==

<p><img src="https://gimg2.gateimg.com/image/article/1743066793RDZZ.png" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen259677"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Op 25 maart 2025 wordt de beleggingsportefeuille van World Liberty Financial (WLFI) gewaardeerd op ongeveer $80,89 miljoen, voornamelijk bestaande uit ETH, WBTC en andere DeFi-gerelateerde tokens.</p>
<p>Onderzoek toont aan dat het inkoopbeleid van WLFI is ontworpen om de activa te diversifiëren, het marktrisico te verminderen en de groei van het gedecentraliseerde financiële ecosysteem te ondersteunen.</p>
<p>Hoewel de invloed van de Trump-familie investeerdersinteresse kan hebben gewekt, staat het project ook voor controverse, met een ongerealiseerd verlies van ongeveer $100 miljoen, wat vragen oproept over de transparantie en duurzaamheid ervan.</p>
<h2 id="h2-Introductie828375"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>World Liberty Financial (WLFI) is een gedecentraliseerd financieel (DeFi) project dat verbonden is met de familie Trump. Terwijl het project een grootse visie promoot van ‘hervorming van gedecentraliseerde financiën voor democratisering’, heeft het in de praktijk een duidelijke marktgerichte benadering laten zien door een reeks cryptocurrencies te kopen. Ondanks de invloed van beroemdheden, staat het nu voor een papieren verlies van $100 miljoen. De vraag rijst: is dit een legitieme langetermijnbeleggingsstrategie, of is het een slim vermomde promotie-inspanning voor het eigen voordeel van het project?</p>
<p>Dit artikel, gebaseerd op de openbaar beschikbare on-chain gegevens van WLFI, zal ingaan op de motivaties achter haar bezit, investeringslogica en potentiële risico’s, terwijl het complexe ecosysteem van politieke krachten die van invloed zijn op de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptocurrency markt</a>.</p>
<h2 id="h2-WLFI20Blijft20Kopen20Papieren20Verlies20Raakt2010920Miljoen347337"><a name="WLFI Blijft Kopen, Papieren Verlies Raakt $109 Miljoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WLFI Blijft Kopen, Papieren Verlies Raakt $109 Miljoen</h2><p><img src="https://gimg2.gateimg.com/image/article/17430665361.png" alt=""><br>Bron: worldlibertyfinancial.com</p>
<p>World Liberty Financial (WLFI), een DeFi-project verbonden met de familie Trump, heeft sinds de oprichting in 2024 aanzienlijke aandacht getrokken. De huidige president van de VS, Donald Trump, treedt op als de “Chief Crypto Advocate,” met zijn zonen, Eric, Donald Jr. en Barron, die dienen als “ <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Ambassadeurs” of “DeFi-visionairs.” Het project heeft tot doel een platform te bieden voor crypto-investeringen en leningen en heeft onlangs een verscheidenheid aan digitale activa verworven om zijn strategische reserves uit te breiden.</p>
<p>Volgens on-chain gegevens heeft WLFI tot het schrijven van dit artikel ongeveer $343 miljoen geïnvesteerd in 11 cryptocurrencies, waaronder ETH, WBTC, TRX, <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a>, <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">AAVE</a>, ENA, MOVE, ONDO, SEI, AVAX, en MNT. Onder deze, BTC, ETH, TRX, <a href="/price/link-ln" target="_blank" class="blog_inner_link">LINK</a>, SUI, en ONDO maken deel uit van zijn strategische reserves, met een totaal papieren verlies van ongeveer $100 miljoen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17430665482.png" alt=""><br>Bron: ARKHAM</p>
<p>Op het moment van schrijven houden WLFI walletadressen gezamenlijk ongeveer $84,84 miljoen aan crypto-activa vast, waarbij ETH het grootste deel voor zijn rekening neemt. Door de recente langdurige zwakte van ETH heeft dit geleid tot aanzienlijke ongerealiseerde verliezen. Hieronder volgt een uitsplitsing van de belangrijkste bezittingen:</p>
<table>
<thead>
<tr>
<th style="text-align:center">Activa</th>
<th style="text-align:center">Houdingen</th>
<th style="text-align:center">Waarde (USD)</th>
<th style="text-align:center">Percentage</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:center">ETH</td>
<td style="text-align:center">7.93K</td>
<td style="text-align:center">$16.08M</td>
<td style="text-align:center">Kernbezit, zwaar getroffen door marktfluctuaties</td>
</tr>
<tr>
<td style="text-align:center">TRX</td>
<td style="text-align:center">40.72M</td>
<td style="text-align:center">$9.44M</td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:center">WBTC</td>
<td style="text-align:center">162.69</td>
<td style="text-align:center">$14.24M</td>
<td style="text-align:center">Aankoopprijs: $10M</td>
</tr>
<tr>
<td style="text-align:center">stETH</td>
<td style="text-align:center">4.94K</td>
<td style="text-align:center">$10.09M</td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:center">VERPLAATSEN</td>
<td style="text-align:center">7.581M</td>
<td style="text-align:center">$3.81M</td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:center">MNT</td>
<td style="text-align:center">5.99M</td>
<td style="text-align:center">$5.07M</td>
<td style="text-align:center">Recent aankopen op 16 en 24 maart</td>
</tr>
<tr>
<td style="text-align:center">Anderen（SUI, SEI, AVAX en meer）</td>
<td style="text-align:center">Diversified</td>
<td style="text-align:center">$30.95M</td>
<td style="text-align:center">Diversified in opkomende projecten</td>
</tr>
</tbody>
</table>
<p>Bron: Gate.io, samengesteld uit openbare informatie</p>
<h2 id="h2-Investeringslogica20Politieke20en20Commercile20Synergie467116"><a name="Investeringslogica: Politieke en Commerciële Synergie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Investeringslogica: Politieke en Commerciële Synergie</h2><p>Bij het analyseren van de portefeuille van WLFI, worden de holdings gedomineerd door grote cryptocurrencies zoals BTC, ETH en TRX, met opkomende activa zoals MNT, MOVE, AVAX en ONDO die ook prominent aanwezig zijn. Interessant is dat dit verschilt van de cryptocurrencies die genoemd worden in de recente oproep van Trump voor de cryptoreserves van de Amerikaanse overheid, met <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, SOL en ADA uitgesloten. Dit suggereert een commerciële strategie om tokens te vermijden die door de SEC als effecten worden beschouwd.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17430665593.png" alt=""><br>Bron:@realDonaldTrump</p>
<p>WLFI heeft partnerschappen gesloten met projecten zoals Ondo Finance (ONDO), Ethena (ENA), Chainlink (LINK), Sui (SUI) en <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> (AAVE), die allemaal gericht zijn op DeFi of Real-World Asset (RWA), in lijn met WLFI’s zelfpositionering als een DeFi-leider.</p>
<p>Ondanks verklaringen van de Trump-organisatie waarin wordt beweerd geen directe controle te hebben over de zakelijke activiteiten van WLFI, beweren critici dat de aankopen van het project mogelijk worden gedreven door ‘influencer-monetisatie’. Met andere woorden, voordelen accepteren van tokenprojecten, grote aankopen doen om de prijs van bepaalde tokens op te drijven en streven naar asymmetrische commerciële winsten, terwijl ze de projecten helpen exposure en geloofwaardigheid te krijgen. Zo steeg bijvoorbeeld de CRO-token met meer dan 30% na de aankondiging van een samenwerking tussen de groep van Trump en Truth.Fi om ETF’s en gerelateerde producten te lanceren tijdens het schrijven van dit artikel.</p>
<p>Bovendien vertoont de handelsactiviteit van WLFI een opmerkelijke correlatie met het presidentschap van Trump. Na zijn inauguratie daalden de perifere risico’s van het project aanzienlijk, met een toename van transacties en volumes in opkomende tokens zoals MNT, wat wijst op verwachtingen van een versoepeld macro-economisch klimaat en een herstel op de altcoinmarkt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17430665684.png" alt=""><br>Bron:ARKHAM</p>
<p>Vanuit politiek oogpunt helpt de betrokkenheid van de familie Trump bij cryptoinvesteringen om hun ‘anti-establishment’ imago te versterken, in lijn met de libertaire neigingen van hun aanhangers (zoals oppositie tegen financiële regulering). Ironisch genoeg stelt het whitepaper van WLFI dat de familie Trump, via DT Marks DEFI LLC, 75% van de nettowinst ontvangt, waarbij de overige 25% wordt verdeeld onder kernleden. Dit ‘zero-risk profit entitlement’ minimaliseert hun blootstelling aan marktvolatiliteit terwijl het risico wordt verschoven naar tokenhouders.</p>
<p>Bovendien is Steven Witkoff, een belangrijk lid van het campagneteam van Trump, betrokken bij WLFI, waardoor het zich verder positioneert als een speler in politieke manoeuvres.</p>
<p>Gebruikersbeperkingen: WLFI is momenteel alleen beschikbaar voor gebruikers buiten de VS en is niet geregistreerd bij financiële toezichthoudende instanties, waardoor directe verantwoording onder de Amerikaanse effectenwetgeving wordt vermeden.</p>
<p>Token Lockup: WLFI-tokens uit de pre-sale zijn vergrendeld voor 12 maanden tot november 2025, samenvallend met de termijn van de voorzitter van de SEC, waardoor er een mogelijkheid ontstaat voor mogelijke verkoop na de vergrendeling.</p>
<p>Gevoelige activafiltering: Zoals vermeld vermijdt WLFI tokens die onder toezicht van de SEC staan (zoals <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a>) en richt zich op RWA-activa zoals ONDO en protocoltokens zoals AAVE, waarbij regelgevingsconflicten worden geminimaliseerd.</p>
<h2 id="h2-WLFIs20Investeringsstrategie20Niet20Alleen20Over20het20Geld848181"><a name="WLFI’s Investeringsstrategie: Niet Alleen Over het Geld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WLFI’s Investeringsstrategie: Niet Alleen Over het Geld</h2><p>Uit de bovenstaande analyse blijkt duidelijk dat de portefeuillebewegingen van WLFI opzettelijk gescheiden zijn van zowel het cryptoreservatieplan van de Amerikaanse overheid als de namenstoken van de familie Trump, TRUMP. Dit suggereert een onderscheidend investeringspatroon binnen de aanpak van de Trump-familie ten opzichte van crypto-activa: de familie lijkt de voorkeur te geven aan belangrijke activa en DeFi/RWA-sectoren in hun investeringsbenadering.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17430665785.png" alt=""><br>Bron: blog.ondo.finance</p>
<p>In het bijzonder heeft hun strategische positionering in opkomende activa partnerschappen met projecten zoals Chainlink en Ondo gefaciliteerd, terwijl ook de blootstelling en geloofwaardigheid van hun bezittingen worden versterkt. Hun gediversifieerde bezittingen verminderen ook het risicovolatiliteit. Hoewel de grootste bezitting, ETH, heeft geleid tot aanzienlijke papieren verliezen, is dit een veelvoorkomend resultaat voor institutionele beleggers die grote hoeveelheden mainstream activa gedurende lange perioden aanhouden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17430665866.png" alt=""><br>Bron: ARKHAM</p>
<p>Echter, als een politiek verbonden project, heeft WLFI zijn bekendheid gebruikt om marktbewegingen te stimuleren. Toch hebben de transparantie en prestaties van de handel het vertrouwen van volgers aangetast. Sommige critici suggereren dat bepaalde investeerders WLFI-tokens zouden kunnen kopen of betalen om hun tokens door WLFI te laten kopen om toegang te krijgen tot de invloed van Trump. De investeringsbewegingen van WLFI lijken meer op een poging om te profiteren van het beroemdhedeneffect door strategische investeringen vooraf te doen. Met andere woorden, WLFI lijkt meer op een ‘winstgevend schema’ dan op een echt DeFi-project, met risico’s van ‘pump-and-dump’-gedrag. Zo heeft bijvoorbeeld Eric Trump publiekelijk zijn steun betuigd aan <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, gevolgd door de verkoop van zijn aandelen, deed vragen rijzen over transparantie.</p>
<p>De toekomst van WLFI is diep verbonden met het crypto-vriendelijke beleid van de Trump-regering. Zijn marktbewegingen hebben aanzienlijke aandacht getrokken en zijn marktinvloed vergroot. Het staat echter ook voor uitdagingen zoals marktvolatiliteit, gebrek aan transparantie en governance-kwesties. Recente marktfluctuaties hebben gezien dat de WLFI’s holdings verschuiven van grote winsten naar gematigde verliezen, waarbij de uitdagingen waar het voor staat bij het beheren van zijn investeringsstrategie en risico’s worden benadrukt. Dit dient als een herinnering om dergelijke investeringen met voorzichtigheid te benaderen en blindelings de door beroemdheden gedreven markttrends te vermijden.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Charle Y.</strong>, Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling. Alle investeringen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<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 genoemd. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>