R2F0ZS5pbyBBTUEgY29uIFBhcmlidXMtSW52ZXN0IGluIERlRmksIFJpZGVmaW5pc2NpIGlsIHR1byByZW5kaW1lbnRv

<p><img src="https://gimg2.gateimg.com/image/article/16855135871.jpg" alt=""><br><strong>Ora: 17 gennaio 2022, 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 Deniz, CEO &amp; Co-Fondatore di Paribus nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio di Gate.io</a>.</strong><br><strong>Sito ufficiale: <a href="https://paribus.io/" rel="nofollow noopener noreferrer" target="_blank">https://paribus.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/paribus_io" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/paribus_io</a></strong><br><strong>Segui Paribus su <a href="https://twitter.com/paribus_io" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16855138342.jpg" alt=""><br><strong>Deniz - CEO &amp; Co-Fondatore di Paribus</strong></p>
<h2 id="h2-QampA20da20Gateio543873"><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-Q120Puoi20dirci20qualcosa20su20di20te20e20su20Paribus885295"><a name="Q1: Puoi dirci qualcosa su di te e su Paribus?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi dirci qualcosa su di te e su Paribus?</h3><p><strong>Deniz</strong>: Certo!</p>
<p>Sono Deniz, CEO e co-fondatore di Paribus. Ho lavorato come ingegnere software per 12 anni, gli ultimi 5 anni nel settore delle criptovalute. Ho una laurea triennale e una magistrale in Ingegneria del Software e sin da giovane ho amato il software e il codice, sebbene io sia più concentrato sugli aspetti aziendali e di visione di Paribus come CEO.<br><img src="https://gimg2.gateimg.com/image/article/16855138613.png" alt=""><br>Paribus è la prima piattaforma di prestito/prestito cross-chain del suo genere su <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a>. Abbiamo un algoritmo sofisticato e dinamico per il tasso di interesse che sbloccherà liquidità tra le catene attraverso una serie di asset crittografici come posizioni di liquidità, sintetici, terreni virtuali e NFT. La nostra visione è di consentire a tutti questi asset crittografici di essere utilizzati come garanzia per prestiti presi in asset crittografici convenzionali. L’idea e la visione della piattaforma sono nate man mano che il mercato NFT e la quantità di liquidità in quel settore crescevano anno dopo anno. Abbiamo pensato a noi stessi, perché non utilizzare questo valore per sbloccare liquidità e finanziare ulteriori iniziative anziché vendere un asset direttamente.</p>
<h3 id="h3-Q220Ottimo20quindi20cosa20possono20fare20gli20utenti20con20Paribus195446"><a name="Q2: Ottimo, quindi cosa possono fare gli utenti con Paribus?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Ottimo, quindi cosa possono fare gli utenti con Paribus?</h3><p><img src="https://gimg2.gateimg.com/image/article/16855138764.png" alt=""><br><strong>Deniz</strong>: Paribus è una piattaforma di prestiti e prestiti cross-chain che sfrutta sia asset convenzionali che non convenzionali per consentire agli utenti finali di facilitare le loro operazioni senza la vendita diretta dei loro asset. Puoi, come proprietario di un NFT, ottenere una valutazione, depositarla in un pool e prendere in prestito stablecoin in base ad essa in base a un modello di tasso di interesse dinamico. Come gli NFT, supporteremo anche Terre Virtuali e sintetici per sfruttare il loro valore sottostante e offrire liquidità ai nostri utenti finali su asset dormienti o meno liquidi. Oltre agli asset non convenzionali, accettiamo naturalmente anche garanzie sotto forma di ADA, ETH, BTC e altro.</p>
<h3 id="h3-Q320Sembra20interessante20Quindi20sarebbe20possibile20ottenere20prestiti20garantiti20da20NFT20puoi20spiegarmi20come20funzionerebbe857831"><a name="Q3: Sembra interessante. Quindi sarebbe possibile ottenere prestiti garantiti da NFT, puoi spiegarmi come funzionerebbe?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Sembra interessante. Quindi sarebbe possibile ottenere prestiti garantiti da NFT, puoi spiegarmi come funzionerebbe?</h3><p><strong>Deniz</strong>: L’idea si basa su NFT raggruppati. Immaginiamo di gestire pool di NFT che consentono il deposito di NFT basati su determinate caratteristiche/tratti che rendono l’NFT di pari valore al resto degli NFT in quel pool. Un detentore di NFT riceverà in cambio una rappresentazione tokenizzata del proprio NFT. Possono poi utilizzare questi token per depositarli nei nostri Pool di Prestiti NFT, dove possono prendere in prestito su di essi sulla base di un modello di interesse dinamico.</p>
<p>Una volta che un utente è pronto a ripagare il proprio prestito, può riprendere i suoi token NFT tokenizzati e recuperare il proprio NFT (o l’equivalente di esso) nel proprio portafoglio. Ciò che differenzia il nostro modello è che abbiamo iniziato a mettere insieme set di dati da inserire nei nostri algoritmi di ML per aiutare con le valutazioni e l’identificazione di NFT simili. Ottimizzare questo processo ci permetterà di valutare meglio gli NFT consentendo veramente agli utenti finali di sfruttare al massimo i propri asset. Lo stesso processo sarà applicato alle Terre Virtuali, che tecnicamente parlando sono NFT con le loro caratteristiche uniche specializzate.</p>
<h3 id="h3-Q420Ok20suona20sicuramente20sofisticato20Inoltre20qual2020lo20scopo20del20token20Paribus20PBX958349"><a name="Q4: Ok, suona sicuramente sofisticato. Inoltre, qual è lo scopo del token Paribus ($PBX)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Ok, suona sicuramente sofisticato. Inoltre, qual è lo scopo del token Paribus ($PBX)?</h3><p><strong>Deniz</strong> Sicuramente, interessante e con un campo d’applicazione molto ampio, motivo per cui credo fortemente che Paribus sia un cambiamento epocale per gli asset non convenzionali.</p>
<p>Il nostro token di governance PBX è stato pensato appositamente per la nostra comunità. Per il nostro token PBX, abbiamo tre utilizzi principali: 1) Ci saranno migliori tassi di prestito per coloro che sono detentori di PBX. 2) Condivisione delle ricompense, tutti i detentori di PBX che partecipano ai nostri programmi di liquidità avranno la possibilità di condividere le ricompense. 3) Governance, i detentori di PBX potranno creare, votare e attuare proposte di miglioramento. La nostra comunità potrà aggiungere nuove funzionalità e/o modificare le funzionalità esistenti con il potere della Governance PBX.</p>
<h3 id="h3-Q520Come20potrebbero20gli20utenti20guadagnare20interessi20in20futuro20dal20token20PBX20Ci20saranno20degli20incentivi20oltre20ai20migliori20tassi20di20prestito20che20hai20gi20menzionato20per20i20detentori20di20PBX913269"><a name="Q5: Come potrebbero gli utenti guadagnare interessi in futuro dal token $PBX? Ci saranno degli incentivi (oltre ai migliori tassi di prestito che hai già menzionato) per i detentori di PBX?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Come potrebbero gli utenti guadagnare interessi in futuro dal token $PBX? Ci saranno degli incentivi (oltre ai migliori tassi di prestito che hai già menzionato) per i detentori di PBX?</h3><p><strong>Deniz</strong>: Gli utenti potranno guadagnare interessi in due modi su Paribus.</p>
<p>1) depositare fondi nelle piscine di prestito rendendo la liquidità disponibile per essere presa in prestito e guadagnare interessi in base al modello di tasso di interesse dinamico implementato.<br>2) Gli utenti saranno in grado di guadagnare una quota delle commissioni generate dalla piattaforma su ogni creazione e riscatto di prestito.</p>
<p>Tutte le commissioni verranno restituite agli stakeholder di PBX e/o ai programmi di buy-back e bruciamento.</p>
<h3 id="h3-Q620Ottimo20Ci20sono20programmi20futuri20per20Paribus20di20avere20capacit20Cross20Chain175426"><a name="Q6: Ottimo! Ci sono programmi futuri per Paribus di avere capacità Cross Chain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Ottimo! Ci sono programmi futuri per Paribus di avere capacità Cross Chain?</h3><p><strong>Deniz</strong>: Sì, Paribus costruirà ponti sia con le blockchain basate su EVM che non basate su EVM. A seconda della catena che viene collegata, utilizzeremo tecnologie come il Protocollo di Comunicazione Inter Blockchain (IBC) e/o il Protocollo di Interoperabilità Cross-Chain (CCIP). Vogliamo integrarci con il maggior numero possibile di catene e essere su <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> ci aiuta enormemente nei nostri obiettivi di interoperabilità.</p>
<h3 id="h3-Q720Suona20bene20Quali20sono20i20piani20per20Paribus20nei20prossimi20620mesi483354"><a name="Q7: Suona bene! Quali sono i piani per Paribus nei prossimi 6 mesi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Suona bene! Quali sono i piani per Paribus nei prossimi 6 mesi?</h3><p><strong>Deniz</strong>: Il nostro obiettivo principale per i prossimi 6 mesi è rilasciare il nostro MVP su Arbitrum. La prossima iterazione immediatamente successiva all’MVP sarà l’integrazione di sintetici come garanzie. Da lì in poi ci stiamo concentrando esclusivamente su NFT e su come integrarli al meglio nella nostra piattaforma secondo il nostro litepaper. È possibile trovare la roadmap completa di paribus qui: <a href="https://blog.paribus.io/paribus-the-road-ahead-ad7acd3bc935" rel="nofollow noopener noreferrer" target="_blank">https://blog.paribus.io/paribus-the-road-ahead-ad7acd3bc935</a></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 il punto di vista 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 fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>