R2F0ZS5pbyBBTUEgbWV0IFBhcmlidXMtSW52ZXN0ZWVyIGluIERlRmksIEhlcmRlZmluaWVlciB1dyBPcGJyZW5nc3Q=

<p><img src="https://gimg2.gateimg.com/image/article/16885520661.png" alt=""><br><strong>Tijd: 30 juni 2023, 14: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 Dalkilic, CEO 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 Twitter en Telegram</strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16885521732.jpg" alt=""><br><strong>Deniz Dalkilic — CEO van Paribus</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio313138"><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-Q120Paribus20is20een20DeFiprotocol20voor20lenen20en20uitlenen20maar20wat20maakt20Paribus20speciaal20in20vergelijking20met20anderen20in20deze20ruimte944234"><a name="Q1: Paribus is een DeFi-protocol voor lenen en uitlenen, maar wat maakt Paribus speciaal in vergelijking met anderen in deze ruimte?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Paribus is een DeFi-protocol voor lenen en uitlenen, maar wat maakt Paribus speciaal in vergelijking met anderen in deze ruimte?</h3><p><img src="https://gimg2.gateimg.com/image/article/16885521853.png" alt=""><br><strong>Deniz</strong>: Het is waar, Uitleen- en uitleenprotocollen bestaan al een tijdje, maar met Paribus hebben we Superieure Technologie met een AI/ML-prijsmodel dat directe leningen mogelijk maakt in plaats van ouderwetse P2P-modellen. Ook zijn er waarborgen ingesteld. Maar wat ons echt onderscheidt van andere projecten is dat we ons protocol hebben ontwikkeld om zich aan te passen aan een breed scala aan activa, waaronder Exoten zoals NFT’s, Synthetica, Metaverse en RWA.</p>
<h3 id="h3-Q220Je20bent20onlangs20gelanceerd20op20Arbitrum20met20je20Mainnet20V120Waarom20Arbitrum20en20welke20chain20is20de20volgende20in20lijn208103"><a name="Q2: Je bent onlangs gelanceerd op Arbitrum met je Mainnet V1 Waarom Arbitrum? en welke chain is de volgende in lijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Je bent onlangs gelanceerd op Arbitrum met je Mainnet V1 Waarom Arbitrum? en welke chain is de volgende in lijn?</h3><p><strong>Deniz</strong>: We geloven dat Arbitrum een nieuwe en innovatieve keten is met een groeiend ecosysteem waar we mee kunnen groeien. Ons doel is om met elke keten samen te werken, momenteel wachten we op een prijsorakel feed zodat we kunnen migreren naar <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> via een brugoplossing. Onze app is echter klaar om te lenen en liquiditeit te bieden om passieve beloningen te verdienen.</p>
<h3 id="h3-Q320Op20uw20routekaart20heeft20u20Metahypotheek20en20uw20eigen20Metaverse20HQ20staan20Kunt20u20wat20meer20uitleg20geven20over20deze20functie3221"><a name="Q3: Op uw routekaart heeft u Meta-hypotheek en uw eigen Metaverse HQ staan. Kunt u wat meer uitleg geven over deze functie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Op uw routekaart heeft u Meta-hypotheek en uw eigen Metaverse HQ staan. Kunt u wat meer uitleg geven over deze functie?</h3><p><strong>Deniz</strong>: Het gedachteproces achter meta-hypotheken is dat we dezelfde functionaliteit van traditionele hypotheken kunnen overnemen en naar de metaverse kunnen brengen, met behoud van een vergelijkbare structuur zoals ze in de echte wereld zijn. Dit is simpelweg een stap om te voldoen aan de groeiende vraag naar financiële participatie binnen metaversen. We streven ernaar om het meest toegankelijke en gebruiksvriendelijke platform te zijn binnen deze ruimte.</p>
<h3 id="h3-Q420NFTlenen20komt20binnenkort20live20op20Paribus20Kun20je20ons20vertellen20hoe20het20zal20werken20en20wat20zijn20je20verwachtingen20305"><a name="Q4: NFT-lenen komt binnenkort live op Paribus. Kun je ons vertellen hoe het zal werken en wat zijn je verwachtingen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: NFT-lenen komt binnenkort live op Paribus. Kun je ons vertellen hoe het zal werken en wat zijn je verwachtingen?</h3><p><img src="https://gimg2.gateimg.com/image/article/16885522054.png" alt=""><br><strong>Deniz</strong>: Voor onze NFT- uitleenzijde hebben we een speciale A.I.-module gebouwd die de gebruiker in staat zal stellen om directe leningen te krijgen in plaats van ouderwetse P2P-modellen. We gaan samenwerken met alle blue chip NFT-projecten en zullen een nieuwe functie introduceren waar we aan werken genaamd cascading liquidation, die het in feite mogelijk maakt voor leners om een limiet in te stellen en een extra beveiligingsnet te bieden.</p>
<h3 id="h3-Q520Als20volgende20staat20Governance20op20de20agenda20om20een20DAO20te20worden20We20weten20dat20jullie20daarvoor20ook20een20zeer20uniek20model20hebben20dus20leg20alsjeblieft20uit20hoe20het20zal20werken20en20hoe20belangrijk20het20is20voor20de20levensduur20van20de20protocollen931868"><a name="Q5: Als volgende staat Governance op de agenda om een DAO te worden. We weten dat jullie daarvoor ook een zeer uniek model hebben, dus leg alsjeblieft uit hoe het zal werken en hoe belangrijk het is voor de levensduur van de protocollen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Als volgende staat Governance op de agenda om een DAO te worden. We weten dat jullie daarvoor ook een zeer uniek model hebben, dus leg alsjeblieft uit hoe het zal werken en hoe belangrijk het is voor de levensduur van de protocollen?</h3><p><strong>Deniz</strong>: Met het Paribus Governance-model introduceren we een kwadratische stemmingsysteem. We geloven dat dit een krachtig instrument is dat zorgt voor een meer gelijkwaardige verdeling van stemrechten onder gemeenschapsleden. Helaas werken de meeste DAO’s niet op deze manier. Het doel van de overgang naar een DAO is altijd een belangrijk uitgangspunt geweest voor Paribus. We willen een systeem creëren dat de gemeenschap in staat stelt veranderingen door te voeren en transparantie biedt voor alle betrokkenen, terwijl ze beloond worden met PBX-tokens voor hun deelname. Bovendien geloof ik dat dit aspect veel deuren voor ons zal openen op bijna elk gebied, dus ik geloof zeker dat governance een cruciaal aspect is van de Paribus-visie en dat het erg belangrijk zal zijn om ons langetermijnsucces te waarborgen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Gemeenschap<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 is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>