V2VyZWxkIExpYmVydHkgRmluYW5jaWFsIFdoaXRlcGFwZXIgQW5hbHlzZTogV2F0IGlzIGRlIHZvb3J1aXR6aWNodGVuIHZvb3IgZGUgVVNEMSBTdGFibGVjb2luPw==

2025-06-05, 08:24

<p><img src="https://gimg2.gateimg.com/image/wlfi202506051622383993433725.png" alt="">
</p><p>Het cryptocurrency-project World Liberty Financial (WLFI), ondersteund door de familie van de voormalige Amerikaanse president Donald Trump, is snel een brandpunt geworden voor de integratie van politiek, financiën en blockchain-technologie sinds de oprichting in 2024. De White Paper van het project schetst een ambitieuze blauwdruk die gedecentraliseerde financiële protocollen, governance-tokens en de stablecoin USD1 omvat, terwijl het ook voortdurende controverses oproept vanwege kwesties van winstverdeling en naleving.</p>
<h2 id="h2-Kerninhoud20van20het20White20Paper20Governancestructuur20en20winstverdeling182991"><a name="Kerninhoud van het White Paper: Governance-structuur en winstverdeling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kerninhoud van het White Paper: Governance-structuur en winstverdeling</h2><ol>
<li><p>Project Achtergrond en Rol Positionering: WLFI is gepositioneerd als een gedecentraliseerd financieel platform voor “gebruikers co-bestuur”, dat leningen, stablecoin en token governance functies omvat. Trump is vermeld als de “Chief Crypto Advocate”, met zijn zonen Eric Trump en Donald Trump Jr. als “Web3 Ambassadors”, terwijl de 18-jarige Barron Trump de titel “DeFi Visionary” heeft gekregen. De White Paper vermeldt ook dat de familie Trump “het bedrijf niet bezit, beheert of opereert”, en mogelijk alleen erevergoeding kan ontvangen.</p>
</li><li><p>Token Allocatie Geschil</p>
<ul>
<li>Zeer gecentraliseerde controle: De familie Trump controleert 22,5 miljard governance tokens WLFI (goed voor 22,5% van de totale voorraad) via het holdingbedrijf DT Marks DEFI LLC, en geniet 75% van de rechten op de verdeling van het netto-inkomen van het protocol.</li><li>Insider-geleid: 70% van de WLFI-tokens is gereserveerd voor oprichters, team en dienstverleners, met slechts 30% beschikbaar voor openbare verkoop.</li><li>Niet-overdraagbaar ontwerp: WLFI-tokens zijn aanvankelijk ingesteld als niet-overdraagbaar, wat betekent dat gebruikers ze niet kunnen verhandelen of overdragen, en ze alleen kunnen gebruiken voor governance stemprocedures, wat de liquiditeit aanzienlijk beperkt.</li></ul>
</li><li>Financiering en Kapitaalstroom: Het project heeft $550 miljoen opgehaald via twee rondes van tokenverkoop, met een waardering van $1,5 miljard. Van dit bedrag was $30 miljoen gereserveerd voor operationele middelen, maar de eerste ronde van openbare verkopen bereikte slechts $12,9 miljoen, wat niet voldeed aan het initiële doel.</li></ol>
<h2 id="h2-USD120stablecoin20Productontwerp20en20marktpositionering281188"><a name="USD1 stablecoin: Productontwerp en marktpositionering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>USD1 stablecoin: Productontwerp en marktpositionering</h2><ol>
<li><p>Institutionele beveiligingsarchitectuur van niveau: USD1 zal in maart 2025 worden gelanceerd, met 100% reserve-actief ondersteuning, met onderliggende activa verankerd in kortlopende Amerikaanse staatsobligaties, Amerikaanse dollar deposito’s en contante equivalenten, waardoor het ontkoppelingsrisico dat gepaard gaat met algoritmische stablecoins wordt geëlimineerd. De reserves worden beheerd door BitGo, de grootste bewaker ter wereld, en zijn onderworpen aan regelmatige audits en verzekering, wat rechtstreeks inspeelt op de kernbehoeften van institutionele klanten op het gebied van veiligheid en compliance.</p>
</li><li><p>Doorbraak in grensoverschrijdende financiële scenario’s: USD1 positioneert zich als een “naadloos grensoverschrijdend transactiehulpmiddel,” met belangrijke gebruikstoepassingen die al zijn geïmplementeerd:</p>
<ul>
<li>In mei 2025 voltooide het soevereine fonds MGX van de VAE een investering van $2 miljard in Binance met USD1.</li><li>Gereguleerde liquiditeitsdiensten aanbieden via BitGo Prime om de nalevingsdrempels voor traditionele instellingen die deelnemen aan DeFi te verlagen.</li></ul>
</li><li>Multi-chain implementatie en uitbreiding: voor het eerst gelanceerd in <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain is van plan in de toekomst uit te breiden naar meer publieke ketens en interoperabiliteit tussen ketens te bereiken via het Chainlink cross-chain protocol.</li></ol>
<h2 id="h2-Concurrentievoordeel20Politieke20middelen20en20nalevingsdividenden205557"><a name="Concurrentievoordeel: Politieke middelen en nalevingsdividenden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Concurrentievoordeel: Politieke middelen en nalevingsdividenden</h2><ul>
<li><p>Beleidssteun: In lijn met de strategie van de Trump-administratie om de “dollarhegemonie te consolideren”, steunt de minister van Financiën openbaar het “gebruik van stablecoins om de status van de dollar als wereldwijde reservevaluta te handhaven”, en de “GENIUS Act” effent de weg voor banken om stablecoins uit te geven.</p>
</li><li><p>Soeverein-niveau samenwerking: Vroegtijdige adoptie door instellingen zoals het Abu Dhabi Government Fund, dat de geloofwaardigheid ervan verifieert in grootschalige grensoverschrijdende transacties.</p>
</li><li><p>Compliance barrières: De bewakings- en auditmechanismen van BitGo creëren een onderscheiden voordeel, dat wordt geëvalueerd als een “grote doorbraak in de institutionele digitale activaruimte.”</p>
</li></ul>
<h2 id="h2-Risicos20en20Uitdagingen941562"><a name="Risico’s en Uitdagingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risico’s en Uitdagingen</h2><ol>
<li><p>De markt is zeer druk: we moeten concurreren met giganten zoals <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>(USDT) en Circle (USDC), terwijl traditionele financiële krachten zoals PayPal en Ripple ook de arena zijn binnengetreden, waardoor de kosten voor gebruikersmigratie extreem hoog zijn.</p>
</li><li><p>Centralisatie en Regelgevende Zorgen</p>
<ul>
<li>Aanvoercentralisatie: On-chain gegevens tonen aan dat 84,4% van USD1 wordt beheerd door twee portemonnees, terwijl nog eens 9,5% wordt gehouden door een derde portemonnee, wat zorgen oproept over marktmanipulatie.</li><li>Risico’s van soevereine weerstand: De Europese Centrale Bank waarschuwt dat private stablecoins het traditionele financiële systeem kunnen ondermijnen. De EU MiCA-regelgeving vereist dat de meeste reserves worden aangehouden bij gereguleerde banken en beperkt de handelsvolumes.</li></ul>
</li><li>Controverse over belangenconflicten: Leden van de Amerikaanse Senaat stellen vragen over de potentiële belangenconflicten van de familie Trump bij het ontvangen van substantiële aandelen (75% netto-inkomen) via erefuncties, terwijl de naleving van het project langdurige controle ondergaat.</li></ol>
<h2 id="h2-Toekomstige20Vooruitzichten20Belangrijke20Variabelen20in20de20Institutionele20Markt291504"><a name="Toekomstige Vooruitzichten: Belangrijke Variabelen in de Institutionele Markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstige Vooruitzichten: Belangrijke Variabelen in de Institutionele Markt</h2><p>De kans voor USD1 ligt in het vastleggen van de dubbele trends van de digitaliseringsstrategie van de Amerikaanse dollar en de institutionele adoptie van DeFi. Als het erin slaagt door te dringen in scenario’s zoals grensoverschrijdende betalingen en transacties van soevereine fondsen, wordt verwacht dat het een deel van de markt zal veroveren van giganten in het tijdperk van stablecoin 2.0. Het succes of falen hangt echter sterk af van:</p>
<ol>
<li>De continuïteit van Trump’s politieke invloed;</li><li>De tolerantie van wereldwijde regelgevende instanties ten opzichte van het “familiecontrole” model;</li><li>Of het bestaande concurrenten op het gebied van transparantie kan overtreffen (zoals reserveringsaudits).</li></ol>
<p>World Liberty Financial is zowel een testgrond voor de familie Trump om politieke kapitaal om te zetten in een cryptocurrency-entiteit als een microkosmos van traditionele financiële krachten die de dollarhegemonie uitbreiden via stablecoins. USD1 opent marktkloven met een institutioneel ontwerp, maar de sterk gecentraliseerde governance en het familie-eerst distributiemodel staan in scherpe tegenstelling tot het DeFi-ideaal van “gebruikersco-governance.” Als het er niet in slaagt om machtsstructuren in balans te brengen en de transparantie in de toekomst te verbeteren, zal het waarschijnlijk moeite hebben om een echte voet aan de grond te krijgen binnen het duopolie van het USDT- en USDC-stablecoin-framework.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hier vormt geen aanbod, verzoek of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="4">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>