R2F0ZS5pbyBBTUEgbWV0IENsZWFycG9vbCAtIGRlIGVlcnN0ZSBnZWRlY2VudHJhbGlzZWVyZGUga3JlZGlldG1hcmt0

<p><img src="https://gimg2.gateimg.com/image/article/16902684781.jpeg" alt=""><br><strong>Tijd: 27 november 2021, 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 Robert Alcorn, mede-oprichter en CEO van Clearpool 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://clearpool.finance/" rel="nofollow noopener noreferrer" target="_blank">https://clearpool.finance/</a></strong><br><strong>Twitter: <a href="https://twitter.com/ClearpoolFin" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/ClearpoolFin</a></strong><br><strong>Volg Clearpool op <a href="https://twitter.com/ClearpoolFin" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/clearpoolofficial" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16902686742.jpg" alt=""><br><strong>Robert Alcorn — Medeoprichter en CEO van Clearpool</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio666915"><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-Q120Kunt20u20zichzelf20en20de20kernleden20van20uw20team20introduceren552839"><a name="Q1: Kunt u zichzelf en de kernleden van uw team introduceren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u zichzelf en de kernleden van uw team introduceren?</h3><p><strong>Rob</strong>: Zeker.</p>
<p>Ik ben Rob, ik ben de CEO en mede-oprichter van Clearpool! Ik heb meer dan 20 jaar ervaring in het bedrijfsleven, inclusief 12 jaar in de wereldwijde financiële markten. Voor Clearpool was ik uitvoerend directeur, APAC Repo Trader bij First Abu Dhabi Bank. Sinds 2015 ben ik betrokken bij crypto toen ik blockchain-technologie begon te onderzoeken voor een digitaal vermogensbeheerplatform waar ik destijds aan werkte. Sindsdien handel ik in crypto en heb ik veel vrienden in de branche, waaronder mijn mede-oprichter Alessio Quaglini, de CEO van Hex Trust. Alessio en ik zijn voormalige collega’s uit onze bankdagen. Hij is een senior adviseur voor Clearpool.</p>
<p>Jakob Kronbichler kwam al vroeg bij ons in het oprichtende team, hij heeft een staat van dienst in het lanceren van verschillende start-ups voor Rocket Internet en was meer recentelijk commercieel directeur bij een van de grootste digitale neobanken in Azië. Pavel Ivanov is onze CTO en Vadim Zolotokrylin is onze Product Owner, ze hebben allebei een rijke ervaring in blockchain-ontwikkeling, net als ons bredere team van ontwikkelaars. In totaal zijn we met een team van negen mensen gevestigd in Hong Kong, Singapore en Moskou.</p>
<h3 id="h3-Q220Wat20is20Clearpool382540"><a name="Q2: Wat is Clearpool?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat is Clearpool?</h3><p><strong>Rob</strong>: Clearpool is de eerste gedecentraliseerde dynamische marktplaats voor ongedekte liquiditeit. Het stelt institutionele leners in staat om liquiditeit rechtstreeks aan te trekken uit het DeFi-ecosysteem zonder de noodzaak van onderpand.</p>
<p>Clearpool introduceert single-borrower doorlopende liquiditeitspools met een dynamisch rentemechanisme dat zijn belangrijkste input haalt uit de gebruiksverhouding van het zwembad - de hoeveelheid liquiditeit die momenteel door de lener van het zwembad wordt gebruikt.</p>
<p>Dit dynamische mechanisme, gedreven door marktvraag en -aanbod, zorgt ervoor dat elke pool altijd een evenwichtstoestand bereikt wat betreft poolgrootte en rentetarief.</p>
<p>Leners hebben geen regelmatige rentebetalingen of geplande aflossingen van de hoofdsom, en kredietverstrekkers worden beloond met hogere rentetarieven wanneer de risico’s toenemen.</p>
<p>Wanneer geldverstrekkers liquiditeit aan een pool verschaffen, ontvangen ze cpTokens. Deze tokens vertegenwoordigen de aan de pool geleverde liquiditeit, accumuleren de poolrente en beloningen op elk blok, en vertegenwoordigen het risicoprofiel van de lener van de pool.</p>
<p>cpTokens kunnen op elk moment worden ingewisseld, afhankelijk van de beschikbare liquiditeit, en kunnen worden verhandeld op een secundaire markt, waardoor LP’s opties hebben op het gebied van liquiditeit en risicobeheer. cpTokens vormen de bouwstenen voor een systeem van getokeniseerd risico, waardoor Clearpool later verdere oplossingen voor risicobeheer en hedging voor geldschieters kan introduceren.<br><img src="https://gimg2.gateimg.com/image/article/16902689053.png" alt=""><br>Het is dit niveau van verfijning dat Clearpool in staat zal stellen om stromen aan te trekken uit het $120 biljoen traditionele kapitaalmarkten ecosysteem.</p>
<h3 id="h3-Vraag20320Hoe20kunnen20retailbeleggers20betrokken20raken20bij20dit20project750561"><a name="Vraag 3: Hoe kunnen retailbeleggers betrokken raken bij dit project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 3: Hoe kunnen retailbeleggers betrokken raken bij dit project?</h3><p><strong>Rob</strong>: CPOOL is de utility- en bestuurlijke token voor het Clearpool-protocol. CPOOL-houders zullen stemmen over de opname van nieuwe leners, een proces dat deelnemers in aanmerking zal laten komen om extra CPOOL te verdienen via een beloningssysteem voor incentives.</p>
<p>Uiteindelijk zal er een volledig gedecentraliseerd governance framework worden geïntroduceerd, waardoor CPOOL-houders toekomstige wijzigingen en upgrades aan het protocol kunnen voorstellen, stemmen en implementeren.</p>
<p>Pre-staking zal beschikbaar zijn na de lancering van CPOOL op meerdere CEX-platforms, en we hebben ook aantrekkelijke beloningen voor degenen die ETH/CPOOL-liquiditeit verschaffen op <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> v3.</p>
<p>Vóór de mainnet-lancering van het Clearpool v1.0-protocol zal er een nieuw stakingprogramma worden aangekondigd, waarbij langdurige stakers aanzienlijk hogere beloningen zullen verdienen. CPOOL-staking zal een vereiste actie zijn voor leners, die een bepaalde hoeveelheid CPOOL moeten inzetten om toegang te krijgen tot het gebied van het protocol waar ze een voorstel kunnen doen om op de whitelist te komen.</p>
<p>Liquiditeitsverschaffers verdienen extra CPOOL-rewards, waardoor de rentetarieven van het zwembad aantrekkelijk worden. Clearpool zal een terugkoopprogramma aankondigen, waarbij een deel van de protocol-inkomsten zal worden gebruikt om CPOOL op de open markt te kopen om de beloningspools voortdurend te ondersteunen.</p>
<p>Dus genoeg redenen om te kopen en vast te houden!</p>
<h3 id="h3-Q420Zeer20interessant20inderdaad20En20hoe20beveiligt20Clearpool20de20activa20van20gebruikers20En20hoe20zullen20jullie20omgaan20met20de20regelgevende20en20nalevingsbeleid496333"><a name="Q4: Zeer interessant inderdaad! En hoe beveiligt Clearpool de activa van gebruikers? En hoe zullen jullie omgaan met de regelgevende en nalevingsbeleid?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Zeer interessant inderdaad! En hoe beveiligt Clearpool de activa van gebruikers? En hoe zullen jullie omgaan met de regelgevende en nalevingsbeleid?</h3><p><strong>Rob</strong>: Een van onze belangrijkste partners is Hex Trust, de toonaangevende bewaarder van digitale activa in Azië. Hex zal bewaar- en transactiemonitoringdiensten leveren aan Clearpool en haar gebruikers. Hex is gelicenseerd en gereguleerd in zowel Hong Kong als in Singapore, dus ze brengen veel expertise op het gebied van regelgeving en compliancebeleid. Samen met Hex heeft Clearpool een identiteitsbewijs en KYC-systeem ontwikkeld, waarmee we de identiteit en KYC-status van onze leners kunnen verifiëren.</p>
<p>Het hebben van een nauwe samenwerking met een bedrijf als Hex toont aan dat Clearpool het inzicht heeft om op een conforme manier te opereren en tegelijkertijd te profiteren van de voordelen van cryptografie en decentralisatie. Het is ons langetermijndoel om een aanzienlijk marktaandeel van TradFi aan te trekken en Clearpool de belangrijkste plek te maken voor de uitgifte van on-chain schulden, de samenwerking met Hex zal ons helpen deze visie te bereiken. De veiligheid van gebruikersfondsen is van het grootste belang voor ons team, om die reden worden onze slimme contracten gecontroleerd door een toonaangevend controlebedrijf voor slimme contractbeveiliging om ervoor te zorgen dat er geen kwetsbaarheden bestaan.</p>
<h3 id="h3-Vraag20520Wat20is20de20volgende20stap20na20de20IDO20Is20er20nog20iets20waar20investeerders20naar20kunnen20uitkijken805922"><a name="Vraag 5: Wat is de volgende stap na de IDO? Is er nog iets waar investeerders naar kunnen uitkijken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 5: Wat is de volgende stap na de IDO? Is er nog iets waar investeerders naar kunnen uitkijken?</h3><p><strong>Rob</strong>: Ja! Langetermijn CPOOL-houders en stakers zullen in de toekomst de beste kansen hebben op Clearpool.</p>
<p>Direct na de IDO zal ons pre-staking programma beschikbaar zijn op verschillende platforms, dit zal CPOOL-houders geweldige kansen bieden om hun bezit te vergroten naarmate we de mainnet lancering naderen. Houd een oogje in het zeil voor een aankondiging hierover.</p>
<p>Clearpool stelt particuliere beleggers in staat deel te nemen aan bepaalde soorten beleggingsmogelijkheden die in TradFi doorgaans alleen beschikbaar zijn voor instellingen of HNWIs. De institutionele leners op Clearpool, zoals zeer succesvolle hedgefondsen en handelsbedrijven, genereren enorme rendementen en kunnen daarom hogere rentetarieven betalen voor ongedekte liquiditeit. LP’s op Clearpool krijgen dus de kans om deel te nemen aan het succes van de strategieën van deze bedrijven door aan hen uit te lenen en de hogere rentetarieven te ontvangen.</p>
<p>Extra bonussen die worden uitbetaald in de inheemse CPOOL-token zullen de totale APY’s verhogen tot zeer aantrekkelijke niveaus, vooral voor langdurige houders en stakers. Dit maakt Clearpool een van de meest aantrekkelijke platforms in DeFi voor geldschieters en investeerders!</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 enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw posten van het artikel is toegestaan mits Gate.io wordt genoemd. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>