R2F0ZS5pbyBBTUEgY29uIFJlcHVibGlrIC0gVW5hIHJpdm9sdXppb25lIHBlciBwb3J0YXJlIHByb3ByaWV0w6AgZSBkaXJpdHRpIGRpIHZvdG8gYWxsYSBjb211bml0w6AgY2hlIGNyZWk=

<p><img src="https://gimg2.gateimg.com/image/article/17035014241.jpeg" alt=""><br><strong>Ora: 21 dicembre 2023 alle 11:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione di AMA (Ask-Me-Anything) con Richmond Teo, Lead Advisor di Republik nel <a href="https://twitter.com/i/spaces/1lDxLPEEBWLxm" rel="nofollow noopener noreferrer" target="_blank">Twitter Space</a>.</strong><br><strong>Sito Ufficiale: <a href="https://republik.gg/" rel="nofollow noopener noreferrer" target="_blank">https://republik.gg/</a></strong><br><strong>Twitter: <a href="https://twitter.com/RepubliK_GG" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/RepubliK_GG</a></strong><br><strong>Segui Republik su <a href="https://twitter.com/RepubliK_GG" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/officialrepublik" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/17035018612.jpeg" alt=""><br><strong>Richmond Teo - Consulente principale di Republik</strong></p>
<h2 id="h2-QampA20da20Gateio907826"><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-D120Potrebbe20presentare20RepubliK20come20piattaforma20Qual2020la20storia20dellazienda353190"><a name="D1: Potrebbe presentare RepubliK come piattaforma? Qual è la storia dell’azienda?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>D1: Potrebbe presentare RepubliK come piattaforma? Qual è la storia dell’azienda?</h3><p><strong>Richmond</strong>: RepubliK è iniziato all’inizio del 2022 con un piccolo team che cercava di creare esperienze sociali significative in grado di competere con Instagram e TikTok. RepubliK è una rivoluzione che restituisce il potere dei social media ai creatori e agli utenti che lo hanno reso possibile. Immagina un mondo in cui tutto ciò che creiamo e condividiamo collettivamente è di proprietà e gestito dalla stessa comunità che lo ha reso possibile.</p>
<p>Allora, in passato abbiamo analizzato un paio di forze che guidano ciò che vediamo come il grande mondo del cambiamento. Uno di essi è come <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> porta questa enorme forza che consente alle persone di connettersi direttamente, di raggiungere direttamente, di transare direttamente con il proprio pubblico, la propria base di fan, o praticamente chiunque. Consente alle persone di creare elementi significativi che potrebbero avere valore e queste cose possono rappresentare molte cose diverse in molti casi diversi.</p>
<p>Abbiamo visto questa capacità e crescita dei creatori e dell’industria dei creatori e come potrebbero potenzialmente sfruttare il potere di web3 per arricchirsi, trovare altre fonti di reddito contemporaneamente all’enorme crescita dell’industria creativa, e pensiamo che i creatori rappresenteranno la maggioranza delle spese pubblicitarie e di marketing per molti anni a venire.</p>
<p>Mentre esaminiamo le grandi industrie e le grandi aziende tecnologiche di oggi, vogliamo riflettere su cosa dovrebbe essere centralizzato e cosa dovrebbe essere decentralizzato. Mentre analizziamo questo ambito, sembra ovvio che aziende come Google e Apple dovrebbero rimanere organizzazioni centralizzate, perché svolgono molto bene in quel modo. Tuttavia, se guardiamo alle aziende di social media come Facebook, Instagram, TikTok e tutte le altre più diffuse, vediamo che in realtà non offrono tecnologie che sono proibitivamente difficili da interrompere.</p>
<p>Quindi vedo Web3 portare avanti la decentralizzazione che può influire sull’industria tradizionale per la prima volta in 10 anni nel cripto. Sono nel cripto dal 2011, quando ho avviato la mia prima azienda nel cripto, e ho aspettato questo momento in cui le persone comuni entrerebbero nel cripto e sarebbe veloce, sicuro, efficiente e le persone sarebbero in grado di fare di più, interagire di più e guadagnare di più. In sostanza, abbiamo messo insieme questi pezzi e abbiamo capito che l’industria dei creatori è molto matura per la disruption perché la decentralizzazione avverrà probabilmente su piattaforme in cui la maggior parte dei creatori guadagna oggi.</p>
<p>Abbiamo creato qualcosa chiamato COTO round (Creator Only Token Offering) all’inizio del 2022 e abbiamo fatto venire i creatori. Ci hanno detto quali fossero i loro punti dolenti, quali fossero i problemi e, ad essere onesti, la maggior parte delle cose si riducono agli stessi pochi problemi. Il primo è che Facebook, TikTok prende tutti i ricavi pubblicitari, prende tutto. I creatori non ricevono nemmeno un centesimo, anche se portano così tanti, così tanti occhi e così tante visualizzazioni. E poi volevano longevità. Volevano reddito passivo. Quindi se sto pubblicando, sto facendo qualcosa. Voglio avere un reddito per questo.</p>
<p>Non volevano che ogni singola cosa che facevano fosse, ‘Ehi, sai, ho così tanti follower. Posso ottenere questo accordo con questo marchio? Devo pubblicare questo? Quanto mi pagano per ogni post?’ Volevano aggiungere un reddito passivo in cima a ciò, e molte altre questioni. Quindi abbiamo lavorato con loro per progettare RepubliK e ciò che abbiamo oggi è una sorta di piattaforma simile a TikTok/Instagram. La differenza chiave è davvero che le persone attive sulla piattaforma e che generano molto valore per la piattaforma vengono distribuite con i token RPK e la quantità di token RPK che ottengono dipende da quanto hanno contribuito.</p>
<p>Quindi il contributo avviene in termini di pubblicazione di ottimi contenuti, invitando utenti che sono diventati attivi su RepubliK e cose che riteniamo di portare valore a noi per distribuire i token RPK e soddisfare i criteri dei token RPK. Fondamentalmente, l’idea è quella di ridistribuire RPK per restituire reddito e aiutare i creatori lungo il loro percorso, aiutarli a fare molte cose molto meglio, come monetizzare meglio e utilizzare meglio gli strumenti web3.</p>
<p>Avremo una serie di metodi di monetizzazione che i creatori di Web2 sono abituati ad utilizzare e che i creatori di Web3 troverebbero ovviamente semplici, come la mancia per sbloccare le chat con qualcuno, si può anche lasciare una mancia per abbonarsi, pagare per abbonarsi o pagare per contenuti esclusivi. La funzione di mancia è ora disponibile sulla piattaforma RepubliK, dove ci sono migliaia e migliaia di persone che si lasciano piccole quantità di RPK ogni giorno e stiamo generando commissioni per questo, quindi è stato immensamente popolare. Stiamo per introdurre le funzionalità aggiuntive e presto le persone potranno iniziare a depositare e prelevare dalla piattaforma.</p>
<p>Ciò significa che su RepubliK, gli utenti web3 possono fondamentalmente fare cose che piacciono agli utenti web3, mentre gli utenti Web2 possono usarlo nel modo in cui preferiscono. Quindi questo è l’essenza di dove ci troviamo. Il token RPK è quotato su Gate e altre cinque borse, quindi siamo molto felici di avere il nostro token in circolazione e liberamente disponibile per i nostri creatori e la nostra comunità. Abbiamo anche annunciato nell’ottobre del 2023 di aver raccolto $6 milioni con una valutazione di $75 milioni da investitori crittografici davvero buoni, compresi i bracci di venture dei migliori scambi e molti altri.</p>
<p>Dato l’annuncio del nostro round di finanziamento di 6 milioni di dollari a una valutazione di 75 milioni di dollari a ottobre da investitori come OKX Ventures, HTX Ventures, Mirana Ventures, 6th Man Ventures, Enjin e altri, siamo cresciuti rapidamente fino a superare 1,5 milioni di utenti registrati, più di 700.000 utenti attivi mensili e oltre 280.000 utenti attivi al giorno (DAU). Il lancio beta di RepubliK è avvenuto a marzo 2023 e siamo usciti dalla modalità stealth a settembre 2023.</p>
<h3 id="h3-Q220Quali20problemi20hai20riscontrato20nello20spazio20dei20social20media20di20oggi20e20come20interviene20RepubliK20per20risolverli386913"><a name="Q2: Quali problemi hai riscontrato nello spazio dei social media di oggi e come interviene RepubliK per risolverli?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Quali problemi hai riscontrato nello spazio dei social media di oggi e come interviene RepubliK per risolverli?</h3><p><strong>Richmond</strong>: Sebbene le piattaforme sociali tradizionali offrano potenti canali per attirare l’attenzione, le opzioni per percorsi verso interazioni redditizie sono limitate. La maggior parte dei ricavi dei creatori derivano da accordi esterni con i marchi, mentre le funzioni di monetizzazione sulla piattaforma rimangono frammentate e separate. Le tariffe delle piattaforme rimangono alte e i ricavi pubblicitari sono in costante declino. Inoltre, c’è una mancanza di coerenza per quanto riguarda le politiche e le linee guida sui contenuti, che cambiano frequentemente, creando un ambiente difficile e incerto per i creatori.</p>
<p>Le piattaforme di social media tradizionali generano entrate principalmente dal contenuto degli utenti, ma spesso non condividono questa ricchezza con i creatori di contenuti stessi, tanto meno con gli utenti che hanno supportato questi creatori. RepubliK interrompe questo modello decentralizzando la distribuzione del valore al fine di ridistribuire il valore ai propri utenti e creatori sotto forma di token RPK, garantendo che coloro che contribuiscono alla crescita della piattaforma siano equamente compensati. Ciò avviene attraverso un sistema XP gamificato che premia vari tipi di coinvolgimento, tra cui la creazione di buoni contenuti, i like, i riferimenti dalla condivisione di contenuti, i riferimenti nella piattaforma e le strisce di login giornaliere. I token RPK vengono quindi distribuiti in modo perpetuo ai portafogli in-app degli utenti attivi in base alla percentuale di XP che hanno sulla piattaforma.</p>
<p>Come utilità del token nativo RPK, RepubliK sta continuamente sviluppando strumenti di monetizzazione che creatori e utenti delle piattaforme social tradizionali conoscono e possono trarre facilmente vantaggio, tra cui funzioni di lasciapassare e chat a pagamento. I creatori che monetizzano sulla piattaforma RepubliK riducono significativamente i costi incrementali associati a compiti amministrativi, spese legali o agenti di talento. Di conseguenza, i creatori possono ottenere un valore maggiore che in precedenza era difficile da ottenere all’interno dei sistemi tradizionali, che erano gravati di inefficienze e costi.</p>
<p>A differenza delle piattaforme tradizionali in cui la presa di decisioni è centralizzata, il token RPK di RepubliK dà anche potere ai suoi utenti con diritti di governance. Ciò significa che gli utenti che detengono i token RPK hanno voce in capitolo nel voto sulle decisioni della piattaforma, come nuove funzionalità, partnership, contenuti e come viene gestita la comunità, contribuendo così a creare un senso di appartenenza e partecipazione democratica, che spesso manca nei social media convenzionali.</p>
<p>RepubliK sfrutta anche l’intelligenza artificiale al solo scopo di scoprire talenti, fornendo agli aspiranti creatori una bassa barriera d’ingresso per connettersi e costruire comunità delle proprie nicchie senza la necessità di essere esperti negli algoritmi in continua evoluzione delle piattaforme legacy che danno priorità ai marchi, ai meccanismi pubblicitari e ai percentili più alti dei KOL. Ciò significa che i creatori hanno ora la possibilità di creare contenuti rappresentativi di se stessi senza mai doversi “vendere”. L’A.I. Recommendation Engine personalizza il feed di ogni individuo per riflettere i contenuti che gli piacciono in base alle sue interazioni sulla piattaforma e apprende costantemente.</p>
<h3 id="h3-Q320E20quali20sono20i20vantaggi20di20RepubliK20rispetto20ad20altri20socialfis20che20stanno20lavorando20alla20risoluzione20del20problema20della20distribuzione20del20valore20dei20social20media127398"><a name="Q3: E quali sono i vantaggi di RepubliK rispetto ad altri socialfis che stanno lavorando alla risoluzione del problema della distribuzione del valore dei social media?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: E quali sono i vantaggi di RepubliK rispetto ad altri socialfis che stanno lavorando alla risoluzione del problema della distribuzione del valore dei social media?</h3><p><strong>Richmond</strong>: RepubliK è molto unico nello spazio SocialFi - Abbiamo obiettivi molto diversi e il nostro prodotto si distingue dalla maggior parte dei progetti socialfi. La maggior parte dei progetti socialfi crea e scambia NFT e token di creatori o mette aspetti dei social media come grafi sociali e post sulla blockchain, tuttavia RepubliK non si concentra su nessuno dei due.</p>
<p>Invece di come la maggior parte delle piattaforme o dei progetti sono divisi in equity + governance + utility + currency + NFT + land, ecc., abbiamo scelto di includere tutte le funzioni nel Token RPK. Abbiamo semplicemente UN Token che racchiude l’intero valore della comunità, il che è il modo più equo - Un’economia che esiste all’interno di una piattaforma di social media. Siamo anche concentrati nel premiare i nostri utenti in modo perpetuo e sostenibile - generando utilità RPK e governance sulla piattaforma con la nostra emissione continua di Community RPK Rewards.</p>
<p>Per quanto riguarda gli NFT, se i creatori vogliono creare un Token e commercializzarli, il nostro punto di vista unico è che crediamo che i Creator Token dovrebbero essere collegati a qualcosa. Nel nostro caso, <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> loro ai valori creati dal creatore sulla piattaforma e a causa di quel collegamento, avremo RPK Tokens bloccati nella cassaforte ogni volta che un creatore emette Tokens. L’altro grande problema che abbiamo riscontrato in questo settore è che le persone hanno praticamente coniato un numero infinito di NFT. Dovrebbe esserci un valore di scarsità per gli NFT che non esisteva. Per le entità che coniano sulla piattaforma RepubliK, sarà necessario bloccare una certa quantità di RPK Tokens in una cassaforte con l’NFT, quindi quando i creatori iniziano a coniare token, questo comporterà un costo per loro e quindi non conieranno semplicemente quantità illimitate e vedranno cosa la gente comprerà. I futuri Creator Tokens o NFT di RepubliK saranno supportati da RPK per prevenire l’eccesso di offerta e, soprattutto, il trasferimento di valore, l’uso e le funzioni principali non dipendono dall’inflazione del prezzo del token.</p>
<p>RepubliK è anche consapevole delle sfide che gli utenti di Web 2.0 affrontano quando entrano nello spazio SocialFi / crypto e per colmare questa lacuna in modo efficace, il nostro approccio è a due punte, concentrandosi sia sulla semplicità che sulla sicurezza. La piattaforma è progettata per creare familiarità con le funzionalità e le funzioni delle app dei social media mainstream. La piattaforma incentiva i contenuti video e fotografici che sono più simili a TikTok e Instagram e stiamo sempre sviluppando molteplici modi per gli utenti di guadagnare e utilizzare i token RPK. La forma e la funzione della piattaforma stessa hanno la capacità di attirare gli utenti di web2, il che ha fatto crescere il nostro numero di utenti molto più di altri progetti socialfi.</p>
<p>Gli utenti non sono neanche tenuti a collegare i portafogli Web 3.0 per interagire con RepubliK. Per agevolare le transazioni, abbiamo adottato un sistema simile a quello degli exchange centralizzati, in cui gli utenti possono facilmente depositare e prelevare fondi fornendo i propri indirizzi, in modo simile a come interagirebbero con una piattaforma online tradizionale. Questo eliminerà le complessità associate alle transazioni decentralizzate. Considerando che molti utenti di Web 2.0 potrebbero non possedere ETH, RepubliK ha reso possibile pagare le commissioni di gas in RPK. Questo semplificherà le transazioni e le renderà più accessibili a un pubblico più ampio.</p>
<p>Mentre molte piattaforme SocialFi si concentrano principalmente sulla tokenizzazione, RepubliK offre una gamma più ampia di strumenti di monetizzazione familiari ai creatori di contenuti Web2, come abbonamenti e accesso esclusivo ai contenuti. Ciò consente ai creatori di diversificare i propri flussi di entrate, costruire carriere più sostenibili e presentare senza problemi le loro comunità Web2 o fanbase per partecipare alla tokenomics della piattaforma. Come ho detto, abbiamo intervistato molti creatori e non molti di loro si preoccupano tanto dei grafici sociali o dei loro post e di tutto ciò che viene verificato. Non è che non se ne preoccupino completamente, ma in realtà non è un problema urgente. Quindi non c’è mai stata una richiesta per RepubliK di prendere in considerazione il fatto che vorrebbero effettivamente trasferire i loro grafici sociali tra piattaforme diverse. I creator hanno diversi tipi di pubblico su piattaforme diverse. Quello in cui crediamo davvero è che in futuro gli utenti dei social media saranno effettivamente più disposti a pagare per le interazioni piuttosto che pagare solo per il supporto. Per questo motivo stiamo sviluppando diversi modi per consentire ai creatori di monetizzare, ma anche loro devono fare una cosa, ovvero interagire con gli utenti. Quello che abbiamo visto mancare è che non c’è davvero un’interazione bidirezionale. Chiunque può acquistare il tuo token o come vuoi chiamarlo, ma ciò non significa che quella persona ti parlerà e interagirà con te in cambio. Abbiamo visto iterazioni di token creator fino al 2017 e abbiamo deciso che il modo migliore è fare in modo che i creatori dimostrino di poter generare entrate sulla piattaforma e che i loro token creator sarebbero preziosi se legati ai loro guadagni. La cosa più importante è che le persone erano contente del fatto che, ad esempio, se hanno pagato per chattare con te, dovresti chattare anche tu con loro. E sai, e sai, hanno pagato per abbonarsi a te.</p>
<h3 id="h3-Q420RepubliK2020conosciuta20per20la20sua20tokenomica20unica20potresti20dirci20di20pi20a20riguardo173679"><a name="Q4: RepubliK è conosciuta per la sua tokenomica unica, potresti dirci di più a riguardo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: RepubliK è conosciuta per la sua tokenomica unica, potresti dirci di più a riguardo?</h3><p><strong>Richmond</strong> La prima cosa che è unica è che pensiamo davvero a ricompensare costantemente la comunità nel tempo e volevamo farlo in modo sostenibile. Quindi penso che una delle parole chiave che userei per descrivere come RepubliK pensa alla nostra tokenomica sia ‘è sostenibile? Possiamo farlo per sempre?’ Rispetto a qualsiasi altro progetto che almeno abbia visto, abbiamo destinato la percentuale più grande di token per gli airdrop alla comunità e per il periodo più lungo. Perpetuamente.</p>
<p>A differenza del tipico modello di airdrop una tantum diffuso in molti progetti web3, l’approccio di RepubliK alla distribuzione dei token è progettato per la sostenibilità a lungo termine e il coinvolgimento continuo degli utenti - generando utilità RPK e governance sulla piattaforma con la nostra emissione di continui Community RPK Rewards. Abbiamo dovuto cambiare la parola da “airdrop” a chiamarli “continuous community rewards” perché quando Web3 pensa agli airdrop, pensa a un grande airdrop prima del lancio e per suscitare l’entusiasmo della comunità o per mettere un Token nelle mani di molte persone. Tuttavia, RepubliK sa effettivamente a chi vogliamo darlo. Sono le persone che hanno contribuito a noi.</p>
<p>L’importo della ricompensa della comunità RPK che ogni utente riceve rappresenta la percentuale di XP che hai su RepubliK. Chiunque può guadagnare XP interagendo con la piattaforma, come la pubblicazione di buoni contenuti, il like ai contenuti, i referral dalla condivisione dei contenuti, i referral nella piattaforma e il raggiungimento di serie di accessi giornalieri. I token RPK vengono quindi distribuiti in modo perpetuo ai portafogli in-app degli utenti attivi. Questo non solo è più equo, ma incoraggia anche una partecipazione e un contributo costanti da parte dei membri della nostra comunità. Continuando a ridistribuire continuamente i token RPK nella comunità, tutti beneficiano della crescita e del successo della piattaforma. Questo modello di ricompense perpetue è in netto contrasto con le usuali strategie di airdrop una tantum, che spesso portano a speculazioni a breve termine e non necessariamente incoraggiano un coinvolgimento a lungo termine nella piattaforma.</p>
<p>$RPK Le ricompense della comunità sono piccole e sono progettate per essere quotidiane e continue in modo che gli utenti reali e attivi accumulino RPK durante l’intera durata della piattaforma. Man mano che la nostra piattaforma si sviluppa con un numero crescente di funzioni di utilità e governance, la nostra comunità crescerà a sua volta, il che significa che il valore di $RPK che ogni utente riceve continuamente e detiene aumenterà anche. Quindi, fintanto che un utente è attivo, ha guadagnato XP sulla piattaforma (che è come determiniamo i tuoi contributi) e ha superato un test di vitalità per sbloccare la tua Vault (portafoglio in-app), sei idoneo a iniziare a ricevere ricompense. Se sei nuovo, ne riceverai meno, il che è equo, ma man mano che diventi più attivo e guadagni sempre più XP sulla piattaforma, ne riceverai sempre di più RPK Tokens.</p>
<p>Quindi come possiamo rendere questo sostenibile? Tutte le commissioni raccolte sulla piattaforma andranno verso la ridistribuzione. Combiniamo l’utilità, la governance, gli NFT, il valore del marketplace, tutto ciò che ha valore nell’ecosistema in uno, che è il Token RPK. Le commissioni dalle persone, le persone che utilizzano le funzioni di monetizzazione in-app, le commissioni dalle persone che scambiano token creator e NFT sulla piattaforma che stiamo per lanciare l’anno prossimo, vengono tutte restituite alle persone che hanno reso popolare i social media.</p>
<h3 id="h3-Q520Per20coloro20che20si20rivolgono20ai20loro20amici20e20alle20loro20comunit20che20non20sanno20nulla20su20Web320come20RepubliK20colmer20il20divario20tra20la20tecnologia20Web320per20creatori20e20utenti20di20Web2765343"><a name="Q5: Per coloro che si rivolgono ai loro amici e alle loro comunità che non sanno nulla su Web3, come RepubliK colmerà il divario tra la tecnologia Web3 per creatori e utenti di Web2?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Per coloro che si rivolgono ai loro amici e alle loro comunità che non sanno nulla su Web3, come RepubliK colmerà il divario tra la tecnologia Web3 per creatori e utenti di Web2?</h3><p><strong>Richmond</strong>: Sul fronte delle funzionalità della piattaforma,<br>Abbiamo ricevuto feedback dalla nostra comunità che desiderano inserire i loro creatori Web2, amici, comunità e famiglie ma sono preoccupati che l’industria socialfi non sia la più amichevole per il web2. Siamo consapevoli delle sfide che gli utenti Web 2 affrontano quando entrano nello spazio SocialFi / crypto e abbiamo progettato la piattaforma per supportare la nostra comunità e contribuire a colmare questa lacuna in modo efficace. Il nostro approccio è duplice, concentrandosi sia sulla semplicità che sulla sicurezza.</p>
<p>Innanzitutto, la piattaforma è progettata per creare familiarità con le app di social media mainstream attraverso le sue funzioni interattive come pubblicazione, registrazione, commento, like e condivisione, ecc., che sono molto user-friendly per tutti gli utenti. Gli utenti non sono neanche obbligati a connettere portafogli Web 3.0 per interagire con RepubliK. Per facilitare le transazioni, abbiamo adottato un sistema simile agli exchange centralizzati in cui gli utenti possono facilmente depositare e prelevare fondi fornendo i loro indirizzi, proprio come farebbero su una piattaforma online tradizionale. Ciò eliminerà le complessità associate alle transazioni decentralizzate.</p>
<p>Abbiamo reso molto semplice avviare l’interazione di un utente per guadagnare un viaggio su RepubliK. Dopo esserti registrato su RepubliK, puoi guadagnare facilmente XP e RPK in modo molto rapido. I due modi principali sono: 1) pubblicare contenuti interessanti e coinvolgenti, 2) invitare nuovi utenti all’app. Abbiamo un sistema di referral molto unico, in cui la condivisione di qualsiasi contenuto dall’app, indipendentemente dal fatto che sia tuo o meno, farà automaticamente contare come tuo referral chiunque clicchi e si registri tramite quel link. Ci sono anche una serie di compiti giornalieri legati all’interazione, ma per avviare realmente il tutto, ti incoraggiamo a candidarti come ambasciatore o moderatore per l’app RepubliK, il che massimizzerà l’esposizione dei tuoi contenuti.</p>
<p>Mentre molte piattaforme SocialFi si concentrano principalmente sulla tokenizzazione, RepubliK offre una gamma più ampia di strumenti di monetizzazione familiari ai creatori di contenuti Web2, come abbonamenti e accesso a contenuti esclusivi. Ciò consente ai creatori di diversificare le proprie fonti di reddito, costruire carriere più sostenibili e introdurre in modo trasparente le proprie comunità Web2 o fanbase a partecipare all’economia dei token della piattaforma. E simile a qualsiasi popolare piattaforma di social media, incoraggiamo un’interazione genuina degli utenti e la creazione di contenuti ma con il vantaggio aggiunto di essere ricompensati per i contributi. Il focus che mettiamo sull’coinvolgimento della comunità e gli incentivi che porta rende la piattaforma interessante e più relazionale per un’ampia audience.</p>
<p>Sul fronte delle integrazioni, RepubliK collaborerà anche con Fireblocks per garantire che i fondi degli utenti siano gestiti in modo sicuro e sicuro per fornire fiducia tra gli utenti non familiari con la sicurezza crittografica; e abbiamo collaborato con Mantle (layer 2) per transazioni rapide, a basso costo ma sicure. Comprendendo che molti utenti di Web 2.0 potrebbero non possedere ETH, RepubliK ha reso possibile pagare le commissioni di gas in RPK. Questo semplificherà le transazioni e le renderà più accessibili a un pubblico più ampio.</p>
<p>La nostra ultima partnership è con The Open Network (TON) che è stata annunciata il 19 dicembre. Questa integrazione prevista per il Q2 2024 rivoluzionerà l’esperienza degli utenti di RepubliK fornendo una piattaforma senza soluzione di continuità ed efficiente per le transazioni di token con $RPK supportato sul portafoglio TON, affrontando i problemi che la maggior parte degli utenti web2 affrontano. Abbiamo una missione condivisa per integrare i prossimi 500 milioni di utenti su Web3 e questa integrazione è stata progettata per garantire un’adozione diffusa attraverso la facilità d’uso, la sicurezza, trasferimenti a basso costo ultra veloci e aprire l’accesso alla piattaforma di RepubliK per milioni di nuovi utenti.</p>
<h3 id="h3-Q620Puoi20condividere20di20pi20sui20piani20futuri20di20RepubliK20per20mantenere20il20valore20del20token210556"><a name="Q6: Puoi condividere di più sui piani futuri di RepubliK per mantenere il valore del token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Puoi condividere di più sui piani futuri di RepubliK per mantenere il valore del token?</h3><p><strong>Richmond</strong>: In termini di mantenimento del valore del token, pensiamo effettivamente di essere ancora ai primi giorni. Quindi non pensiamo al mantenimento del valore del token in questo momento, pensiamo invece a farlo crescere in modo esponenziale. Ci vuole del tempo affinché le persone comprendano le differenze tra noi e la maggior parte degli altri token e cosa rappresenta il Token RPK quando diciamo l’intero valore della community. Questo perché non c’è altro contenitore di valore oltre a questo token, quindi ci vuole tempo affinché vedano effettivamente le commissioni generate ritornare alla community. Ci vuole anche tempo affinché vedano RPK bruciarsi o il buyback del token e esperienze simili.</p>
<p>Per quanto riguarda ciò che abbiamo intenzione di costruire, penso che la piattaforma sia ancora in una fase relativamente iniziale. Credo che abbiamo compiuto parecchio nonostante la giovane età come token e come piattaforma, e presto le persone potranno depositare e prelevare.</p>
<p>Non abbiamo portafogli connessi a web3 perché è un grande punto critico per molti utenti web2. Quindi abbiamo deciso di adottare un modello diverso che verrà presto aperto, in cui invieremo transazioni in modo molto sicuro alle persone e questa funzionerà essenzialmente come una CEX in cui le persone possono depositare e prelevare e noi possiamo mantenerlo efficiente e conveniente per loro.</p>
<p>Ci aspettiamo che molte persone vorranno prelevare e anche depositare molti RPK Tokens. Pertanto, ci sono un paio di incentivi per depositare RPK Tokens. Uno ovviamente è che sarai in grado di scommetterlo sulla piattaforma RepubliK e guadagnare una buona quantità di rendimento. Oltre all’alto rendimento per lo staking, aggiungeremo governance, status e visibilità come ricompense. Quindi, avendo RPK Tokens nel tuo account sulla piattaforma, sei in grado di guadagnare, avere una maggiore influenza nella governance della piattaforma e essere in grado di raggiungere diversi livelli di stato con moltiplicatori XP che garantiscono quasi che guadagni più XP in futuro.</p>
<p>Per quanto riguarda la ricompensa della visibilità, può essere visibile per il tuo contenuto e anche visibilità per il tuo profilo dove sei più facilmente scoperto e sei più prestigioso. Man mano che più creatori si uniscono a noi e più persone vogliono interagire con loro, le persone sono incentivati a detenere token RPK su RepubliK perché otterranno tutti questi vantaggi all’interno della piattaforma. Sviluppiamo anche utilità per le tue funzioni usuali come DM e chat in modo che possano essere classificate per livelli di stato e per RPK e portafogli, in modo da galleggiare nella lista dei DM dei tuoi creatori preferiti significativamente più di altri.</p>
<p>Lanceremo lo staking molto presto con un rendimento molto generoso per il primo gruppo di persone. Quindi questo è qualcosa da aspettarsi quando avrai i tuoi token RPK nella piattaforma.</p>
<p>Al momento ci sono solo 200M di RPK coniati. Sempre più token verranno aspirati nella piattaforma e molti di essi verranno bloccati come commissioni generate, altri verranno bloccati nello staking, altri verranno utilizzati per lo status e altri verranno bloccati in futuro perché è necessario creare token di creazione e coniare NFT. Naturalmente, una percentuale sempre maggiore di creatori che emettono token di creazione vedrà i loro pagamenti RPK bloccati in smart contract. Quindi prevediamo che, man mano che apriamo la piattaforma con più funzionalità di utilità e governance, questo assorbirà molti dei token RPK che non sono nella piattaforma.</p>
<p>Al momento pianifichiamo di attivare depositi e prelievi abbastanza presto in modo che le persone possano ottenere questi benefici. Quindi penso che fondamentalmente porterà valore, attirerà sempre più token RPK, ridurrà l’offerta sul mercato, e ci aspettiamo che il tasso di riduzione dell’offerta superi sempre i nuovi token RPK che vengono coniati e distribuiti alla comunità. Manteniamo quel bilanciamento per garantire che le persone non solo ricevano token RPK, ma che ottengano sempre più valore. Vogliamo assicurarci che ciò sia sempre in una traiettoria ascendente per la nostra comunità.</p>
<h3 id="h3-Q720RepubliK2020per20tutti20e20quelli20che20hanno20appena20sentito20parlare20di20RepubliK20hanno20gi20perso20questo20treno7717"><a name="Q7: RepubliK è per tutti e quelli che hanno appena sentito parlare di RepubliK hanno già perso questo treno?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: RepubliK è per tutti e quelli che hanno appena sentito parlare di RepubliK hanno già perso questo treno?</h3><p><strong>Richmond</strong>: RepubliK è per tutti, ma non tutti sono per RepubliK. Ci sono infatti persone che sconsigliamo vivamente di utilizzare la piattaforma RepubliK: i bot farmers e gli airdrop hunters che cercano un guadagno rapido. Questo è principalmente a causa della nostra tokenomica che viene distribuita quotidianamente e in modo continuo agli utenti attivi e genuini, e delle nostre azioni anti-bot. Detto ciò, non è mai troppo tardi per questi 2 tipi di persone:</p>
<p><strong>Creatori</strong><br>Le persone con una passione che cercano nuovi modi alternativi per guadagnare dai loro contenuti. Potrebbero essere meme, cripto, danza, moda, cibo, istruzione - qui il cielo è il limite. Potrebbero avere un seguito esistente su altre piattaforme ma stanno cercando un modello più sostenibile in cui il loro valore non diminuirà man mano che il pubblico cambia interessi, o potrebbero anche essere persone che stanno leggendo questo e che hanno deciso 2 secondi fa che vogliono costruire una comunità propria e guadagnare reddito passivo nel tempo. Potrebbero anche essere creatori che sono grati alla loro comunità e vorrebbero fornire incentivi o ricompense ai loro fan o credere nel favorire un vero legame e interazioni più strette con loro.</p>
<p><strong>Utenti dei social media</strong><br>Le persone che già interagiscono e scorrono sui social media (chi non lo fa?) che credono che sia giunto il momento che tutti siano ricompensati per aver reso popolari queste piattaforme di social media e i creatori stessi. Utenti che cercano un’esperienza di consumo dei media più coinvolgente e interattiva, dove possono sostenere i contenuti e i creatori che amano e connettersi liberamente con gli altri.</p>
<p>Ho menzionato solo la nostra tabella di marcia fino alla fine dell’anno, dove ci saranno staking, depositi e prelievi. Il prossimo anno, verrà aggiunta molta più altra funzionalità. Al momento, i tassi di crescita degli utenti sono piuttosto esponenziali e le nostre commissioni in-app e le transazioni stanno crescendo in modo esponenziale. Quindi penso che in termini di possesso del token RepubliK sia estremamente, estremamente presto e decisamente molto lontano dall’aver perso il treno in termini di guadagnare XP e valore come parte della piattaforma RepubliK.</p>
<p>Le persone che hanno ottenuto molta esperienza hanno pubblicato contenuti molto buoni o sono state in grado di fare riferimento a molti utenti. Anche se non sei bravo in nessuno dei due, avrai sempre più RPK fintanto che utilizzi la piattaforma e sei attivo sulla piattaforma. Non vedo l’ora che le dinamiche di cui abbiamo parlato nelle ultime domande entrino in gioco e che tutto quel valore sia veramente riflettuto nel token RPK.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità 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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>