R2F0ZS5pbyBBTUEgY29uIExlbmRz

2024-05-08, 06:06

<p><img src="https://gimg2.gateimg.com/image/article/17151480361.jpg" alt=""><br><strong>Ora: 7 maggio 2024, 13:00 UTC</strong><br><strong>Gate.io ha ospitato una sessione AMA (Ask-Me-Anything) con Haroun, CEO di Lends in <a href="https://t.me/gateio_en" rel="nofollow noopener noreferrer" target="_blank">Community di scambio Gate.io</a>.</strong><br><strong>Sito Ufficiale: <a href="https://www.lends.so/" rel="nofollow noopener noreferrer" target="_blank">https://www.lends.so/</a></strong><br><strong>Twitter: <a href="https://twitter.com/lends_so" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/lends_so</a></strong><br><strong>Segui Lends su <a href="https://twitter.com/lends_so" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://discord.com/invite/lends" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong></p>
<h2 id="h2-Q120Puoi20presentarti20ai20membri20della20comunit341903"><a name="Q1: Puoi presentarti ai membri della comunità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi presentarti ai membri della comunità?</h2><p>Ciao a tutti, mi chiamo Haroun e sono il CEO di Lends. Con me c’è Ahmed, che è il CTO di Lends. Insieme, abbiamo fondato Lends.</p>
<h2 id="h2-Q220Qual2020il20problema20centrale20che20Lends20mira20a20risolvere20nel20mercato20del20prestito48154"><a name="Q2: Qual è il problema centrale che Lends mira a risolvere nel mercato del prestito?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Qual è il problema centrale che Lends mira a risolvere nel mercato del prestito?</h2><p>Lends mira a risolvere diversi problemi fondamentali nel mercato tradizionale del prestito. In primo luogo, affronta gli spread inefficaci tra i tassi di prestito e di prestito, dove i mutuatari pagano tassi di interesse più elevati, mentre i creditori guadagnano rendimenti inferiori. Questa inefficienza deriva dagli intermediari coinvolti nel processo di prestito.</p>
<p>In secondo luogo, Lends affronta il problema della limitata scoperta dei prezzi nelle tradizionali piscine di prestito. Spesso queste piscine mancano di trasparenza, rendendo difficile per i prestatori e i mutuatari determinare tassi di mercato equi.</p>
<p>In terzo luogo, Lends risolve il problema del rischio condiviso nei pool di prestito, in cui tutti i prestatori condividono il rischio in modo uguale, indipendentemente dal loro appetito per il rischio o dalla solvibilità del mutuatario.</p>
<p>Per affrontare questi problemi, Lends utilizza i libri degli ordini, che permettono ai prestatori e ai mutuatari di interagire direttamente, senza intermediari. Questo approccio basato sul mercato consente una determinazione dei prezzi più efficiente, una migliore scoperta dei prezzi e un’esposizione al rischio personalizzabile. Inoltre, Lends offre una soluzione di prestito componibile, che consente la creazione di prodotti di prestito diversificati su misura per esigenze specifiche.</p>
<h2 id="h2-Q320Come20funziona20il20modello20di20prestito20del20libro20degli20ordini20di20Lends20e20quali20sono20i20suoi20vantaggi258306"><a name="Q3: Come funziona il modello di prestito del libro degli ordini di Lends e quali sono i suoi vantaggi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Come funziona il modello di prestito del libro degli ordini di Lends e quali sono i suoi vantaggi?</h2><p>Il modello di prestito del libro degli ordini di Lends funziona in modo simile a una borsa valori tradizionale. I prestiti vengono richiesti dai mutuatari con il tasso di interesse e l’importo del prestito desiderati, mentre i prestatori offrono di fornire prestiti ai loro tassi di interesse e importi preferiti. Questi ordini vengono quindi abbinati in base al prezzo e alla quantità, proprio come gli ordini di acquisto e vendita in un mercato azionario.</p>
<p>Il vantaggio chiave di questo modello di libro degli ordini è che consente una scoperta dei prezzi dinamica e in tempo reale. Man mano che l’offerta e la domanda di prestiti fluttuano, i tassi di interesse (prezzi) si adeguano di conseguenza. Questo approccio guidato dal mercato garantisce che i prezzi dei prestiti siano sempre riflettenti delle attuali condizioni di mercato, fornendo un ecosistema di prestiti più efficiente e trasparente.<br>Inoltre, il modello di libro degli ordini elimina la necessità di intermediari, poiché i prestatori e i prestiti possono interagire direttamente. Questa interazione diretta riduce gli spread tra i tassi di prestito e di prestito, ottenendo tassi migliori per entrambe le parti.</p>
<p>Un altro significativo vantaggio è la capacità per i prestatori di personalizzare la propria esposizione al rischio. Invece di concedere prestiti in un fondo comune condiviso, i prestatori possono scegliere quali prestiti specifici finanziare in base ai profili desiderati di rischio-rendimento.</p>
<p>Nel complesso, il modello di prestito del libro degli ordini di Lends favorisce l’efficienza del capitale, la trasparenza dei prezzi e la componibilità, affrontando molte delle inefficienze presenti nei mercati tradizionali del credito.</p>
<h2 id="h2-Q420Qual2020il20ruolo20del20token20LENDS20allinterno20dellecosistema20Lends437685"><a name="Q4: Qual è il ruolo del token $LENDS all’interno dell’ecosistema Lends?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Qual è il ruolo del token $LENDS all’interno dell’ecosistema Lends?</h2><p>Il token $LENDS svolge un ruolo cruciale all’interno dell’ecosistema Lends, agendo come token di governance e fornendo incentivi economici per i partecipanti. Le sue funzioni principali includono:</p>
<ol>
<li>Governance e processo decisionale: i detentori di token $LENDS possono partecipare al processo di governance votando sulle decisioni importanti, come l’inserimento nella whitelist di nuovi asset, valute e oracoli per la piattaforma di prestito. Hanno anche voce in capitolo nell’approvazione della creazione di nuovi contratti di prestito e nella definizione dello sviluppo futuro del protocollo Lends.</li><li>Sviluppo delle funzionalità e dell’evoluzione: attraverso l’esercizio dei loro diritti di voto, i detentori di token $LENDS possono influenzare la direzione del progetto, proponendo e votando su nuove funzionalità, aggiornamenti e miglioramenti all’ecosistema Lends.</li><li>Rimborso delle commissioni e condivisione dei ricavi: gli utenti che bloccano i loro token $LENDS possono guadagnare una parte dei ricavi del protocollo sotto forma di rimborsi delle commissioni o ricompense. Questo incentiva la partecipazione a lungo termine e l’allineamento con il successo della piattaforma Lends.</li><li>Allineamento degli incentivi: La distribuzione dei token $LENDS allinea gli interessi degli stakeholder, inclusi i prestatori, i debitori e il team di sviluppo, garantendo la sostenibilità e la crescita a lungo termine della piattaforma.</li></ol>
<p>Sfruttando il token $LENDS, Lends favorisce un approccio decentralizzato e basato sulla comunità, in cui i detentori di token hanno un interesse diretto nel successo della piattaforma e possono plasmare attivamente la sua evoluzione attraverso meccanismi di governance e incentivi economici.</p>
<h2 id="h2-Q520Come20intende20Lends20garantire20un20modello20di20crescita20sostenibile20e20a20lungo20termine996579"><a name="Q5: Come intende Lends garantire un modello di crescita sostenibile e a lungo termine?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Come intende Lends garantire un modello di crescita sostenibile e a lungo termine?</h2><p>Lends si impegna a garantire un modello di crescita sostenibile e a lungo termine attraverso un approccio multifattoriale che allinea gli incentivi e favorisce un ecosistema autosufficiente. Gli elementi chiave di questa strategia includono:</p>
<ol>
<li>Strategie di prestito e cassette di sicurezza diversificate: Lends mira a offrire una vasta gamma di strategie di prestito e cassette di sicurezza, che si rivolgono a differenti appetiti di rischio e obiettivi di investimento. Questa diversificazione riduce la dipendenza da un singolo modello di prestito, mitigando i rischi e promuovendo la sostenibilità a lungo termine.</li><li>Riduzione della dipendenza dagli incentivi dei token inflazionistici: invece di fare affidamento pesantemente sugli incentivi dei token inflazionistici, che possono diluire nel tempo il valore dei token, Lends si concentra sulla generazione di rendimenti sostenibili attraverso le sue attività di prestito e la struttura delle commissioni.</li><li>Distribuzione equilibrata delle commissioni: Lends applica una commissione del 10% sugli interessi ricevuti dai prestatori, di cui il 70% viene ridistribuito ai fornitori di liquidità, incentivandoli a contribuire al capitale della piattaforma. Il restante 30% viene assegnato come ricompensa per i partecipanti attivi o “stakers”, incoraggiando l’impegno a lungo termine e l’allineamento con il successo della piattaforma.</li><li>Meccanismo di incentivi personalizzabile: Lends introdurrà un meccanismo che consentirà agli utenti di bloccare i loro token $LENDS, concedendo loro la possibilità di incentivare e dirottare ulteriori entrate verso specifici vault o pool di prestito. Questa personalizzazione permette agli utenti di plasmare attivamente la crescita della piattaforma e creare opportunità di investimento più attraenti.</li><li>Governance decentralizzata: Attraverso il token di governance $LENDS, i partecipanti possono proporre e votare sui cambiamenti al protocollo, garantendo che la piattaforma evolva in una direzione che privilegia la sostenibilità a lungo termine e si allinea agli interessi della comunità.</li></ol>
<p>Unendo strategie di prestito diversificate, una struttura tariffaria equilibrata, incentivi personalizzabili e governance decentralizzata, Lends mira a creare un ecosistema autosufficiente che promuove la crescita a lungo termine riducendo al minimo la dipendenza da incentivi insostenibili del token.</p>
<h2 id="h2-Q620Quante20catene20totali20sono20disponibili20per20lo20scambio20di20token20sulla20piattaforma20Lends20Swap20e20cosa20possono20aspettarsi20gli20utenti20in20termini20di20commissioni658835"><a name="Q6: Quante catene totali sono disponibili per lo scambio di token sulla piattaforma Lends Swap e cosa possono aspettarsi gli utenti in termini di commissioni?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Quante catene totali sono disponibili per lo scambio di token sulla piattaforma Lends Swap e cosa possono aspettarsi gli utenti in termini di commissioni?</h2><p>La piattaforma Lends Swap è progettata per fornire agli utenti un’esperienza senza soluzione di continuità ed economica per gli scambi di token tra diverse blockchain. Attualmente, la piattaforma supporta scambi tra 8 blockchain di Layer-1.</p>
<p>In termini di commissioni, la piattaforma Lends Swap offre una proposta allettante: gli utenti possono godere di commissioni zero su tutti gli scambi di token facilitati attraverso la piattaforma. Questa struttura senza commissioni elimina il comune punto dolente dei costi di transazione elevati associati agli scambi decentralizzati (DEX) e agli scambi centralizzati (CEX), rendendo più conveniente per gli utenti gestire i loro portafogli di criptovalute su diverse catene.</p>
<p>Inoltre, integrandosi con molteplici blockchain di Layer-1, la piattaforma Lends Swap fornisce agli utenti una maggiore liquidità e opportunità di trading. Gli utenti possono scambiare in modo fluido token da una blockchain all’altra, consentendo loro di diversificare le loro posizioni e sfruttare le caratteristiche uniche e gli ecosistemi offerti da ciascuna blockchain supportata.</p>
<p>Con il suo supporto multi-chain e la sua struttura a zero commissioni, la piattaforma Lends Swap mira a semplificare l’esperienza di scambio di token, ridurre i costi delle transazioni e consentire agli utenti di navigare in modo più efficiente il sempre crescente panorama delle finanze decentralizzate (DeFi).</p>
<div class="blog-details-info"><br><div>Autore: <strong>Comunità di Gate.io.</strong>, Team di 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 il repostaggio 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>