Q29zYSBzb25vIGkgUmVzb2x2IExhYnM/IEVzcGxvcmFuZG8gbGUgaW5ub3ZhemlvbmkgZSBpIHJpc2NoaSBkZWwgc3VvIHByb3RvY29sbG8gc3RhYmxlY29pbiBhIGRvcHBpbyB0b2tlbi4=

2025-06-16, 06:19

<p><img src="https://gimg2.gateimg.com/image/re202506161418563982301556.png" alt="">
</p><p>Resolv Labs fa il suo debutto nel 2024 con il protocollo stablecoin Delta neutral, attirando 50.000 utenti e 340 milioni di dollari in TVL in soli 9 mesi (attraverso Ethereum, Base, e <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Il prodotto principale, la stablecoin USR, attraverso la collateralizzazione ETH/BTC e la copertura dei contratti perpetui, raggiunge la caratteristica “yield + bassa volatilità”, iniettando un nuovo paradigma nel mercato DeFi. Il token di governance RESOLV, lanciato a maggio 2025, sta diventando un motore chiave per l’espansione dell’ecosistema del protocollo.</p>
<h2 id="h2-Innovazione20Fondamentale913247"><a name="Innovazione Fondamentale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Innovazione Fondamentale</h2><p>La competitività di Resolv deriva dalla sua progettazione economica della stratificazione del rischio:</p>
<ul>
<li>Stablecoin USR: Ancorato a 1 USD, offre un rendimento base del 3%-5% attraverso lo staking di ETH/BTC su Lido, combinato con strategie di copertura di contratti perpetui (su piattaforme come Binance, Hyperliquid, ecc.), raggiungendo un rendimento annualizzato complessivo del 7%-10%, fornendo rendimenti da “obbligazioni quasi governative” per investitori a bassa propensione al rischio.</li><li>RLP Risk Token: In quanto posizione subordinata, sopporta il rischio di liquidazione in condizioni di mercato estreme, in cambio di un alto rendimento annuo del 20%-30%, e funge da pool di buffer assicurativo per USR (il riscatto è sospeso quando il rapporto di collateralizzazione è inferiore al 110%).</li><li>Token di Governance RESOLV: Coordinare la governance ecologica e la cattura del valore, formando una struttura trinitaria di “stablecoin + strato di rischio + diritti di governance”.</li></ul>
<h2 id="h2-Economia20del20Token20RESOLV957932"><a name="Economia del Token RESOLV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Economia del Token RESOLV</h2><h3 id="h3-Il20modello20di20allocazione20rafforza20il20consenso20a20lungo20termine458107"><a name="Il modello di allocazione rafforza il consenso a lungo termine" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il modello di allocazione rafforza il consenso a lungo termine</h3><ul>
<li>Offerta totale di 1 miliardo di token, con una circolazione iniziale del 12% (aumentata al 15,6% dopo la quotazione sugli scambi);</li><li>L’airdrop rappresenta il 10% (sblocco TGE utente della Stagione 1), ecosistema e comunità 40,9% (sblocco lineare di 24 mesi), team 26,7% (blocco di 1 anno + rilascio di 30 mesi), investitori 22,4% (blocco di 1 anno + rilascio di 24 mesi);</li><li>Il lungo periodo di lock-up per i token del team e degli investitori allevia la pressione di vendita e mette in evidenza l’impegno verso la conformità.</li></ul>
<h3 id="h3-Utilit20del20Token20Doppio20Motore20di20Governance20e20Entrate510276"><a name="Utilità del Token: Doppio Motore di Governance e Entrate" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Utilità del Token: Doppio Motore di Governance e Entrate</h3><ul>
<li>Diritti di governance: Vota per determinare i parametri del protocollo come gli attivi collaterali e le strutture delle commissioni;</li><li>Ricompense per il staking: La durata di detenzione attiva un effetto moltiplicatore (fino a 2x ricompense), condividendo le commissioni di conio/riscatto di USR;</li><li>Integrazione DeFi Lego: Può essere combinato con USR per accedere a protocolli come Pendle (tokenizzazione dei rendimenti), Curve (pool di liquidità), Hyperliquid (copertura), ecc., per ottenere un miglioramento del rendimento cross-chain.</li></ul>
<h3 id="h3-Progresso20Ecologico20Crescita20dei20Dati20e20Approvazione20dello20Scambio927089"><a name="Progresso Ecologico: Crescita dei Dati e Approvazione dello Scambio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Progresso Ecologico: Crescita dei Dati e Approvazione dello Scambio</h3><ul>
<li>Utenti e Scala di Capitale: Gli utenti attivi mensili rappresentano il 56%, superando la media del settore del 30%, con un importo totale di coniazione e riscatto che supera 1,7 miliardi di dollari;</li><li>Layout dell’exchange: Arrivo su Gate a Giugno 2025, supportando coppie di trading come RESOLV/USDT e USDC, lanciando contemporaneamente contratti perpetui con leva 50x;</li><li>Adozione Istituzionale: Le soluzioni di custodia Fireblocks attraggono le istituzioni di gestione degli asset crypto a utilizzare USR come asset di “tesoreria on-chain”.</li></ul>
<h3 id="h3-Avviso20di20rischio20Sfide20potenziali20sotto20complessit622991"><a name="Avviso di rischio: Sfide potenziali sotto complessità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Avviso di rischio: Sfide potenziali sotto complessità</h3><ol>
<li>Volatilità del tasso di finanziamento: Se il tasso di finanziamento del contratto perpetuo diventa negativo (ad esempio, in un mercato ribassista), RLP potrebbe subire perdite o addirittura esaurirsi;</li><li>Pressione Regolamentare: Le stablecoin che generano interessi potrebbero essere considerate come titoli secondo il MiCA dell’UE, affrontando una ristrutturazione di conformità.</li><li>Vulnerabilità dei contratti intelligenti: i bridge multi-chain e i contratti di copertura aumentano la superficie di attacco, richiedendo l’approvazione da parte delle principali società di auditing (attualmente solo auditati da MixBytes).</li></ol>
<h2 id="h2-Piano20Futuro20Espansione20CrossChain20ed20Evoluzione20della20Governance262936"><a name="Piano Futuro: Espansione Cross-Chain ed Evoluzione della Governance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Piano Futuro: Espansione Cross-Chain ed Evoluzione della Governance</h2><p>Il piano di Resolv per il 2025 si concentra su tre direzioni principali:</p>
<ol>
<li>Collaterale multi-asset: BTC è già supportato e in futuro espanderemo il vault di altcoin per diversificare le fonti di reddito;</li><li>Strategia di Looping: Collaborare con il protocollo del mercato monetario per rilasciare scenari di prestito USR;</li><li>Governanza DAO: Il voto on-chain sarà lanciato nel quarto trimestre del 2025, con i detentori di RESOLV che controlleranno i parametri chiave.</li></ol>
<p>Impatto sul mercato: il modello di “yield nativo on-chain” di Resolv affronta direttamente i punti dolenti delle stablecoin senza interessi come USDC e DAI, e il suo design a strati RLP mostra anche una maggiore resistenza alla volatilità rispetto a concorrenti come Ethena (che ha un pool di buffer senza rischio). Se la resilienza del modello può essere convalidata durante i cicli di mercato rialzisti e ribassisti, si prevede che rimodelli il panorama del settore delle stablecoin DeFi.</p>
<p>Il valore del token RESOLV è essenzialmente la conferma dei diritti alla distribuzione delle entrate del protocollo. Con il lancio della sua governance DAO e l’espansione della rete di liquidità cross-chain, Resolv sta evolvendo da un protocollo stabile a un’infrastruttura per dollari on-chain generanti rendimento—se riuscirà a bilanciare alti rendimenti con la sostenibilità sarà fondamentale per rompere il “ciclo di morte delle stablecoin algoritmiche.”</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso di tutti o di una parte dei Servizi da Località Vietate. Per ulteriori informazioni, si prega di leggere l'Accordo dell'Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="2">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>