R2F0ZS5pbyBBTUEgbWV0IENWSS1BIE1hcmtldCBGZWFyIEluZGV4IHZvb3IgZGUgQ3J5cHRvIFNwYWNl

<p><img src="https://gimg2.gateimg.com/image/article/16801626381.jpeg" 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 Tomer Menuchin, Hoofd van BizDev bij de <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://discord.com/invite/yuDsy7SM2H" rel="nofollow noopener noreferrer" target="_blank">Discord</a> en <a href="https://t.me/cviofficial" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16801628182.png" alt=""><br><strong>Tomer Menuchin - Hoofd BizDev</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio803412"><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-V120Kunt20u20ons20alstublieft20vertellen20wat20CVI20is20en20wat20zijn20enkele20usecases497965"><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>In een notendop - De CVI is een VIX voor de cryptowereld.</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 waarmee handelaren gemakkelijk posities tegen de index kunnen openen en verhandelen, wil het populair en wijdverbreid worden aangenomen.</p>
<p>Als onderdeel van de lancering van CVI hebben we een innovatief en volledig gedecentraliseerd ecosysteem geïntroduceerd, dat bestaat uit: Het CVI-handelsplatform, Volatiliteitstokens en de $GOVI-token.</p>
<p>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, handelen in 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 uitstekende bescherming zijn tegen volatiliteit &amp; tijdelijk verlies, aangezien een lange positie op de index in waarde zou toenemen wanneer er extreme volatiliteit is in welke richting dan ook.</p>
<p>Ik nodig iedereen uit die geïnteresseerd is om meer te lezen over ons ecosysteem en protocol om onze Gitbook te bezoeken: docs.cvi.finance! We hebben geprobeerd alles daar zo duidelijk mogelijk uit te leggen.</p>
<h3 id="h3-Vraag20220Wat20inspireerde20de20oprichting20van20de20Crypto20Volatility20Index20en20wat20zou20je20zeggen20dat20het20project20probeert20te20bereiken580532"><a name="Vraag 2: Wat inspireerde de oprichting 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>Vraag 2: Wat inspireerde de oprichting van de Crypto Volatility Index en wat zou je zeggen dat het project probeert te bereiken?</h3><p>Er zijn 2 grafieken die altijd in ons hoofd zijn wanneer we aan de toekomst denken en die deel uitmaken van onze visie. Ze tonen de acceptatie van de originele VIX van de aandelenmarkt in de loop van de tijd.<br><img src="https://gimg2.gateimg.com/image/article/16801628833.jpg" alt=""><br>De grafieken tonen enkele jaren van opwarming gevolgd door exponentiële groei.</p>
<p>In reguliere aandelenmarkten is de VIX super populair, de ETN’s hebben dagelijkse volumes van enkele miljarden! Vanwege de exponentiële groei die begon met de VIX ETN’s, geloven we sterk dat de CVI een enorm investeringsinstrument is. Met de veel hogere volatiliteit in crypto, is er geen twijfel in onze gedachten 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 als het kopen van de token op een DEX een longpositie op de index kan innemen. De volgende stap die binnenkort wordt gezet, is het opbouwen van schaalbare liquiditeit hiervoor, waardoor het op vele manieren het equivalent wordt van de VIX ETN’s die zijn aangepast aan crypto, als een ERC20-token.</p>
<h3 id="h3-Q320Aangezien20je20CVOL20al20hebt20genoemd20kun20je20nu20wat20meer20uitleggen20over20GOVI20jullie20Governance20Token909704"><a name="Q3: Aangezien je CVOL al hebt genoemd, kun je nu wat meer uitleggen over GOVI, jullie 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 uitleggen over GOVI, jullie Governance Token?</h3><p>Zeker. De GOVI-token is een ERC-20-token, momenteel verhandelbaar op Gate, evenals DEXs 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 bestuurlijke token voor het CVI-protocol en het platform.</p>
<p>Ik geloof dat we een van de eerlijkste lanceringen hebben gedaan met de lancering van GOVI.</p>
<p>De GOVI-token is airdropped naar meer dan 3000 mensen, die het gedurende enkele maanden hebben geclaimd.<br>Daarnaast wordt 60% van de distributie in de loop van de tijd gedaan aan de gebruikers van het platform via liquiditeitsmining.</p>
<p>Dit maakt ook veel zin in ons perspectief, aangezien wie is er beter om het platform te beheren en de eigenaren te worden dan de eigen gebruikers die een belang hebben in het spel.</p>
<p>Door hun GOVI-tokens te staken, verdienen GOVI-stakers een deel van de vergoedingen die worden geïnd vanaf het platform (die momenteel worden gebruikt om GOVI terug te kopen op de markt). In minder dan een jaar hebben we $1 miljoen USD-equivalent aan vergoedingen uitgekeerd aan GOVI-stakers en we blijven groeien! <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-Q420Zoals20wij20begrijpen20komt20u20binnenkort20ook20met20een20oplossing20voor20onbepaalde20verliesbescherming20kunt20u20alstublieft20uitleggen20hoe20het20zal20werken320129"><a name="Q4: Zoals wij begrijpen, komt u binnenkort ook met een oplossing voor onbepaalde verliesbescherming, kunt u alstublieft uitleggen hoe het zal werken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Zoals wij begrijpen, komt u binnenkort ook met een oplossing voor onbepaalde verliesbescherming, kunt u alstublieft uitleggen hoe het zal werken?</h3><p>De CVI is het enige protocol dat deze dienst aan gebruikers biedt zonder hen om hun liquiditeit te vragen - Het kan volledig gescheiden blijven op een dex of elders gestaked.</p>
<p>Het CVI-team is erg enthousiast om liquiditeitsverschaffers te helpen hun activa te beschermen die anders worden blootgesteld aan tijdelijke verliezen. Met behulp van ons eigen model wordt elke aangekochte bescherming tegen tijdelijke verliezen weergegeven als een NFT die de dekkingswaarde, de juiste tijdsduur en het door de gebruiker geselecteerde paar vertegenwoordigt. Hierdoor worden eventuele tijdelijke verliezen automatisch terugbetaald aan de portemonnee van de gebruiker gedurende die tijdsduur op een naadloze en veilige manier.</p>
<p>Door gebruik te maken van de impermanente verliesbescherming van CVI kunnen gebruikers liquiditeit leveren op elke chain, DEX of platform. Gebruikers hoeven hun LP-tokens niet te staken om de CVI impermanente verliesbescherming 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 - Aangezien er geen tegenpartijrisico is voor de beschermers en het kan liquiditeit beschermen op meerdere verschillende ketens.</p>
<h3 id="h3-Q520Hoe20wordt20de20bescherming20tegen20tijdelijk20verlies20berekend761536"><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>De berekening maakt deel uit van hoe we de CVI benutten, als een indicator van geïmpliceerde 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 is aangepast aan de historische gegevens. Het effect van de curve kan als volgt worden verklaard: wanneer de volatiliteitsindex laag is, kunnen we een stabiele groei verwachten van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">eth prijs</a>, wat resulteert in een hoog Impermanent Verlies. Als 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 hoge Impermanent Loss.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het herplaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>