R2F0ZS5pbyBBTUEgbWV0IFBhcmlidXMtSW52ZXN0ZWVyIGluIERlRmksIGhlcmRlZmluaWVlciB1dyBvcGJyZW5nc3Q=

<p><img src="https://gimg2.gateimg.com/image/article/16855135871.jpg" alt=""><br><strong>Tijd: 17 januari 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 Deniz, CEO &amp; Co-Founder van Paribus 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://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>Volg Paribus op <a href="https://twitter.com/paribus_io" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16855138342.jpg" alt=""><br><strong>Deniz - CEO &amp; Co-Founder van Paribus</strong></p>
<h2 id="h2-Vraag20amp20Antwoord20van20Gateio450103"><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-Q120Kun20je20ons20wat20over20jezelf20en20over20Paribus20vertellen986801"><a name="Q1: Kun je ons wat over jezelf en over Paribus vertellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je ons wat over jezelf en over Paribus vertellen?</h3><p><strong>Deniz</strong>: Zeker!</p>
<p>Ik ben Deniz, CEO &amp; Co-founder van Paribus. Ik heb 12 jaar als software engineer gewerkt, waarvan de laatste 5 jaar in de crypto-wereld. Ik heb een BSc en MSc in Software Engineering en ben van jongs af aan dol geweest op software en code, hoewel ik als CEO meer gericht ben op het zakelijke en visionaire aspect van Paribus.<br><img src="https://gimg2.gateimg.com/image/article/16855138613.png" alt=""><br>Paribus is het eerste platform in zijn soort voor lenen/lenen tussen verschillende blockchainnetwerken. <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> We hebben een geavanceerd en dynamisch rentealgoritme dat liquiditeit zal ontsluiten over ketens via een reeks crypto-activa zoals liquiditeitsposities, synthetica, virtueel land en NFT’s. Onze visie is om al deze crypto-activa te laten gebruiken als onderpand voor leningen die zijn uitgegeven in conventionele crypto-activa. Het idee en de visie voor het platform ontstonden toen de NFT-markt en de hoeveelheid liquiditeit binnen die ruimte jaar op jaar groeiden. We dachten bij onszelf, waarom gebruiken we deze waarde niet om liquiditeit vrij te maken en extra ondernemingen te financieren in plaats van een activum direct te verkopen.</p>
<h3 id="h3-Q220Geweldig20wat20kunnen20gebruikers20doen20met20Paribus581065"><a name="Q2: Geweldig, wat kunnen gebruikers doen met Paribus?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Geweldig, wat kunnen gebruikers doen met Paribus?</h3><p><img src="https://gimg2.gateimg.com/image/article/16855138764.png" alt=""><br><strong>Deniz</strong> Paribus is een cross-chain leen- en leenplatform dat zowel conventionele als niet-conventionele activa benut om eindgebruikers in staat te stellen hun ondernemingen te faciliteren zonder volledige verkoop van hun activa. U kunt als eigenaar van een NFT een waardering krijgen, deze in een pool storten en stabiele munten tegen deze waarde lenen op basis van een dynamisch rentemodel. Net als NFT’s ondersteunen we virtuele landen en synthetica om hun onderliggende waarde te benutten en liquiditeit te bieden aan onze eindgebruikers op inactieve of minder liquide activa. Naast niet-conventionele activa accepteren we natuurlijk ook onderpand in de vorm van ADA, ETH, BTC en meer.</p>
<h3 id="h3-Q320Klinkt20interessant20Dus20je20zou20in20staat20zijn20om20NFTonderpandleningen20te20krijgen20kun20je20me20uitleggen20hoe20dat20zou20werken964844"><a name="Q3: Klinkt interessant. Dus je zou in staat zijn om NFT-onderpandleningen te krijgen, kun je me uitleggen hoe dat zou werken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Klinkt interessant. Dus je zou in staat zijn om NFT-onderpandleningen te krijgen, kun je me uitleggen hoe dat zou werken?</h3><p><strong>Deniz</strong>: Het idee is gebaseerd op gepoolde NFT’s. We stellen ons voor dat NFT-pools worden gebruikt waarin NFT’s kunnen worden gedeponeerd op basis van bepaalde kenmerken/eigenschappen die de NFT gelijkwaardig maken aan de rest van de NFT’s in die pool. Een NFT-houder ontvangt als tegenprestatie een getokeniseerde representatie van hun NFT. Ze kunnen deze tokens vervolgens gebruiken om deze te storten in onze NFT-uitleenpool(s), waar ze erop kunnen lenen op basis van een dynamisch rentemodel.</p>
<p>Zodra een gebruiker klaar is om zijn lening terug te betalen, kan hij zijn getokeniseerde NFT-tokens terugnemen en zijn NFT (of het equivalent daarvan) in zijn portemonnee terugkrijgen. Wat ons model anders maakt, is dat we begonnen zijn met het samenstellen van gegevenssets om in onze ML-algo’s te voeren om te helpen bij waarderingen en identificatie van vergelijkbare NFT’s. Het stroomlijnen van dit proces stelt ons in staat om NFT’s beter te waarderen en eindgebruikers echt in staat te stellen hun activa optimaal te benutten. Hetzelfde proces zal worden toegepast op virtueel land, dat technisch gezien NFT’s zijn met hun unieke gespecialiseerde eigenschappen.</p>
<h3 id="h3-Q420Ok20klinkt20zeker20geavanceerd20Wat20is20ook20het20doel20van20de20Paribus20PBX20token408846"><a name="Q4: Oké, klinkt zeker geavanceerd. Wat is ook het doel van de Paribus ($PBX) token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Oké, klinkt zeker geavanceerd. Wat is ook het doel van de Paribus ($PBX) token?</h3><p><strong>Deniz</strong>: Zeker, interessant en het bereik is zeer breed, daarom geloof ik sterk dat Paribus een gamechanger is voor niet-conventionele activa.</p>
<p>Onze governance-token PBX is zorgvuldig gemaakt voor onze gemeenschap. Voor onze PBX-token hebben we drie primaire gebruiksscenario’s: 1) Er zullen betere leenrentes zijn voor degenen die PBX-houders zijn. 2) Beloningsdeling, PBX-houders die deelnemen aan onze liquiditeitsprogramma’s krijgen de mogelijkheid om beloningen te delen. 3) Governance, PBX-houders kunnen verbeteringsvoorstellen creëren, stemmen en implementeren. Onze gemeenschap kan nieuwe functies toevoegen en/of bestaande functionaliteiten bewerken met de kracht van PBX Governance.</p>
<h3 id="h3-Q520Hoe20zouden20gebruikers20in20de20toekomst20rente20kunnen20verdienen20vanuit20de20PBXtoken20Zullen20er20andere20prikkels20zijn20anders20dan20de20betere20leenrentes20die20u20al20hebt20genoemd20voor20PBXhouders190796"><a name="Q5: Hoe zouden gebruikers in de toekomst rente kunnen verdienen vanuit de $PBX-token? Zullen er andere prikkels zijn (anders dan de betere leenrentes die u al hebt genoemd) voor PBX-houders?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Hoe zouden gebruikers in de toekomst rente kunnen verdienen vanuit de $PBX-token? Zullen er andere prikkels zijn (anders dan de betere leenrentes die u al hebt genoemd) voor PBX-houders?</h3><p><strong>Deniz</strong>: Gebruikers kunnen op twee manieren rente verdienen op Paribus.</p>
<p>1) stort geld in leenpools om liquiditeit beschikbaar te maken om te lenen en rente te verdienen op basis van het dynamische rentemodel dat is geïmplementeerd.<br>2) Gebruikers kunnen een deel van de kosten verdienen die het platform genereert bij elke leningcreatie en inlossing.</p>
<p>Alle kosten zullen terugkeren naar PBX-stakers en/of inkoop- en burn-programma’s.</p>
<h3 id="h3-Q620Geweldig20Zijn20er20in20de20toekomst20plannen20voor20Paribus20om20Cross20Chain20mogelijkheden20te20hebben684135"><a name="Q6: Geweldig! Zijn er in de toekomst plannen voor Paribus om Cross Chain mogelijkheden te hebben?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Geweldig! Zijn er in de toekomst plannen voor Paribus om Cross Chain mogelijkheden te hebben?</h3><p><strong>Deniz</strong>: Ja, Paribus zal bruggen bouwen met zowel EVM-gebaseerde als niet-EVM-gebaseerde blockchains. Afhankelijk van de keten die wordt overbrugd, zullen we technologieën zoals het IBC (Inter Blockchain Communication) Protocol en/of het Cross-Chain Interoperability Protocol (CCIP) gebruiken. We willen integreren met zoveel mogelijk ketens en het feit dat we op <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> zitten helpt ons doel om interoperabel te zijn.</p>
<h3 id="h3-Q720Klinkt20goed20Wat20zijn20dan20de20plannen20voor20Paribus20in20de20komende20620maanden39280"><a name="Q7: Klinkt goed! Wat zijn dan de plannen voor Paribus in de komende 6 maanden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Klinkt goed! Wat zijn dan de plannen voor Paribus in de komende 6 maanden?</h3><p><strong>Deniz</strong>: Ons belangrijkste doel voor de komende 6 maanden is om onze MVP op Arbitrum uit te brengen. De volgende iteratie na de MVP zal direct de integratie van synthetica als onderpand zijn. Vanaf dat moment richten we ons uitsluitend op NFT’s en hoe we ze het beste in ons platform kunnen integreren volgens onze litepaper. Het volledige routekaart van Paribus is hier te vinden: <a href="https://blog.paribus.io/paribus-the-road-ahead-ad7acd3bc935" rel="nofollow noopener noreferrer" target="_blank">https://blog.paribus.io/paribus-de-weg-vooruit-ad7acd3bc935</a></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 visie van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Herpublicatie van het artikel zal worden toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>