R2F0ZS5pbyBBTUEgY29uIENsb3V0LmFydC1DcmVhemlvbmUgZGkgdW4gZWNvc2lzdGVtYSBzb3N0ZW5pYmlsZSwgdHJhc3BhcmVudGUgZSBpbGxpbWl0YXRv

<p><img src="https://gimg2.gateimg.com/image/article/16886390911.jpeg" alt=""><br><strong>Ora: 22 novembre 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Jure Zih, Fondatore di Clout.art nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito web ufficiale: <a href="https://clout.art/" rel="nofollow noopener noreferrer" target="_blank">https://clout.art/</a></strong><br><strong>Twitter: <a href="https://twitter.com/cloutdotart" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/cloutdotart</a></strong><br><strong>Segui Clout.art su <a href="https://twitter.com/cloutdotart" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://discord.com/invite/hW6pX4USpT" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16886392212.jpeg" alt=""><br><strong>Jure Zih - Fondatore di Clout.art</strong></p>
<h2 id="h2-QampA20da20Gateio883231"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Puoi20per20favore20presentarti20e20raccontarci20di20Cloutart760597"><a name="Q1: Puoi per favore presentarti e raccontarci di Clout.art?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi per favore presentarti e raccontarci di Clout.art?</h3><p><strong>Jure</strong>: Certamente! Il mio nome è Jure, e sono il fondatore di Clout art. Sono nel settore degli NFT dal 2018, ho lanciato il primo protocollo per gli NFT e il primo framework di sviluppo per ERC-721 con la precedente azienda - abbiamo effettivamente contribuito a finalizzare lo standard.</p>
<p>Avanti veloce di 3 anni, gli NFT hanno preso il volo e ho visto una grande opportunità nel monetizzare i contenuti giusti sui social media. L’idea era semplice: prendere i contenuti che già esistono e trovare un modo per monetizzarli con l’aiuto degli NFT.</p>
<h3 id="h3-Q220Ottimo20grazie20per20lintroduzione20Ora20puoi20dirci20cosa2020SWAY20e20come20funziona20con20Cloutart20Stiamo20avendo20alcuni20problemi20tecnici20Jure20potresti20per20favore20digitare20nuovamente20la20risposta917590"><a name="Q2: Ottimo, grazie per l’introduzione. Ora puoi dirci cosa è SWAY e come funziona con Clout.art? Stiamo avendo alcuni problemi tecnici, Jure potresti per favore digitare nuovamente la risposta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Ottimo, grazie per l’introduzione. Ora puoi dirci cosa è SWAY e come funziona con Clout.art? Stiamo avendo alcuni problemi tecnici, Jure potresti per favore digitare nuovamente la risposta?</h3><p><strong>Jure</strong>: SWAY è il token nativo del protocollo Sway Social. Si tratta di un protocollo di social media decentralizzato di proprietà dei creatori che utilizza gli NFT per tradurre il capitale sociale in una classe di asset.</p>
<p>Clout art è effettivamente la prima piattaforma interna ad utilizzare SWAY ed uno studio di caso su ciò che stiamo cercando di costruire. Ma come parte del Clout art, SWAY avrà funzionalità relative ai creatori di Clout art. In poche parole: 1. I creatori di contenuti istituiscono pool individuali per i loro NFT. 2. Gli utenti puntano gettoni SWAY ai pool (creatori di contenuti) che desiderano sostenere. 3. I gettoni SWAY scommessi condividono il ricavato generato dai loro pool specifici.</p>
<p>Stiamo rilasciando materiali quotidianamente su Sway e creator pools, una buona lettura che spiega come tutto si unisce è disponibile sul nostro Medium (cerca il titolo “Staking is the new following”)</p>
<h3 id="h3-Q320Potresti20dirci20quale20problema20stai20risolvendo20con20Cloutart754913"><a name="Q3: Potresti dirci quale problema stai risolvendo con Clout.art?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Potresti dirci quale problema stai risolvendo con Clout.art?</h3><p><strong>Jure</strong>: Con Clout art, stiamo affrontando il problema della monetizzazione dei contenuti. Essere un influencer significa che probabilmente stai cercando tutte le diverse modalità per ottenere entrate e perché non vendere alcuni dei tuoi momenti sotto forma di post? Ti basta meno di 1 minuto per creare e NFT ed è gratuito!</p>
<p>Ogni giorno vengono creati oltre 160 milioni di nuovi post sui social media, miliardi se non quadrilioni di post dell’anno scorso, dell’anno prima… stanno lì, senza fare nulla. Nonostante ciò, ogni post ha un valore sentimentale per il creatore ed è prezioso per la comunità. La comunità decide quanto è prezioso dando like e commenti. Ora puoi venderlo!</p>
<p>Con Sway Social e $SWAY, stiamo affrontando un problema leggermente diverso. Si tratta di come espandere il modello economico di un singolo creatore alla sua comunità. Crediamo in <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> e nei DAO e pensiamo che il futuro sia nel trasferimento di valore tramite protocolli come questi.</p>
<p>In altre parole, quando guadagni come creatore, perché non far guadagnare anche i tuoi seguaci? Dopotutto, sono stati loro a sostenerti di più!</p>
<h3 id="h3-Q420Molto20cool20Ci20sono20artisti20di20fama20e20creatori20ben20noti20che20si20uniscono123727"><a name="Q4: Molto cool! Ci sono artisti di fama e creatori ben noti che si uniscono?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Molto cool! Ci sono artisti di fama e creatori ben noti che si uniscono?</h3><p><strong>Jure</strong>: Sì! Abbiamo appena avuto Sean Kingston (musicista; Beautiful Girls, Eenie Meenie) vendere un NFT sulla piattaforma. Ma ne arriveranno altri e abbiamo anche alcune offerte incredibili in arrivo… vale la pena rimanere in attesa!</p>
<h3 id="h3-Q520Fantastico20quali20sono20i20tuoi20piani20per20il20futuro479252"><a name="Q5: Fantastico, quali sono i tuoi piani per il futuro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Fantastico, quali sono i tuoi piani per il futuro?</h3><p><strong>Jure</strong>: Molte cose, ma a cui siamo ossessionati è la corrente dominante. Vogliamo rendere questa esperienza una cosa di massa, in cui gli utenti possano farlo tutto da mobile, senza doversi preoccupare di Metamask e delle chiavi private e possano acquistare facilmente con le loro carte di credito… ma allo stesso tempo avere ancora un’infrastruttura NFT sul retro.</p>
<p>Inoltre, abbiamo un aggiornamento dell’infrastruttura molto importante in arrivo molto presto… e ci assicureremo che gli utenti di Gate ne vengano a conoscenza per primi.</p>
<div class="blog-details-info"><br><div>Autore: Rio Fu., Comunità 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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>