UEVPUExFIENvaW46IFZhbiBHcm9uZHdldCBWZWlsaW5nIG5hYXIgQ3J5cHRvIExlZ2VuZGUg4oCUIERlIEZhbnRhc3Rpc2NoZSBSZWlzIHZhbiBQZW9wbGUgREFP

2025-06-10, 07:47

<p><img src="https://gimg2.gateimg.com/image/ppl202506101543492805818006.png" alt="">
</p><p>In november 2021 zorgde een nieuwsbericht voor opschudding in de crypto-gemeenschap: een groep nerds die zichzelf ConstitutionDAO noemden, probeerde de aankoop van een exemplaar van de Amerikaanse Grondwet te crowdfunden - niet een fotokopie, maar de originele gedrukte versie van de Grondwettelijke Conventie van 1787, een van de slechts 11 resterende privécollecties. In slechts enkele dagen werd 47 miljoen dollar ingezameld van duizenden gewone mensen, uitgewisseld voor 1 ETH = 1 miljoen PEOPLE-tokens. Toen ze nipt verloren op een veiling van Sotheby’s van hedgefondsreuzen, eindigde het verhaal daar niet; in plaats daarvan markeerde het het begin van de fantastische reis van de PEOPLE-token.</p>
<h2 id="h2-Oorsprong20Een20Crypto20Totem20Geboren20uit20een20Mislukte20Veiling583260"><a name="Oorsprong: Een Crypto Totem Geboren uit een Mislukte Veiling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Oorsprong: Een Crypto Totem Geboren uit een Mislukte Veiling</h2><p>De geboorte van ConstitutionDAO is gevuld met idealisme. Het probeert te bewijzen dat “het volk” waardevolle geschiedenis kan bezitten die toebehoort aan het volk (“Wij het Volk” is de openingszin van de Grondwet). Hoewel de veiling is mislukt, overleefde de PEOPLE Token die het uitgaf onverwacht:</p>
<ul>
<li>Duale terugkoopmechanisme: Donateurs kunnen ETH inwisselen tegen de oorspronkelijke ratio (1 miljoen PEOPLE = 1 ETH), of het omzetten in de governance Token WTP</li><li>Deflatoir model vastgesteld: Ingewisselde PEOPLE worden permanent vernietigd, en de totale voorraad blijft afnemen vanaf de initiële 5,06 miljard</li><li>Waarde gekoppeld aan ETH: Prijsdalingen leiden tot inwisseling en vernietiging, wat de schaarste van de Token verhoogt.</li></ul>
<p>Dit ontwerp stelt MENSEN in staat om gewone MEME-munten te overstijgen en wordt de eerste gemeenschapsactivum dat wordt ondersteund door ETH-reserves.</p>
<h2 id="h2-Technische20Kern20Deflationair20Model20en20Gedecentraliseerde20Autonome20Organisatie850313"><a name="Technische Kern: Deflationair Model en Gedecentraliseerde Autonome Organisatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Technische Kern: Deflationair Model en Gedecentraliseerde Autonome Organisatie</h2><p>De kernwaarde logica van PEOPLE is opgebouwd uit een drievoudig mechanisme:</p>
<ul>
<li>Harde ondergrens: De wisselkoers van 1 ETH = 1 miljoen PEOPLE vormt prijssteun, theoretisch kan het nooit nul worden.</li><li>Passieve deflatie: Wanneer de markt fluctueert, leiden arbitrageurs die ETH uitwisselen tot de vernietiging van Tokens, wat cyclisch de waarde van de resterende Tokens versterkt.</li><li>Volledig gemeenschapsgedreven: Geen manipulatie door een projectpartij, de Token distributie wordt automatisch uitgevoerd via het Juicebox DAO-protocol.</li></ul>
<p>Dit mechanisme heeft een groep houders aangetrokken die er vast van overtuigd zijn dat “PEOPLE het geestes symbool van DAO is.”</p>
<h2 id="h2-Markttraject20Van20stilte20naar20de20achtbaan20aangestoken20door20Musk621585"><a name="Markttraject: Van stilte naar de achtbaan aangestoken door Musk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttraject: Van stilte naar de achtbaan aangestoken door Musk</h2><p>De prijs geschiedenis van PEOPLE is een weerspiegeling van de sentimenten op de encryptiemarkt:</p>
<ul>
<li>November 2021: Steeg van $0,0038 naar $0,169 na een mislukte veiling, wat een honderdvoudig wonder bereikte</li><li>2022 - 2023: Lange termijn consolidatie op $0,03 - $0,06, ook wel een “zombie Token” genoemd</li><li>2024 keerpunt: Musk noemde PEOPLE twee keer, wat een stijging van 400% in 3 dagen veroorzaakte, met een marktkapitalisatie van meer dan $530 miljoen</li><li>Veerkrachtvalidatie: Hersteld na meerdere diepe dalingen, wat bewijst dat de consensus van de gemeenschap sterker is dan de meeste MEME-munten.</li></ul>
<p>Analisten hebben aanzienlijke verschillen in hun verwachtingen: conservatieve voorspellingen suggereren dat het $0,13 zal bereiken tegen 2025 (DigitalCoinPrice), terwijl optimistische voorspellingen anticiperen dat het $2,6 zal bereiken tegen 2030 (PricePrediction.net).</p>
<h2 id="h2-Gemeenschapsgeloof20De20integratie20van20Web3geest20en20MEMEcultuur74257"><a name="Gemeenschapsgeloof: De integratie van Web3-geest en MEME-cultuur" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gemeenschapsgeloof: De integratie van Web3-geest en MEME-cultuur</h2><p>De blijvende vitaliteit van PEOPLE is geworteld in een dubbele culturele consensus:</p>
<ul>
<li>DAO geest totem: symboliseert de kracht van gewone mensen die zich verzetten tegen kapitaal (“Mensen snijden geen mensen” is de gemeenschapsleus geworden)</li><li>Nieuwe school MEME drager: Musk positioneert het als de “opvolger van DOGE,” verspreidend via meme-afbeeldingen (de menselijke maanlanding afbeelding is een satire van DOGE)</li><li>Praktische verkenning: Sommige scenario’s proberen te worden gebruikt voor DAO governance stemmingen en liefdadigheidsdonaties.</li></ul>
<p>Deze cultuur maakt het een opvallende verschijning tussen MEME-munten zoals SHIB en PEPE.</p>
<h2 id="h2-Toekomstige20uitdagingen20Overgang20van20symbolen20naar20duurzame20ecosystemen459947"><a name="Toekomstige uitdagingen: Overgang van symbolen naar duurzame ecosystemen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstige uitdagingen: Overgang van symbolen naar duurzame ecosystemen</h2><p>Ondanks innovatieve modellen staat de MENSHEID nog steeds voor evolutionaire knelpunten:</p>
<ul>
<li>Beperkingen van de nut: Gebrek aan toepassingsscenario’s zoals DeFi en NFT’s, afhankelijk van sentimentgestuurd.</li><li>Deflatoire Dubbelzijdig Zwaard: Als grootschalige terugbetalingen leiden tot een extreem lage circulatie, kan dit de handelsliquiditeit verzwakken.</li><li>Regulerende gevoeligheid: Als een DAO-erfenis zonder fysieke ondersteuning is het beleidsrisico hoger dan dat van functionele tokens.</li></ul>
<p>Of het de positionering van “Constitutionele Veiling Souvenirs” kan doorbreken, hangt af van <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> De diepte van de acceptatie van infrastructuur voor DAO-tools.</p>
<p>Vandaag de dag schommelt de marktkapitalisatie van PEOPLE nog steeds tussen de 100 miljoen en 200 miljoen dollar, minder dan 3% van de piek DOGE. Maar het bestaan ervan is op zichzelf een wachtwoord: terwijl de kopie van de Grondwet rustig ligt in de kluis van een miljardair in New York, stroomt PEOPLE in portefeuilles over de hele wereld. Een DAO is ontbonden, maar 5 miljard Tokens zijn de fysieke dragers van de gedecentraliseerde geest geworden—net als de zin die de Discord-gemeenschap overspoelde: “We hebben de Grondwet niet gekocht, maar we hebben het geloof gekocht.”</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="2">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>