Vml0YWxpayBCdXRlcmluIHNvc3RpZW5lIGxhIGNvbGxlemlvbmUgZGkgTkZULCBhdW1lbnRhIGlsIHZhbG9yZSBzdSBPcGVuU2Vh

2023-03-21, 08:02

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""><br>Vitalik Buterin ha approvato la creazione e la vendita delle collezioni NFT quadratiche.</p>
<p>La collezione NFT supportata da Vitalik Buterin è composta da 9.909 NFT standard e 12 NFT in edizione limitata.</p>
<p>Il modello di finanziamento quadratico mira a contribuire ai fondi per i progetti <a href="/web3" target="_blank" class="blog_inner_link">web3</a> che hanno attirato molti investitori.</p>
<p>Metalabel e <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a> sono i creatori della collezione di NFT Quadratici.</p>
<p>Parole chiave: NFT quadratici, NFT di Vitalik Buterin, modello di finanziamento quadratico, <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a>, Istituto della Pluralità, Liberal Radicalism, Metalabel, progetti web3</p>
<h2 id="h2-Introduzione529506"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Ci sono molti fattori che determinano come gli asset digitali come le criptovalute o i token non fungibili si comportano sul mercato. Ad esempio, un forte supporto della comunità può portare all’aumento del momentum del prezzo di una criptovaluta. D’altra parte, i token non fungibili supportati da personalità influenti raccolgono molti soldi sul mercato. Questo post discute le performance dei Quadratic NFT su <a href="https://www.gate.io/blog_detail/515/the-best-nft-marketplace-for-2022" target="_blank">il mercato di OpenSea</a>.</p>
<h2 id="h2-Collezione20di20NFT20quadratici419162"><a name="Collezione di NFT quadratici" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Collezione di NFT quadratici</h2><p>La collezione Quadratic NFT, creata da MetaLabel in collaborazione con <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a> è inteso come un omaggio a Vitalik Buterin, il co-fondatore di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain per il suo contributo al modello di finanziamento Web3, il modello di finanziamento quadratico. Con il modello di finanziamento quadratico, uno sponsor del progetto inietta una quantità uguale di fondi in un’attività web3 come gli investitori.</p>
<p><strong>Leggi anche: <a href="https://www.gate.io/blog_detail/2265/web3-gaming-sees-a-solid-start-to-2023" target="_blank">Web3 Gaming vede un solido inizio del 2023</a> </strong></p>
<p>Questo modello di finanziamento, quindi, inietta fondi aggiuntivi in un progetto basato su blockchain che ha molti contributori finanziari indipendenti. Questo aumenta la decentralizzazione e la pluralità nel finanziamento e nella governance dei progetti web3.<br><img src="https://gimg2.gateimg.com/image/article/1679385587q.png" alt=""><br>Registro di finanziamento quadratico - NFTlately</p>
<p>Il principio sottostante, in questo caso, è che le balene non influenzano la quantità di fondi che lo sponsor inietta in un progetto. Questo perché la donazione si basa sul numero di investitori che il progetto ha attratto. Pertanto, con questo modello, più persone hanno la possibilità di sostenere e beneficiare dei progetti web3.</p>
<p><a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a>, un progetto che finanzia strumenti web3 open-source, utilizza questo modello di finanziamento per sostenere i progetti decentralizzati. Al momento, <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a> ha fornito oltre 70 milioni di dollari a diversi progetti web3 basati sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain.</p>
<p><strong>Leggi anche: <a href="https://www.gate.io/blog_detail/2264/how-to-bridge-the-gap-between-web3-and-tradfi" target="_blank">Come colmare il divario tra Web3 e TradFi</a> </strong></p>
<h2 id="h2-Cosa20sono20i20record20di20finanziamento20quadratico808792"><a name="Cosa sono i record di finanziamento quadratico?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa sono i record di finanziamento quadratico?</h2><p>I registri del Finanziamento Quadratico, noti anche come un record o “Buterin NFT”, sono NFT che incorporano un whitepaper che parla del modello di Finanziamento Quadratico, creato da Vitalik Buterin e i suoi partner. Questo whitepaper chiamato “Liberal Radicalism” ha le firme di Buterin e dei suoi co-creatori, ovvero Glen E. Weyl e Zoë Hitzig. Infatti, spiega il concetto matematico del modello di finanziamento quadratico. Include anche una poesia intitolata “Ode al QF”.</p>
<p>La collezione NFT è composta da 9.209 NFT standard e 12 NFT in edizione limitata che accompagnano il whitepaper con le firme di Vitalik Buterin, Glen E. Weyl e Zoë Hitzig. Inoltre, questa collezione comprende anche due saggi sul modello di finanziamento quadratico, scritti da Kevin Owocki e Scott Moore. <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a> i co-fondatori di Gate.io.</p>
<h3 id="h3-Gitcoin2020e20MetaLabel306238"><a name="Gitcoin  e 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> e MetaLabel</h3><p>Abbiamo già menzionato <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a> e Metalabel come creatori dei Quadratic NFT. Metalabel, creato da Yancey Strickler (co-fondatore di Kickstarter), Rob Kalin (fondatore di Etsy) e molti altri pionieri di Web2, è un’organizzazione che aiuta i creatori a monetizzare il proprio lavoro utilizzando la tecnologia decentralizzata.</p>
<p>Il suo obiettivo è consentire ai creatori di contenuti di collaborare e produrre collezioni di gruppo come newsletter e pubblicazioni musicali.</p>
<h3 id="h3-Rilascio20di20NFT20quadrati368742"><a name="Rilascio di NFT quadrati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rilascio di NFT quadrati</h3><p>Gli NFT Quadratici sono già sul mercato, essendo stati rilasciati tra l’1 e l’8 marzo 2023. In totale sono stati coniati 9.209 NFT standard, che sono la prima edizione della serie “Quality Drops” di Metalabel. Fin dall’inizio, Buterin è stato coinvolto dopo aver apposto la sua firma sul whitepaper.</p>
<p>Oltre a questi NFT standard, ci sono 12 NFT edizione “Signature” che sono stati venduti tramite un’asta olandese con un prezzo di offerta iniziale di 10ETH. Nel complesso, questa collezione di finanziamento quadratica ha generato 390 ETH.</p>
<p>I proventi di questo NFT drop saranno distribuiti a tre progetti, ovvero <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a>, che ottiene il 70% delle vendite totali, l’Istituto Plurality (un’associazione di creatori e ricercatori coinvolti in progetti web3) che ottiene il 20% e Metalabel che riceverà il 10%. Metalabel ha riferito che sono stati raccolti $781.000 per progetti web3 pubblici.</p>
<p><strong>Leggi anche: <a href="https://www.gate.io/blog_detail/2286" target="_blank">NFT timeline: Una breve storia delle NFT e dove siamo ora</a></strong></p>
<p>In risposta alla vendita, Strickler ha detto: “Siamo rimasti sbalorditi dalla risposta a Quality Drop 01 e da ciò che significa per il futuro della collaborazione creativa. Contribuire a generare più di 700.000 dollari di finanziamento per beni pubblici e una nuova consapevolezza del grande lavoro creativo utilizzando il formato dei record significa che questa è una nuova ed entusiasmante modalità per i creatori di pubblicare e finanziare il loro lavoro.”</p>
<h3 id="h3-Vitalik20Buterin20e20NFT920687"><a name="Vitalik Buterin e NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vitalik Buterin e NFT</h3><p>Sebbene i Quadratic NFT siano il primo progetto in cui Buterin è stato coinvolto, ha contribuito molto allo sviluppo della tecnologia NFT. Come sappiamo, Buterin ha sviluppato il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain e lo ha lanciato nel 2015 con l’obiettivo di espandere la tecnologia blockchain. Interessantemente, la maggior parte dei progetti NFT si basano sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain.</p>
<p><strong>Leggi anche: <a href="https://www.gate.io/ru/blog_detail/493/the-large-and-underexplored-design-space-of-nfts?lang=en" target="_blank">Lo ‘spazio di progettazione non esplorato’ di Vitalik: NFT non trasferibili</a></strong><img src="https://gimg2.gateimg.com/image/article/16793856602.png" alt=""><br>Vitalik Buterin - NFTcalender</p>
<p>Ma Buterin insieme a Yoni Assia, Lior Hakim, Meni Rosenfeld e Rotem Lev sono stati i primi individui attivi a concentrarsi sulla tecnologia NFT fin dalla creazione del whitepaper per le monete colorate, precursori degli NFT. È importante notare che la maggior parte delle prime collezioni NFT come Wrapped <a href="https://www.gate.io/blog_detail/189/the-1st-blockchain-game-cryptokitties" target="_blank">CryptoKitties</a> e i CryptoPunks esistono sulla <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain.</p>
<h2 id="h2-Conclusion51671"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Vitalik Buterin ha approvato la creazione e la vendita delle Quadratic NFT create per commemorare il suo contributo al modello di Finanziamento Quadratico. L’edizione delle 9.909 NFT standard e delle 12 NFT Limited Edition è stata lanciata il 1° marzo ed è stata un grande successo, poiché ha raccolto milioni di dollari. Il ricavato generato verrà distribuito tra <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a>, Metalabel e l’Istituto Plurality.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>