R2F0ZS5pbyBBTUEgY29uIFRPTUkgLSBSZW5kZXJlIGxhIGxpYmVydMOgIHVuYSByZWFsdMOg

<p><img src="https://gimg2.gateimg.com/image/article/16820648051.png" alt=""><br><strong>Ora: 20 aprile 2023, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Chiedimi-qualsiasi-cosa) con Dag, specialista della Comunità e del Contenuto presso TOMI nel <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://tomi.com/" rel="nofollow noopener noreferrer" target="_blank">https://tomi.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/tomipioneers" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/tomipioneers</a></strong><br><strong>Segui TOMI su <a href="https://t.me/tomipioneers" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://discord.com/invite/tomi" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16820650312.jpeg" alt=""><br><strong>Dag - specialista della comunità e del contenuto presso TOMI</strong></p>
<h2 id="h2-QampA20da20Gateio69487"><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-Q120Potresti20presentarti20al20nostro20pubblico20per20favore128627"><a name="Q1: Potresti presentarti al nostro pubblico, per favore?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti presentarti al nostro pubblico, per favore?</h3><p><strong>Dag</strong>: Il mio nome è Dag, sono lo specialista della comunità e dei contenuti di tomi. Sono molto felice di conoscervi tutti e di parlare di tutte le cose entusiasmanti che circondano tomi. E in un certo senso suppongo di essere un riflesso dello vero spirito di tomi, dato che siamo un progetto guidato dalla comunità. Sono stato effettivamente reclutato dalla comunità per assumere questo ruolo e diventare parte del team di tomi. Non conosco la maggior parte del team dato che si tratta di un progetto anonimo, ma stiamo tutti lavorando insieme verso un obiettivo collettivo, la decentralizzazione.</p>
<h3 id="h3-Q220Credo20che20la20maggior20parte20del20pubblico20conosca20gi20Tomi20ma20per20coloro20che20non20lo20sanno20potresti20dirci20qualcosa20sul20progetto99574"><a name="Q2: Credo che la maggior parte del pubblico conosca già Tomi, ma per coloro che non lo sanno, potresti dirci qualcosa sul progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Credo che la maggior parte del pubblico conosca già Tomi, ma per coloro che non lo sanno, potresti dirci qualcosa sul progetto?</h3><p><img src="https://gimg2.gateimg.com/image/article/16820651303.png" alt=""><br><strong>Dag</strong>: Certo, come ho già menzionato, siamo guidati dalla comunità, ma l’idea principale di Tomi è creare prodotti decentralizzati per liberare le persone dai vincoli del mondo centralizzato in cui viviamo oggi. Alcuni esempi, come i tuoi dati vengono venduti a terze parti per creare annunci mirati sulla base della tua cronologia di navigazione, o forse ancora più importante: dare alle persone che vivono in paesi in cui Internet è censurato o controllato, una piattaforma per esprimersi liberamente.</p>
<h3 id="h3-Q320La20cosa20unica20di20tomi2020che20stai20veramente20lavorando20su20una20vasta20gamma20di20prodotti20per20creare20unintera20infrastruttura20di20prodotti20che20garantiscono20la20privacy20e20consentono20la20libert20di20espressione20Puoi20condividere20alcuni20di20questi20prodotti20e20spiegarli20brevemente72418"><a name="Q3: La cosa unica di tomi è che stai veramente lavorando su una vasta gamma di prodotti per creare un’intera infrastruttura di prodotti che garantiscono la privacy e consentono la libertà di espressione. Puoi condividere alcuni di questi prodotti e spiegarli brevemente?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: La cosa unica di tomi è che stai veramente lavorando su una vasta gamma di prodotti per creare un’intera infrastruttura di prodotti che garantiscono la privacy e consentono la libertà di espressione. Puoi condividere alcuni di questi prodotti e spiegarli brevemente?</h3><p><img src="https://gimg2.gateimg.com/image/article/16820651114.png" alt=""><br><strong>Dag</strong>: Certo, il prodotto più importante per me deve essere la nostra internet decentralizzata che stiamo sviluppando. La visione di tomi è creare l’infrastruttura necessaria per avere una piattaforma completamente decentralizzata per ripristinare le libertà delle persone. E su questo abbiamo tomiPAY, il nostro portafoglio multi-chain, abbiamo il nostro browser per questa internet decentralizzata, il tomiNET, abbiamo anche tDNS, che è il nostro sistema di denominazione dei domini decentralizzato. E tutti questi prodotti sono attivi, la maggior parte è nella fase di test ma comunque, potete provarli. Voglio dire, l’elenco è ancora più lungo di questo, l’obiettivo di tomi è coprire tutte le aree per fornire ai membri della nostra comunità un’alternativa completamente decentralizzata e privata per sperabilmente un giorno, dismettere il sistema centralizzato in cui viviamo e che usiamo oggi. Questo è uno dei principali motivi per cui stiamo sviluppando il TPL e per cui oggi sono così entusiasta di parlarvi.</p>
<h3 id="h3-Q420Hai20parlato20di20TPL20e20tdUSD20che2020stato20annunciato20pochi20giorni20fa2020incredibile20e20stiamo20aspettando20con20impazienza20che20lo20sviluppo20venga20completato20Cosa20puoi20dirmi20su20di20loro946901"><a name="Q4: Hai parlato di TPL e tdUSD che è stato annunciato pochi giorni fa. È incredibile e stiamo aspettando con impazienza che lo sviluppo venga completato. Cosa puoi dirmi su di loro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Hai parlato di TPL e tdUSD che è stato annunciato pochi giorni fa. È incredibile e stiamo aspettando con impazienza che lo sviluppo venga completato. Cosa puoi dirmi su di loro?</h3><p><strong>Dag</strong>: Sono d’accordo, è tutto molto emozionante! Come hai detto, non è ancora completamente funzionante, ma siamo sulla buona strada per portare una soluzione veramente rivoluzionaria per le transazioni cripto e la privacy finanziaria. Se ci pensi, è abbastanza strano come ci siamo abituati al fatto che ogni transazione sulla blockchain sia pubblica. Probabilmente ti sentiresti molto disturbato se fossi in grado di vedere esattamente cosa hai nel tuo conto bancario, o quali asset possiedi nel tuo deposito bancario. Quindi perché dovrebbe essere diverso con la tua cripto?</p>
<h3 id="h3-Q520Come20funziona20tecnicamente20Nel20caso20in20cui20non20fosse20stato20spiegato20nella20risposta20precedente357850"><a name="Q5: Come funziona tecnicamente? (Nel caso in cui non fosse stato spiegato nella risposta precedente)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Come funziona tecnicamente? (Nel caso in cui non fosse stato spiegato nella risposta precedente)</h3><p><strong>Dag</strong>: Quindi fondamentalmente, per entrare un po’ nel tecnico, per accedere al TPL e scoprire il mondo delle transazioni private di criptovalute, utilizzerai il tuo portafoglio tomiPay. Lì avremo una scheda TPL dedicata, dove sarai in grado di collegare il tuo USDT/USDC a tpUSD. E quando premi il pulsante per collegare USDT, li blocciamo e li mettiamo in gioco. Ovviamente riceverai l’equivalente di tpUSD esistente nel nostro TPL! E le ricompense per questo staking vengono utilizzate per riacquistare i token tomi che poi vanno allo sviluppo ulteriore dell’ecosistema. Ma ovviamente, per evitare ritardi, teniamo sempre il 20% degli asset degli utenti non bloccati, in modo che possano accedervi velocemente!<br><img src="https://gimg2.gateimg.com/image/article/16820650825.png" alt=""><br>Forse menzionare se c’è tempo: L’idea per questi prodotti è nata dalle effettive esigenze degli utenti, stiamo osservando una lacuna nel mercato e questi due prodotti si combinano perfettamente per sostenere la nostra futura visione della decentralizzazione.</p>
<h3 id="h3-Q620Di20recente20si2020parlato20molto20di20CBDC20nelle20cronache20Per20coloro20che20non20sono20familiari20i20CBDC20sono20valute20digitali20emesse20dalle20banche20centrali20il20che20significa20che20sono20valute20molto20centralizzate20Tomi20fornisce20una20soluzione20reale20al20problema20della20privacy510275"><a name="Q6: Di recente, si è parlato molto di CBDC nelle cronache. Per coloro che non sono familiari, i CBDC sono valute digitali emesse dalle banche centrali, il che significa che sono valute molto centralizzate. Tomi fornisce una soluzione reale al problema della privacy?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Di recente, si è parlato molto di CBDC nelle cronache. Per coloro che non sono familiari, i CBDC sono valute digitali emesse dalle banche centrali, il che significa che sono valute molto centralizzate. Tomi fornisce una soluzione reale al problema della privacy?</h3><p><strong>Dag</strong>: Assolutamente, intendo, siamo tutti per l’adozione globale delle criptovalute, ma troviamo estremamente problematico vedere il governo cercare di CENTRALIZZARE gli asset DEcentralizzati. Come probabilmente sappiamo tutti, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è emerso dopo la crisi finanziaria del 2008 a seguito della mancanza di fiducia del pubblico nei confronti dei governi e delle autorità centralizzate nella gestione dei loro beni. Quindi intendo dire che questo è anche uno dei motivi per cui esiste tomi, per creare opzioni decentralizzate per sostenere appieno la capacità degli individui di esistere senza dipendere da questi sistemi centralizzati!</p>
<h3 id="h3-Q720Come20hai20intenzione20di20mantenere20la20stabilit20del20tasso20di20cambio20tpUSD426034"><a name="Q7: Come hai intenzione di mantenere la stabilità del tasso di cambio tpUSD?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Come hai intenzione di mantenere la stabilità del tasso di cambio tpUSD?</h3><p><strong>Dag</strong>: Mantenere la stabilità del tasso di cambio di una stablecoin è ovviamente cruciale per il suo successo. Ci sono diversi tipi di stablecoin, tra cui quelle collaterali, quelle collaterali a criptovalute e quelle algoritmiche. Ognuna ha i suoi vantaggi e svantaggi.<br>Le stablecoin collaterali sono garantite da asset reali o dollari effettivi, offrendo un alto livello di stabilità. Ad esempio, USDT è una stablecoin collaterale che è agganciata al dollaro statunitense.</p>
<p>Le stablecoin garantiti da criptovalute, come DAI, hanno un supporto di criptovalute e sono gestiti da un DAO.</p>
<p>Gli stablecoin algoritmici, d’altra parte, utilizzano algoritmi software per controllare l’offerta e la domanda al fine di mantenere il loro ancoraggio. Vale la pena notare che gli stablecoin algoritmici possono essere più rischiosi rispetto agli stablecoin garantiti o cripto-garantiti.</p>
<p>Il crollo di una stablecoin, come è successo con <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Luna sulla rete Cosmos, può destabilizzare un intero ecosistema. Nel caso di tpUSD, abbiamo scelto di adottare un approccio cripto-collateralizzato. Quindi ogni tpUSD sarà supportato da un USDT/USDC, fornendo un alto livello di stabilità. Ciò significa che il prezzo di tpUSD sarà mantenuto ad un tasso di cambio stabile di 1 dollaro, dando agli utenti fiducia nel valore dei loro asset.</p>
<h3 id="h3-Q820Il20vostro20progetto2020interamente20basato20su20DAO20e20la20vostra20aspirazione2020per20una20vera20democrazia20Ci20potete20dire20come20questi20sviluppi20sono20integrati20con20la20vostra20comunit175989"><a name="Q8: Il vostro progetto è interamente basato su DAO, e la vostra aspirazione è per una vera democrazia. Ci potete dire come questi sviluppi sono integrati con la vostra comunità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q8: Il vostro progetto è interamente basato su DAO, e la vostra aspirazione è per una vera democrazia. Ci potete dire come questi sviluppi sono integrati con la vostra comunità?</h3><p><img src="https://gimg2.gateimg.com/image/article/16820650646.png" alt=""><br><strong>Dag</strong>: Esattamente, innanzitutto, tutti i detentori di pionieri di Tomi, il nostro NFT di governance, hanno la capacità di suggerire e votare proposte in una DAO per cambiare la governance di Tomi. Potrebbero licenziare membri del team se lo ritenessero necessario, o ottenere finanziamenti per creare eventi per promuovere Tomi, il cielo è il limite in realtà. Ma non è necessario possedere un NFT per suggerire nuove proposte alla governance di Tomi, è un processo collaborativo in cui tutti nella comunità partecipano, se lo desiderano. E finché troverai un detentore di un pioniere e collaborerai con lui, potrai cambiare la governance di Tomi senza possedere un Pioneer NFT.</p>
<h3 id="h3-Q920Parlando20della20comunit20quali20sono20i20passi20che20stai20compiendo20per20far20crescere20la20comunit463946"><a name="Q9: Parlando della comunità, quali sono i passi che stai compiendo per far crescere la comunità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q9: Parlando della comunità, quali sono i passi che stai compiendo per far crescere la comunità?</h3><p><strong>Dag</strong>: In realtà, la prima proposta che è stata approvata è stata quella della tomiARMY, la sua piattaforma per qualsiasi membro della comunità di unirsi e poter guadagnare token tomi per svolgere determinati compiti per promuovere l’azienda. È super divertente e coinvolgente, quindi vi consiglio davvero di dare un’occhiata. Ed è anche un ottimo modo per guadagnare token gratuiti! Abbiamo anche appena lanciato la nostra comunità giapponese tomi, quindi hanno la propria pagina Twitter e tutto, e naturalmente speriamo che questa cresca ancora di più per accogliere più membri della comunità che si impegnano nella propria lingua madre. Il nostro focus è sempre sulla comunità e sulla sua crescita, poiché, alla fine, la governance di tomi proviene dai membri della nostra comunità.</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. Sarà consentito il ripostaggio dell'articolo a condizione che sia citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>