Vml0YWxpayBCdXRlcmluIEVuZG9yc2VzIE5GVC1jb2xsZWN0aWUsIFBvbXB0IFdhYXJkZSBvcCBPcGVuU2Vh

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""><br>Vitalik Buterin heeft de creatie en verkoop van Quadratic-collectie NFT’s goedgekeurd.</p>
<p>De door Vitalik Buterin gesteunde NFT-collectible bestaat uit 9.909 standaard NFT’s en 12 Limited Edition NFT’s.</p>
<p>Het Quadratic Funding-model heeft als doel fondsen bij te dragen aan web3-projecten die veel investeerders hebben aangetrokken.</p>
<p>Metalabel en <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a> zijn de makers van de Quadratic-collectie NFT’s.</p>
<p>Trefwoorden: Quadratische NFT’s, Vitalik Buterin NFT’s, Quadratisch financieringsmodel, <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a>, Plurality Institute, Liberal Radicalism, Metalabel, web3-projecten</p>
<h2 id="h2-Inleiding681348"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Er zijn veel factoren die bepalen hoe digitale activa zoals cryptocurrencies of niet-vervangbare tokens het doen op de markt. Bijvoorbeeld, een sterke gemeenschapsondersteuning kan leiden tot een toename van de prijsmomentum van een cryptocurrency. Aan de andere kant halen niet-vervangbare tokens gesteund door invloedrijke persoonlijkheden veel geld op de markt. In deze post wordt de prestaties van Quadratic NFT’s besproken op <a href="https://www.gate.io/blog_detail/515/the-best-nft-marketplace-for-2022" target="_blank">de OpenSea markt</a>.</p>
<h2 id="h2-Quadratische20NFTcollectie228697"><a name="Quadratische NFT-collectie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quadratische NFT-collectie</h2><p>De Quadratic NFT-collectie, gemaakt door MetaLabel in samenwerking met <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a>, is bedoeld om Vitalik Buterin, de medeoprichter van de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain voor zijn bijdrage aan het <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> financieringsmodel, het Kwadratische Financieringsmodel. Met het Kwadratische Financieringsmodel injecteert een project sponsor een gelijk bedrag aan fondsen in een web3 bedrijf als de investeerders.</p>
<p><strong>Lees ook: <a href="https://www.gate.io/blog_detail/2265/web3-gaming-sees-a-solid-start-to-2023" target="_blank">Web3 Gaming kent een solide start van 2023</a> </strong></p>
<p>Dit financieringsmodel injecteert daarom extra middelen in een blockchain-gebaseerd project met veel onafhankelijke financiële bijdragers. Dit vergroot decentralisatie en pluraliteit in de financiering en governance van web3-projecten.<br><img src="https://gimg2.gateimg.com/image/article/1679385587q.png" alt=""><br>Quadratische Financieringsrecord - NFTlately</p>
<p>Het onderliggende principe in dit g is dat walvissen de hoeveelheid geld die de sponsor in een project steekt niet beïnvloeden. Dit komt doordat de donatie gebaseerd is op het aantal investeerders dat het project heeft aangetrokken. Op die manier krijgen meer mensen de kans om web3-projecten te ondersteunen en ervan te profiteren.</p>
<p><a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a>, een project dat open-source web3-tools financiert, gebruikt dit financieringsmodel om gedecentraliseerde projecten te ondersteunen. Tot nu toe, <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a> heeft meer dan $70 miljoen verstrekt aan verschillende web3-projecten op basis van de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain.</p>
<p><strong>Lees ook: <a href="https://www.gate.io/blog_detail/2264/how-to-bridge-the-gap-between-web3-and-tradfi" target="_blank">Hoe de kloof tussen Web3 en TradFi te overbruggen</a> </strong></p>
<h2 id="h2-Wat20zijn20Quadratic20Fundingrecords387942"><a name="Wat zijn Quadratic Funding-records?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn Quadratic Funding-records?</h2><p>De Quadratic Funding-records, ook wel een record of ‘Buterin NFT’ genoemd, zijn NFT’s die een whitepaper bevatten die gaat over het Quadratic Funding-model, gemaakt door Vitalik Buterin en zijn partners. Deze whitepaper genaamd ‘Liberal Radicalism’ bevat handtekeningen van Buterin en zijn mede-oprichters, namelijk Glen E. Weyl en Zoë Hitzig. In feite legt het de wiskundige concepten van het Quadratic Funding-model uit. Het bevat ook een gedicht getiteld ‘Ode aan QF’.</p>
<p>De NFT-collectie bestaat uit 9.209 standaard NFT’s en 12 limited edition NFT’s die bij de whitepaper horen, die de handtekeningen van Vitalik Buterin, Glen E. Weyl en Zoë Hitzig bevat. Daarnaast bestaat deze collectie ook uit twee essays over het Quadratic Funding-model, geschreven door Kevin Owocki en Scott Moore. <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a> oprichters van ‘s werelds</p>
<h3 id="h3-Gitcoin2020en20MetaLabel741224"><a name="Gitcoin  en MetaLabel" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a> en MetaLabel</h3><p>We hebben het al genoemd <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a> en Metalabel als de makers van de Quadratic NFT’s. Metalabel, opgericht door Yancey Strickler (mede-oprichter van Kickstarter), Rob Kalin (oprichter van Etsy) en vele andere Web2-pioniers, is een organisatie die makers helpt hun werk te monetiseren met behulp van gedecentraliseerde technologie.</p>
<p>Het richt zich erop om content makers in staat te stellen samen te werken en groepscollecties te produceren, zoals nieuwsbrieven en muziekuitgaven.</p>
<h3 id="h3-Quadratische20NFTrelease534681"><a name="Quadratische NFT-release" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quadratische NFT-release</h3><p>De kwadratische NFT’s zijn al op de markt, uitgebracht tussen 1 en 8 maart 2023. In totaal zijn er 9.209 standaard NFT’s, de eerste editie van de serie “Quality Drops” van Metalabel, geslagen. Vanaf het begin is Buterin betrokken geweest, aangezien hij zijn handtekening heeft toegevoegd aan het whitepaper.</p>
<p>Afgezien van deze standaard NFT’s, zijn er 12 “Signature” editie NFT’s die zijn verkocht via een Nederlands veilingformaat met een startbiedprijs van 10ETH. In totaal genereerde deze kwadratische financieringscollectie 390 ETH.</p>
<p>De opbrengsten van deze NFT-uitgave zullen worden verdeeld over drie projecten, te weten <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a>, die 70% van de totale verkoop ontvangt, het Plurality Institute (een vereniging van makers en onderzoekers die betrokken zijn bij web3-projecten) dat 20% krijgt en Metalabel dat 10% zal ontvangen. Metalabel meldde dat er $781.000 is opgehaald voor openbare web3-projecten.</p>
<p><strong>Lees ook: <a href="https://www.gate.io/blog_detail/2286" target="_blank">NFT-tijdlijn: Een beknopte geschiedenis van NFT’s en waar we nu staan</a></strong></p>
<p>Als reactie op de verkoop zei Strickler: “We zijn weggeblazen door de reactie op Quality Drop 01 en wat het betekent voor de toekomst van creatieve samenwerking. Het helpen genereren van meer dan $700.000 aan financiering voor algemeen nut en een hernieuwde waardering voor geweldig creatief werk met behulp van het opnameformaat zegt dat dit een spannende nieuwe manier is voor makers om hun werk uit te brengen en te financieren.”</p>
<h3 id="h3-Vitalik20Buterin20en20NFTs284374"><a name="Vitalik Buterin en NFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vitalik Buterin en NFT’s</h3><p>Hoewel de Quadratic NFT’s het eerste project is waarbij Buterin betrokken is geweest, heeft hij veel bijgedragen aan de ontwikkeling van de NFT-technologie. Zoals we weten, heeft Buterin de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain en lanceerde het in 2015 met als doel de blockchaintechnologie uit te breiden. Interessant is dat de meeste NFT-projecten gebaseerd zijn op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain.</p>
<p><strong>Lees ook: <a href="https://www.gate.io/ru/blog_detail/493/the-large-and-underexplored-design-space-of-nfts?lang=en" target="_blank">De ‘Onderbenutte Ontwerpruimte’ van Vitalik: niet-overdraagbare NFT</a></strong><img src="https://gimg2.gateimg.com/image/article/16793856602.png" alt=""><br>Vitalik Buterin - NFT-kalender</p>
<p>Buterin samen met Yoni Assia, Lior Hakim, Meni Rosenfeld en Rotem Lev waren de eerste actieve individuen die zich richtten op de NFT-technologie sinds ze het whitepaper voor de Colored coins hebben gemaakt, de voorlopers van NFT’s. Opmerkelijk is dat de meeste eerste NFT-collecties zoals Wrapped <a href="https://www.gate.io/blog_detail/189/the-1st-blockchain-game-cryptokitties" target="_blank">CryptoKitties</a> en CryptoPunks bestaan op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain.</p>
<h2 id="h2-Conclusie889897"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Vitalik Buterin heeft de oprichting en verkoop van de Quadratic NFT’s goedgekeurd, die zijn gemaakt om zijn bijdrage aan het Quadratic Funding-model te herdenken. De editie van de 9.909 standaard en 12 Limited Edition NFT’s werd gelanceerd op 1 maart en was een groot succes, omdat het miljoenen dollars heeft opgehaald. De gegenereerde inkomsten zullen worden verdeeld onder <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a>, Metalabel en het Plurality Institute.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Onderzoeker bij Gate.io<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 is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>