VW5pc3dhcCBkaXZpZGVuZHZvb3JzdGVsIGtvbXQgZXJhYW4sIGt1bm5lbiB3ZSBpbnZlc3RlcmVuIGluIGVlbiBuaWV1d2UgZW1wb3dlcm1lbnQ/

2024-02-27, 08:02

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR384850"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Op de avond van 23 februari <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> De Foundation heeft een voorstel uitgebracht om LP-fee-dividenden toe te kennen aan UNI, wat de UNI-token snel meer dan 50% heeft doen stijgen.</p>
<p>Volgens de laatste gegevens bedraagt de huidige geannualiseerde LP-vergoeding van <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> ongeveer $626M. Zodra het voorstel is goedgekeurd, wordt verwacht dat UNI-houders een geannualiseerd dividend van $62M - $156M zullen ontvangen, wat de huidige marktprijs van UNI aanzienlijk zal stimuleren.</p>
<p>Dit voorstel zal waarschijnlijk net zo spelgericht blijven als eerdere pogingen om dividenden toe te kennen, maar het is nog steeds de moeite waard om naar uit te kijken.</p>
<h2 id="h2-Kennismaking258963"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Op de avond van 23 februari verspreidde een voorstel om UNI-tokenstakers te belonen met Uniswap-kosten zich snel naar de cryptomarkt en steeg de UNI-token met 50% bij het horen van het nieuws. Daarom zal in dit artikel verder worden onderzocht of dit voorstel haalbaar is en of het een positieve invloed zal hebben op DeFi-industrietokens die alleen regeren maar niet stemmen.</p>
<h2 id="h2-DEXleider20Uniswap20UNI20zag20een20stijging20in20het20dividendvoorstel445285"><a name="DEX-leider Uniswap (UNI) zag een stijging in het dividendvoorstel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DEX-leider Uniswap (UNI) zag een stijging in het dividendvoorstel</h2><p>Op de avond van 23 februari heeft Erin Koen, de governance leider van de Uniswap Foundation, een voorstel geplaatst op het Uniswap Governance Forum. Het voorstel is om een vergoedingsmechanisme in te voeren om houders te belonen die al vertrouwen hebben gesteld en hun UNI-tokens hebben gestaked.</p>
<p>Beïnvloed door dit nieuws bereikte de governancetoken UNI van Uniswap in korte tijd een groeipercentage van meer dan 50%, waardoor het een populaire token werd. Volgens de markt van Gate.io klommen de UNI-prijzen snel van ongeveer $7 naar $11 en bereikten binnen het uur een hoogtepunt van bijna $12.6. Op de schrijfdatum zijn de UNI-prijzen terugglen tot ongeveer $10.5.<img src="https://gimg2.gateimg.com/image/article/1709020776img_v3_028f_9f04844f-964f-4667-bc60-175f09b9efix.jpg" alt=""><br>Bron: Gate.io</p>
<p>Eigenlijk, als het gaat om UNI, moeten we Uniswap uitleggen, een baanbrekend crypto-protocol. Uniswap is een gedecentraliseerde exchange (DEX) gebaseerd op het Automated Market Maker (AMM) mechanisme, gemaakt door Siemens ingenieur Hayden Adams in november 2018.</p>
<p>Deze beurs maakt ongeoorloofde creatie van liquiditeitspools mogelijk voor elke ERC20-token, en automatische bepaling van de prijzen van activa via een constante productformule, waardoor efficiënte en naadloze token-handel wordt bereikt. Gebruikers interageren met liquiditeitspools en aanbieders passen prijzen dynamisch aan op basis van vraag en aanbod van de pool, waarbij ze er kosten voor verdienen.</p>
<p>Ondanks de groeiende en stabiele positie van Uniswap op het DEX-traject, is de prijs van zijn token UNI lange tijd op een laag niveau gebleven, voornamelijk als gevolg van zijn rudimentaire token-economie. In de beginfase van de oprichting van Uni werden in totaal één miljard tokens uitgegeven en verdeeld onder gemeenschapsleden, teamleden, investeerders en adviseurs. Echter, nadat de tokens waren uitgegeven, kregen ze alleen governance rechten, waaronder het recht om wijzigingen in het protocol voor te stellen en te stemmen over fondstoewijzing. Dit laat de token zonder praktisch gebruik anders dan deelname aan gemeenschapsgovernance, wat resulteert in een lange tijd op een laag niveau blijvende prijs.</p>
<p>Het voorstel om de dividenden voor UNI-tokenhouders deze keer te verhogen, is duidelijk een significante verbetering in de economie van de token, en als gevolg daarvan heeft de token een toename van 50% aan feedback ontvangen van dit positieve effect.</p>
<h2 id="h2-Gedetailleerde20uitleg20van20de20belangrijkste20punten20van20het20dividendvoorstel20LP672677"><a name="Gedetailleerde uitleg van de belangrijkste punten van het dividendvoorstel: LP" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gedetailleerde uitleg van de belangrijkste punten van het dividendvoorstel: LP</h2><p>Uniswap-ontwikkelaar en leidende governance-vertegenwoordiger van de stichting, Erin Koen (@eek637), heeft op de avond van 23 februari zijn voorstel gepubliceerd in de hoop op een grootschalige upgrade van het Uniswap-protocolbestuur om actieve deelname aan delegatie te stimuleren.<img src="https://gimg2.gateimg.com/image/article/1709020818img_v3_028f_027a13e8-6616-4117-b2ee-e3d9e40fabix.jpg" alt=""><br>Bron: @UniswapFND</p>
<p>Uit de officiële introductie blijkt dat dit voorstel tot doel heeft om de problemen van gratis rijden en onverschilligheid in de huidige governance aan te pakken en de representatieve participatie te vergroten. De specifieke suggesties zijn als volgt:</p>
<p>Optimaliseer het protocol governance mechanisme van Uniswap om automatisering en barrièrevrije incasso van protocolkosten te bereiken.</p>
<p>Verdeel de verzamelde overeenkomstige kosten eerlijk onder de houders die UNI-tokens hebben gestaked en hun stemrechten hebben geautoriseerd volgens de vastgestelde verhoudingen.</p>
<p>Behoud controle over kernparameters door het bestuursteam, inclusief het bepalen van welke fondspools kosten moeten betalen en het specifieke bedrag aan kosten.</p>
<p>Bij succes zal het nieuwe klanten aantrekken en ‘verouderde’ autorisatie overdragen aan vertegenwoordigers die actief het akkoord ondersteunen, terwijl technische implementatie protocol governance-upgrades, kostenallocatie en kernparametercontrole omvat. Het ritme-arrangement omvat 7 dagen open dialoog, 10 dagen Code4rena reviewwedstrijd, snapshot-stemming en on-chain stemming.</p>
<p>Het moet worden opgemerkt dat er twee soorten kosten zijn op Uniswap, waarvan de front-end vergoeding 0,15% in rekening wordt gebracht via Uniswap Labs front-end transacties vanaf medio oktober 2023, voor de duurzame werking van Uniswap Labs; Een ander type zijn LP-kosten, die voortvloeien uit transactiekosten in Uniswap-pools, zoals WBTC/ETH-poolkosten van 0,3%.</p>
<p>Dit voorstel is gericht op LP-kosten, waaronder 1⁄10naar1⁄4van LP-kosten als overeenkomstskosten en worden toegewezen aan UNI-houders via governance-aanpassingen. Volgens de laatste gegevens bedraagt de huidige jaarlijkse LP-vergoeding van Uniswap ongeveer $626M. Zodra het voorstel is goedgekeurd, zullen UNI-houders naar verwachting een jaarlijkse dividendaanbod van $62M - $156M ontvangen, wat de huidige marktprijs van UNI aanzienlijk zal verhogen.</p>
<h2 id="h2-Het20voorstel20is20moeilijk20om20s20nachts20te20realiseren20maar20de20vooruitzichten20zijn20nog20steeds20veelbelovend656985"><a name="Het voorstel is moeilijk om ‘s nachts te realiseren, maar de vooruitzichten zijn nog steeds veelbelovend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het voorstel is moeilijk om ‘s nachts te realiseren, maar de vooruitzichten zijn nog steeds veelbelovend</h2><p>In feite heeft Uniswap, als leider van DEX, zijn positie in de branche stevig versterkt door productinnovatie. Uniswap lanceerde in mei 2021 de V3-versie en heeft plannen om de V4-versie uit te brengen na de aankomende Duncan-upgrade. De hooks-functie geïntroduceerd in de V4-versie geeft Uni programmeerbaarheid, waardoor de flexibele combinatie en efficiëntiecontrole van het fonds aanzienlijk verbeteren en de kapitaalwaarde van het project verder verbeteren.</p>
<p>Dit kan een belangrijke voorwaarde zijn voor de Uniswap Foundation om dividendvoorstellen in te dienen om het welvaartseffect voor tokens op dit moment vast te leggen, maar het is te voorzien dat dit voorstel waarschijnlijk net zo spelgebonden zal blijven als eerdere pogingen om dividenden toe te kennen.</p>
<p>Allereerst is het Uniswap-projectteam lange tijd terughoudend geweest ten opzichte van het voorstel voor winstdeling, uit vrees dat dit de belangen van liquiditeitsverstrekkers kan schaden. Daarom zijn veel vergelijkbare voorstellen uiteindelijk opgegeven.</p>
<p>Het voorstel werd alleen eenzijdig voorgesteld door de Uniswap Foundation en het Uniswap projectteam heeft de informatie zelfs niet doorgestuurd. Het is niet moeilijk te zien dat de meningsverschillen van iedereen significant zijn.</p>
<p>Bovendien zijn de houders van UNI-tokens voornamelijk grote investeringsinstellingen zoals a16z, wat betekent dat de resultaten van governance stemvoorstellen nog steeds beïnvloed kunnen worden door deze durfkapitaalinstituten.</p>
<p>Daarnaast heeft de Amerikaanse SEC rechtszaken aangespannen tegen meerdere crypto-investeringsinstellingen over kwesties met betrekking tot token-securitisatie, en Uniswap heeft vorig jaar nipt een rechtszaak gewonnen. Als Uniswap het voorstel voor winstdelingbestuur goedkeurt, kan dit leiden tot handhavingsmaatregelen door de Amerikaanse officiële UNI als definitie van beveiligingscategorieën, wat een grote invloed zal hebben op het noteringsplan van Uniswap Labs.<img src="https://gimg2.gateimg.com/image/article/1709020877img_v3_028f_ec577d87-9866-49d9-8275-d1fa695290ix.jpg" alt=""><br>Bron: @mikewawszczak</p>
<p>Daarom is de goedkeuring van dit voorstel vanuit de huidige situatie nog steeds vol onzekerheid. Bij het afwegen van de belangen van UNI-houders en LP’s, handhavingsacties van de regelgeving en het streven naar decentralisatie en vrijstelling van vergunningen, evenals de rechten en belangen van grote investeringsinstellingen en kleine en middelgrote investeerders, is er nog steeds behoefte om het evenwicht tussen projectpartijen en gemeenschappen te testen.</p>
<p>Verdergaand is dit ongetwijfeld een poging om pure governance tokens om te zetten in utility tokens, wat mogelijk een golf van enthousiasme teweegbrengt in DeFi en zelfs het hele crypto-veld. In de afgelopen twee dagen, <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> Finance heeft aangekondigd dat het Uniswap zal emuleren en het voorgestelde inkomstendistributieplan zal binnen 10 dagen worden geïmplementeerd.</p>
<p>Eindelijk moeten de resultaten van de on-chain stemming nog bekend worden gemaakt op 8 maart. Laten we afwachten en zien.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege auteursrechtenschending.<br></div><p></p><br></div></div></div></div>