R2F0ZS5pbyBBTUEgY29uIGwnaW5kaWNlIGRpIHBhdXJhIGRpIG1lcmNhdG8gQ1ZJLUEgcGVyIGxvIHNwYXppbyBjcmlwdG8=

<p><img src="https://gimg2.gateimg.com/image/article/16801626381.jpeg" alt=""><br><strong>Tempo: 1 giugno 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Tomer Menuchin, responsabile dello sviluppo aziendale in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Community di scambio Gate.io</a>.</strong><br><strong>Sito Ufficiale: <a href="https://cvi.finance/" rel="nofollow noopener noreferrer" target="_blank">https://cvi.finance/</a></strong><br><strong>Twitter: <a href="https://twitter.com/official_cvi" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/official_cvi</a></strong><br><strong>Segui CVI su <a href="https://discord.com/invite/yuDsy7SM2H" rel="nofollow noopener noreferrer" target="_blank">Discord</a> e <a href="https://t.me/cviofficial" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16801628182.png" alt=""><br><strong>Tomer Menuchin — Responsabile dello sviluppo aziendale</strong></p>
<h2 id="h2-QampA20da20Gateio353661"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Potresti20dirci20cos20CVI20e20quali20sono20alcuni20casi20duso160106"><a name="Q1: Potresti dirci cos’è CVI e quali sono alcuni casi d’uso?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti dirci cos’è CVI e quali sono alcuni casi d’uso?</h3><p>In poche parole - Il CVI è un VIX per lo spazio cripto.</p>
<p>L’indice CVI varia tra 0 e 200, e tiene traccia della volatilità implicita dei 30 giorni di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p>Ora, in modo simile al VIX e all’ecosistema di prodotti ad esso correlati, affinché CVI diventi popolare e ampiamente adottato, dovrebbe esserci uno strumento che consenta ai trader di aprire facilmente posizioni contro l’indice e commerciarlo.</p>
<p>Pertanto, come parte del lancio di CVI, abbiamo introdotto un ecosistema decentralizzato innovativo e completo che include: la piattaforma di trading CVI, i token di volatilità e il token $GOVI.</p>
<p>Sia la piattaforma (cvi.finance) che i token di volatilità consentono alle persone di scambiare le aspettative del mercato per la futura volatilità.</p>
<p>Quindi, fare trading dell’indice CVI è un ottimo modo per trovare opportunità di trading redditizie sul mercato senza dover prevedere la direzione del prezzo. Gli operatori ottengono un profitto sui mercati volatili, che i prezzi stiano salendo o scendendo.</p>
<p>Inoltre, può essere un ottimo strumento di copertura contro la volatilità e le perdite temporanee, poiché una posizione long sull’indice aumenterebbe di valore in caso di estrema volatilità in entrambe le direzioni.</p>
<p>Invito tutti coloro che sono interessati a leggere di più sul nostro ecosistema e protocollo a visitare il nostro Gitbook: docs.cvi.finance! Abbiamo cercato di spiegare tutto lì il più chiaramente possibile.</p>
<h3 id="h3-Q220Cosa20ha20ispirato20listituzione20dellIndice20di20volatilit20delle20criptovalute20e20cosa20diresti20che20il20progetto20sta20cercando20di20raggiungere444041"><a name="Q2: Cosa ha ispirato l’istituzione dell’Indice di volatilità delle criptovalute e cosa diresti che il progetto sta cercando di raggiungere?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Cosa ha ispirato l’istituzione dell’Indice di volatilità delle criptovalute e cosa diresti che il progetto sta cercando di raggiungere?</h3><p>Ci sono 2 grafici che sono sempre nella nostra mente quando pensiamo al futuro e fanno parte della nostra visione. Mostrano l’adozione del VIX originale del mercato azionario nel tempo.<br><img src="https://gimg2.gateimg.com/image/article/16801628833.jpg" alt=""><br>I grafici mostrano diversi anni di riscaldamento seguiti da una crescita esponenziale.</p>
<p>Nei mercati azionari tradizionali, l’indice VIX è estremamente popolare, i suoi ETN registrano volumi di diverse miliardi al giorno! A causa della crescita esponenziale che è iniziata con gli ETN VIX, siamo fermamente convinti che il CVI sia un enorme strumento di investimento. Con la volatilità molto più alta delle criptovalute, non abbiamo dubbi che un indice VIX delle criptovalute, come il CVI, sarà epico!</p>
<p>Mezzo anno fa abbiamo lanciato il nostro token di volatilità CVOL, che consente a chiunque di assumere una posizione lunga sull’indice semplicemente acquistando il token su un DEX. Il prossimo passo in arrivo è quello di costruire una liquidità scalabile per esso, ciò lo renderà in molti modi l’equivalente degli ETN VIX adattati alle criptovalute, come un token ERC20.</p>
<h3 id="h3-Q320Dal20momento20che20hai20gi20menzionato20CVOL20puoi20spiegare20un20po20di20pi20su20GOVI20il20tuo20token20di20governance434918"><a name="Q3: Dal momento che hai già menzionato CVOL, puoi spiegare un po’ di più su GOVI, il tuo token di governance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Dal momento che hai già menzionato CVOL, puoi spiegare un po’ di più su GOVI, il tuo token di governance?</h3><p>Certamente. Il token GOVI è un token ERC-20, attualmente negoziabile su Gate, così come su DEX. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> ed Arbitrum e funge da token di governance per il protocollo CVI e la piattaforma.</p>
<p>Credo che siamo riusciti a fare uno dei lanci più equi con il lancio di GOVI.</p>
<p>Il token GOVI è stato distribuito a più di 3000 persone, che lo hanno richiesto nel corso di diversi mesi.<br>Inoltre, il 60% della distribuzione avviene nel tempo agli utenti della piattaforma tramite il mining di liquidità.</p>
<p>Questo ha anche molto senso dal nostro punto di vista, poiché chi è meglio a controllare la piattaforma e diventarne proprietario se non i propri utenti che hanno un interesse nel gioco.</p>
<p>Stakeggiando i loro token GOVI, i stakeholder di GOVI guadagnano una quota delle commissioni raccolte dalla piattaforma (che attualmente vengono utilizzate per riacquistare GOVI sul mercato). In meno di un anno abbiamo raggiunto 1 milione di dollari equivalenti in commissioni distribuite agli stakeholder di GOVI e continuiamo a crescere! <a href="https://twitter.com/official_CVI/status/1455497684589158400" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/official_CVI/status/1455497684589158400</a></p>
<h3 id="h3-Q420Come20abbiamo20capito20stai20per20lanciare20presto20anche20una20soluzione20di20protezione20dalle20perdite20impermanenti20puoi20spiegarci20come20funzioner444633"><a name="Q4: Come abbiamo capito, stai per lanciare presto anche una soluzione di protezione dalle perdite impermanenti, puoi spiegarci come funzionerà?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Come abbiamo capito, stai per lanciare presto anche una soluzione di protezione dalle perdite impermanenti, puoi spiegarci come funzionerà?</h3><p>Il CVI è l’unico protocollo che offre questo servizio agli utenti senza chiedere loro la loro liquidità - può rimanere completamente separato su un dex o staked altrove.</p>
<p>Il team di CVI è molto entusiasta di aiutare i fornitori di liquidità a proteggere i loro asset che altrimenti sarebbero esposti a perdite impermanenti. Utilizzando il nostro modello proprietario, qualsiasi protezione contro le perdite impermanenti acquistata si rifletterà in un NFT che rappresenta il valore di copertura, l’intervallo di tempo appropriato e la coppia selezionata dall’utente. In questo modo, qualsiasi perdita impermanente subita verrà automaticamente rimborsata sul portafoglio dell’utente per quel periodo di tempo in modo semplice e sicuro.</p>
<p>Quindi, utilizzando la protezione dalle perdite temporanee di CVI, gli utenti possono fornire liquidità su qualsiasi catena, DEX o piattaforma. Gli utenti non hanno bisogno di mettere in gioco i loro token LP per acquistare la protezione dalle perdite temporanee di CVI.</p>
<p>La liquidità stessa può anche essere su una catena diversa da quella in cui viene presa la protezione.</p>
<p>Questa soluzione debolmente accoppiata è fondamentale dal nostro punto di vista - Poiché non vi è alcun rischio della controparte per coloro che garantiscono la protezione e può proteggere la liquidità su diverse catene diverse.</p>
<h3 id="h3-Q520Come20si20calcola20la20protezione20dalle20perdite20temporanee813288"><a name="Q5: Come si calcola la protezione dalle perdite temporanee?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Come si calcola la protezione dalle perdite temporanee?</h3><p>Il calcolo fa parte di come sfruttiamo il CVI, come indicatore di volatilità implicita, per proteggerci dalle perdite temporanee.</p>
<p>Definiamo la dipendenza tra il CVI e la percentuale di IL prevista per i prossimi 14, 30 e 60 giorni come una semplice parabola quadratica adattata ai dati storici. L’effetto della curva può essere spiegato nel seguente modo: quando l’indice di volatilità è basso, possiamo aspettarci una crescita stabile di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">prezzo eth</a>, che conclude in un alto Impermanent Loss. Quando l’indice di volatilità è alto, possiamo aspettarci un crollo nel <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">prezzo eth</a>, che si conclude in un alto Impermanent Loss.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità 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 ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>