Z2F0ZUxpdmUgQU1BIFJlY2FwLVBvcCBTb2NpYWw=

2023-10-27, 07:15

<p><img src="https://gimg2.gateimg.com/image/article/1698389136Blog.jpg" alt=""></p>
<h2 id="h2-Puoi20fornire20una20breve20panoramica20di20PopSocial20e20il20suo20obiettivo20principale828690"><a name="Puoi fornire una breve panoramica di PopSocial e il suo obiettivo principale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Puoi fornire una breve panoramica di PopSocial e il suo obiettivo principale?</h2><p><strong>Michael Shen (CEO di Pop Social):</strong><br>Pop Social è il tuo gateway sociale alimentato da intelligenza artificiale per Web3. La piattaforma svolgerà un ruolo fondamentale nel futuro della creatività, dando potere sia ai creatori che agli utenti sulla sua piattaforma, premiandoli con Pop Tokens per l’interazione attiva con l’app. Pop ridefinirà il modo in cui interagiamo l’uno con l’altro, portando un nuovo approccio ai social media e elevando la spinta globale verso la decentralizzazione sociale.</p>
<p>Attraverso la democratizzazione della proprietà dei contenuti e l’alimentazione dell’economia dei creatori di intelligenza artificiale, Pop colmerà il divario tra i social media tradizionali e l’esperienza sociale condivisa di <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> per portare il prossimo miliardo di utenti su Web3. Costruiamo l’infrastruttura della piattaforma sociale per accelerare il ritmo di astrazione di Web3 e l’adozione di massa.</p>
<p>Pop crea un’identità sociale unificata SBT per gli utenti attraverso le sue Identità Sociali Agnostiche alla Catena, unendo identità centralizzate frammentate dalle piattaforme tradizionali e dai protocolli tecnici Web3 per unire comunità globali decentralizzate.</p>
<h2 id="h2-Quali20sono20alcune20delle20caratteristiche20principali20e20delle20funzionalit20della20piattaforma20PopSocial53459"><a name="Quali sono alcune delle caratteristiche principali e delle funzionalità della piattaforma PopSocial?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono alcune delle caratteristiche principali e delle funzionalità della piattaforma PopSocial?</h2><p><strong>Michael Shen (CEO di Pop Social):</strong><br>Su Pop Social, puoi esplorare contenuti, guardare, mettere mi piace, commentare, condividere e interagire con video, immagini, articoli e altro ancora. Tutte le forme di coinvolgimento verranno premiate, in modo che ogni utente su Pop DApp possa ottenere valore ogni giorno in cambio del tempo trascorso su Pop. Nel frattempo, i creatori possono beneficiare di tutto questo e altro ancora creando e pubblicando contenuti unici su Pop DApp.</p>
<p>Pop in seguito rilascerà funzioni speciali ispirate alla tecnologia dell’IA per incoraggiare gli utenti a pubblicare contenuti divertenti, pertinenti e coinvolgenti per ottenere vantaggi da creator. Pop permetterà anche agli utenti di ospitare uno spazio privato sulla piattaforma per la comunicazione diretta tra creator e i loro follower. Pop Spaces creerà uno spazio condiviso e paritario per favorire l’innovazione, le collaborazioni e le discussioni. Nelle prossime settimane saranno introdotte ulteriori funzionalità nell’app Pop.</p>
<h2 id="h2-Cos20Pop20Token20Quali20sono20i20casi20duso20per20PPT128495"><a name="Cos’è Pop Token? Quali sono i casi d’uso per $PPT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Pop Token? Quali sono i casi d’uso per $PPT?</h2><p><strong>Michael Shen (CEO di Pop Social):</strong><br>Il Pop Token (PPT) è il nostro principale token on-chain, progettato per premiare utenti, creatori e inserzionisti. Fa parte della nostra visione di un modello di token SocialFi sostenibile che rafforza il legame tra utenti e creatori. PPT crea un loop di feedback positivo, stimolando l’adozione da parte degli utenti e l’interazione dei creatori. Supporta anche un sistema di governance in cui i creatori possono ricevere supporto dalla propria comunità.</p>
<p>Il principale obiettivo di PPT è quello di incrementare l’adozione da parte degli utenti e offrire ai creatori ricompense più dinamiche rispetto ai social media tradizionali. In breve, PPT è il motore del sistema Pop, a vantaggio degli utenti, dei creatori e degli inserzionisti. Con PPT, puoi fare varie cose sulla nostra piattaforma, come acquistare e creare NFT, sbloccare funzionalità speciali, supportare i creatori e accedere a contenuti premium.</p>
<p>Puoi guadagnare PPT interagendo con la piattaforma quotidianamente. Il tuo punteggio di coinvolgimento, determinato da Pop Credit (PCR), riflette il tuo contributo all’ecosistema. Questi crediti provengono da attività come consumare e condividere contenuti, invitare altre persone, creare contenuti e partecipare alla comunità.</p>
<h2 id="h2-Potresti20approfondire20gli20aspetti20di20interoperabilit20di20Pop20Come20connette20catene20protocolli20e20sviluppatori20diversi20per20creare20un20ecosistema20inclusivo20e20vibrante408653"><a name="Potresti approfondire gli aspetti di interoperabilità di Pop? Come connette catene, protocolli e sviluppatori diversi per creare un ecosistema inclusivo e vibrante?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Potresti approfondire gli aspetti di interoperabilità di Pop? Come connette catene, protocolli e sviluppatori diversi per creare un ecosistema inclusivo e vibrante?</h2><p><strong>Michael Shen (CEO di Pop Social):</strong><br>Pop Social si impegna a raggiungere l’interoperabilità collegando diverse catene blockchain, protocolli e sviluppatori. Questa interoperabilità è cruciale per creare un’esperienza fluida e inclusiva per gli utenti. Pop è progettato per supportare più blockchain, consentendo agli utenti di interagire con la piattaforma utilizzando la loro blockchain preferita, come BSC, POLYGON,OPBNB.</p>
<p>Attraverso contratti intelligenti e soluzioni cross-chain, Pop Social punta a colmare il divario tra diversi ecosistemi blockchain, consentendo agli utenti di trasferire asset, inclusi token e NFT, tra varie catene. Inoltre, abbiamo intenzione di collaborare con sviluppatori e progetti nello spazio blockchain per lanciare il nostro PNS, che può essere personalizzato con diverse piattaforme e ampliare l’interoperabilità e migliorare l’esperienza complessiva dell’utente.</p>
<h2 id="h2-Potresti20fornire20alcune20informazioni20sulla20tua20Roadmap20e20su20come20sta20progredendo20POP20finora20Qual2020il20tuo20piano20futuro364145"><a name="Potresti fornire alcune informazioni sulla tua Roadmap e su come sta progredendo POP finora? Qual è il tuo piano futuro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Potresti fornire alcune informazioni sulla tua Roadmap e su come sta progredendo POP finora? Qual è il tuo piano futuro?</h2><p><strong>Michael Shen (CEO di Pop Social):</strong><br>Attualmente, abbiamo un’app beta funzionale con un totale di oltre 400.000 download, vari portafogli NFT e una vasta rete di KOL. Attualmente stiamo testando i meccanismi di guadagno degli utenti e stiamo stress-testando il nostro prodotto per il lancio in Mainnet. Durante gli ultimi mesi, abbiamo visto una crescita enorme all’interno dell’Ecosistema Pop e, anche se il progetto è ancora in testnet, le nostre metriche degli utenti ora ci posizionano equivalenti alla classifica dei primi 3 progetti nella <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Categoria SocialFi. Ora abbiamo più di 500.000 membri dei social media e della comunità combinati e stiamo crescendo rapidamente.</p>
<p>Abbiamo circa 390.000+ utenti totali 50.000+ utenti attivi giornalieri. Nei prossimi mesi, POP accoglierà più utenti da SEA, LATAM e dal resto del mondo. Inoltre, per accogliere più creatori di contenuti, lancio del creatore e incubatore, partnership di marchi, eventi token gated, premi e airdrop, ecc.</p>
<p>In questo momento, il team di Pop Social è entusiasta di entrare nella fase di PPT IDO e di essere quotato su piattaforme di lancio e scambi. Questo è un grande traguardo verso cui il nostro progetto si sta dirigendo dopo aver completato due round di vendita di token PPT di successo. In dettaglio, la vendita della comunità del primo round ha venduto 1.920.000 PPT e ha raccolto $360.960 in meno di 24 ore. Allo stesso modo, la vendita della comunità del secondo round ha venduto 2.000.000 di PPT e ha raccolto $400.000 in poco più di 24 ore.</p>
<div class="blog-details-info"><br><div>Autore: <strong>GateLive</strong>, Team 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 ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>