R2F0ZS5pbyBBTUEgY29uIEJPU2Fnb3JhIC0gVW5hIHBpYXR0YWZvcm1hIGJsb2NrY2hhaW4gb3R0aW1penphdGEgcGVyIGwnaW50ZWdyYXppb25lIG5lbGxhIHZpdGEgZGkgdHV0dGkgaSBnaW9ybmk=

<p><img src="https://gimg2.gateimg.com/image/article/16832632281.png" alt=""><br><strong>Ora: 18 maggio 2023, 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 Vicky, Senior Marketing Manager presso BOSagora in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Ufficiale: <a href="https://bosagora.io/en/" rel="nofollow noopener noreferrer" target="_blank">https://bosagora.io/it/</a></strong><br><strong>Twitter: <a href="https://twitter.com/BOSAGORA1" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/BOSAGORA1</a></strong><br><strong>Segui BOSagora su <a href="https://t.me/bosagora_eng" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://twitter.com/bosagora1" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16832635392.png" alt=""><br><strong>Vicky - Responsabile Marketing presso BOSagora</strong></p>
<h2 id="h2-QampA20da20Gateio257417"><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-Q120Potresti20brevemente20presentare20cosa2020BOSagora671258"><a name="Q1: Potresti brevemente presentare cosa è BOSagora?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti brevemente presentare cosa è BOSagora?</h3><p><strong>Vicky</strong>: Certamente.</p>
<p>BOSagora($BOA) è stato il primo progetto ICO coreano nel 2017, una piattaforma blockchain ottimizzata per l’integrazione nella vita di tutti i giorni. Diversi vantaggi sono forniti a tutti i membri della Rete del Congresso attraverso la piattaforma. La piattaforma BOSagora è una piattaforma blockchain pubblica decentralizzata auto-evolutiva costruita su Smart Contracts e un sistema decisionale incorporato chiamato Congress Network che segue la regola di un voto per un nodo. In altre parole, promuove DAO, dove tutti gli amministratori del nodo hanno gli stessi diritti di voto senza la delega dei diritti di voto o l’elezione di un delegato. Una proposta nella Rete del Congresso, e viene approvata tramite il voto della Rete del Congresso, può avere l’opportunità di utilizzare il ‘Commons Budget’.</p>
<p>Per differenziarsi dalle altre reti blockchain, l’ecosistema di BOSagora è incentrato sulla connettività alla vita quotidiana. Con l’integrazione della rete ‘Agora’ e dei chioschi, ci si aspetta che K2E (Kiosk to Earn) svolga un ruolo importante nell’ecosistema della rete Web3.0.</p>
<h3 id="h3-Q220Abbiamo20notato20che20BOSagora20ha20fatto20diversi20annunci20illuminanti20relativi20allultimo20incontro20con20lazienda20THE920che20ha20attirato20lattenzione20del20pubblico20Ti20dispiacerebbe20condividere20alcuni20di20questi20annunci20con20noi36717"><a name="Q2: Abbiamo notato che BOSagora ha fatto diversi annunci illuminanti relativi all’ultimo incontro con l’azienda THE9, che ha attirato l’attenzione del pubblico. Ti dispiacerebbe condividere alcuni di questi annunci con noi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Abbiamo notato che BOSagora ha fatto diversi annunci illuminanti relativi all’ultimo incontro con l’azienda THE9, che ha attirato l’attenzione del pubblico. Ti dispiacerebbe condividere alcuni di questi annunci con noi?</h3><p><strong>Vicky</strong> Certo. Di recente abbiamo organizzato un meetup offline con l’azienda THE9 per discutere dell’integrazione del business dei token e fornire un modello Kiosk to Earn (K2E). Integrando con THE9, BOSagora si aspetta di vedere un’ampia diffusione dell’uso nella vita reale grazie ai punti fedeltà emessi da una vasta rete globale di chioschi basati sul blockchain di BOSagora, combinata con l’attesa proliferazione dei chioschi a livello globale. Di conseguenza, è previsto che l’uso delle monete BOA aumenterà significativamente.</p>
<p>Quindi, come e perché integrarsi con THE9 beneficia del volume di trading di BOA coin?<br><img src="https://gimg2.gateimg.com/image/article/16832637333.jpg" alt=""><br>THE9 Company, che ha originato il chiosco coreano (= terminale di pagamento) ed è la società di chioschi di primo livello al mondo, sta espandendo la sua infrastruttura attraverso la collaborazione con diverse imprese. Sono il principale fornitore di chioschi per attrazioni turistiche, con oltre 300 milioni di utenti in Cina. Uno dei loro partner in Cina è Disneyland Resort, e sono anche il principale fornitore di chioschi per la ricarica di denaro elettronico in Indonesia, installati in telecomunicazioni e supermercati. Inoltre, sono il principale fornitore di chioschi per i teatri in Vietnam. Puoi trovare un elenco dei partner di THE9 come l’immagine.</p>
<p>THE9 non si ferma qui; hanno un piano a lungo termine per espandere la loro attività nel Sud-est asiatico e in Europa. Con la loro crescita sostenibile e il valore illimitato, crediamo che siano un partner adatto per espandere l’ecosistema Agora e aumentare l’uso di BOA.</p>
<p>Cosa rende così forte il loro business dei chioschi? In realtà, hanno attratto diversi partner con il loro servizio di noleggio a tariffe zero e la prima piattaforma globale di punti royalty basata sul nostro blockchain. Secondo il loro attuale trend di espansione, THE9 prevede di installare oltre 1 milione di chioschi nelle principali città di tutto il mondo entro il 2029, servendo circa 1 miliardo di utenti dei punti royalty di THE9. Siamo entusiasti di vedere quanto ampiamente utilizzati diventeranno i chioschi di THE9 in tutto il mondo. Con sempre più persone che possiedono punti royalty, ci sarà una crescente domanda per Agora.</p>
<h3 id="h3-Q320Hai20menzionato20alcune20volte20il20termine20K2E20Kiosk20to20Earn20che20sembra20essere20un20nuovo20concetto20nello20spazio20delle20criptovalute20che20molte20persone20potrebbero20non20aver20mai20sentito20prima20Potresti20spiegare20di20pi20su20cosa20sia20e20come20funzioni624974"><a name="Q3: Hai menzionato alcune volte il termine K2E (Kiosk to Earn), che sembra essere un nuovo concetto nello spazio delle criptovalute che molte persone potrebbero non aver mai sentito prima. Potresti spiegare di più su cosa sia e come funzioni?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Hai menzionato alcune volte il termine K2E (Kiosk to Earn), che sembra essere un nuovo concetto nello spazio delle criptovalute che molte persone potrebbero non aver mai sentito prima. Potresti spiegare di più su cosa sia e come funzioni?</h3><p><strong>Vicky</strong>: Grazie per il tuo interesse nel modello K2E. È simile ad altri modelli X2E, in cui puoi guadagnare bonus aggiuntivi contribuendo. Tuttavia, la differenza più significativa è che K2E è direttamente collegato alla nostra vita quotidiana. Questo perché puoi guadagnare punti royalty utilizzando il chiosco più vicino a te, che possono poi essere scambiati con token.<br><img src="https://gimg2.gateimg.com/image/article/16832636854.jpg" alt=""><br>[1. Utilizzare il chiosco per acquistare prodotti o servizi]<br>🔽<br>[2. Guadagnare punti fedeltà direttamente nel portafoglio]<br>🔽<br>[3. Utilizzare i punti fedeltà per acquistare altri articoli o token elencati su CEX]<br>🔽<br>[4. Scambiare i token THE9 con monete BOA o altri token di servizio basati su mainnet in DEX]<br><img src="https://gimg2.gateimg.com/image/article/16832636535.jpg" alt=""><br>Qual è il ruolo di BOA in questo modello K2E? BOA funge da moneta nativa che può essere utilizzata per tutte le transazioni sulla mainnet di Agora. Quando il token THE9 viene emesso su Agora, gli utenti possono scambiarlo o collegarlo tramite BOASwap. Durante questo processo, viene generata una piccola commissione di gas pagata in BOA. Questa relazione è simile a <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e Metamask. In breve, BOA svolge un ruolo essenziale nei passaggi 3 e 4 sopra. Speriamo che ti aiuti a comprendere meglio il concetto.</p>
<h3 id="h3-Sono20sicuro20che20K2E20diventer20parte20della20nostra20vita20quotidiana20e20ci20piacerebbe20provare20il20chiosco20A20proposito20quanti20token20basati20su20Agora20possono20essere20scambiati20con20i20token20THE920o20le20monete20native20di20BOA20ora21653"><a name="Sono sicuro che K2E diventerà parte della nostra vita quotidiana e ci piacerebbe provare il chiosco. A proposito, quanti token basati su Agora possono essere scambiati con i token THE9 o le monete native di BOA ora?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sono sicuro che K2E diventerà parte della nostra vita quotidiana e ci piacerebbe provare il chiosco. A proposito, quanti token basati su Agora possono essere scambiati con i token THE9 o le monete native di BOA ora?</h3><p><strong>Vicky</strong>: Grazie per il tuo grande supporto. Prima del lancio della mainnet di Agora, ci siamo già associati con vari servizi di vita quotidiana che hanno mostrato un grande interesse nell’industria blockchain. Alcuni di questi partner sono legati ai servizi P2E online e offline, mentre altri sono coinvolti nei servizi di asset reali. Stiamo continuamente lavorando per portare nuovi partner, e puoi aspettarti di vedere nuove partnership annunciate a breve.</p>
<p>Abbiamo sei partner Dapp in totale:<br>1.) Investimento FM - Emissione di NFT rimborsabili al 100%<br>2.) FINPLUS Global - Emissione di NFT redditizi e token FNPL<br>3.) Lightning Beans - Emissione di NFT e token di gioco<br>4.) Purple Ocean - Emissione di NFT di gioco<br>5.) Pingong - Emissione di token bollente<br>6.) Azienda THE9 - Emissione del token THE 9</p>
<p>Tutti i token sopra possono essere facilmente scambiati, pontiati e inviati con commissioni di transazione (in BOA) applicate. Inoltre, anche il trading di NFT utilizzerà BOA. Non solo, con il modello K2E, tutti i token su Agora sono possibili da applicare nella vita quotidiana. Vediamo come gli utenti possono incorporare i loro token nella vita quotidiana.<br><img src="https://gimg2.gateimg.com/image/article/16832636266.jpg" alt=""><br>Ora puoi goderti un servizio di bowling Dapp offline chiamato PINGONG, che funziona sul mainnet ‘Agora’. Competendo a distanza contro squadre in Thailandia, puoi guadagnare token PINGONG vincendo le partite.<br>Nel frattempo, hai un viaggio all’estero con la tua famiglia!</p>
<p>All’arrivo, scoprirai che un ristorante locale ha già installato il chiosco di THE9.</p>
<p>Utilizzando BOASwap (DEX) per scambiare i tuoi token PINGONG con i token THE9, puoi comodamente effettuare un ordine al chiosco.</p>
<h3 id="h3-Q520Grazie20per20aver20condiviso20gli20aggiornamenti20sugli20aspetti20aziendali20e20di20marketing20dellecosistema20di20Agora20Siamo20curiosi20anche20degli20sviluppi20tecnici20poich20alcuni20dei20nostri20membri20sono20interessati20a20questo20settore20Saresti20disposto20a20condividere20alcuni20aggiornamenti20tecnici20con20noi342429"><a name="Q5: Grazie per aver condiviso gli aggiornamenti sugli aspetti aziendali e di marketing dell’ecosistema di Agora. Siamo curiosi anche degli sviluppi tecnici, poiché alcuni dei nostri membri sono interessati a questo settore. Saresti disposto a condividere alcuni aggiornamenti tecnici con noi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Grazie per aver condiviso gli aggiornamenti sugli aspetti aziendali e di marketing dell’ecosistema di Agora. Siamo curiosi anche degli sviluppi tecnici, poiché alcuni dei nostri membri sono interessati a questo settore. Saresti disposto a condividere alcuni aggiornamenti tecnici con noi?</h3><p><strong>Vicky</strong>: Naturalmente. Facciamo una breve panoramica dell’overview degli sviluppi. Il mainnet di BOSagora - ‘Agora’ è stato lanciato l’11 gennaio di quest’anno e, alla data di questo meetup che abbiamo tenuto, sono stati generati 18.856 blocchi con il coinvolgimento di un totale di 2.348 validatori per garantire la stabilità della rete. La ricompensa media si attesta al 13,31%, mentre la quantità totale di BOA staked è di 93.920.000, che rappresenta approssimativamente un terzo dell’attuale offerta circolante.</p>
<p>Non solo questo, abbiamo recentemente completato diversi strumenti per garantire il corretto funzionamento della rete. Questi includono BOASwap (DEX), BOAScan (esploratore Tx), AGORAscan (esploratore di blocchi) e BOASpace (mercato NFT), tutti i quali offrono un ambiente user-friendly e la migliore esperienza possibile.</p>
<h3 id="h3-Q620Sembra20impressionante20Deve20aver20richiesto20molto20sforzo20stabilire20un20cos20grande20gruppo20di20validator20in20cos20poco20tempo20Come20ha20fatto20il20suo20team20Intendo20dire20potrebbe20anche20condividere20maggiori20informazioni20sul20processo20di20diventare20un20validator20sulla20mainnet20di20Agora20Inoltre20potrebbe20darci20unidea20di20quanto20si20pu20guadagnare20allanno20come20validator480409"><a name="Q6: Sembra impressionante! Deve aver richiesto molto sforzo stabilire un così grande gruppo di validator in così poco tempo. Come ha fatto il suo team? Intendo dire, potrebbe anche condividere maggiori informazioni sul processo di diventare un validator sulla mainnet di Agora? Inoltre, potrebbe darci un’idea di quanto si può guadagnare all’anno come validator?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Sembra impressionante! Deve aver richiesto molto sforzo stabilire un così grande gruppo di validator in così poco tempo. Come ha fatto il suo team? Intendo dire, potrebbe anche condividere maggiori informazioni sul processo di diventare un validator sulla mainnet di Agora? Inoltre, potrebbe darci un’idea di quanto si può guadagnare all’anno come validator?</h3><p><strong>Vicky</strong>:<br><img src="https://gimg2.gateimg.com/image/article/16832636027.jpg" alt=""><br>Crediamo che i validatori siano contribuenti essenziali all’ecosistema di Agora e, come tale, offriamo loro un alto APR rispetto ad altri progetti. Ad oggi, l’APR per i validatori è del 47,0% nel primo anno. Chiunque soddisfi le seguenti condizioni può diventare un validatore.</p>
<p>Prerequisiti:<br>1.) Impiegare almeno 40.000 BOA<br>2.) Gestire un nodo di validazione a una velocità di rete stabile (operare su un server o un computer personale)<br>3.) Competenze tecniche di base</p>
<p>Inoltre, consigliamo vivamente coloro che sono interessati a guadagnare reddito passivo tramite l’esecuzione di un nodo di fare riferimento a questa guida:<br><a href="https://medium.com/bosagora/guideline-of-validator-setup-40-000-boa-staking-7c09f119161c" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/bosagora/guideline-of-validator-setup-40-000-boa-staking-7c09f119161c</a></p>
<p>La guida include tutorial passo-passo su come depositare il tuo BOA, impostare il CI e l’EI e un modo semplice per impostare un sistema di monitoraggio per controllare lo stato del tuo nodo.</p>
<p>Infine, vorremmo menzionare che lo staking su Agora è diverso dallo staking DeFi regolare e potrebbe rappresentare sfide per coloro che non hanno competenze tecniche o non sono in grado di assumersi la responsabilità di24⁄7management. In risposta a questa domanda, il nostro team è attualmente in discussione con varie parti per fornire servizi di staking in pool. Saremo lieti di annunciare questo servizio sul nostro account Twitter ufficiale una volta che sarà lanciato. Vi preghiamo di tenerlo d’occhio.</p>
<h3 id="h3-Q720E20rimarremo20in20sospeso20fino20al20lancio20di20questo20Nonostante20il20mercato20sia20facilmente20influenzato20dallambiente20cosa20spinge20i20vostri20possessori20a20continuare20a20stare20con20il20team20di20BOSagora373376"><a name="Q7: E rimarremo in sospeso fino al lancio di questo. Nonostante il mercato sia facilmente influenzato dall’ambiente, cosa spinge i vostri possessori a continuare a stare con il team di BOSagora?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: E rimarremo in sospeso fino al lancio di questo. Nonostante il mercato sia facilmente influenzato dall’ambiente, cosa spinge i vostri possessori a continuare a stare con il team di BOSagora?</h3><p><strong>Vicky</strong>: Mentre il mercato può essere facilmente influenzato da vari fattori esterni, crediamo che la nostra forte comunità e il nostro impegno per la nostra visione e il nostro percorso siano ciò che ci permette di rimanere al fianco dei nostri detentori. Abbiamo un team dedicato che si impegna costantemente per mantenere le nostre promesse e siamo sempre alla ricerca di modi per migliorare ed evolvere la nostra piattaforma. Ad esempio, collaboriamo con varie Dapp e esploriamo il miglior modo di applicare la ‘Blockchain quotidiana’ nella nostra vita quotidiana. Il modello K2E è un esempio di questo.<br><img src="https://gimg2.gateimg.com/image/article/16832635768.jpg" alt=""><br>Inoltre, la nostra trasparenza e la comunicazione aperta con la comunità aiutano anche a costruire fiducia e favorire un rapporto positivo tra il nostro team e i nostri detentori. Recentemente, abbiamo aggiornato la nostra roadmap del 2023 e condiviso lo stato di tutti i nostri asset con gli indirizzi del portafoglio per mantenere la trasparenza.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Rio Fu.</strong>, 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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>