JFVOSSBpcyBpbiBkZSBhZmdlbG9wZW4gMyBkYWdlbiBtZXQgbWVlciBkYW4gNDklIGdlc3RlZ2VuLCBob2UgaGVlZnQgZGUgVW5pc3dhcCBGb3VuZGF0aW9uIGludGVuc2UgZ2VtZWVuc2NoYXBzZGlzY3Vzc2llcyB2ZXJvb3J6YWFrdD8=

2024-02-26, 10:04

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TDLR223113"><a name="TD;LR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TD;LR</h2><p>De <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> De stichting stelt een grootschalige upgrade voor van het bestuur van het Uniswap-protocol om actieve, participatieve en doordachte delegatie te stimuleren, waardoor het Uni-vergoedingsmechanisme UNI-tokenhouders beloont die hun tokens hebben geautoriseerd en beheerd.</p>
<p>Het voorstel van de <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> Foundation beschrijft de motivatie achter deze verandering en geeft een gedetailleerde beschrijving van de technische en logistieke veranderingen die nodig zijn om het te implementeren.</p>
<p>Als er geen significante obstakels zijn, zal de snapshot-stemming voor dit voorstel worden vrijgegeven op 1 maart 2024, en de on-chain stemming zal worden vrijgegeven op 8 maart 2024.</p>
<h2 id="h2-Inleiding7029"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>De Uniswap Foundation stelt voor om eventuele protocolkosten toe te wijzen aan houders van gestapelde UNI-tokens, en de markt heeft enthousiast gereageerd op dit nieuws. $ UNI is in de afgelopen 3 dagen met meer dan 49% gestegen en staat momenteel rond 11U; Bovendien waren er vóór de bekendmaking bewegingen in de on-chain whale wallet.<br><img src="https://gimg2.gateimg.com/image/article/1708941800img_v3_028e_ebf446be-6460-4fc6-8365-50a2d5eccfix.jpg" alt=""><br>Bron: Gate.io</p>
<h2 id="h2-Uniswap20Foundation20Verdeel20Protocolkosten20onder20UNItokenhouders247795"><a name="Uniswap Foundation: Verdeel Protocolkosten onder UNI-tokenhouders" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Uniswap Foundation: Verdeel Protocolkosten onder UNI-tokenhouders</h2><p>Uniswap is een van de grootste gedecentraliseerde beurzen (DEX) en is een gedecentraliseerd beursprotocol gebouwd op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het Uniswap-protocol werd opgericht door Hayden Adams in 2018, en de technische principes ervan werden voor het eerst voorgesteld door Vitalik Buterin, medeoprichter van Ethereum. Momenteel is Uniswap de DEX met de grootste handelsvolume op Ethereum.</p>
<p>Uniswap biedt de basisfuncties van een beurs, zoals het verhandelen van cryptocurrencies en liquiditeitsdelving. Het draait op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en gebruikers maken gebruik van het Automatic Market Maker Protocol (AMM), ook wel bekend als de Constant Product Market Maker, in plaats van traditionele spotmarktorders om ERC-20 tokens uit te wisselen.</p>
<p>Op 23 februari kondigde de Uniswap Foundation in een bericht aan dat de snapshot-stemming voor het voorstel “Activate Uniswap Protocol Governance” op 1 maart 2024 zal worden vrijgegeven en dat on-chain voting op 8 maart 2024 zal worden vrijgegeven.</p>
<p>Het voorstel suggereert een upgrade van het protocol en de voorgestelde veranderingen omvatten: 1. Upgrade van het governance protocol van Uniswap om geen licentie of programmatische protocolkosten te vereisen; 2. Verdeel eventuele protocolkosten proportioneel onder UNI-tokenhouders die hun stemrechten hebben gestaked en toevertrouwd; 3. Sta governance toe om kernparameters te blijven controleren: welke pools betaling vereisen en de grootte van de kosten.</p>
<p>Ondertussen omvat dit voorstel twee nieuwe slimme contracten, die naar verwachting incentive fees zullen omzetten in universele ERC-20 tokens en deze zullen verdelen onder de stakers en houders van UNI.<br><img src="https://gimg2.gateimg.com/image/article/1708941826img_v3_028e_7d4cbb23-6c89-4342-9f45-ff3b2cb0d1ix.jpg" alt=""><br>Bron: Uniswap</p>
<h2 id="h2-Waarom20is20het20voorstel20belangrijk544635"><a name="Waarom is het voorstel belangrijk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom is het voorstel belangrijk</h2><p>Aanvankelijk was het belangrijkste doel van Uniswap bij het uitgeven van tokens om vampieraanvallen te weerstaan die veroorzaakt werden door <a href="/price/sushi-sushi" rel="nofollow noopener noreferrer" target="_blank">Sushi</a> De aantrekkingskracht van gebruikersliquiditeit van Gate.io, aangezien de zorgen van Uniswap Lab over nalevingscontroles de ‘kostenconversie’-schakelaar niet hebben ingeschakeld, zoals de meeste DeFi-projecten.</p>
<p>Dat wil zeggen, hoewel het Uniswap-platform zelf transactiekosten ontvangt via massale transacties, zijn ze onafhankelijk van de $UNI-token en zijn ze niet omgezet in het tokenaanbod van UNI of ten goede gekomen aan houders, wat heeft geleid tot een aanzienlijke afname van de interesse van UNI-houders in deelname aan bestuursstemmingen en protocollen.</p>
<p>Volgens de gegevens van Dune heeft Uniswap’s front-end transactiekosten sinds oktober 2023 alleen al meer dan $3,5 miljoen opgeleverd, en zodra ze worden omgezet en verdeeld, kunnen de voordelen aanzienlijk zijn.</p>
<p>De kostenconversie wordt gedurende ongeveer 4 maanden geactiveerd en de verdiende kosten worden bijgeschreven op de Uniswap DAO-schatkist. Dit voorstel kan UNI daadwerkelijk versterken en hogere investeringsrendementen bieden aan houders, waardoor meer gebruikers UNI-tokenhouders worden en de prijs dienovereenkomstig snel stijgt.</p>
<h2 id="h2-De20trend20van20onchain20walvisportefeuilles252679"><a name="De trend van on-chain walvisportefeuilles" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De trend van on-chain walvisportefeuilles</h2><p>Volgens Lookonchain monitoring, op 23 februari verwijderden adressen die beginnen met 0×-Eab 1,2 miljoen UNI-liquiditeit en stortten vervolgens 1 miljoen UNI in Binance; Op 24 februari verkocht het adres dat gemarkeerd is als ‘Uniswap Team/Investor/Advisor Wallet’ op de keten 90.000 UNI’s voor $11,48. De portemonnee ontving in totaal 5,44 miljoen UNI’s en heeft momenteel 926.000 in bezit.</p>
<p>Het is vermeldenswaard dat het portefeuilleadres dat is gemarkeerd als encryptieonderzoeksinstituut a16z $64 miljoen aan UNI ($720 miljoen, goed voor 6,4% van het totale aanbod) vasthoudt, wat een beslissende invloed heeft op de stemming, aangezien 4% van het UNI-aanbod voor stemt om het quorum te bereiken.</p>
<p>A16z heeft $64 miljoen UNI ($720 miljoen) ontvangen van het Uniswap-team/investeerder/adviseur portemonnee en overgemaakt naar 31 portemonnees.</p>
<h2 id="h2-Conclusie753091"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Uniswap is altijd een top DEX-beurs geweest, die een aanzienlijke hoeveelheid Ethereum-kapitaal aantrekt <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a>, maar de UNI-token zelf mist voldoende macht en opwaartse momentum; En nu hebben het UNI-team en de gemeenschap duidelijk relevante strategieën op dit gebied gemaakt.</p>
<p>Het is vermeldenswaard dat er een zekere mate van onafhankelijkheid is tussen Uniswap Lab en Uniswap Foundation. Uniswap Lab voert voornamelijk onderzoek en ontwikkeling uit, terwijl de Foundation de belangen van sommige gemeenschappen vertegenwoordigt op het gebied van governance. Dit voorstel is ook gedaan door de Uniswap Foundation.</p>
<p>Blur-oprichter Pacman prees ook de acties van UNI en verklaarde dat de BLUR-gemeenschap kan leren van de ervaring van UNI.</p>
<p>Bovendien staat de release van Uniswap v4 voorlopig gepland op het Ethereum-mainnet in het derde kwartaal van 2024. Op dit moment zal de machtiging van Uni houders en investeerders veel vertrouwen geven, maar het kan ook te maken krijgen met ernstige regelgevingskwesties na het bijwerken van het protocol. Het voorstel bevindt zich nog steeds in de wachtstand voor de stemming en is nog niet daadwerkelijk geïmplementeerd, dus investeerders moeten letten op mogelijke risico’s.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S.</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 enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt genoemd. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>