R2F0ZS5pbyBBTUEgbWV0IFVuaWxlbmQgRmluYW5jZSAtIE1hYWsgZWxrIGFjdGl2dW0gcHJvZHVjdGllZg==

<p><img src="https://gimg2.gateimg.com/image/article/17072837711.jpeg" alt=""><br><strong>Tijd: 5 februari 2023 om 11:00 uur UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Ayush Garg, Marketing en Operations Lead van Unilend Finance in de <a href="https://twitter.com/i/spaces/1RDGllOAaMRGL" rel="nofollow noopener noreferrer" target="_blank">Twitter Space</a>.</strong><br><strong>Officiële website: <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>Volg Unilend Finance op <a href="https://twitter.com/UniLend_Finance" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/UniLendFinance" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/17072841052.jpeg" alt=""><br><strong>Ayush Garg - Marketing en Operations Lead van Unilend Finance</strong></p>
<h2 id="h2-Vraag20en20Antwoord20van20Gateio998265"><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-V120Welkom20UniLend20team20Het20is20een20genoegen20om20jullie20hier20te20hebben20Stel20jezelf20alsjeblieft20voor20en20het20UniLendproject20voor20degenen20die20het20nog20niet20kennen436085"><a name="V1: Welkom UniLend team. Het is een genoegen om jullie hier te hebben. Stel jezelf alsjeblieft voor en het UniLend-project voor degenen die het nog niet kennen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Welkom UniLend team. Het is een genoegen om jullie hier te hebben. Stel jezelf alsjeblieft voor en het UniLend-project voor degenen die het nog niet kennen.</h3><p><strong>Ayush</strong>: GM Iedereen! Ik wil de Gate.io-community bedanken voor de uitnodiging om te praten over ons project. We stellen ons voor dat dit gesprek interessante informatie zal bevatten die iedereen wil horen. Ik kom uit een achtergrond in de informatica en heb ervaring opgedaan bij bedrijven zoals Uber en Box8. Ik maak sinds 2017 deel uit van de cryptowereld. Ik heb ook samengewerkt met de start-up Oasis - Initiated by IIM Ahmedabad en de regering van Rajasthan. Ik maak deel uit van het team van UniLend sinds de lancering als leider op het gebied van marketing en operaties.</p>
<p>Betreffende UniLend, het is een Multichain toestemmingsloos Uitleen- en Leenprotocol voor alle ERC20-tokens. We ontwikkelen een Futuristische Basislaag voor alle DeFi-toepassingen. We hebben twee versies van het UniLend-protocol gelanceerd. UniLend Versie 2 is ‘s werelds eerste toestemmingsloze uitleen- en leenprotocol voor ALLE ERC20-tokens. Het is momenteel actief op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Sepolia en <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> zkEVM testnet. Stel je eens voor <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> voor lenen &amp; uitlenen, dat is UniLend.</p>
<p>Onze v1-permissionless Flash-leningen en uitleenfunctionaliteit is actief op 4 belangrijke blockchains: Ethereum, Polygon, BSC en Moonriver, en heeft meer dan 50 miljoen aan Flash-leningen bereikt, met meer dan 30 tokens vermeld, waaronder de inheemse tokens van belangrijke blockchains: $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>Onze missie is om ‘Elke digitale activum productief te maken’. Het concept voor UniLend is voortgekomen uit het eenvoudige idee om elke token te voorzien van DeFi-functionaliteit. In wezen biedt UniLend Finance elke denkbare DeFi-mogelijkheid voor elk ERC20-activum, inclusief de $500B+ aan activa die momenteel zijn uitgesloten van DeFi.</p>
<h3 id="h3-Q220Er20is20veel20ophef20rond20de20lancering20van20UniLend20V220Mainnet20op201220februari20Hoe20onderscheidt20het20protocol20zich20van20grote20DeFi20uitleenplatforms20zoals20Aave20en20Compound39984"><a name="Q2: Er is veel ophef rond de lancering van UniLend V2 Mainnet op 12 februari. Hoe onderscheidt het protocol zich van grote DeFi uitleenplatforms zoals Aave en Compound?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Er is veel ophef rond de lancering van UniLend V2 Mainnet op 12 februari. Hoe onderscheidt het protocol zich van grote DeFi uitleenplatforms zoals <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> en Compound?</h3><p><strong>Ayush</strong>: Ja, we zijn enthousiast over de UniLend V2 Mainnet Launch en kijken ernaar uit dat de gemeenschap het gaat verkennen. Laten we beginnen met het onderzoeken van het huidige landschap van de DeFi-ruimte. Laten we eerst kijken naar de huidige situatie van de DeFi-ruimte.</p>
<p>De huidige problemen die de DeFi-industrie teisteren, komen voort uit de fragmentatie ervan. Sommige protocollen bieden lenen en uitlenen functionaliteit voor een beperkte set tokens. UniLend overbrugt die kloof door het combineren van het decentralisatie aspect van het mogelijk maken van elk ERC20-actief als onderpand voor het lenen en uitlenen aspect.</p>
<p>We hebben UniLend V2 gelanceerd op twee testnets: <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Sepolia en <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> zkEVM. Het is het eerste toestemmingsloze uitleen- en uitleenprotocol voor ALLE ERC20-tokens ter wereld. Er zijn geen beperkingen voor geldschieters en leners. Iedereen kan gemakkelijk ERC20-tokens uitlenen en lenen, aangezien het protocol toestemmingsloos is. Gebruikers kunnen op een eenvoudige manier een dubbele activapool maken voor het uitlenen en lenen van elk paar activa op een toestemmingsloze manier, met prijsvoedingsorakels en gasoptimalisatie.</p>
<p>Lees hier details: <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">Samengesteld</a>, Beta Finance en, <a href="/price/balancer-bal" rel="nofollow noopener noreferrer" target="_blank">Balancer</a> zijn belangrijke concurrenten, maar geen van hen is toegankelijk voor alle ERC20-activa. Ze zijn poortwachters of bieden multi-pool oplossingen. Hier zijn V2-killerfuncties. Het protocol is bewapend met de grootste innovaties van de industrie:<br>🔸 Toestemmingloos lenen en uitlenen<br>🔸 Geïsoleerd dubbel activapool<br>🔸 Niet-vervangbare tokenisatie<br>🔸 Geconcentreerde liquidatie<br>Het omvat ook geavanceerde functies zoals On Chain Price Feeds, Flexibel Lenen en Flash Loans, waardoor deze versie uniek is en een product van de volgende generatie. We zullen prijsfeeds ondersteunen van verschillende bronnen, waaronder Chainlink, <a href="/price/band-protocol-band" rel="nofollow noopener noreferrer" target="_blank">Band Protocol</a> SupraOracles &amp; <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> V3 TWAP-orakel om de v2 flexibeler te maken en aan te passen aan veranderende markten en innovaties. De v2-versie van UniLend is niet alleen een protocolupdate. Onze visie is om een basellaag van lenen en uitlenen te bouwen voor de geldmarkten, wat nog niet gedaan is in crypto.</p>
<h3 id="h3-Q320Gefeliciteerd20met20het20afronden20van20de20UniLend20V220testnet20Welke20vooruitgang20is20geboekt20om20de20lancering20van20het20mainnet20mogelijk20te20maken20Is20het20UniLend20V220testnet20nog20steeds20beschikbaar20voor20gebruikers69694"><a name="Q3: Gefeliciteerd met het afronden van de UniLend V2 testnet! Welke vooruitgang is geboekt om de lancering van het mainnet mogelijk te maken? Is het UniLend V2 testnet nog steeds beschikbaar voor gebruikers?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Gefeliciteerd met het afronden van de UniLend V2 testnet! Welke vooruitgang is geboekt om de lancering van het mainnet mogelijk te maken? Is het UniLend V2 testnet nog steeds beschikbaar voor gebruikers?</h3><p><img src="https://gimg2.gateimg.com/image/article/17072841383.jpeg" alt=""><br><strong>Ayush</strong>: Zeker, UniLend V2 is succesvol geweest op Testnet. Na twee jaar van rigoureus testen, feedback van de gemeenschap en constante ontwikkeling, hebben we het UniLend V2-testnet met succes afgerond en aanzienlijke vooruitgang geboekt in de web3-ruimte. Laten we eens kijken naar de prestaties:</p>
<ol>
<li>UniLend V2 begon op Ethereum Sepolia- en Polygon zkEVM-testnetten met innovaties zoals Permissionless Lending and Borrowing, Isolated Dual Asset Pools, NFT-tokenisatie en Concentrated Liquidation.</li><li>Overtrof de 100.000 transacties op V2, wat de nadruk legt op schaalbaarheid en een sterke vraag naar geavanceerde DeFi-oplossingen. Het platform maakt een efficiënte uitvoering van tal van transacties mogelijk met beveiliging van het hoogste niveau.</li><li>Meer dan 12.000 enthousiaste gebruikers hebben onze V2 grondig getest.</li><li>Vernieuwde UniLend V2 UI voor een naadloze ervaring: One-Click Pool Switching, Moeiteloos Sorteren, Responsief ontwerp, klaar voor de lancering van het mainnet.</li><li>Geïntegreerde Unstoppable Domains op V2 Testnet, waardoor gebruikers wallets kunnen verbinden en Web3-domeinnamen kunnen gebruiken in plaats van traditionele wallet-adressen.</li><li>Lanceerde het UniLend V2 Bug Bounty-programma op ImmuneFi ter waarde van $ 25,000 beloningen om de beveiliging te verbeteren.</li><li>Lancering van 50+ liquiditeitspools op UniLend V2-testnet, waardoor gebruikers leen- en leenfuncties kunnen verkennen zonder echt geld.</li><li>Voerde succesvolle V2 Testnet-campagnes uit, zoals GoalwithDeFi, $ 5000-campagne, Howzzat en thema-evenementen, waarbij de betrokkenheid van de gemeenschap bij het testen van uitleen- en leenfuncties werd bevorderd en substantiële tractie werd verkregen.</li><li>Dankbaar voor de steun van onze gemeenschap bij het vormgeven van UniLend, hebben we meer dan $ 10.000 beloond aan actieve UniLend V2-testers. <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>Gebruikers kunnen nog steeds de UniLend V2-testnet ervaren, waar iedereen kan deelnemen aan het uitlenen en lenen van tokens. Testnet: <a href="https://testnet.unilend.finance/" rel="nofollow noopener noreferrer" target="_blank">https://testnet.unilend.finance/</a></p>
<h3 id="h3-Laten20we20ons20verdiepen20in20de20inheemse20token20van20UniLend20UFT20Kunt20u20uitweiden20over20de20gebruiksmogelijkheden20en20tokenomics20We20zijn20enthousiast20om20meer20te20weten20te20komen20over20de20toekomst20van20UFT808168"><a name="Laten we ons verdiepen in de inheemse token van UniLend, $UFT. Kunt u uitweiden over de gebruiksmogelijkheden en tokenomics? We zijn enthousiast om meer te weten te komen over de toekomst van $UFT!" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Laten we ons verdiepen in de inheemse token van UniLend, $UFT. Kunt u uitweiden over de gebruiksmogelijkheden en tokenomics? We zijn enthousiast om meer te weten te komen over de toekomst van $UFT!</h3><p><strong>Ayush</strong>: Er zijn zoveel punten die we kunnen aanhalen. We zullen proberen dit kort te houden. UFT is een governance-token. Het is de eerste token die gebruikers in staat stelt om hun tokens uit te lenen terwijl ze liquiditeit bieden voor toestemmingsloze Flash-leningen en uitleenprotocollen. ODDZ, YOP, PBR, CFI en nog veel meer zijn actief op Ethereum.</p>
<p>MATIC, UFT, MOVR en nog veel meer tokens met uitleen-flashleningen zijn beschikbaar op onze V1 Polygon, BSC en Moonriver. Bovendien hebben kredietverstrekkers veel airdrops ontvangen en er zullen naar alle waarschijnlijkheid nog veel meer komen in de toekomst.</p>
<p>We hebben onze Governance gelanceerd, een belangrijke ontwikkeling gericht op het verbeteren van de bruikbaarheid van de UFT-token en het in staat stellen van onze communityleden om actief deel te nemen aan het vormgeven van de toekomst van UniLend. Dit is een essentiële stap naar ware decentralisatie van UniLend Finance.</p>
<p>UFT-token is een zeer liquide activum en is beschikbaar voor Spot-, Margin- en Futures-handel op meer dan 19 grote DEX’s en CEX’s over de hele wereld zoals 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 en nog veel meer. We staan ook genoteerd op Coinbase Custody, wat de horizon van UniLend Finance wereldwijd verbreedt. UFT is nu ook beschikbaar op de Binance-web3-portemonnee en is toegevoegd aan Isolated Margin en Cross Margin op Binance. We hebben ook UFT Price Feeds gelanceerd via Chainlink. Chainlink heeft UFT-USD-prijsfeeds toegevoegd op Ethereum. UFT Price Feed is ook LIVE op meerdere ketens aangedreven door RedStone. Redstone ondersteunt nu UFT-prijsfeeds op alle EVM-compatibele ketens. Het toenemende gebruik van UFT DeFi stelt veel andere DeFi-toepassingen in staat om UFT snel en veilig in hun ecosysteem te integreren.</p>
<p>U kunt onze tokenomics hier bekijken: <a href="https://buff.ly/3dbYwxM" rel="nofollow noopener noreferrer" target="_blank">https://buff.ly/3dbYwxM</a></p>
<h3 id="h3-Q520Gemeenschap20en20partnerschappen20zijn20essentile20pijlers20voor20elk20gedecentraliseerd20project20Kunt20u20meer20inzicht20geven20in20hoe20UniLend20zich20richt20op20en20prioriteit20geeft20aan20deze20aspecten68857"><a name="Q5: Gemeenschap en partnerschappen zijn essentiële pijlers voor elk gedecentraliseerd project. Kunt u meer inzicht geven in hoe UniLend zich richt op en prioriteit geeft aan deze aspecten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Gemeenschap en partnerschappen zijn essentiële pijlers voor elk gedecentraliseerd project. Kunt u meer inzicht geven in hoe UniLend zich richt op en prioriteit geeft aan deze aspecten?</h3><p><img src="https://gimg2.gateimg.com/image/article/17072841784.jpeg" alt=""><br><strong>Ayush</strong>: We zijn zo dankbaar om zo’n geweldige gemeenschap en ecosysteempartners te hebben. Ons multiketen ecosysteem is onze kracht. We hebben meer dan 134 strategische partnerschappen gesmeed. UniLend is uitgegroeid tot een bereik van 147k+ over meer dan 12 inhoudsdistributiekanalen. Verder hebben we 8 regionale gemeenschappen voor gemakkelijke communicatie en geen taalbarrières die de groei van UniLend beïnvloeden, dus u kunt ook lid worden van onze officiële regionale gemeenschappen:</p>
<ol>
<li>Indonesië: <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>Filippijnen: <a href="https://t.me/UniLend_Philippines" rel="nofollow noopener noreferrer" target="_blank">https://t.me/UniLend_Philippines</a></li><li>Turks: <a href="https://t.me/UniLend_Turkish" rel="nofollow noopener noreferrer" target="_blank">https://t.me/UniLend_Turkish</a></li><li>Koreaanse: <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>Spaans: <a href="https://t.me/UniLend_Spanish" rel="nofollow noopener noreferrer" target="_blank">https://t.me/UniLend_Spanish</a></li></ol>
<h3 id="h3-Q620Kunt20u20gebruiksscenarios20voor20UniLend20V220verstrekken20met20nadruk20op20de20veelzijdigheid20en20mogelijke20toepassingen690871"><a name="Q6: Kunt u gebruiksscenario’s voor UniLend V2 verstrekken, met nadruk op de veelzijdigheid en mogelijke toepassingen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Kunt u gebruiksscenario’s voor UniLend V2 verstrekken, met nadruk op de veelzijdigheid en mogelijke toepassingen?</h3><p><strong>Ayush</strong>: Goede vraag! UniLend V2 heeft tal van gebruiksscenario’s, en om er verder op in te gaan, hebben we een educatieve serie geïntroduceerd met de naam “Unraveling UniLend V2”. Deze serie werpt licht op de use cases van de innovatieve functies van UniLend V2. Een opmerkelijke use case draait om nieuwe tokens. Ons baanbrekende protocol heeft de mogelijkheid om elk nieuw digitaal activum om te zetten in een productiviteitskrachtpatser. Door het uitlenen en lenen van nieuwe tokens mogelijk te maken, willen we stabiliteit waarborgen en innovatie bevorderen. Tokens kunnen worden gepoold voor het uitlenen en uitlenen, waardoor de verkoopdruk wordt beteugeld en het kapitaal voor vroege investeerders wordt gestimuleerd. UniLend biedt een platform waar deze activa stabiliteit en bruikbaarheid vinden. We brengen een revolutie teweeg in DeFi, waar volatiliteit en kansen elkaar ontmoeten, waardoor nieuwe tokens stabiliteit kunnen vinden en hun volledige potentieel kunnen bereiken. Dit is slechts één voorbeeld van de innovatieve functies van UniLend V2, en er komen nog meer onthullingen, dus houd ons in de gaten voor updates!</p>
<h3 id="h3-V720Hoe20kunnen20leden20van20de20gemeenschap20actief20betrokken20zijn20bij20het20vormgeven20van20de20spannende20toekomst20van20het20UniLendprotocol20nu20UniLend20Governance20live20is867814"><a name="V7: Hoe kunnen leden van de gemeenschap actief betrokken zijn bij het vormgeven van de spannende toekomst van het UniLend-protocol nu UniLend Governance live is?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V7: Hoe kunnen leden van de gemeenschap actief betrokken zijn bij het vormgeven van de spannende toekomst van het UniLend-protocol nu UniLend Governance live is?</h3><p><strong>Ayush</strong>: Via ons Governance-kader stellen we de gemeenschap in staat door stemrecht te verlenen en actieve deelname aan besluitvormingsprocessen te vergemakkelijken. Deze bestuursstructuur stelt gebruikers in staat een cruciale rol te spelen in het vormgeven van de toekomst van UniLend, het versterken van betrokkenheid van de gemeenschap en het verhogen van het nut van de UFT-token. Gebruikers kunnen eenvoudig voorstellen indienen, deelnemen aan discussies, stemmen uitbrengen en hun ideeën werkelijkheid zien worden. Elk lid van de gemeenschap kan UniLend Improvement Proposals (UIP’s) creëren, ons belangrijkste bestuursmechanisme dat voorstellen voor veranderingen binnen ons protocol mogelijk maakt. Deelname aan discussies, stemmen uitbrengen en deelnemen aan UIP’s stellen gebruikers in staat actief invloed uit te oefenen op ons protocol, waarbij nieuwe functies, upgrades en meer worden geïntroduceerd.</p>
<p>Daarnaast hebben we de governance-wrapped token geïntroduceerd - UFTG (UniLend Finance Governance Token). UFTG, als hoeksteen van ons Governance-model, dient als sleutel om actief deel te nemen aan de vormgeving van de toekomst van UniLend. Het bezitten van UFTG is uw ticket om een integraal onderdeel te worden van onze governance-processen, wat onze toewijding aan door de gemeenschap gedreven beslissingen en een gedecentraliseerde toekomst symboliseert. Gebruikers kunnen deelnemen aan de discussies op het Governance Forum van UniLend op Commonwealth: <a href="https://commonwealth.im/unilend-finance/discussions" rel="nofollow noopener noreferrer" target="_blank">https://commonwealth.im/unilend-finance/discussions</a><br>Voor begeleiding, raadpleeg de gebruikershandleiding: <a href="https://medium.com/@unilend/unilend-governance-user-guide-de05d5c0a71f" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/@unilend/unilend-governance-gebruikershandleiding-de05d5c0a71f</a></p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gemeenschap van Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingssuggesties.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>