R2F0ZS5pbyBBTUEgbWV0IEFuZ2xlLUEgLSBLYXBpdGFhbGVmZmljacOrbnQsIGdlZGVjZW50cmFsaXNlZXJkLCBvdmVyLWdlY29sbGF0ZXJhbGlzZWVyZCBzdGFiaWVsY29pbnByb3RvY29sIGFjaHRlciBhZ0VVUg==

<p><img src="https://gimg2.gateimg.com/image/article/16883674991.jpg" alt=""><br><strong>Tijd: 17 november 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> hield een AMA (Ask-Me-Anything) sessie met Pablo Veyrat, Core Contributor bij Angle Protocol in 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://www.angle.money/" rel="nofollow noopener noreferrer" target="_blank">https://www.angle.money/</a></strong><br><strong>Twitter: <a href="https://twitter.com/AngleProtocol" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/AngleProtocol</a></strong><br><strong>Volg Angle op <a href="https://twitter.com/AngleProtocol" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/AngleAnnouncements" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16883676692.png" alt=""><br><strong>Pablo Veyrat - Kernbijdrager bij Angle Protocol</strong></p>
<h2 id="h2-Vraag20amp20Antwoord20van20Gateio236635"><a name="Vraag &amp; Antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag &amp; Antwoord van Gate.io</h2><h3 id="h3-Q120Kun20je20beginnen20met20uitleggen20aan20de20gemeenschap20wat20Angle20is413935"><a name="Q1: Kun je beginnen met uitleggen aan de gemeenschap wat Angle is?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je beginnen met uitleggen aan de gemeenschap wat Angle is?</h3><p><strong>Pablo</strong>: Ja! Angle is een gedecentraliseerd stablecoin-protocol. We hebben een nieuwe manier ontwikkeld om stabiele cryptovaluta te creëren, een manier die is ontworpen om efficiënter en robuuster te zijn dan Maker’s DAI, maar ook meer generaliseerbaar.<br><img src="https://gimg2.gateimg.com/image/article/16883676883.png" alt=""><br>We hebben twee weken geleden onze Euro-stablecoin uitgebracht, die in 10 dagen de grootste Euro-stablecoin ter wereld is geworden.</p>
<h3 id="h3-Q220Wat20zijn20enkele20van20Angles20producten20naast20Euro20stablecoins68777"><a name="Q2: Wat zijn enkele van Angle’s producten naast Euro stablecoins?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat zijn enkele van Angle’s producten naast Euro stablecoins?</h3><p><strong>Pablo</strong>: Geweldig dat je dat vraagt!</p>
<p>Stablecoins zijn dus de belangrijkste focus van het protocol. Maar om dit te laten werken, hebben we andere functies nodig. Een daarvan is eeuwigdurende futures: je kunt hefboomposities innemen op de variatie van het onderpand (USDC of DAI - ten opzichte van de Euro).</p>
<p>We bieden ook klassieke opbrengstfuncties aan: door aan Angle uit te lenen, kunt u opbrengst krijgen op uw USDC of uw DAI. De reden hiervoor is dat we Yearn hebben geforkt en dat we het onderpand van het protocol gebruiken in strategieën.<br><img src="https://gimg2.gateimg.com/image/article/16883677184.png" alt=""><br>We kunnen zelfs een hogere opbrengst garanderen dan wat je zou krijgen door rechtstreeks Yearn te gebruiken. Dit is behoorlijk technisch, maar we kunnen je opbrengst geven op onderpand dat je in de eerste plaats niet hebt gekocht.</p>
<h3 id="h3-Q320Kunt20u20ons20vertellen20wat20de20Angletoken20is620899"><a name="Q3: Kunt u ons vertellen wat de Angle-token is?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Kunt u ons vertellen wat de Angle-token is?</h3><p><strong>Pablo</strong>: ANGLE is het bestuurstoken van het protocol, het is het token dat het recht geeft om te stemmen voor protocol-upgrades en om het overschot van het protocol af te handelen.</p>
<p>Het protocol verdient geld (we hebben in onze eerste twee weken $2.5 miljoen winst gemaakt), deze token geeft u het recht om te beslissen wat u met dit geld wilt doen.</p>
<p>We werken momenteel aan het verbeteren van het nut van de token op het platform, zodat de verdeling van inkomsten duidelijker wordt.</p>
<h3 id="h3-V420Kun20je20ons20iets20vertellen20over20hoe20het20team20of20jijzelf20zijn20begonnen20met20crypto442101"><a name="V4: Kun je ons iets vertellen over hoe het team of jijzelf zijn begonnen met crypto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V4: Kun je ons iets vertellen over hoe het team of jijzelf zijn begonnen met crypto?</h3><p><strong>Pablo</strong>: Ik was een student aan de Stanford Universiteit en daarvoor aan de Ecole Polytechnique in Frankrijk. Was eerst een investeerder en begon toen echt te begrijpen wat er aan de hand was.<br>Tijdens mijn tijd aan Stanford heb ik een crypto-klas gevolgd en ben toen begonnen met het experimenteren met DeFi, het was in 2020.</p>
<p>Op dat moment begon ik rendement te halen uit de USD-stablecoins die ik bezat, maar ik was in Frankrijk (vanwege Covid) en ik realiseerde me dat ik werd blootgesteld aan een groot wisselkoersrisico: mijn rendement in USD was niet voldoende om het verlies van de USD ten opzichte van de Euro te dekken, en dus dacht ik dat we een Euro stablecoin moesten creëren.</p>
<p>Zo is het Angle-project begonnen! En vervolgens vanuit het idee van een Euro stablecoin, ontdekten we dat we de manier waarop stablecoin-protocollen werken moesten verbeteren: en zo kwamen we bij het Angle Protocol, dat naar verluidt het allereerste over-gecollateraliseerde, kapitaal-efficiënte en gedecentraliseerde stablecoin-protocol is.</p>
<h3 id="h3-Q520Bedankt20voor20het20delen20Pablo20Was20je20al20actief20in20de20cryptowereld20vr20202020of20was20dat20je20eerste20ervaring20ermee681579"><a name="Q5: Bedankt voor het delen, Pablo. Was je al actief in de crypto-wereld vóór 2020 of was dat je eerste ervaring ermee?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Bedankt voor het delen, Pablo. Was je al actief in de crypto-wereld vóór 2020 of was dat je eerste ervaring ermee?</h3><p><strong>Pablo</strong>: Ik was een investeerder en had al een goed begrip van blockchains voordat dat (beginnend in 2018), maar 2020 is echt het moment waarop ik erdoor geobsedeerd raakte, en vooral toen ik begon te beseffen dat DeFi veelbelovend was maar niet inclusief.</p>
<p>Alles draait om de USD, maar er zijn geen geld lego’s voor mensen in Europa, voor mensen in Azië, voor mensen waar ze ook ter wereld zijn.</p>
<p>Dat is wat me de wens gaf om dingen te veranderen! En daar is Angle voor: efficiënte en transparante stabiele munten bouwen voor iedereen.</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 standpunten van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt genoemd. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>