R2F0ZS5pbyBBTUEgbWV0IENyeXB0byBWb2xhdGlsaXR5IEluZGV4LUVlbiBtYXJrdHZyZWVzaW5kZXggdm9vciBkZSBjcnlwdG9ydWltdGU=

<p><img src="https://gimg2.gateimg.com/image/article/16835283751.jpg" alt=""><br><strong>Tijd: 1 juni 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Yoni Neeman, Chief Innovation Officer van COTI, die leiding geeft aan de ontwikkeling van de Crypto Volatility Index (CVI) bij het <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële website: <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>Volg CVI op <a href="https://t.me/cviofficial" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://discord.com/invite/yuDsy7SM2H" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16835286132.png" alt=""><br><strong>Yoni Neeman - Chief Innovation Officer van COTI</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio981126"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-V120Kunt20u20ons20alstublieft20vertellen20wat20CVI20is20en20wat20zijn20enkele20usecases962106"><a name="V1: Kunt u ons alstublieft vertellen wat CVI is, en wat zijn enkele use-cases?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Kunt u ons alstublieft vertellen wat CVI is, en wat zijn enkele use-cases?</h3><p><strong>Yoni</strong>: In een notendop - De CVI is een VIX voor de cryptomarkt.</p>
<p>De CVI-index varieert tussen 0 en 200 en volgt de 30-daagse geïmpliceerde volatiliteit van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p>Nu, net als bij de VIX en het ecosysteem van producten eromheen, moet er voor CVI een instrument zijn dat handelaren in staat stelt om gemakkelijk posities tegen de index te openen en te verhandelen om populair en wijdverbreid te worden aangenomen.</p>
<p>Daarom hebben we als onderdeel van de CVI-lancering een innovatief en volledig gedecentraliseerd ecosysteem geïntroduceerd, dat bestaat uit: Het CVI-handelsplatform, Volatiliteitstokens en de $GOVI-token.<br>Zowel het platform (cvi.finance) als de volatiliteitstokens stellen mensen in staat om te handelen in de verwachtingen van de markt voor toekomstige volatiliteit.</p>
<p>Dus, het verhandelen van de CVI-index is een geweldige manier om winstgevende handelsmogelijkheden op de markt te vinden zonder de richting van de prijs te hoeven voorspellen. Handelaren maken winst op volatiele markten, of de prijzen nu stijgen of dalen.</p>
<p>Bovendien kan het een goede bescherming zijn tegen volatiliteit en tijdelijk verlies, aangezien een longpositie op de index in waarde zou toenemen bij extreme volatiliteit in beide richtingen.</p>
<p>Ik nodig iedereen uit die geïnteresseerd is om meer te lezen over ons ecosysteem en protocol om een bezoek te brengen aan onze Gitbook: docs.cvi.finance! We hebben geprobeerd alles daar zo duidelijk mogelijk uit te leggen.</p>
<h3 id="h3-Q220Op20dat20punt20Wat20inspireerde20het20ontstaan20van20de20Crypto20Volatility20Index20en20wat20zou20je20zeggen20dat20het20project20probeert20te20bereiken14645"><a name="Q2: Op dat punt. Wat inspireerde het ontstaan van de Crypto Volatility Index, en wat zou je zeggen dat het project probeert te bereiken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Op dat punt. Wat inspireerde het ontstaan van de Crypto Volatility Index, en wat zou je zeggen dat het project probeert te bereiken?</h3><p><strong>Yoni</strong>: Er zijn 2 grafieken die altijd in ons hoofd zitten als we aan de toekomst denken en deel uitmaken van onze visie. Ze tonen de adoptie van de oorspronkelijke VIX van de aandelenmarkt in de loop van de tijd.<br><img src="https://gimg2.gateimg.com/image/article/16835286633.jpg" alt=""><br>De grafieken tonen verschillende jaren van opwarming gevolgd door exponentiële groei.</p>
<p>In reguliere aandelenmarkten is de VIX super populair, de ETN’s hebben een volume van enkele miljarden per dag! Vanwege de exponentiële groei die begon met de VIX ETN’s, zijn wij er sterk van overtuigd dat de CVI een enorm investeringsinstrument is. Met de veel hogere volatiliteit in crypto, twijfelen wij er niet aan dat een VIX van crypto, zoals de CVI, episch zal zijn!</p>
<p>Een half jaar geleden lanceerden we onze Volatility-token CVOL, waarmee iedereen net zo eenvoudig een longpositie op de index kan innemen als het kopen van de token op een DEX. De volgende stap die binnenkort komt, is het opbouwen van schaalbare liquiditeit hiervoor, waardoor het op vele manieren het equivalent wordt van de VIX ETN’s aangepast aan crypto, als een ERC20-token.</p>
<h3 id="h3-Q320Aangezien20je20CVOL20al20hebt20genoemd20kun20je20nu20wat20meer20uitleg20geven20over20GOVI20jouw20Governance20Token901425"><a name="Q3: Aangezien je CVOL al hebt genoemd, kun je nu wat meer uitleg geven over GOVI, jouw Governance Token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Aangezien je CVOL al hebt genoemd, kun je nu wat meer uitleg geven over GOVI, jouw Governance Token?</h3><p><strong>Yoni</strong> Zeker. De GOVI-token is een ERC-20-token, momenteel verhandelbaar in Gate, evenals DEX’s op <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> en Arbitrum en fungeert als het governance-token voor het CVI-protocol en het platform.</p>
<p>Ik geloof dat we erin geslaagd zijn om een van de eerlijkste lanceringen te doen met de lancering van GOVI.</p>
<p>De GOVI-token werd gedropt aan meer dan 3000 mensen, die het gedurende enkele maanden hebben geclaimd.</p>
<p>Daarnaast wordt 60% van de distributie in de loop van de tijd gedaan aan de gebruikers van het platform via liquiditeitsmining.</p>
<p>Dit is naar onze mening ook heel logisch, want wie is er beter in staat om het platform te beheersen en de eigenaren te worden dan zijn eigen gebruikers die een belang hebben in het spel.</p>
<p>Door hun GOVI-tokens in te zetten, verdienen GOVI-stakers een deel van de opbrengsten die worden verzameld van het platform (die momenteel worden gebruikt om GOVI terug te kopen op de markt). In minder dan een jaar tijd hebben we $1 miljoen USD-equivalent aan vergoedingen uitgekeerd aan GOVI-stakers en we blijven groeien!</p>
<p><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-Q420Zoals20we20begrijpen20komt20u20binnenkort20ook20met20een20oplossing20voor20tijdelijk20verliesbescherming20kunt20u20alstublieft20uitleggen20hoe20dit20zal20werken546820"><a name="Q4: Zoals we begrijpen, komt u binnenkort ook met een oplossing voor tijdelijk verliesbescherming, kunt u alstublieft uitleggen hoe dit zal werken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Zoals we begrijpen, komt u binnenkort ook met een oplossing voor tijdelijk verliesbescherming, kunt u alstublieft uitleggen hoe dit zal werken?</h3><p><strong>Yoni</strong>: De CVI is het enige protocol dat deze service aan gebruikers biedt zonder hen om hun liquiditeit te vragen - Het kan volledig gescheiden blijven op een dex of ergens anders gestaked worden.</p>
<p>Het CVI-team is erg enthousiast om liquiditeitsverschaffers te helpen hun activa te beschermen die anders blootgesteld zouden zijn aan tijdelijke verliezen. Met behulp van ons eigen model wordt elke aangeschafte bescherming tegen tijdelijke verliezen weergegeven als een NFT die de dekkingswaarde, de juiste tijdsduur en het door de gebruiker geselecteerde paar vertegenwoordigt. Op deze manier wordt elk ervaren tijdelijk verlies automatisch terugbetaald aan de portemonnee van de gebruiker voor die tijdsduur op een naadloze en veilige manier.</p>
<p>Dus door gebruik te maken van de impermanent loss protection van CVI kunnen gebruikers liquiditeit verschaffen op elk chain, DEX of platform. De gebruikers hoeven hun LP-tokens niet in te zetten om de CVI impermanent loss protection te kopen.</p>
<p>De liquiditeit zelf kan zelfs op een andere keten zijn dan waar de bescherming wordt genomen.</p>
<p>Deze losjes gekoppelde oplossing is naar onze mening essentieel - Omdat er geen tegenpartijrisico is voor de beschermingsnemers en het liquiditeit kan beschermen op meerdere verschillende ketens.</p>
<h3 id="h3-Q520Hoe20wordt20de20bescherming20tegen20tijdelijk20verlies20berekend632316"><a name="Q5: Hoe wordt de bescherming tegen tijdelijk verlies berekend?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Hoe wordt de bescherming tegen tijdelijk verlies berekend?</h3><p><strong>Yoni</strong> De berekening maakt deel uit van hoe we de CVI gebruiken, als een indicator van impliciete volatiliteit, om te beschermen tegen tijdelijk verlies.</p>
<p>We definiëren de afhankelijkheid tussen CVI en het verwachte IL-percentage voor de komende 14, 30 en 60 dagen als een eenvoudige kwadratische parabool die wordt aangepast aan de historische gegevens. Het effect van de curve kan worden verklaard door het volgende: wanneer de volatiliteitsindex laag is, kunnen we stabiele groei verwachten van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">eth prijs</a>, wat resulteert in een hoge Impermanent Loss. Wanneer de volatiliteitsindex hoog is, kunnen we een duik verwachten in de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">eth prijs</a>, wat resulteert in een hoog Tijdelijk Verlies.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Rio Fu.</strong>, Gate.io-gemeenschap<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel te herplaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>