QWxsZXMgd2F0IHUgbW9ldCB3ZXRlbiBvdmVyIGRlICdDcmF6eSBJbm5vdmF0b3InIC0gV29ybGRjb2lu

<p><img src="https://gimg2.gateimg.com/blog/167999845218246089620230328-181352.jpeg" alt=""></p>
<h2 id="h2-TLDR322664"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Op 24 juli 2023 werd de token-economie van Worldcoin officieel aangekondigd. Tegelijkertijd hebben meerdere beurzen, zoals Gate.io, ook succesvol Worldcoin (WLD) gelanceerd.</p>
<p>Onder het bombardement van meerdere berichten, ontstak Worldcoin, een project vol Cyberpunk-smaak, de hele cryptowereld.</p>
<h2 id="h2-WorldCoin2020Gekke20Innovator90807"><a name="WorldCoin - “Gekke Innovator”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WorldCoin - “Gekke Innovator”</h2><p><img src="https://gimg2.gateimg.com/image/article/16909471445531690946512_.pic.jpg" alt=""></p>
<p>WorldCoin is een cryptocurrency-project opgericht door Sam Aitman in 2020, dat tot doel heeft een wereldwijd, eerlijk en inclusief open-source financieel protocol te bouwen.</p>
<p>WorldCoin’s visie is om het grootste en meest eerlijke digitale identiteit- en valutasysteem ter wereld te creëren, dat identiteitsverificatie kan bereiken door de iris van miljoenen mensen te scannen.</p>
<p>WorldCoin bestaat uit twee belangrijke entiteiten: de WorldCoin Foundation en Tools for Humanity, de daadwerkelijke ontwikkelingsentiteiten. Het ontwerp van dit project bestaat uit drie componenten: WorldID, WorldCoin en een portemonnee (WorldAPP) die een identiteit ID en munt draagt.</p>
<p>-WorldID: Digitale identiteit gebaseerd op privacybescherming en bewijs van persoonlijkheid.</p>
<p>WorldCoin: De eerste token die wereldwijd gratis aan mensen wordt gedistribueerd, gepland om te worden gedistribueerd naar 1 miljard mensen.</p>
<p>–WorldAPP: Een portemonnee voor het doen van betalingen, aankopen en transfers over de hele wereld.</p>
<p>Via deze drie kunnen gebruikers interageren met WorldCoin’s tokens, andere digitale activa en traditionele valuta’s om betalings-, aankoop- en overdrachtsactiviteiten te voltooien.</p>
<p>Om zijn financiële netwerk snel uit te breiden, is WorldCoin van plan om zijn token te airdroppen naar 1 miljard mensen wereldwijd. De eerste stap om dit doel te bereiken is echter het voorkomen van ‘heksaanvallen’, waarbij één persoon meerdere adressen controleert om winst te maken (een veelvoorkomende maatregel bij couponknippers). Om deze reden heeft WorldCoin gekozen voor een directe methode, namelijk het rechtstreeks verifiëren van de identiteit van de echte persoon.</p>
<p>Om dit doel te bereiken, heeft WorldCoin een biometrisch apparaat ontwikkeld genaamd Orb, dat de uniekheid van een persoon verifieert door de iris te scannen en gebruik maakt van zero-knowledge proof om de beveiliging te waarborgen.</p>
<h2 id="h2-OrbPoPIedereen20Governance261688"><a name="Orb+PoP=Iedereen Governance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Orb+PoP=Iedereen Governance?</h2><p>Hoewel irisscanning misschien als een privacyzorg klinkt, heeft Worldcoin volgens hen al rekening gehouden met dit probleem in het ontwerp.</p>
<p>Orb is een bolvormig hardware-apparaat ontwikkeld door Tools For Humanity. Het maakt gebruik van irisherkenningstechnologie om op een veilige en privacybehoudende manier de menselijkheid en uniekheid van een persoon te verifiëren.<br><img src="https://gimg2.gateimg.com/image/article/16909472135541690946563_.pic.jpg" alt=""></p>
<p>Onder de schaal bestaat de Orb uit twee halfronden gescheiden door een moederbord en krachtige rekenkundige eenheden voor maximale lokale verwerking. Daarvan is de eerste helft gewijd aan het afdichten van optische en en de tweede helft aan koelen en luidsprekers. De belangrijkste beeldvormingsen omvatten een telelens en 2D-gimbaalsysteem, een wereldwijde sluitercamerasensor en optische filters. Daarvan kan een beweegbare lens het gezichtsveld met &gt;2 ordes van grootte vergroten en meerdere neurale netwerken beheersen de beeldvastlegging. De aangepaste telelens gebruikt gecoat glas om beeldvastlegging in het nabij-infraroodspectrum te optimaliseren. De geïntegreerde vloeibare lens kan automatisch scherpstellen op milliseconde-niveau bereiken, aangestuurd door een neuraal netwerk om scherpstelling te optimaliseren. De sluiter sensor en pulsbelichting worden gesynchroniseerd om vervaging te voorkomen.</p>
<p>Over het algemeen kun je Orb begrijpen als een instrument voor het scannen van de iris. Na het scannen van de irisafbeelding van het menselijk oog, zet het Orb-apparaat de irisgegevens om in een unieke identificatiecode genaamd IrisHash, die lokaal wordt voltooid. Dit betekent dat de oorspronkelijke irisafbeelding niet wordt opgeslagen of geüpload. Deze unieke identificatiecode IrisHash is een korte numerieke code die wordt opgeslagen in een database om te controleren of een persoon al is geregistreerd.<br><img src="https://gimg2.gateimg.com/image/article/16909472395551690946579_.pic.jpg" alt=""></p>
<p>Dit betekent dat Worldcoin niet uw identiteit of persoonlijke informatie vereist, en Orb-scannen bevestigt alleen dat u de enige echte persoon bent, zonder te kijken naar wie u bent.</p>
<p>Het is een belangrijke ontwerpbeslissing, omdat Worldcoin ervoor kan zorgen dat iedereen zich slechts één keer kan registreren en tegelijkertijd de privacy van de gebruiker kan respecteren.</p>
<p>Biometrie heeft zich ontwikkeld, inclusief gezichtsherkenning, vingerafdrukherkenning, DNA-testen, etc., maar Worldcoin koos voornamelijk voor iris vanwege zijn uniciteit, fraudepreventie en prestaties. Iris is moeilijker te vervalsen dan gezicht en vingerafdruk, en gezien dat het nodig is om te airdroppen voor 1 miljard mensen, is de prestatie van iris meer voordelig, of het nu moeilijk is voor het vergelijken van gezichtsherkenning databases of DNA-testen.</p>
<p>Eén van de redenen waarom de cryptobranche nog niet de kern vormt van de mondiale virtuele economie is dat de cryptowereld geen kredietsysteem en arbitrage-instanties heeft en de daders meerdere identiteiten kunnen gebruiken om te bedriegen. Deze chaos heeft de ontwikkeling van cryptocurrency belemmerd. Daarom is het noodzakelijk om ervoor te zorgen dat iedereen unieke identiteitsbevestiging op de blockchain kan verkrijgen om ervoor te zorgen dat de cryptobranche kan uitgroeien tot een mondiale Web3-economie. Dit kan fraude en kwaadwillend gedrag verminderen, het vertrouwen vergroten en is ook de reden waarom DID vaak wordt aangeduid als een hoogwaardig traject met een breed marktperspectief.</p>
<p>WorldCoin gebruikt irisherkenning om het probleem van unieke echte identiteitsverificatie op te lossen. Door het opzetten van een betrouwbaar digitaal identiteitsverificatiesysteem kan het kwaadaardig gedrag verminderen, het vertrouwen verbeteren en de cryptomarkt meer inclusief en innovatief maken.</p>
<p>Bovendien streeft WorldCoin ook naar wereldwijde governance en digitale groepsbesluitvorming. Veel Web3-projecten hanteren een op tokens gebaseerd governance-model, waarbij elke token één stem heeft. Hoewel dit model in zekere mate decentralisatie en democratisering realiseert, kan het sommige individuen uitsluiten en degenen met meer economische macht bevoordelen. Om dit probleem aan te pakken, is een betrouwbaar mechanisme nodig dat bestand is tegen Sybil Attack en de implementatie van autonome governance-modellen op basis van unieke menselijke identiteiten vereenvoudigt.</p>
<p>Het Proof of Personality (PoP) -referentiesysteem van WorldCoin is essentieel. Door PoP te gebruiken, heeft WorldCoin het doel bereikt om mensen daadwerkelijk het protocol te laten besturen en ervoor te zorgen dat iedereen er baat bij heeft. Dit mechanisme benadrukt het principe van ‘één persoon, één stem’, waardoor iedereen op gelijke wijze kan deelnemen aan het besluitvormingsproces zonder te worden gestoord door dubbele identiteiten.</p>
<h2 id="h2-Token20Economie403003"><a name="Token Economie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Token Economie</h2><p>Volgens het officiële whitepaper van Worldcoin is de initiële aanbodlimiet van de Worldcoin governance-token WLD 10 miljard.</p>
<p>A. 75% van hen zal worden toegewezen aan de Worldcoin-gemeenschap, waarbij het merendeel van de tokens wordt toegewezen aan gebruikers en de overgebleven tokens worden toegewezen aan ecosysteemfondsen en netwerkactiviteiten;</p>
<p>B. 9,8% toegewezen aan het oorspronkelijke ontwikkelingsteam;</p>
<p>C. 13,5% wordt toegewezen aan investeerders van Tools for Humanity;</p>
<p>D. De overige 1,7% wordt gereserveerd voor Tools for Humanity.</p>
<p>De maximale circulatievoorraad bij de lancering van WLD is 143 miljoen. Daarvan zal 43 miljoen WLD worden toegewezen aan gebruikers die Orb-validatie hebben doorstaan in de pre-launch fase van het project, en 100 miljoen WLD zal worden uitgeleend aan marktmakers buiten de Verenigde Staten.<br><img src="https://gimg2.gateimg.com/image/article/16909473325561690946596_.pic.jpg" alt=""></p>
<h2 id="h2-Uniek20Operator20Model148700"><a name="Uniek Operator Model" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Uniek Operator Model</h2><p><img src="https://gimg2.gateimg.com/image/article/16909473595571690946607_.pic_hd.jpg" alt=""></p>
<p>De exploitanten van Worldcoin voeren voornamelijk de uitvoering van het project op wereldwijde schaal uit.</p>
<p>Worldcoin werft exploitanten van over de hele wereld, waarbij ze vereisen dat ze lokaal wettelijk geregistreerde ondernemingen zijn, en expliciet vermelden in de voorwaarden dat ze geen diensten zullen verlenen aan inwoners van andere juridisch beperkte landen zoals de Verenigde Staten, wat de strikte nalevingsvereisten van Worldcoin weerspiegelt. Immers, het verzamelen van biologische informatie van lokale bewoners is zeer gevoelig in elk land.</p>
<p>Nadat het bedrijf zich heeft aangemeld om een ​​operator te worden, zal het Worldcoin-team het beoordelings- en sollicitatieproces ingaan, inclusief KYC-authenticatie, nalevingstraining en exploitatieregio’s. Nadat ze een set Orb-apparatuur hebben verstrekt, kunnen ze aan de slag.</p>
<p>De operator is voornamelijk verantwoordelijk voor het voltooien van de wetenschappelijke popularisering en het scannen van werk voor lokale gebruikers. Telkens wanneer een operator succesvol helpt bij het voltooien van registratie voor een gebruiker, ontvangen ze een bepaalde hoeveelheid Worldcoin als beloning. Dit is een universeel stimuleringsmechanisme dat wordt gebruikt om operators aan te moedigen om meer mensen actief te helpen registreren.</p>
<p>De totale voorraad van Worldcoin is 10 miljard, waarvan het overgrote deel zal worden verstrekt aan gebruikers en operators. Om vroege bijdragers te motiveren, zal het aantal tokens dat gebruikers en operators ontvangen per registratie in de loop van de tijd afnemen.</p>
<h2 id="h2-Hoe20kunnen20gebruikers20deelnemen20aan20Worldcoin489221"><a name="Hoe kunnen gebruikers deelnemen aan Worldcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe kunnen gebruikers deelnemen aan Worldcoin?</h2><h3 id="h3-Download20de20World20App995779"><a name="Download de World App" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Download de World App</h3><p><img src="https://gimg2.gateimg.com/image/article/16909473995581690946622_.pic.jpg" alt=""></p>
<p>Ga naar de officiële website van Worldcoin（ <a href="https://worldcoin.org/download-app" rel="nofollow noopener noreferrer" target="_blank">https://worldcoin.org/download-app)</a>) Download en installeer de World App, een noodzakelijk tool voor deelname aan Worldcoin of World ID. Op dit moment is de toepassing compatibel met Android- en iPhone-apparaten.</p>
<h3 id="h3-Registreer20een20persoonlijke20account692847"><a name="Registreer een persoonlijke account" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Registreer een persoonlijke account</h3><p>Gebruikers kunnen zich registreren met een telefoonnummer.</p>
<p>Na succesvolle registratie kunnen gebruikers er ook voor kiezen om over te schakelen naar andere landen of regio’s.<br><img src="https://gimg2.gateimg.com/image/article/16909474355591690946655_.pic.jpg" alt=""></p>
<p>Na voltooiing van de registratie ziet u uw World ID weergegeven in het grijs, wat aangeeft dat het nog steeds moet worden gideerd. Dit betekent dat u de World App nog niet kunt gebruiken en eerst irisauthenticatie moet uitvoeren.</p>
<h3 id="h3-Voer20Iris20Authenticatie20uit315935"><a name="Voer Iris Authenticatie uit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Voer Iris Authenticatie uit</h3><p>Na succesvolle registratie moet de gebruiker de validatie voortzetten in de World App en een afspraak maken voor Orb iris-authenticatie. In de applicatie kunt u een nabijgelegen Worldcoin-operator vinden voor iris-authenticatie. In de applicatie kunt u nabijgelegen locaties zien voor selectie, maar let op dat u vooraf een afspraak moet maken.</p>
<p>Bij het maken van een afspraak hoeft u geen echte naam in te vullen, maar kunt u informatie verstrekken waarmee het personeel de identiteit van de persoon die de afspraak maakt kan bevestigen.</p>
<p>Het volledige irisauthenticatieproces verloopt zeer snel en is binnen 10 seconden voltooid. (Ondersteund door personeel ter plaatse)</p>
<p>Na het voltooien van de irisherkenning zal je World ID van grijs naar zwart veranderen en aangeven dat je klaar bent om de functies van de app te gebruiken.<br><img src="https://gimg2.gateimg.com/image/article/16909474855601690946668_.pic.jpg" alt=""></p>
<h3 id="h3-Achter20Authenticatie977241"><a name="Achter Authenticatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Achter Authenticatie</h3><p>De volgende grafiek illustreert de relevante processen en operaties achter World App, Worldcoin, World ID en Orb iris authenticatie.<br><img src="https://gimg2.gateimg.com/image/article/16909475065611690946681_.pic.jpg" alt=""></p>
<p>Ten eerste zal de applicatie na het downloaden van de World App willekeurig een genereren. <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">Geheim</a> sleutel.</p>
<p>Vervolgens moeten gebruikers operators vinden met Orb-authenticatiekwalificaties. Orb-authenticatie wordt uitgevoerd door echte medewerkers die gegevens lokaal verwerken en ondertekenen, en de gegevens met betrekking tot irisbeelden zullen worden vernietigd. De door Orb verwerkte gegevens worden na validatie geüpload.</p>
<h3 id="h3-Worldcoin20Authenticatie20Beloningen568806"><a name="Worldcoin Authenticatie Beloningen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Worldcoin Authenticatie Beloningen</h3><p>Volgens officiële informatie van Worldcoin ontvangen gebruikers die de Orb iris-scantechnologie voltooien 25 WLD-tokens (momenteel geprijsd op $2.46 per token) als hun eerste (en eenmalige) beloning. Daarna zullen gebruikers die zich registreren en authenticeren een beloning van 1 WLD per week ontvangen (die na verloop van tijd zal afnemen).</p>
<h2 id="h2-Waar20is20de20toekomst624368"><a name="Waar is de toekomst?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waar is de toekomst?</h2><p>Wat betreft het project zelf is Worldcoin ongetwijfeld een zeldzaam hardcore project in de branche. Zowel het eigen softwareontwerp als de technologische mogelijkheden in de hardwareapparaten geven het de mogelijkheid om de bestaande modi in zekere mate te veranderen.</p>
<p>Maar op dit moment is de grootste uitdaging waar het nog steeds voor staat, regulering.</p>
<p>*”Op 28 juli heeft de Franse privacyregulerende instantie volgens Reuters verklaard dat zij een onderzoek heeft ingesteld naar Worldcoin en ondersteuning biedt aan de relevante afdelingen in Beieren om Worldcoin te onderzoeken. Zij is van mening dat er sprake lijkt te zijn van problemen met de wettigheid van de biometrische gegevensverzameling en -opslag van Worldcoin.</p>
<p>Op 31 juli verklaarde Michael Will, de voorzitter van de Duitse gegevensreguleringsinstantie, volgens Reuters, dat vanwege de betrokkenheid van grootschalige gevoelige biometrische gegevens, de Duitse gegevensreguleringsinstantie sinds het einde van vorig jaar het Worldcoin-project onderzoekt. De nieuwe technologie die door Worldcoin is aangenomen, brengt veel risico’s met zich mee, waaronder de vraag of gebruikers expliciet instemmen met de verwerking van hun zeer gevoelige biometrische gegevens op basis van ‘voldoende en duidelijke’ informatie.</p>
<p>Het kan worden ingebeeld dat de ‘strijd’ tussen Worldcoin en regelgevende instanties over de hele wereld misschien nog maar net is begonnen, en dit is eigenlijk een microkosmos van de langdurige strijd tussen technologie en ethiek (Ik geloof dat Sam Aitman, als de maker van Chat GPT, hier niet onbekend mee is). Daarom kan het balanceren van technologische ontwikkeling en regelgeving in de toekomst de grootste uitdaging zijn voor Worldcoin.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Leo F.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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 schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>