U25hcHNob3Q6IDIwMjUgR2VkZWNlbnRyYWxpc2VlcmQgR292ZXJuYW5jZSBTdGVtcGxhdGZvcm0=

2022-06-06, 15:58

<p><img src="https://gimg2.gateimg.com/image/news202505291510187769307178.png" alt="">
</p><p>Snapshot Labs is een gedecentraliseerd stemingssysteem dat door crypto-projecten wordt gebruikt om hun gebruikersbasis te peilen. Deze informatievoorziener werd in 2021 opgericht door een onbekend individu met de pseudoniem Fabien Fabien. Hij fungeert als zowel CEO als oprichter. Deze CEO ontwikkelde het stemprotocol aanvankelijk als een zijproject terwijl hij werkte bij Balancer, een geautomatiseerde liquiditeitsprovider of AMM.</p>
<p>Tijdens het proces van het creëren van wat hij een eenvoudig stemsysteem noemde, realiseerde hij zich dat zijn idee grotere dingen kon doen. Tegen 2025 is Snapshot aanzienlijk ontwikkeld, ondersteunt nu meer dan 5.000 gedecentraliseerde autonome organisaties (DAO’s) wereldwijd en introduceert geavanceerde functies zoals reputatiegewogen stemmen, cross-chain governance-integratie en AI-ondersteunde voorstelanalyses. Het platform heeft aanzienlijke groei gerealiseerd, met actieve DAO’s die zijn gestegen van 2.000 in 2021 naar meer dan 5.000 in 2025, en maandelijkse voorstellen die zijn gestegen van 1.000 naar 4.300. Het Snapshot-ecosysteem omvat nu 1,2 miljoen totale kiezers, een aanzienlijke stijging van 180.000 in 2021.</p>
<p>Het platform lanceerde zijn token begin 2025 en implementeerde een governance-structuur die stemrechten binnen het ecosysteem toewijst. Verbeterde beveiligingsprotocollen en integratie met tweede-laags oplossingen verbeteren de schaalbaarheid, terwijl grote beurzen zoals Binance en Coinbase de infrastructuur van Snapshot hebben geïntegreerd, wat zijn positie als standaard voor decentralisatie governance versterkt.</p>
<h2 id="h2-Momentopname20202520Decentralisatie20governance20stemplatform412785"><a name="Momentopname: 2025 Decentralisatie governance stemplatform" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Momentopname: 2025 Decentralisatie governance stemplatform</h2><h3 id="h3-202520Update20De20Evolutie20van20Snapshot20in20Governance524805"><a name="2025 Update: De Evolutie van Snapshot in Governance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2025 Update: De Evolutie van Snapshot in Governance</h3><p>Tegen 2025 is Snapshot aanzienlijk ontwikkeld tot een governance-tool voor meer dan 5.000 gedecentraliseerde autonome organisaties (DAO’s) wereldwijd. Het platform heeft geavanceerde stemmechanismen geïntroduceerd, waaronder:</p>
<ul>
<li><strong>Reputatiegewogen stemmen</strong> Stem op basis van de reputatie of bijdragegewichten van gebruikers om ervoor te zorgen dat meer ervaren of actieve leden van de gemeenschap een grotere invloed hebben.</li><li><strong>Cross-chain Governance Integratie</strong> Ondersteun governance stemmen over verschillende blockchains, waardoor de governance mogelijkheden van het multi-chain ecosysteem worden verbeterd.</li><li><strong>Kunstmatige Intelligentie Geassisteerde Voorstel Analyse</strong> Kunstmatige intelligentietechnologie gebruiken om de inhoud van voorstellen te analyseren, diepere inzichten en suggesties te bieden om de gemeenschap te helpen beter geïnformeerde beslissingen te nemen.</li></ul>
<h3 id="h3-Neem20indicator20groei20aan897057"><a name="Neem indicator groei aan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Neem indicator groei aan</h3><table>
<thead>
<tr>
<th>Indicator</th>
<th>2021</th>
<th>2025</th>
</tr>
</thead>
<tbody>
<tr>
<td>Aantal Actieve DAO’s</td>
<td>2.000</td>
<td>5.000+</td>
</tr>
<tr>
<td>Maandelijks voorstel aantal</td>
<td>1.000</td>
<td>4.300</td>
</tr>
<tr>
<td>Totaal aantal stemmers</td>
<td>180.000</td>
<td>1,2 miljoen</td>
</tr>
</tbody>
</table>
<h3 id="h3-Tokenuitgifte20en20Governancestructuur959486"><a name="Tokenuitgifte en Governance-structuur" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tokenuitgifte en Governance-structuur</h3><p>Snapshot lanceerde zijn token begin 2025, met de implementatie van een governance-structuur die stemrechten binnen het ecosysteem toekent. Dit initiatief versterkt de betrokkenheid van de gemeenschap en de governance-capaciteiten verder.</p>
<h3 id="h3-Verbeterde20beveiligingsprotocollen20en20schaalbaarheid166512"><a name="Verbeterde beveiligingsprotocollen en schaalbaarheid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verbeterde beveiligingsprotocollen en schaalbaarheid</h3><ul>
<li><strong>Verbeterde beveiligingsprotocollen</strong> Verhoogde de beveiliging van het stemproces, waardoor kwaadaardige aanvallen en manipulatie worden voorkomen.</li><li><strong>Integratie met tweede laag oplossingen</strong> Verhoogde de schaalbaarheid van het platform, waardoor meer stemactiviteiten en grotere deelname van de gemeenschap mogelijk zijn.</li></ul>
<h3 id="h3-Integratie20van20Belangrijke20Beurzen25043"><a name="Integratie van Belangrijke Beurzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Integratie van Belangrijke Beurzen</h3><p>Leidende platforms, waaronder Binance en Coinbase, hebben de infrastructuur van Snapshot geïntegreerd, waardoor de positie ervan als standaard voor decentralisatie-governance wordt versterkt.</p>
<h2 id="h2-Een20uitgebreide20interpretatie20van20het20gedecentraliseerde20stemsysteem2020Snapshot330232"><a name="Een uitgebreide interpretatie van het gedecentraliseerde stemsysteem - Snapshot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een uitgebreide interpretatie van het gedecentraliseerde stemsysteem - Snapshot</h2><h3 id="h3-Wat20is20Snapshot791745"><a name="Wat is Snapshot?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Snapshot?</h3><p>Snapshot Labs is een gedecentraliseerd stem systeem dat crypto projecten gebruiken om hun gebruikersbasis te ondervragen. Het platform is opgericht door een onbekend persoon met het pseudoniem Fabien, die zowel CEO als oprichter is. Fabien ontwikkelde het stemprotocol aanvankelijk als een nevenproject terwijl hij werkte bij <a href="/price/balancer-bal" target="_blank" class="blog_inner_link">Balancer</a> (een geautomatiseerde market maker of AMM). Tijdens het proces van het creëren van een eenvoudig stem systeem, realiseerde hij zich dat zijn idee iets groters kon doen.</p>
<h3 id="h3-platformfuncties77152"><a name="platformfuncties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>platformfuncties</h3><ul>
<li><strong>Kosten-effectiviteit</strong> Gebruik het op IPFS gebaseerde off-chain verificatiesysteem zonder gasfees te betalen.</li><li><strong>Verschillende stemformaten</strong> Ondersteunt verschillende stemmodi zoals secundaire stemmen, enkele stemmen en goedkeuringsstemmen.</li><li><strong>Flexibele stemcalculatiemethoden</strong> Je kunt verschillende contracten gebruiken voor stemmen, zoals ERC20, NFT, enz.</li><li><strong>Tijdigheid</strong> Verminderde de tijd en moeite die nodig is om stemmen te creëren en uit te voeren.</li><li><strong>Beveiliging</strong> Gebruik het IPFS-protocol om de veiligheid en transparantie van het stemproces te waarborgen.</li></ul>
<h2 id="h2-Hoe20gebruik20je20Snapshot845620"><a name="Hoe gebruik je Snapshot?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe gebruik je Snapshot?</h2><h4 id="h4-Voorstel20Aanmaken214325"><a name="Voorstel Aanmaken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Voorstel Aanmaken</h4><ol>
<li>Maak een profiel aan op de <a href="/price/ethereum-name-service-ens" target="_blank" class="blog_inner_link">Ethereum Name Service</a> (ENS).</li><li>Creëer een ruimte op de website en registreer deze op ENS, zodat kiezers uw project gemakkelijk kunnen vinden.</li><li>Ga op de website naar de projectruimte en neem contact op met de walletprovider, waar je de relevante tokens kunt verkrijgen.</li><li>Open een nieuw voorstel en vul de nodige details van het voorstel in, zoals titel en samenvatting, stemtype, start- en einddata, enz.</li><li>Je hebt een bloknummer nodig dat standaard aan je wordt geleverd. Je kunt ervoor kiezen om het te gebruiken of je eigen te creëren. Het bloknummer wordt gebruikt om de Snapshot van de stemming te berekenen.</li><li>Dien uw voorstel in.</li></ol>
<h4 id="h4-Stemmen437416"><a name="Stemmen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stemmen</h4><ol>
<li>Klik op de Snapshot-pagina.</li><li>Verbind je portemonnee met de relevante portemonneeprovider waar je tokens houdt.</li><li>Blijf stemmen.</li><li>Onderteken met uw portemonnee.</li><li>Voltooi de stemming.</li></ol>
<h3 id="h3-Tokens20en20forks861782"><a name="Tokens en forks" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tokens en forks</h3><p>De tokenuitgifte van Snapshot is gepland voor begin 2025, met de implementatie van een governance-structuur die stemrechten binnen het ecosysteem toekent. Het platform is open source en is meerdere keren geforkt, waarbij Fabien voortdurend bijdragen en innovatie aanmoedigt.</p>
<h3 id="h3-Conclusie255600"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Snapshot is een belangrijk hulpmiddel geworden op het gebied van decentralisatie governance, dat de governancebehoeften van meer dan 5.000 DAO’s wereldwijd ondersteunt. Door geavanceerde stemmechanismen en verbeterde beveiligingsprotocollen in te voeren, biedt Snapshot gemeenschappen een veilig, verifieerbaar en kosteneffectief stemplatform. Met de integratie van grote exchanges wordt de positie van Snapshot verder versterkt, waardoor het de standaardtool voor decentralisatie governance wordt.</p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Blogteam</strong><br>  <div class="info-tips"><em>Deze inhoud vormt geen aanbod, sollicitatie of advies. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br>  <div></div>Houd er rekening mee dat Gate mogelijk al zijn of een deel van zijn diensten kan beperken of verbieden vanuit beperkte gebieden. Lees de gebruikersovereenkomst voor meer informatie, link:<a href="https://www.gate.io/zh/user-agreement。" data-index="1"></a><a href="https://www.gate.io/en/user-agreement" data-index="2">https://www.gate.io/nl/gebruiksvoorwaarden</a>.<br><p></p><br></em></div></div></div>