R2F0ZS5pbyBBTUEgY29uIFVuaWxlbmQgRmluYW5jZSAtIFJlbmRlcmUgb2duaSBhc3NldCBwcm9kdXR0aXZv

<p><img src="https://gimg2.gateimg.com/image/article/17072837711.jpeg" alt=""><br><strong>Ora: 5 febbraio 2023 alle 11: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 Ayush Garg, Responsabile Marketing e Operazioni di Unilend Finance nel <a href="https://twitter.com/i/spaces/1RDGllOAaMRGL" rel="nofollow noopener noreferrer" target="_blank">Twitter Space</a>.</strong><br><strong>Sito Ufficiale: <a href="https://unilend.finance/" rel="nofollow noopener noreferrer" target="_blank">https://unilend.finance/</a></strong><br><strong>Twitter: <a href="https://twitter.com/UniLend_Finance" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/UniLend_Finance</a></strong><br><strong>Segui Unilend Finance su <a href="https://twitter.com/UniLend_Finance" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/UniLendFinance" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/17072841052.jpeg" alt=""><br><strong>Ayush Garg - Responsabile Marketing e Operazioni di Unilend Finance</strong></p>
<h2 id="h2-QampA20da20Gateio900363"><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-Q120Benvenuto20team20UniLend2020un20piacere20averti20qui20Ti20preghiamo20di20presentarti20e20presentare20il20progetto20UniLend20per20coloro20che20non20lo20conoscono20ancora161687"><a name="Q1: Benvenuto team UniLend. È un piacere averti qui. Ti preghiamo di presentarti e presentare il progetto UniLend per coloro che non lo conoscono ancora." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Benvenuto team UniLend. È un piacere averti qui. Ti preghiamo di presentarti e presentare il progetto UniLend per coloro che non lo conoscono ancora.</h3><p><strong>Ayush</strong>: GM a tutti! Vorrei ringraziare la comunità di Gate.io per averci invitato a parlare del nostro progetto. Immaginiamo che questa conversazione conterrà informazioni interessanti che tutti vorranno sentire. Provengo da una formazione in Informatica con esperienza lavorativa in aziende come Uber e Box8. Faccio parte dello spazio Crypto dal 2017. Ho anche lavorato con la startup Oasis - Iniziata da IIM Ahmedabad e il governo del Rajasthan. Faccio parte del team di UniLend dal suo lancio come responsabile del Marketing e delle Operazioni.</p>
<p>Per quanto riguarda UniLend, si tratta di un protocollo Multichain di prestito e prestito senza autorizzazione per tutti i token ERC20. Stiamo sviluppando uno strato base futuristico per tutte le applicazioni DeFi. Abbiamo lanciato due versioni del protocollo UniLend. UniLend Versione 2 è il primo protocollo di prestito e prestito senza autorizzazione per TUTTI i token ERC20 al mondo. Attualmente è attivo su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Sepolia e <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> zkEVM testnet. Basta immaginare <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> per prestiti e prestiti, c’è UniLend.</p>
<p>La nostra funzionalità di prestiti e prestiti Flash v1 senza permessi è attiva su 4 blockchain principali: Ethereum, Polygon, BSC e Moonriver, e ha raggiunto un valore superiore a 50 milioni di prestiti Flash, elencando più di 30 token inclusi i token nativi delle principali blockchain: $WMATIC $ <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> $WMOVR $WETH.<br><a href="https://twitter.com/UniLend_Finance/status/1512123593748271105" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/UniLend_Finance/status/1512123593748271105</a></p>
<p>La nostra missione è “Rendere produttivo ogni attivo digitale”. Il concetto di UniLend è nato dalla semplice idea di dotare ogni token di funzionalità DeFi. In sostanza, UniLend Finance offre ogni capacità DeFi immaginabile per qualsiasi attivo ERC20, compresi i più di $500 miliardi di attivi attualmente esclusi da DeFi.</p>
<h3 id="h3-Q220C20molto20fermento20intorno20al20lancio20della20Mainnet20di20UniLend20V220il201220febbraio20In20che20modo20il20suo20protocollo20si20distingue20dai20principali20platform20di20prestito20DeFi20come20Aave20e20Compound987939"><a name="Q2: C’è molto fermento intorno al lancio della Mainnet di UniLend V2 il 12 febbraio. In che modo il suo protocollo si distingue dai principali platform di prestito DeFi come Aave e Compound?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: C’è molto fermento intorno al lancio della Mainnet di UniLend V2 il 12 febbraio. In che modo il suo protocollo si distingue dai principali platform di prestito DeFi come <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> e Compound?</h3><p><strong>Ayush</strong>: Sì, siamo entusiasti del lancio della Mainnet UniLend V2 e desiderosi che la comunità lo esplori. Iniziamo esaminando il panorama attuale dello spazio DeFi. Cominciamo con l’attuale scenario dello spazio DeFi.</p>
<p>Attualmente, i problemi che affliggono l’industria DeFi derivano dalla sua frammentazione. Alcuni protocolli offrono funzionalità di prestito e prestito per un insieme limitato di token. UniLend sta colmando questa lacuna combinando l’aspetto della decentralizzazione che consente a qualsiasi asset ERC20 di essere utilizzato come garanzia per l’aspetto del prestito e prestito.</p>
<p>Abbiamo lanciato UniLend V2 su due testnet: <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Sepolia e <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> zkEVM. È il primo protocollo di prestito e prestito senza permessi al mondo per TUTTI i token ERC20. Non ci sono restrizioni per i prestatori e i mutuatari. Chiunque può facilmente prestare e prendere in prestito qualsiasi token ERC20 poiché il protocollo è senza permessi. Gli utenti possono facilmente creare un pool di asset duali per il prestito e il prestito per qualsiasi coppia di asset in modo senza permessi con oracoli di feed di prezzo e ottimizzazione del gas.</p>
<p>Leggi i dettagli qui: <a href="https://twitter.com/UniLend_Finance/status/1585696069572513792?s=20&amp;t=LXlQ4KQjqA5N-aAGiyt0ZQ" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/UniLend_Finance/status/1585696069572513792?s=20&amp;t=LXlQ4KQjqA5N-aAGiyt0ZQ</a> <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a>, <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Compound</a>, Beta Finance e <a href="/price/balancer-bal" rel="nofollow noopener noreferrer" target="_blank">Balancer</a> sono concorrenti principali ma nessuno di loro è senza autorizzazione per tutti gli asset ERC20. Sono guardiani o forniscono soluzioni multi-pool. Ecco le caratteristiche killer di V2. Il protocollo è dotato delle più grandi innovazioni del settore:<br>🔸Prestiti e Prestiti Senza Autorizzazione<br>🔸Pool di Asset Duali Isolati<br>🔸Tokenizzazione Non Fungibile<br>🔸Liquidazione Concentrata<br>Include anche funzionalità avanzate come i Feed di Prezzo On Chain, Prestiti Flessibili e Prestiti Flash che rendono questa versione unica e un prodotto di prossima generazione. Supporteremo i feed di prezzo da varie fonti tra cui Chainlink, <a href="/price/band-protocol-band" rel="nofollow noopener noreferrer" target="_blank">Protocollo Band</a>, SupraOracles e <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> V3 TWAP oracle per rendere il v2 più flessibile nell’adattarsi ai mercati in continua evoluzione e alle innovazioni. La versione v2 di UniLend non è solo un aggiornamento del protocollo. La nostra visione è quella di costruire un livello base di prestito e prestiti per i mercati monetari che ancora non è stato realizzato nel settore delle criptovalute.</p>
<h3 id="h3-Q320Complimenti20per20aver20completato20il20testnet20di20UniLend20V220Quali20progressi20sono20stati20fatti20dimostrando20la20prontezza20per20il20lancio20del20mainnet20Inoltre20il20testnet20di20UniLend20V22020ancora20disponibile20per20gli20utenti402994"><a name="Q3: Complimenti per aver completato il testnet di UniLend V2! Quali progressi sono stati fatti, dimostrando la prontezza per il lancio del mainnet? Inoltre, il testnet di UniLend V2 è ancora disponibile per gli utenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Complimenti per aver completato il testnet di UniLend V2! Quali progressi sono stati fatti, dimostrando la prontezza per il lancio del mainnet? Inoltre, il testnet di UniLend V2 è ancora disponibile per gli utenti?</h3><p><img src="https://gimg2.gateimg.com/image/article/17072841383.jpeg" alt=""><br><strong>Ayush</strong>: Certamente, UniLend V2 è stato un successo su Testnet. Dopo due anni di rigorosi test, feedback della comunità e sviluppo costante, abbiamo concluso con successo il testnet di UniLend V2, compiendo progressi significativi nello spazio web3. Riflettiamo sugli obiettivi raggiunti:</p>
<ol>
<li>UniLend V2 è stato avviato su Ethereum Sepolia e sui testnet di Polygon zkEVM, presentando innovazioni come il prestito e l’assunzione senza autorizzazione, i pool di asset duali isolati, la tokenizzazione degli NFT e la liquidazione concentrata.</li><li>Superate le 100.000 transazioni su V2, evidenziando la scalabilità e la forte domanda di soluzioni DeFi avanzate. La piattaforma consente l’esecuzione efficiente di numerose transazioni con una sicurezza di alto livello.</li><li>Oltre 12.000 utenti entusiasti hanno testato rigorosamente il nostro V2.</li><li>Rivisitata l’interfaccia utente di UniLend V2 per un’esperienza senza soluzione di continuità: Cambio di pool con un clic, Ordinamento senza sforzo, Design reattivo, preparandosi al lancio del mainnet.</li><li>Integrati i Domini Inarrestabili su V2 Testnet, consentendo agli utenti di collegare portafogli e utilizzare nomi di dominio <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> invece degli indirizzi tradizionali dei portafogli.</li><li>Lanciato il programma di bug bounty di UniLend V2 su ImmuneFi del valore di $25.000 per migliorare la sicurezza.</li><li>Lanciati più di 50 pool di liquidità su UniLend V2 testnet, consentendo agli utenti di esplorare funzionalità di prestito e assunzione senza fondi reali.</li><li>Condotte campagne di successo su V2 Testnet, come GoalwithDeFi, campagna da $5000, Howzzat e eventi a tema, promuovendo il coinvolgimento della comunità nel test delle funzionalità di prestito e assunzione e ottenendo un’ampia adesione.</li><li>Riconoscenti per il supporto della nostra comunità nello shaping di UniLend, abbiamo premiato oltre $10.000 agli attivi tester di UniLend V2. <a href="https://x.com/UniLend_Finance/status/1735734010809332199?s=20" rel="nofollow noopener noreferrer" target="_blank">https://x.com/UniLend_Finance/status/1735734010809332199?s=20</a></li></ol>
<p>Gli utenti possono comunque sperimentare UniLend V2 testnet, dove chiunque può partecipare al prestito e all’assunzione di token. Testnet: <a href="https://testnet.unilend.finance/" rel="nofollow noopener noreferrer" target="_blank">https://testnet.unilend.finance/</a></p>
<h3 id="h3-Q420Approfondiamo20il20token20nativo20di20UniLend20UFT20Potresti20approfondire20le20sue20utilit20e20tokenomics20Siamo20entusiasti20di20saperne20di20pi20sul20futuro20di20UFT874565"><a name="Q4: Approfondiamo il token nativo di UniLend, $UFT. Potresti approfondire le sue utilità e tokenomics? Siamo entusiasti di saperne di più sul futuro di $UFT!" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Approfondiamo il token nativo di UniLend, $UFT. Potresti approfondire le sue utilità e tokenomics? Siamo entusiasti di saperne di più sul futuro di $UFT!</h3><p><strong>Ayush</strong>: Ci sono così tanti punti che possiamo sollevare. Cercheremo di mantenerlo breve comunque. UFT è un token di governance. È il primo token che consente agli utenti di prestare i loro token fornendo liquidità per Flash Loans e protocolli di prestito senza permesso, ODDZ, YOP, PBR, CFI e molti altri sono attivi su Ethereum.</p>
<p>MATIC, UFT, MOVR e molti altri token con prestiti Flash di prestito sono attivi sulla nostra V1 di Polygon, BSC e Moonriver. Inoltre, i prestatori hanno ricevuto molti airdrop e probabilmente ce ne saranno molti altri in futuro.</p>
<p>Abbiamo lanciato la nostra Governance, un importante sviluppo mirato a potenziare l’utilità del token UFT e a dare potere ai membri della nostra comunità di partecipare attivamente alla definizione del futuro di UniLend. Si tratta di un passo essenziale che porta verso la vera decentralizzazione di UniLend Finance.</p>
<p>Il token UFT è un asset altamente liquido ed è disponibile per il trading Spot, Margin e Futures su oltre 19 importanti DEX e CEX in tutto il mondo come Gate.io, Binance, <a href="/price/huobi-ht" rel="nofollow noopener noreferrer" target="_blank">Huobi</a> Global, Deepcoin, Bitrue, Uniswap, QuickSwap, Wazirx, DFyn, MXEC, LunarCrush Trade e molti altri. Siamo anche quotati su Coinbase Custody, ampliando globalmente gli orizzonti di UniLend Finance. UFT è ora disponibile anche sul portafoglio web3 di Binance ed è stato aggiunto sia sul margine isolato che sul margine incrociato su Binance. Abbiamo anche lanciato i feed di prezzo UFT di Chainlink. Chainlink ha aggiunto i feed di prezzo UFT-USD su Ethereum. Il feed di prezzo UFT è anche in LIVE su Multiple Chains Powered by RedStone. Redstone supporta ora i feed di prezzo UFT su tutte le catene compatibili con EVM. L’aumento delle utilità di UFT DeFi consente a molte altre applicazioni DeFi di integrare UFT in modo rapido e sicuro nel loro ecosistema.</p>
<p>Puoi consultare la nostra tokenomics qui: <a href="https://buff.ly/3dbYwxM" rel="nofollow noopener noreferrer" target="_blank">https://buff.ly/3dbYwxM</a></p>
<h3 id="h3-Q520La20comunit20e20le20partnership20sono20pilastri20essenziali20per20qualsiasi20progetto20decentralizzato20Puoi20fornire20ulteriori20dettagli20su20come20UniLend20si20concentra20su20questi20aspetti20e20li20prioritizza975736"><a name="Q5: La comunità e le partnership sono pilastri essenziali per qualsiasi progetto decentralizzato. Puoi fornire ulteriori dettagli su come UniLend si concentra su questi aspetti e li prioritizza?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: La comunità e le partnership sono pilastri essenziali per qualsiasi progetto decentralizzato. Puoi fornire ulteriori dettagli su come UniLend si concentra su questi aspetti e li prioritizza?</h3><p><img src="https://gimg2.gateimg.com/image/article/17072841784.jpeg" alt=""><br><strong>Ayush</strong>: Siamo così grati di avere una comunità e dei partner di ecosistema così straordinari. Il nostro ecosistema multichain è la nostra forza. Abbiamo stabilito più di 134 partnership strategiche. UniLend è cresciuto fino a raggiungere oltre 147.000 persone attraverso più di 12 canali di distribuzione dei contenuti. Inoltre, abbiamo 8 comunità regionali per facilitare la comunicazione e impedire che le barriere linguistiche influiscano sulla crescita di UniLend, quindi puoi unirti alle nostre comunità regionali ufficiali:</p>
<ol>
<li>Indonesia: <a href="https://t.me/UniLend_Indonesi" rel="nofollow noopener noreferrer" target="_blank">https://t.me/UniLend_Indonesi</a> a</li><li><p>Vietnam: <a href="https://t.me/UniLend_Vietnam" rel="nofollow noopener noreferrer" target="_blank">https://t.me/UniLend_Vietnam</a></p>
</li><li><p>Nigeria: <a href="https://t.me/UniLend_Nigeria" rel="nofollow noopener noreferrer" target="_blank">https://t.me/UniLend_Nigeria</a></p>
</li><li>Filippine: <a href="https://t.me/UniLend_Philippines" rel="nofollow noopener noreferrer" target="_blank">https://t.me/UniLend_Philippines</a></li><li>Turco: <a href="https://t.me/UniLend_Turkish" rel="nofollow noopener noreferrer" target="_blank">https://t.me/UniLend_Turkish</a></li><li>Coreano: <a href="https://t.me/UniLend_Korea" rel="nofollow noopener noreferrer" target="_blank">https://t.me/UniLend_Korea</a></li><li>India: <a href="https://t.me/UniLend_India" rel="nofollow noopener noreferrer" target="_blank">https://t.me/UniLend_India</a></li><li>Spagnolo: <a href="https://t.me/UniLend_Spanish" rel="nofollow noopener noreferrer" target="_blank">https://t.me/UniLend_Spanish</a></li></ol>
<h3 id="h3-Q620Potresti20fornire20casi20duso20per20UniLend20V220evidenziando20la20sua20versatilit20e20potenziali20applicazioni218763"><a name="Q6: Potresti fornire casi d’uso per UniLend V2, evidenziando la sua versatilità e potenziali applicazioni?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Potresti fornire casi d’uso per UniLend V2, evidenziando la sua versatilità e potenziali applicazioni?</h3><p><strong>Ayush</strong> Grande domanda! UniLend V2 vanta numerosi casi d’uso e per approfondirli ulteriormente, abbiamo introdotto una serie educativa chiamata ‘Svelare UniLend V2’. Questa serie fa luce sui casi d’uso delle innovative funzionalità di UniLend V2. Un caso d’uso notevole riguarda i nuovi token. Il nostro rivoluzionario protocollo ha la capacità di trasformare ogni nuovo asset digitale in una potenza produttiva. Abilitando il prestito e l’indebitamento per i nuovi token, miriamo a garantire stabilità e favorire l’innovazione. I token possono essere messi in comune per il prestito e l’indebitamento, limitando la pressione delle vendite e aumentando il capitale per gli investitori precoci. UniLend fornisce una piattaforma dove questi asset trovano stabilità e utilità. Stiamo rivoluzionando DeFi, dove la volatilità incontra l’opportunità, consentendo ai nuovi token di trovare stabilità e raggiungere il loro pieno potenziale. Questo è solo un esempio delle innovative funzionalità di UniLend V2, con altre rivelazioni in arrivo, quindi rimanete sintonizzati per gli aggiornamenti!</p>
<h3 id="h3-Q720Come20possono20i20membri20della20comunit20partecipare20attivamente20alla20definizione20dellentusiasmante20futuro20del20protocollo20UniLend20ora20che20la20Governance20di20UniLend2020attiva266915"><a name="Q7: Come possono i membri della comunità partecipare attivamente alla definizione dell’entusiasmante futuro del protocollo UniLend ora che la Governance di UniLend è attiva?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Come possono i membri della comunità partecipare attivamente alla definizione dell’entusiasmante futuro del protocollo UniLend ora che la Governance di UniLend è attiva?</h3><p><strong>Ayush</strong> Attraverso il nostro quadro di governance, potenziamo la comunità concedendo potere di voto e facilitando la partecipazione attiva ai processi decisionali. Questa struttura di governance consente agli utenti di svolgere un ruolo fondamentale nella definizione del futuro di UniLend, migliorando il coinvolgimento della comunità e aumentando l’utilità del token UFT. Gli utenti possono facilmente presentare proposte, partecipare a discussioni, votare e vedere realizzarsi le proprie idee. Qualsiasi membro della comunità può creare Proposte di Miglioramento UniLend (UIP), il nostro meccanismo primario di governance che consente proposte di modifiche all’interno del nostro protocollo. Partecipando alle discussioni, votando e partecipando alle UIP, gli utenti hanno il potere di influenzare attivamente il nostro protocollo, introducendo nuove funzionalità, aggiornamenti e altro ancora.</p>
<p>Inoltre, abbiamo introdotto il token governance-wrapped - UFTG (UniLend Finance Governance Token). UFTG, come pietra angolare del nostro modello di Governance, serve come chiave per coinvolgere attivamente i membri della comunità nella definizione del futuro di UniLend. Possedere UFTG è il tuo biglietto da visita per diventare una parte integrante dei nostri processi di governance, simboleggiando il nostro impegno per decisioni basate sulla comunità e un futuro decentralizzato. Gli utenti possono unirsi alle discussioni sul Forum sulla Governance di UniLend su Commonwealth: <a href="https://commonwealth.im/unilend-finance/discussions" rel="nofollow noopener noreferrer" target="_blank">https://commonwealth.im/unilend-finance/discussions</a><br>Per indicazioni, fare riferimento alla Guida per l’utente: <a href="https://medium.com/@unilend/unilend-governance-user-guide-de05d5c0a71f" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/@unilend/unilend-governance-user-guide-de05d5c0a71f</a></p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità 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. È consentito il riposting dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>