QW5hbGlzaSBlc2NsdXNpdmEgZGVsbGUgcGFydGVjaXBhemlvbmkgZSBkZWxsYSBzdHJhdGVnaWEgZGkgaW52ZXN0aW1lbnRvIGRlbGxhIGZhbWlnbGlhIFRydW1wIGRpIFdMRkk=

<p><img src="https://gimg2.gateimg.com/image/article/1743066793RDZZ.png" alt=""></p>
<h2 id="h2-TLDR648335"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Al 25 marzo 2025, il portafoglio di investimenti di World Liberty Financial (WLFI) è valutato approssimativamente a $80,89 milioni, composto principalmente da ETH, WBTC e altri token correlati a DeFi.</p>
<p>La ricerca mostra che la strategia di acquisto di WLFI è progettata per diversificare i suoi asset, ridurre il rischio di volatilità di mercato e sostenere la crescita dell’ecosistema della finanza decentralizzata.</p>
<p>Sebbene l’influenza della famiglia Trump possa aver suscitato l’interesse degli investitori, il progetto si trova anche di fronte a polemiche, con una perdita non realizzata di circa 100 milioni di dollari, che solleva dubbi sulla sua trasparenza e sostenibilità.</p>
<h2 id="h2-Introduzione807408"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>World Liberty Financial (WLFI) è un progetto di finanza decentralizzata (DeFi) legato alla famiglia Trump. Sebbene il progetto promuova una visione grandiosa di “ridisegnare la finanza decentralizzata per la democratizzazione”, ha dimostrato un approccio chiaramente orientato al mercato nella pratica, avendo acquistato una serie di criptovalute. Nonostante l’influenza delle celebrità, ora si trova di fronte a una perdita cartacea di 100 milioni di dollari. Sorge la domanda: si tratta di una legittima strategia di investimento a lungo termine, o è piuttosto un’abile iniziativa promozionale mascherata a fini propri del progetto?</p>
<p>Questo articolo, basato sui dati on-chain pubblicamente disponibili di WLFI, approfondirà le motivazioni dietro le sue partecipazioni, la logica degli investimenti e i rischi potenziali, mentre scopre il complesso ecosistema delle forze politiche che influenziano il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a>.</p>
<h2 id="h2-WLFI20Continua20ad20Acquistare20la20Perdita20su20Carta20Colpisce2010920Milioni55004"><a name="WLFI Continua ad Acquistare, la Perdita su Carta Colpisce $109 Milioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WLFI Continua ad Acquistare, la Perdita su Carta Colpisce $109 Milioni</h2><p><img src="https://gimg2.gateimg.com/image/article/17430665361.png" alt=""><br>Fonte: worldlibertyfinancial.com</p>
<p>World Liberty Financial (WLFI), un progetto DeFi legato alla famiglia Trump, ha attirato notevole attenzione dal suo inizio nel 2024. L’attuale Presidente degli Stati Uniti, Donald Trump, agisce come il “Principale Sostenitore delle Criptovalute”, con i suoi figli, Eric, Donald Jr. e Barron, che fungono da <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Ambasciatori” o “Visionari DeFi”. Il progetto mira a offrire una piattaforma per investimenti e prestiti crittografici, e ha recentemente acquisito una varietà di asset digitali per espandere le sue riserve strategiche.</p>
<p>Secondo i dati on-chain, al momento della stesura di questo articolo, WLFI ha investito circa $343 milioni in 11 criptovalute, tra cui 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 e MNT. Tra questi, BTC, ETH, TRX, <a href="/price/link-ln" target="_blank" class="blog_inner_link">LINK</a>, SUI e ONDO fanno parte delle sue riserve strategiche, con una perdita in conto economico totale di circa $100 milioni.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17430665482.png" alt=""><br>Origine: ARKHAM</p>
<p>Al momento della stesura, gli indirizzi del portafoglio WLFI detengono collettivamente circa 84,84 milioni di dollari in attività crittografiche, con ETH che rappresenta la quota più grande. A causa della recente prolungata debolezza dell’ETH, ciò ha comportato perdite significative non realizzate. Di seguito è riportata una suddivisione delle principali detenzioni:</p>
<table>
<thead>
<tr>
<th style="text-align:center">Asset</th>
<th style="text-align:center">Titoli</th>
<th style="text-align:center">Valore（USD）</th>
<th style="text-align:center">Percentuale</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">Core holding, fortemente influenzato dalle fluttuazioni di mercato</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">Prezzo di acquisto iniziale: $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">MUOVERSI</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">Acquisti recenti il 16 e il 24 marzo</td>
</tr>
<tr>
<td style="text-align:center">Altri（SUI, SEI, AVAX e altro）</td>
<td style="text-align:center">Diversificato</td>
<td style="text-align:center">$30.95M</td>
<td style="text-align:center">Diversificato in progetti emergenti</td>
</tr>
</tbody>
</table>
<p>Origine: Gate.io, compilato da informazioni pubbliche</p>
<h2 id="h2-Logica20degli20investimenti20Sinergia20politica20e20commerciale191400"><a name="Logica degli investimenti: Sinergia politica e commerciale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Logica degli investimenti: Sinergia politica e commerciale</h2><p>Analizzando il portafoglio di WLFI, le partecipazioni sono dominate dalle principali criptovalute come BTC, ETH e TRX, con attività emergenti come MNT, MOVE, AVAX e ONDO che figurano in modo prominente. Interessante notare che ciò differisce dalle criptovalute menzionate nella recente richiesta di Trump per le riserve di criptovalute del governo degli Stati Uniti, con <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, SOL e ADA esclusi. Questo suggerisce una strategia commerciale per evitare token considerati titoli dalla SEC.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17430665593.png" alt=""><br>Sorgente:@realDonaldTrump</p>
<p>WLFI ha stabilito partnership con progetti come Ondo Finance (ONDO), Ethena (ENA), Chainlink (LINK), Sui (SUI) e <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> (AAVE), tutti focalizzati su DeFi o Real-World Asset (RWA), in linea con l’autoposizionamento di WLFI come leader DeFi.</p>
<p>Nonostante le dichiarazioni dell’organizzazione Trump che affermano di non avere un controllo diretto sulle attività commerciali di WLFI, i critici sostengono che gli acquisti del progetto possano essere guidati dalla “monetizzazione degli influencer”. In altre parole, accettare vantaggi da progetti token, effettuare acquisti consistenti per aumentare il prezzo di determinati token e cercare guadagni commerciali asimmetrici, il tutto aiutando i progetti a ottenere visibilità e credibilità. Ad esempio, durante la stesura di questo articolo, il token CRO è aumentato di oltre il 30% a seguito dell’annuncio di una collaborazione tra il gruppo di Trump e Truth.Fi per lanciare ETF e prodotti correlati.</p>
<p>Inoltre, l’attività di trading di WLFI mostra una notevole correlazione con la presidenza di Trump. Dopo la sua inaugurazione, i rischi periferici del progetto sono diminuiti significativamente, con un aumento degli scambi e dei volumi nei token emergenti come MNT, indicando aspettative di un ambiente macroeconomico più disteso e un rimbalzo nel mercato delle altcoin.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17430665684.png" alt=""><br>Sorgente: ARKHAM</p>
<p>Da un punto di vista politico, il coinvolgimento della famiglia Trump negli investimenti in criptovalute aiuta a consolidare la loro immagine “anti-establishment”, allineandosi con le tendenze libertarie dei loro sostenitori (come l’opposizione alla regolamentazione finanziaria). Ironia della sorte, il white paper di WLFI afferma che la famiglia di Trump, attraverso DT Marks DEFI LLC, riceve il 75% degli utili netti, con il restante 25% distribuito tra i membri principali. Questo “diritto al profitto a rischio zero” riduce al minimo la loro esposizione alla volatilità del mercato, spostando il rischio sui possessori di token.</p>
<p>Inoltre, Steven Witkoff, un membro chiave del team di campagna di Trump, è coinvolto con WLFI, posizionandolo ulteriormente come un giocatore nelle manovre politiche.</p>
<p>Restrizioni per gli utenti: WLFI è attualmente disponibile solo per gli utenti al di fuori degli Stati Uniti e non è registrato presso alcun organismo di regolamentazione finanziaria, evitando così una responsabilità diretta ai sensi delle leggi sui titoli statunitensi.</p>
<p>Blocco del token: i token WLFI della sua prevendita sono bloccati per 12 mesi fino a novembre 2025, coincidendo con il mandato del presidente della SEC, creando una finestra per potenziali vendite post-blocco.</p>
<p>Filtraggio degli asset sensibili: Come accennato, WLFI evita i token sotto la supervisione della SEC (come <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a>) e si concentra sugli asset RWA come ONDO e sui token del protocollo come AAVE, riducendo al minimo i conflitti regolamentari.</p>
<h2 id="h2-La20strategia20di20investimento20di20Gate20non20riguarda20solo20il20denaro524596"><a name="La strategia di investimento di Gate: non riguarda solo il denaro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La strategia di investimento di Gate: non riguarda solo il denaro</h2><p>Dall’analisi sopra, è chiaro che i movimenti del portafoglio di WLFI sono deliberatamente separati sia dal piano di riserva crittografica del governo degli Stati Uniti che dal token omonimo della famiglia Trump, TRUMP. Questo suggerisce un modello di investimento distinto all’interno dell’approccio della famiglia Trump agli asset crittografici: la famiglia sembra preferire asset principali e settori DeFi/RWA nel loro approccio agli investimenti.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17430665785.png" alt=""><br>Source：blog.ondo.finance</p>
<p>In particolare, il loro posizionamento strategico in asset emergenti ha facilitato partnership con progetti come Chainlink e Ondo, aumentando anche l’esposizione e la credibilità delle loro partecipazioni. Le loro partecipazioni diversificate riducono anche la volatilità del rischio. Anche se la principale partecipazione, ETH, ha portato a significative perdite cartacee, questo è un esito comune per gli investitori istituzionali che detengono grandi quantità di asset mainstream per periodi prolungati.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17430665866.png" alt=""><br>Sorgente: ARKHAM</p>
<p>Tuttavia, essendo un progetto politicamente connesso, WLFI ha sfruttato il suo status di celebrità per guidare i movimenti di mercato. Tuttavia, la trasparenza e le performance commerciali hanno eroso la fiducia dei sostenitori. Alcuni critici suggeriscono che alcuni investitori potrebbero acquistare token WLFI o pagare per far acquistare i loro token da parte di WLFI per ottenere accesso all’influenza di Trump. Le mosse di investimento di WLFI sembrano più un tentativo di trarre profitto dall’effetto celebrità facendo investimenti strategici in anticipo. In altre parole, WLFI sembra più un “schema di profitto” piuttosto che un autentico progetto DeFi, portando a rischi di comportamenti “pump-and-dump”. Ad esempio, l’approvazione pubblica di Eric Trump di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, seguita da una vendita delle sue partecipazioni, ha suscitato domande sulla trasparenza.</p>
<p>Il futuro di WLFI è strettamente legato alle politiche cripto-friendly dell’amministrazione Trump. I suoi movimenti di mercato hanno attirato un’attenzione significativa, aumentando la sua influenza di mercato. Tuttavia, affronta anche sfide come la volatilità di mercato, la mancanza di trasparenza e problemi di governance. Le recenti fluttuazioni di mercato hanno visto i portafogli di WLFI passare da profitti importanti a perdite moderate, evidenziando le sfide che deve affrontare nella gestione della sua strategia di investimento e dei rischi. Questo serve come promemoria per approcciare tali investimenti con cautela e evitare di seguire ciecamente le tendenze di mercato guidate dalle celebrità.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Charle Y.</strong>, Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni prudenti.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>