Q3J5cHRvIEJsYWNrIEhvcnNlIFdMRCBEb29yYnJlZWt0IGRlIEltcGFzc2UgZW4gV29yZHQgVmlyYWFsLCBEdXJmIGplIHRlIFZvbGdlbj8=

2024-03-18, 03:32

<p><img src="https://gimg2.gateimg.com/image/article/1710732798rdzz.jpeg" alt=""></p>
<h2 id="h2-TLDR692026"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>WLD, ‘s werelds eerste crypto-token gebaseerd op irisherkenning, heeft onlangs veel aandacht en discussie opgewekt vanwege de opeenvolgende prijsstijgingen. Welke veranderingen de opkomst met zich mee zal brengen voor het cryptoveld, is de aandacht van elke belegger waard.</p>
<p>Worldcoin is een project dat het UBI-concept implementeert. Het bestaat uit drie onderdelen: World ID, Worldcoin en World APP.</p>
<p>Hoewel Worldcoin op korte termijn nog steeds voor meerdere uitdagingen staat, is zijn zeer creatieve doorbraakpotentieel met name prominent in het gebied van crypto-toepassingen, en het waarde-spel zal een langetermijnproces zijn.</p>
<h2 id="h2-Introductie840070"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De nieuwe verhalende hype van AI is nog steeds aan de gang, en de token Worldcoin (WLD), die door mensen gedwongen aan het AI-concept is gekoppeld, domineert de hete zoekopdracht al bijna een maand. Zelfs de totale circulerende marktwaarde ervan overtrof ooit de waardering van OpenAI. Hoe is dit project uitgegeven en gelanceerd, of het zich kan losmaken van MEME-attributen en echte UBI-waarde kan vrijgeven, en met welke risico’s en kansen zal het in de toekomst worden geconfronteerd? In dit artikel zullen we samen bespreken.</p>
<h3 id="h3-Met20een20stijging20van2045620in20n20maand20leidt20Worldcoin20de20AIsector992153"><a name="Met een stijging van 456% in één maand leidt Worldcoin de AI-sector" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Met een stijging van 456% in één maand leidt Worldcoin de AI-sector</h3><p>Onbewust is Worldcoin gestegen van $2,1 begin februari tot ongeveer $12 begin maart, waarbij in slechts één maand een overmatige stijging van 456% werd geregistreerd, waardoor het de heetste token in de AI-sector werd.</p>
<p>Zoals te zien is in de afbeelding, is de stijging van Worldcoin nauw verbonden met de dynamiek van OpenAI.</p>
<p>Op 15 februari van dit jaar heeft OpenAI, een bedrijf dat bekend staat om ChatGPT, zijn nieuwste ontwikkeling aan het publiek getoond - een videogeneratiemodel genaamd Sora. Dit model is opvallend, omdat het snel hoogwaardige video’s kan genereren tot een minuut lang met slechts een eenvoudige invoer van tekst. In de video zijn de personages divers, de scènes complex, en de details van de personages zijn levendig alsof ze in de echte wereld zijn.<br><img src="https://gimg2.gateimg.com/image/article/17107326161.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Dit nieuws veroorzaakte snel verhitte discussies op sociale media, en het blockchain-project van OpenAI - Worldcoin - werd ook snel aangewakkerd door dit sentiment, wat leidde tot een reeks opwaartse solide trends. In slechts een paar dagen verdubbelde de prijs van Worldcoin en zorgde prompt voor de opkomst van de hele AI-sector, terwijl WLD bijna een maand lang de populaire tokenreeks domineerde.</p>
<p>Op de schrijfdatum is de prijs van Worldcoin licht gedaald tot ongeveer $10,5, en als berekend wordt op basis van een totaal aanbod van 10 miljard stuks, heeft de totale marktwaarde van WLD de $105 miljard overschreden, wat zelfs meer is dan 25% van de laatste waardering van OpenAI. Het is echter vermeldenswaard dat de omloopgraad van WLD gering is, met slechts 1,49% van het totale aantal munten dat momenteel op de markt circuleert.</p>
<p>Volgens de officiële website van Worldcoin zijn er in meer dan 120 landen/regio’s meer dan 4,2 miljoen Orb-geverifieerde Wereld-ID’s aangemaakt, met meer dan 35 miljoen gebruikers en meer dan 1 miljoen actieve gebruikers per week.</p>
<p>Zo’n grote gebruikersbasis en een ontoereikende tokenscirculatie maken de token van nature vatbaar voor aanzienlijke kortetermijnspeculatiehype.</p>
<h3 id="h3-Poging20tot20idealisering20van20UBI143934"><a name="Poging tot idealisering van UBI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Poging tot idealisering van UBI</h3><p>Het Worldcoin blockchain-project werd in 2020 bedacht door de oprichters van OpenAI, Sam Altman en Alex Blania.</p>
<p>Sinds 2021 heeft Worldcoin met succes investeerders aangetrokken, waaronder a16z, DCG, Blockchain Capital, enz., via financieringsactiviteiten, waarbij meer dan $100 miljoen aan durfkapitaal is opgehaald. De inheemse crypto van Worldcoin, WLD, is op 24 juli 2023 officieel op de markt gekomen, waarmee het zijn debuut maakt.</p>
<p>Het project heeft als doel een grootse visie te realiseren van het opbouwen van het grootste en meest rechtvaardige wereldwijde digitale identiteit- en digitale valutasysteem. Kortom, het doel is om gratis cryptocurrency en directe economische ondersteuning te bieden aan elke echte mens op aarde.<br><img src="https://gimg2.gateimg.com/image/article/17107326662.jpeg" alt=""><br>Bron: worldcoin.org/</p>
<p>Dus, waarom is dit project zo gul en bereid om valuta gratis aan het publiek te distribueren?</p>
<p>Dit komt voort uit het diepgaande inzicht van Sam Altman dat met de snelle ontwikkeling van kunstmatige intelligentietechnologie veel banen op aarde in de toekomst door AI vervangen kunnen worden. Wanneer mensen hun baan verliezen, verliezen ze ook een stabiele inkomstenbron. Vandaar dat het concept van het basisinkomen (UBI) is ontstaan.</p>
<p>Het Worldcoin-project streeft ernaar dit concept te realiseren door zijn projecttoken - WLD - te verspreiden om economische steun te bieden aan iedereen. Deze token is geen traditionele Amerikaanse dollars of goud, maar een unieke digitale valuta van het Worldcoin-project. Het zal dienen als een ‘digitaal identiteitsprotocol’ in het tijdperk van kunstmatige intelligentie, met als doel een gedecentraliseerde Proof of Humanity-oplossing op te bouwen om tastbare voordelen te bieden aan iedereen.</p>
<p>De architectuur van Worldcoin bestaat uit drie kernonderdelen:</p>
<ol>
<li><p>Een wereldwijde identiteit - Wereld-ID: een digitale identiteit die wordt gebruikt om privacy te beschermen</p>
</li><li><p>Een wereldwijde digitale valuta - Worldcoin: codenaam WLD, alleen beschikbaar voor mensen</p>
</li><li><p>Een portemonnee die identiteits-ID en valuta bevat - World App: de eerste digitale portemonnee die compatibel is met dit protocol</p>
</li></ol>
<p>In het concept van Proof of Humanity worden de rijke werken gemaakt door kunstmatige intelligentie vaak vergezeld door een grote hoeveelheid junkinhoud, dus het bewijzen van de authenticiteit en uniciteit van een persoon wordt bijzonder belangrijk.</p>
<p>Om dit te bereiken, plant Worldcoin om wereldwijd speciale hardware genaamd Orb te distribueren, waarmee mensen hun identiteit kunnen verifiëren door hun iris te scannen en specifieke applicaties te gebruiken. Worldcoin benadrukt zijn privacybeschermingstechnologie en heeft plannen om geleidelijk decentralisatie van protocolbestuur te bereiken.</p>
<p>In het bedieningsmechanisme van Worldcoin moeten gebruikers de World App gebruiken om privé- en openbare sleutels te genereren, en vervolgens naar nabijgelegen Orb-apparaten gaan om hun identiteit te verifiëren via irisscan. Dit verificatieproces zorgt ervoor dat alleen echte menselijke individuen kunnen slagen, en elk individu kan slechts één keer worden geverifieerd. Zodra met succes geverifieerd, zal de gebruiker de door Orb geverifieerde World ID ontvangen.</p>
<h3 id="h3-Worldcoin20vordert20bij20het20stellen20van20vragen191332"><a name="Worldcoin vordert bij het stellen van vragen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Worldcoin vordert bij het stellen van vragen</h3><p>Veel innovatieve producten zullen twijfels tegenkomen in de beginfase van de lancering op de markt, en sommige zullen uiteindelijk de stresstest voltooien en richting de uitgestrekte oceaan van sterren gaan. Bijvoorbeeld, zijn <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en volgt Worldcoin ook deze weg?</p>
<p>Een komische realiteit is dat Worldcoin zelf geen project is dat AI-technologie gebruikt, en mensen associëren de oprichter van Worldcoin alleen maar gedwongen met OpenAI, waardoor ze het token krachtig opwinden, wat inderdaad in lijn is met de FOMO-kenmerken van de cryptomarkt.</p>
<p>Een andere skeptische zienswijze is dat Worldcoin grotere betekenis heeft, maar op technisch niveau geen duidelijke innovatiepunten heeft getoond.</p>
<p>Specifiek is de WLD-token gebaseerd op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ERC20-token van ‘s, wat samenwerkt met <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> op de onderliggende architectuur en Veilig op de rekening. ENS en <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> worden gebruikt voor overdrachten en transacties. De enige iris-scan biometrische hardware met native technologie, Orb, werd onderzocht door toezichthoudende autoriteiten in landen zoals het VK, Frankrijk en Duitsland vanwege privacy- en beveiligingsproblemen aan het begin van de project lancering. Onlangs zijn ook Spanje, Zuid-Korea en andere regio’s begonnen met het onderzoeken van het verbod.</p>
<p>Worldcoin is echter niet gestopt met het werken aan een puur irisverzamelings- en betalingsproject, en de recente acties lijken te vertrouwen op het voordeel van de DID-markt om het ecosysteem uit te breiden.</p>
<p>Eind vorig jaar kondigde de Worldcoin Foundation een gemeenschapsfinancieringsprogramma aan met de naam Wave0. Het plan wijst $ 5 miljoen aan financiering toe over drie subsidietrajecten om ontwikkelaars in staat te stellen zich te concentreren op het bouwen van aanpasbare technologieën en rechtvaardigere en op het Worldcoin-platform.</p>
<p>Ten eerste heeft de community grant track tot 5000 WLD-fondsen toegewezen voor sponsoring, hackathons en vergelijkbare evenementen. Daarnaast heeft de project grant track tot doel om grootschalige projecten tot 25000 WLD te ondersteunen. Open grants zullen zich richten op de belangrijkste en meest ambitieuze projecten zonder een specifiek budget, en zullen bedragen ontvangen op basis van specifieke omstandigheden. Deze subsidie zal onderzoek en ontwikkelingswerk ondersteunen, vooral die projecten die de intersectie van privacy en biometrie verkennen.</p>
<p>In maart kondigde het Wave0-programma zijn eerste lichting genomineerden aan, met ongeveer 800000 WLD’s toegekend aan 28 projecten over vijf continenten, die innovatieve oplossingen omvatten rond World ID-toepassingen, World ID-protocollen, gebruikersagenten, PoP nieuwe hardware, en meer. Deze omvatten Votexx, Zanzibar, NEBRA, Ribbon Protocol, xx Network, Rarimo, Wonderland, TheVoice, Wallfacer, Clade Club, Merkle Tree Explorer, RewardMe, en meer IDMaster, etc.<br><img src="https://gimg2.gateimg.com/image/article/17107327173.jpeg" alt=""><br>Bron: Worldcoin.org</p>
<p>In de golf van kunstmatige intelligentie heeft Worldcoin een grootse visie en ziet World ID als een belangrijk medium om Universeel Basisinkomen (UBI) voor iedereen te realiseren, wat zeer wordt verwacht. Echter, tegelijkertijd zijn er ook potentiële risico’s en uitdagingen, zoals irisscans en het verzamelen en opslaan van biometrische gegevens, die zorgen hebben opgewekt.</p>
<p>Hoewel Worldcoin op korte termijn nog steeds voor meerdere uitdagingen staat, is het zeer verbeeldingsvolle doorbraakpotentieel met name prominent op het gebied van crypto-toepassingen. Dit potentiële succes en de vooruitzichten op waardestijging van tokens hebben de aandacht getrokken van topventure capitalists uit Silicon Valley, naast de oprichter, Altman.</p>
<p>“Met de bloeiende ontwikkeling van AI groeit de vraag naar en die bewijs van menselijkheid leveren, evenals de vraag naar herverdeling van rijkdom en wereldwijde bestuursen.”</p>
<p>Sam Altman is nog steeds toegewijd om dit project toegankelijker te maken voor de echte wereld, en te midden van controverse en voorspoed, zullen er nog vele hoogtepunten te zien zijn in dit project. We zullen ook afwachten.</p>
<p>Voor investeerders zal de waarde van WLD-tokens diep beïnvloed worden door de marktherkenning van het Worldcoin-concept en of de token praktische toepassingsscenario’s en een dynamisch ecosysteem kan opbouwen. Dit consensus spel zal op lange termijn zijn en moet redelijkerwijs worden geëvalueerd bij het nemen van investeringsbeslissingen, terwijl een rationeel participatieconcept wordt gehandhaafd.</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 enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het herposten van het artikel zal worden toegestaan, mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>