R2F0ZS5pbyBBTUEgY29uIEFuZ2xlLUEgUHJvdG9jb2xsbyBkaSBzdGFibGVjb2luIHNvdnJhLWNvbGxhdGVyYWxpenphdGEsIGRlY2VudHJhbGl6emF0YSBlZCBlZmZpY2llbnRlIGRhbCBwdW50byBkaSB2aXN0YSBkZWwgY2FwaXRhbGUgZGlldHJvIGFnRVVS

<p><img src="https://gimg2.gateimg.com/image/article/16883674991.jpg" alt=""><br><strong>Ora: 17 novembre 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione di AMA (Ask-Me-Anything) con Pablo Veyrat, Core Contributor presso Angle Protocol nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Web Ufficiale: <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>Segui Angle su <a href="https://twitter.com/AngleProtocol" rel="nofollow noopener noreferrer" target="_blank">Cinguettare</a> e <a href="https://t.me/AngleAnnouncements" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16883676692.png" alt=""><br><strong>Pablo Veyrat - Core Contributor presso Angle Protocol</strong></p>
<h2 id="h2-QampA20da20Gateio93083"><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-Q120Potresti20iniziare20spiegando20alla20comunit20cos20Angle484490"><a name="Q1: Potresti iniziare spiegando alla comunità cos’è Angle?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti iniziare spiegando alla comunità cos’è Angle?</h3><p><strong>Pablo</strong>: Sì! Angle è un protocollo di stablecoin decentralizzato. Abbiamo sviluppato un nuovo modo per creare criptovalute stabili, un modo progettato per essere più efficiente e robusto rispetto al DAI di Maker ma anche più generalizzabile.<br><img src="https://gimg2.gateimg.com/image/article/16883676883.png" alt=""><br>Abbiamo rilasciato il nostro stablecoin Euro due settimane fa, che in 10 giorni è diventato il più grande stablecoin Euro al mondo.</p>
<h3 id="h3-Q220Quali20sono20alcuni20dei20prodotti20di20Angle20oltre20alle20stablecoin20Euro626219"><a name="Q2: Quali sono alcuni dei prodotti di Angle oltre alle stablecoin Euro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Quali sono alcuni dei prodotti di Angle oltre alle stablecoin Euro?</h3><p><strong>Pablo</strong> È fantastico che tu lo chieda!</p>
<p>Quindi le stablecoin sono l’obiettivo principale del protocollo. Ma, per farlo funzionare, abbiamo bisogno di altre funzionalità. Uno di questi sono i futures perpetui: è possibile sfruttare le posizioni lunghe sulla variazione del collaterale (USDC o DAI- rispetto all’Euro).</p>
<p>Offriamo anche funzionalità di rendimento classico: prestando a Angle puoi ottenere un rendimento sul tuo USDC o sul tuo DAI. Il motivo di ciò è che abbiamo biforcato Yearn e utilizziamo il collaterale del protocollo nelle strategie.<br><img src="https://gimg2.gateimg.com/image/article/16883677184.png" alt=""><br>Possiamo persino garantire un rendimento più elevato di quello che otterresti utilizzando direttamente Yearn. Questo è abbastanza tecnico, ma possiamo darti un rendimento sul collaterale che non hai acquistato in primo luogo.</p>
<h3 id="h3-Q320Potresti20dirci20cos20il20token20Angle877353"><a name="Q3: Potresti dirci cos’è il token Angle?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Potresti dirci cos’è il token Angle?</h3><p><strong>Pablo</strong>: ANGLE è il token di governance del protocollo, è il token che conferisce il diritto di voto per gli aggiornamenti del protocollo e per gestire l’eccedenza del protocollo.</p>
<p>Il protocollo fa soldi (abbiamo guadagnato $2.5 milioni di profitto nelle prime due settimane), questo token ti dà il diritto di decidere cosa fare con questi soldi.</p>
<p>Attualmente stiamo lavorando per migliorare l’utilità del token in tutta la piattaforma in modo che la distribuzione dei ricavi diventi più evidente.</p>
<h3 id="h3-Q420Puoi20dirci20qualcosa20riguardo20al20modo20in20cui20il20team20o20te20stesso20avete20iniziato20con20le20criptovalute335506"><a name="Q4: Puoi dirci qualcosa riguardo al modo in cui il team o te stesso avete iniziato con le criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Puoi dirci qualcosa riguardo al modo in cui il team o te stesso avete iniziato con le criptovalute?</h3><p><strong>Pablo</strong>: Ero uno studente all’Università di Stanford, e prima ancora all’Ecole Polytechnique in Francia. Prima ero un investitore e poi ho davvero iniziato a capire cosa stava succedendo.<br>Mentre ero a Stanford, ho frequentato un corso di crittografia, e poi ho iniziato a giocare con DeFi, è stato nel 2020.</p>
<p>In quel momento, ho iniziato a ottenere rendimenti sugli stablecoin in USD che possedevo, ma ero in Francia (a causa del Covid) e mi sono reso conto di essere soggetto a un enorme rischio di cambio: il mio rendimento in USD non era sufficiente a coprire la perdita di valore del dollaro rispetto all’euro, e quindi ho pensato che fosse necessario creare uno stablecoin in euro.</p>
<p>Ecco come è iniziato il progetto Angle! E poi, a partire dall’idea di una stablecoin Euro, abbiamo scoperto che dovevamo migliorare il modo in cui i protocolli delle stablecoin funzionano: e siamo arrivati al Protocollo Angle che dovrebbe essere il primo protocollo di stablecoin sovra-collateralizzato, efficiente dal punto di vista del capitale e decentralizzato di sempre.</p>
<h3 id="h3-Q520Grazie20per20la20condivisione20Pablo20e20tu20eri20nel20mondo20delle20criptovalute20prima20del20202020o2020stata20la20tua20prima20esperienza20con20esse380130"><a name="Q5: Grazie per la condivisione, Pablo, e tu eri nel mondo delle criptovalute prima del 2020 o è stata la tua prima esperienza con esse?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Grazie per la condivisione, Pablo, e tu eri nel mondo delle criptovalute prima del 2020 o è stata la tua prima esperienza con esse?</h3><p><strong>Pablo</strong>: Ero un investitore e avevo già una buona comprensione delle blockchain prima di questo (a partire dal 2018), ma il 2020 è davvero il momento in cui ne sono diventato ossessionato, e soprattutto quando ho iniziato a capire che DeFi era promettente ma non inclusivo.</p>
<p>Tutto ruota attorno all’USD, ma non ci sono mattoncini di denaro per le persone in Europa, per le persone in Asia, per le persone ovunque nel mondo.</p>
<p>È questo che mi ha dato il desiderio di iniziare a cambiare le cose! Ed è per questo che Angle è qui: costruire stablecoin efficienti e trasparenti per tutti.</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 si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>