Q3VydmUgRmluYW5jZSBjcnZVU0QsIGVzcGFuZGVuZG8gbGEgc3VhIHBpYXR0YWZvcm1hIERlRmkgU3RhYmxlY29pbg==

2023-05-18, 09:08
<p><img src="https://gimg2.gateimg.com/image/article/1684400249SDFX.jpeg" alt=""></p>
<h2 id="h2-TL20DR147458"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Curve Finance ha lanciato la sua stablecoin, crvUSD, sulla <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain il 3 maggio.</p>
<p>Ha annunciato pubblicamente il lancio di crvUSD che ha una garanzia di $1,8 milioni, il 4 maggio.</p>
<p>Tuttavia, la stablecoin ha registrato una performance al di sotto del suo ancoraggio fin dal lancio.</p>
<p>Il lancio del crvUSD non ha creato un impulso al rialzo del prezzo su <a href="/price/curve-dao-crv" rel="nofollow noopener noreferrer" target="_blank">Curve DAO</a> Token (CRV).</p>
<h2 id="h2-Introduzione739712"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Gli stablecoin DeFi sono tra le criptovalute più popolari in quanto molte persone li utilizzano per trasferire valore tra applicazioni decentralizzate e blockchain. Poiché mantengono un valore costante nel tempo, molte persone li accettano come mezzo di pagamento per servizi e prodotti offerti. Oggi parleremo di un nuovo stablecoin DeFi sul mercato, il crvUSD di Curve Finance.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-is-curve/425" target="_blank">Cos’è Curve?</a></p>
<h2 id="h2-Curve20Finance20presenta20la20sua20stablecoin20crvUSD490184"><a name="Curve Finance presenta la sua stablecoin, crvUSD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Curve Finance presenta la sua stablecoin, crvUSD</h2><p>Curve Finance, <a href="https://www.gate.io/blog_detail/1038/everything-you-need-to-know-about-defi" target="_blank">una finanza decentralizzata (DeFi)</a>, “Come molti hanno capito, è avvenuta la distribuzione dei contratti intelligenti crvUSD. Tuttavia, ciò non è ancora definitivo poiché anche l’interfaccia utente deve essere distribuita. Restate sintonizzati.”</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1672/10-best-defi-protocols-to-invest-during-bear-markets" target="_blank">10 Migliori Protocolli DeFi per Investire Durante i Mercati Orsi</a></p>
<p><a href="https://etherscan.io/token/0x95ecdc6caaf7e4805fcef2679a92338351d24297" rel="nofollow noopener noreferrer" target="_blank">I dati su Etherscan mostrano</a> che Curve Finance ha creato 20 milioni di crvUSD. Interessante, Michael Egorov, il fondatore di Curve Finance, è stato il primo a <a href="https://platform.arkhamintelligence.com/explorer/address/0x7a16ff8270133f063aab6c9977183d9e72835428" rel="nofollow noopener noreferrer" target="_blank">prendere un prestito di 1 milione di crvUSD</a> utilizzando 957 <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> Ether ($1.8 million), un tipo di token derivato dell’ether, come garanzia.</p>
<p>Sebbene il contratto intelligente per crvUSD sia stato implementato sulla mainnet, al 5 maggio l’interfaccia utente web per prendere in prestito la stablecoin non era ancora stata configurata. Pertanto, gli utenti che intendevano prendere in prestito la stablecoin potevano interagire direttamente con il contratto intelligente.</p>
<h2 id="h2-Comprensione20di20crvUSD548109"><a name="Comprensione di crvUSD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprensione di crvUSD</h2><p><a href="https://github.com/curvefi/curve-stablecoin/blob/master/doc/curve-stablecoin.pdf" rel="nofollow noopener noreferrer" target="_blank">Il crvUSD</a> è agganciato al dollaro statunitense ma è supportato da una serie di criptovalute che includono USDC, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e token di fornitura di liquidità di pool di stablecoin, nonché derivati di staking liquido come <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> sfrxETH di Gate.io. Tuttavia, al momento gli utenti possono solo utilizzare <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> Usa sfrxETH come garanzia per prendere in prestito crvUSD.</p>
<p>È importante notare che crvUSD è una stablecoin sovracollateralizzata. In altre parole, è supportata da altri asset crittografici in un rapporto come 2:1. La sovracollateralizzazione aiuta a mantenere il peg del crvUSD contro il dollaro statunitense quando gli asset che lo supportano subiscono un’alta volatilità dei prezzi.</p>
<p>Fondamentalmente, ciò che accade è che se il prezzo di una garanzia scende al di sotto del livello di liquidazione, il protocollo la vende per garantire che non ci siano perdite. Allo stesso modo, Curve Finance fornisce prestiti sovra-garantiti ai suoi utenti.</p>
<p>L’introduzione del crvUSD sul protocollo Curve Finance porta un’importante dimensione aggiuntiva alla piattaforma DeFi. Ciò perché faciliterà scambi economici tra stablecoin e vari asset a prezzo fisso.</p>
<p>Leggi anche: <a href="https://www.gate.io/es/blog_detail/2611/the-power-of-decentralized-finance-defi-a-web3-breakthrough-for-financial-inclusion" target="_blank">Il Potere della Finanza Decentralizzata (DeFi): Una Svolta Web3 per l’Inclusione Finanziaria</a></p>
<h2 id="h2-Come20funziona20la20stablecoin20Curve655535"><a name="Come funziona la stablecoin Curve" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funziona la stablecoin Curve</h2><p>Il protocollo Curve Finance mantiene la stabilità della stablecoin crvUSD attraverso un meccanismo di bruciatura e coniazione in modo simile al token DAI di MakerDAO. Ad esempio, per gli investitori per ottenere crvUSD è necessario depositare gli asset digitali richiesti nel contratto intelligente di Curve Finance. Una volta che qualcuno deposita gli asset crittografici richiesti, il protocollo conia il crvUSD.</p>
<p>D’altra parte, se il mutuatario chiude la sua posizione per recuperare le sue criptovalute o cripto-derivati depositati; il contratto intelligente brucia un importo equivalente di crvUSD.</p>
<p>Ciò che rende Curve Finance diverso dai suoi concorrenti è il suo algoritmo di prestito-liquidazione (LLAMA) che riequilibra il collaterale degli utenti quando il suo prezzo fluttua. Come esempio, se il prezzo del suo collaterale scende al di sotto del livello di liquidazione, il protocollo converte quell’attivo in crvUSD. Tuttavia, riconvertirà crvUSD in quell’attivo digitale appropriato quando il suo prezzo risalirà di nuovo.</p>
<p>È anche importante notare che il collaterale è mantenuto in un pool di market maker automatizzato (AMM) dove fornisce liquidità ai trader anziché rimanere semplicemente in una cassaforte. Questo aumenta l’efficienza del sistema.</p>
<h2 id="h2-Concorso20di20stabilecoin20Curve20crvUSD975165"><a name="Concorso di stabilecoin Curve (crvUSD)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Concorso di stabilecoin Curve (crvUSD)</h2><p>Come punto, crvUSD affronta molta concorrenza sul mercato dato che ci sono <a href="https://www.gate.io/learn/articles/what-is-stablecoin/40" target="_blank">diverse stablecoins</a> con gli stessi casi d’uso. Il mercato delle stablecoin è dominato da <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT, USDC e DAI con una capitalizzazione di mercato di $4,6 miliardi. L’altra stablecoin competitiva è <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> GHO di Gate.io che è ancora in fase di test. Resta da vedere come si comporterà crvUSD sul mercato e il suo effetto sulla <a href="/price/curve-dao-crv" rel="nofollow noopener noreferrer" target="_blank">Curve DAO</a> token (CRV).</p>
<h2 id="h2-La20prospettiva20dei20prezzi20di20CRV341768"><a name="La prospettiva dei prezzi di CRV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La prospettiva dei prezzi di CRV</h2><p>Nonostante abbia un collaterale di $1,8 milioni di crvUSD, il suo valore di scambio è ancora inferiore al suo ancoraggio, pari a $0,927. Allo stesso tempo, il lancio di questa stablecoin non ha creato molto slancio al rialzo per il <a href="/price/curve-dao-crv" rel="nofollow noopener noreferrer" target="_blank">Curve DAO</a> token, CRV. Tuttavia, il prezzo del token CRV è aumentato del 10% nelle 24 ore successive al lancio di crvUSD. Tuttavia, attualmente è in una tendenza al ribasso.</p>
<p>Al momento della scrittura, il <a href="/price/curve-dao-crv" rel="nofollow noopener noreferrer" target="_blank">Curve DAO</a> Il token ha un valore di $0.805 e sta mostrando segni di difficoltà mentre <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> indica.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684400808Curve 1.png" alt=""></p>
<p>Come <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> come mostra il grafico, il valore di CRV è aumentato a $0,911 il 3 maggio e ha fatto un calo il 4 prima di salire nuovamente il 5, in seguito al lancio di crvUSD. Come mostra il grafico successivo, il prezzo di CRV ha raggiunto $0,976 il 5 maggio. Tuttavia, da allora è in calo, chiudendo la giornata a $0,796 il 14 maggio.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684400828Curve 2.png" alt=""></p>
<p>Attualmente, il CRV sta negoziando al 97,67% in meno rispetto al suo massimo storico che è avvenuto il 14 agosto 2020. Potenzialmente, il CRV è un buon asset di investimento poiché alimenta il protocollo Curve Finance.</p>
<h2 id="h2-Conclusion294037"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Curve Finance ha lanciato con successo la sua stablecoin, crvUSD, sulla <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain il 3 maggio 2023. Tuttavia, da allora crvUSD ha avuto una performance al di sotto del suo ancoraggio nonostante un collateral di $1.8 milioni. Inoltre, il lancio della sua stablecoin non è riuscito ad influenzare il prezzo di CRV al rialzo come ci si aspettava dal mercato.</p>
<div class="blog-details-info"><br><div>Autore: <strong> Mashell C. </strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il repostaggio dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards