R2F0ZS5pbyBBTUEgY29uIENsZWFycG9vbCAtIElsIHByaW1vIG1lcmNhdG8gZGVsIGNyZWRpdG8gZGVjZW50cmFsaXp6YXRv

<p><img src="https://gimg2.gateimg.com/image/article/16902684781.jpeg" alt=""><br><strong>Ora: 27 novembre 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Robert Alcorn, Co-Fondatore e CEO di Clearpool nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di Gate.io Exchange</a></strong><br><strong>Sito web ufficiale: <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>Segui Clearpool su <a href="https://twitter.com/ClearpoolFin" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/clearpoolofficial" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16902686742.jpg" alt=""><br><strong>Robert Alcorn - Co-Fondatore e CEO di Clearpool</strong></p>
<h2 id="h2-QampA20da20Gateio624407"><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-Q120Puoi20presentarti20e20presentare20i20membri20principali20del20tuo20team207669"><a name="Q1: Puoi presentarti e presentare i membri principali del tuo team?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi presentarti e presentare i membri principali del tuo team?</h3><p><strong>Rob</strong>: Certamente.</p>
<p>Sono Rob, sono il CEO e co-fondatore di Clearpool! Ho più di 20 anni di esperienza nel mondo degli affari, di cui 12 anni nei mercati finanziari globali. Prima di Clearpool ero Direttore Esecutivo, APAC Repo Trader presso la First Abu Dhabi Bank. Sono coinvolto nel settore delle criptovalute dal 2015, quando ho iniziato a fare ricerca sulla tecnologia blockchain per una piattaforma di gestione patrimoniale digitale su cui stavo lavorando all’epoca. Da allora faccio trading di criptovalute e ho molti amici nel settore, tra cui il mio co-fondatore Alessio Quaglini, CEO di Hex Trust. Alessio ed io siamo ex colleghi dai tempi in cui lavoravamo in banca. È un consulente senior per Clearpool.</p>
<p>Jakob Kronbichler si è unito a noi nel team fondatore fin dall’inizio, ha un track record di lancio di vari start-up per Rocket Internet ed è stato più recentemente Direttore Commerciale presso una delle più grandi neobanche digitali in Asia. Pavel Ivanov è il nostro CTO e Vadim Zolotokrylin è il nostro Product Owner, entrambi hanno una vasta esperienza nello sviluppo di blockchain, così come il nostro team di sviluppatori. In totale siamo un team di nove persone con sede a Hong Kong, Singapore e Mosca.</p>
<h3 id="h3-Q220Cos20Clearpool99943"><a name="Q2: Cos’è Clearpool?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Cos’è Clearpool?</h3><p><strong>Rob</strong>: Clearpool è il primo mercato decentralizzato e dinamico per la liquidità non garantita. Consente ai prestiti istituzionali di attrarre liquidità direttamente dall’ecosistema DeFi senza la necessità di garanzie.</p>
<p>Clearpool introduce piscine di liquidità continue a singolo mutuatario con un meccanismo dinamico del tasso di interesse che prende il suo input principale dal rapporto di utilizzo della piscina - l’importo di liquidità attualmente utilizzato dal mutuatario della piscina.</p>
<p>Questo meccanismo dinamico, guidato dalla domanda e dall’offerta del mercato, garantisce che ogni pool raggiunga sempre uno stato di equilibrio in termini di dimensioni del pool e tasso di interesse.</p>
<p>I mutuatari non hanno pagamenti di interessi regolari o ripagamenti programmati del capitale e i creditori vengono ricompensati con tassi di interesse più elevati quando aumentano i rischi.</p>
<p>Quando i creditori forniscono liquidità a un pool, ricevono cpTokens. Questi token rappresentano la liquidità fornita al pool, accumulano gli interessi e le ricompense del pool ad ogni blocco, e rappresentano il profilo di rischio del prestatore del pool.</p>
<p>I cpTokens possono essere riscattati in qualsiasi momento, soggetti alla liquidità disponibile, e possono essere scambiati in un mercato secondario, offrendo agli LPs opzioni in termini di liquidità e gestione del rischio. I cpTokens sono i mattoni fondanti per un sistema di rischio tokenizzato che permetterà a Clearpool di introdurre successivamente ulteriori soluzioni di gestione del rischio e copertura per i creditori.<br><img src="https://gimg2.gateimg.com/image/article/16902689053.png" alt=""><br>È questo livello di sofisticazione che posizionerà Clearpool per attirare flussi dal sistema tradizionale dei mercati di capitale del valore di 120 trilioni di dollari.</p>
<h3 id="h3-Q320Quindi20come20possono20i20piccoli20investitori20partecipare20a20questo20progetto112652"><a name="Q3: Quindi come possono i piccoli investitori partecipare a questo progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Quindi come possono i piccoli investitori partecipare a questo progetto?</h3><p><strong>Rob</strong>: CPOOL è il token di utilità e governance per il protocollo Clearpool. I detentori di CPOOL voteranno sull’elenco bianco dei nuovi mutuatari, un processo che qualificherà i partecipanti a guadagnare ulteriori CPOOL attraverso un regime di ricompense incentivante.</p>
<p>Alla fine, sarà introdotta una struttura di governance completamente decentralizzata, che consentirà ai detentori di CPOOL di proporre, votare e attuare futuri cambiamenti e aggiornamenti del protocollo.</p>
<p>Il pre-staking sarà disponibile dopo il lancio di CPOOL su diverse piattaforme CEX, e abbiamo anche interessanti ricompense per coloro che forniscono liquidità ETH/CPOOL su <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> v3.</p>
<p>Un nuovo programma di staking verrà annunciato prima del lancio della mainnet del protocollo Clearpool v1.0, dove gli stakeholder a lungo termine guadagneranno ricompense significativamente più alte. Lo staking di CPOOL sarà un’azione obbligatoria per i mutuatari, che dovranno scommettere una quantità di CPOOL per accedere all’area del protocollo dove potranno fare una proposta per essere inseriti in whitelist.</p>
<p>I fornitori di liquidità guadagnano ulteriori ricompense CPOOL, aumentando i tassi di interesse del pool a livelli interessanti. Clearpool annuncerà un programma di buyback, in cui una quota dei ricavi del protocollo verrà utilizzata per acquistare CPOOL sul mercato libero per sostenere perpetuamente i pool di ricompense.</p>
<p>Quindi molte ragioni per acquistare e tenere!</p>
<h3 id="h3-Q420Davvero20molto20interessante20E20come20Clearpool20garantisce20la20sicurezza20degli20asset20degli20utenti20E20come20affronterai20le20normative20e20le20politiche20di20conformit943118"><a name="Q4: Davvero molto interessante! E come Clearpool garantisce la sicurezza degli asset degli utenti? E come affronterai le normative e le politiche di conformità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Davvero molto interessante! E come Clearpool garantisce la sicurezza degli asset degli utenti? E come affronterai le normative e le politiche di conformità?</h3><p><strong>Rob</strong>: Uno dei nostri principali partner è Hex Trust, il principale custode di asset digitali dell’Asia. Hex fornirà servizi di custodia e monitoraggio delle transazioni a Clearpool e ai suoi utenti. Hex è autorizzato e regolamentato sia a Hong Kong che a Singapore, quindi portano molta competenza in termini di normative e politiche di conformità. Insieme ad Hex, Clearpool ha sviluppato un sistema di prova di identità e KYC, che ci consente di verificare l’identità e lo stato KYC dei nostri mutuatari.</p>
<p>Avere una stretta partnership con un’azienda come Hex, mostra che Clearpool ha la lungimiranza di operare in modo conforme sfruttando al contempo i benefici della crittografia e della decentralizzazione. Il nostro obiettivo a lungo termine è attirare una quota di mercato significativa da TradFi e rendere Clearpool il luogo principale per l’emissione di debiti on-chain, la partnership con Hex ci aiuterà a realizzare questa visione. La sicurezza dei fondi degli utenti è di massima importanza per il nostro team, a tal fine i nostri smart contract sono sottoposti a un’auditing da parte di una rinomata società di audit sulla sicurezza dei contratti intelligenti per garantire che non esistano vulnerabilità.</p>
<h3 id="h3-Q520Qual2020il20prossimo20passo20dopo20lIDO20C20qualcosaltro20a20cui20gli20investitori20possono20guardare20avanti226534"><a name="Q5: Qual è il prossimo passo dopo l’IDO? C’è qualcos’altro a cui gli investitori possono guardare avanti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Qual è il prossimo passo dopo l’IDO? C’è qualcos’altro a cui gli investitori possono guardare avanti?</h3><p><strong>Rob</strong>: Sì! I detentori e gli stakeholder a lungo termine di CPOOL avranno le migliori opportunità su Clearpool in futuro.</p>
<p>Immediatamente dopo l’IDO, il nostro programma di pre-staking sarà disponibile su varie piattaforme, ciò darà ai detentori di CPOOL incredibili opportunità per aumentare le loro partecipazioni mentre ci avviciniamo al lancio del mainnet. State attenti a un annuncio su questo.</p>
<p>Clearpool consente agli investitori al dettaglio di partecipare a alcune delle opportunità di investimento che in TradFi sono tipicamente disponibili solo per istituzioni o HNWI. I prestiti istituzionali su Clearpool, come fondi speculativi e società di trading molto di successo, generano enormi rendimenti e possono quindi pagare tassi di interesse più elevati per la liquidità non garantita. Gli LP su Clearpool quindi partecipano al successo delle strategie di queste società prestando loro denaro e ricevendo tassi di interesse più elevati.</p>
<p>I premi bonus aggiuntivi pagati nel token nativo CPOOL aumenteranno i rendimenti complessivi a livelli molto interessanti, soprattutto per i detentori e gli stakers a lungo termine. Ciò renderà Clearpool uno dei luoghi più interessanti nel settore DeFi per i prestatori e gli investitori!</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Community 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 ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>