R2F0ZS5pbyBBTUEgbWV0IFRPTUkgLSBWcmlqaGVpZCB3ZXJrZWxpamtoZWlkIG1ha2Vu

<p><img src="https://gimg2.gateimg.com/image/article/16820648051.png" alt=""><br><strong>Tijd: 20 april 2023, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Vraag-Me-Alles) sessie met Dag, Community &amp; Content specialist bij TOMI in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële Website: <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>Volg TOMI op <a href="https://t.me/tomipioneers" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://discord.com/invite/tomi" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16820650312.jpeg" alt=""><br><strong>Dag - Gemeenschaps- en inhoudsspecialist bij TOMI</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio594254"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-Q120Kunt20u20zichzelf20voorstellen20aan20ons20publiek899890"><a name="Q1: Kunt u zichzelf voorstellen aan ons publiek?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u zichzelf voorstellen aan ons publiek?</h3><p><strong>Dag</strong>: Mijn naam is Dag, ik ben de community- en content specialist van Tomi. Ik ben erg blij om jullie allemaal te ontmoeten en te praten over alle spannende zaken rondom Tomi. Op een bepaalde manier ben ik denk ik een weerspiegeling van de ware geest van Tomi, aangezien we een door de gemeenschap gedreven project zijn. Ik ben eigenlijk gerekruteerd uit de gemeenschap om deze rol op me te nemen en deel uit te maken van het Tomi-team. Ik ken de meeste mensen van het team niet omdat het een anoniem project is, maar we werken allemaal samen aan een gemeenschappelijk doel, decentralisatie.</p>
<h3 id="h3-Q220Ik20geloof20dat20het20merendeel20van20het20publiek20al20bekend20is20met20Tomi20maar20voor20degenen20die20dat20niet20doen20kunt20u20ons20wat20meer20vertellen20over20het20project703639"><a name="Q2: Ik geloof dat het merendeel van het publiek al bekend is met Tomi, maar voor degenen die dat niet doen, kunt u ons wat meer vertellen over het project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Ik geloof dat het merendeel van het publiek al bekend is met Tomi, maar voor degenen die dat niet doen, kunt u ons wat meer vertellen over het project?</h3><p><img src="https://gimg2.gateimg.com/image/article/16820651303.png" alt=""><br><strong>Dag</strong>: Natuurlijk, zoals ik al zei, worden we gedreven door de gemeenschap, maar het kernidee achter tomi is om gedecentraliseerde producten te creëren om mensen te bevrijden van de beperkingen van de gecentraliseerde wereld waarin we vandaag leven. Enkele voorbeelden, hoe uw gegevens worden verkocht aan derden om gerichte advertenties te maken op basis van uw browsegeschiedenis, of misschien nog belangrijker. Geef mensen die leven in landen waar het internet gecensureerd of gecontroleerd wordt, een platform om zich vrij te uiten.</p>
<h3 id="h3-Q320Het20unieke20aan20tomi20is20dat20je20echt20werkt20aan20een20breed20scala20aan20producten20om20een20volledige20infrastructuur20van20producten20te20creren20die20privacy20bieden20en20vrijheid20van20meningsuiting20mogelijk20maken20Kun20je20enkele20van20deze20producten20delen20en20ze20kort20uitleggen968303"><a name="Q3: Het unieke aan tomi is dat je echt werkt aan een breed scala aan producten om een volledige infrastructuur van producten te creëren die privacy bieden en vrijheid van meningsuiting mogelijk maken. Kun je enkele van deze producten delen en ze kort uitleggen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Het unieke aan tomi is dat je echt werkt aan een breed scala aan producten om een volledige infrastructuur van producten te creëren die privacy bieden en vrijheid van meningsuiting mogelijk maken. Kun je enkele van deze producten delen en ze kort uitleggen?</h3><p><img src="https://gimg2.gateimg.com/image/article/16820651114.png" alt=""><br><strong>Dag</strong>: Natuurlijk is het grootste product voor mij ons gedecentraliseerde internet dat we aan het ontwikkelen zijn. De visie van Tomi is om de infrastructuur te creëren die nodig is om een volledig gedecentraliseerd platform te hebben om de vrijheden van mensen te herstellen. En daar hebben we tomiPAY, onze multi-chain portemonnee, we hebben onze browser naar dit gedecentraliseerde internet, de tomiNET, we hebben ook tDNS, wat ons gedecentraliseerde domeinnaamsysteem is. En al deze producten zijn live, de meeste zitten in hun testfase, maar toch, jullie kunnen ze uitproberen. Ik bedoel, de lijst is zelfs langer dan dit, het doel van Tomi is om alle gebieden te bestrijken om onze gemeenschapsleden een volledig gedecentraliseerd en privé-alternatief te bieden om hopelijk op een dag het gecentraliseerde systeem dat we vandaag de dag leven en gebruiken, buiten gebruik te stellen. Dit is een van de belangrijkste redenen waarom we de TPL hebben ontwikkeld en waarom ik hier vandaag zo enthousiast ben om met jullie hierover te praten.</p>
<h3 id="h3-Q420Je20sprak20over20TPL20en20tdUSD20die20een20paar20dagen20geleden20zijn20aangekondigd20Het20is20geweldig20en20we20wachten20vol20ongeduld20op20de20voltooiing20van20de20ontwikkeling20Wat20kun20je20me20daarover20vertellen853269"><a name="Q4: Je sprak over TPL en tdUSD die een paar dagen geleden zijn aangekondigd. Het is geweldig en we wachten vol ongeduld op de voltooiing van de ontwikkeling. Wat kun je me daarover vertellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Je sprak over TPL en tdUSD die een paar dagen geleden zijn aangekondigd. Het is geweldig en we wachten vol ongeduld op de voltooiing van de ontwikkeling. Wat kun je me daarover vertellen?</h3><p><strong>Dag</strong>: Ik ben het eens, het is allemaal erg spannend! Ja, zoals je zei is het nog niet helemaal operationeel, maar we zijn goed op weg om een werkelijk levensveranderende oplossing te bieden als het gaat om cryptotransacties en financiële privacy. Als je erover nadenkt, is het behoorlijk vreemd hoe we gewend zijn geraakt aan het feit dat elke transactie op de blockchain openbaar is. Je zou waarschijnlijk erg van streek zijn als ik precies zou kunnen zien wat je op je bankrekening hebt staan, of welke activa je in je bankdeposito hebt. Dus waarom zou het anders moeten zijn met je crypto?</p>
<h3 id="h3-Q520Hoe20werkt20het20technisch20gezien20In20het20g20dat20het20niet20is20uitgelegd20in20het20vorige20antwoord632545"><a name="Q5: Hoe werkt het technisch gezien? (In het g dat het niet is uitgelegd in het vorige antwoord)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Hoe werkt het technisch gezien? (In het g dat het niet is uitgelegd in het vorige antwoord)</h3><p><strong>Dag</strong>: Dus eigenlijk, om een beetje technisch te worden, om toegang te krijgen tot de TPL en de wereld van private crypto-transacties te ontdekken, gebruikt u uw tomiPay-portemonnee. Daar hebben we een speciale TPL-tabblad, waar u uw USDT / USDC naar tpUSD kunt overbruggen. En wanneer u op de knop drukt om USDT te overbruggen, sluiten we ze op en zetten we ze inzetten. Je krijgt natuurlijk het equivalent van tpUSD dat al op onze TPL bestaat! En de beloningen voor deze inzet worden gebruikt om tomi-tokens terug te kopen die vervolgens worden gebruikt voor de verdere ontwikkeling van het ecosysteem. Maar natuurlijk houden we altijd 20% van de activa van de gebruikers niet ingezet om eventuele vertragingen te voorkomen, zodat ze er supersnel toegang toe kunnen krijgen!<br><img src="https://gimg2.gateimg.com/image/article/16820650825.png" alt=""><br>Misschien vermelden als er tijd is: Het idee voor deze producten kwam voort uit de werkelijke behoeften van gebruikers, we zien een kloof in de markt en deze twee producten komen perfect samen om onze toekomstvisie van decentralisatie te ondersteunen.</p>
<h3 id="h3-Q620Onlangs20is20er20veel20gesproken20over20CBDCs20in20de20krantenkoppen20Voor20degenen20die20niet20bekend20zijn20CBDCs20zijn20digitale20valutas20die20worden20uitgegeven20door20centrale20banken20wat20betekent20dat20ze20zeer20gecentraliseerde20valutas20zijn20Biedt20Tomi20een20echte20oplossing20voor20het20privacyprobleem995393"><a name="Q6: Onlangs is er veel gesproken over CBDC’s in de krantenkoppen. Voor degenen die niet bekend zijn, CBDC’s zijn digitale valuta’s die worden uitgegeven door centrale banken, wat betekent dat ze zeer gecentraliseerde valuta’s zijn. Biedt Tomi een echte oplossing voor het privacyprobleem?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Onlangs is er veel gesproken over CBDC’s in de krantenkoppen. Voor degenen die niet bekend zijn, CBDC’s zijn digitale valuta’s die worden uitgegeven door centrale banken, wat betekent dat ze zeer gecentraliseerde valuta’s zijn. Biedt Tomi een echte oplossing voor het privacyprobleem?</h3><p><strong>Dag</strong>: Absoluut, ik bedoel we zijn allemaal voor wereldwijde crypto-adaptatie, maar we vinden het zeer problematisch om te zien dat de overheid probeert gedecentraliseerde activa te CENTRALISEREN. Zoals we waarschijnlijk allemaal weten, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> kwam tot stand na de financiële crisis van 2008 als gevolg van het gebrek aan vertrouwen van het publiek in overheden en gecentraliseerde autoriteiten om hun bezittingen te beheren. Dus bedoel ik ook dat dit een van de redenen is waarom tomi bestaat, om gedecentraliseerde opties te creëren om het vermogen van individuen te ondersteunen om te bestaan ​​zonder afhankelijk te zijn van deze gecentraliseerde en!</p>
<h3 id="h3-Q720Hoe20plan20je20de20stabiliteit20van20de20tpUSDwisselkoers20te20behouden140672"><a name="Q7: Hoe plan je de stabiliteit van de tpUSD-wisselkoers te behouden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Hoe plan je de stabiliteit van de tpUSD-wisselkoers te behouden?</h3><p><strong>Dag</strong>: Het handhaven van de stabiliteit van de wisselkoers van een stablecoin is natuurlijk cruciaal voor het succes ervan. Er zijn verschillende soorten stablecoins, waaronder onderpand, crypto-onderpand en algoritmische. Elk heeft zijn eigen voor- en nadelen. Onderpandstablecoins worden ondersteund door echte activa of echte dollars, wat zorgt voor een hoog niveau van stabiliteit. USDT is bijvoorbeeld een onderpandstablecoin die gekoppeld is aan de Amerikaanse dollar.</p>
<p>Crypto-gecollateraliseerde stablecoins, zoals DAI, hebben cryptocurrency-ondersteuning en worden beheerd door een DAO.</p>
<p>Aan de andere kant gebruiken algorithmische stabiele munten software-algoritmen om het aanbod en de vraag te reguleren en de koppeling te behouden. Het is vermeldenswaard dat algorithmische stabiele munten riskanter kunnen zijn dan gecollateraliseerde of crypto-gecollateraliseerde stabiele munten.</p>
<p>De ineenstorting van een stablecoin, zoals wat er gebeurde met <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Luna op het Cosmos-netwerk kan een heel ecosysteem destabiliseren. In het g van tpUSD hebben we ervoor gekozen om een crypto-gecollateraliseerde aanpak te nemen. Dus elke tpUSD zal worden gedekt door één USDT/USDC, wat zorgt voor een hoog niveau van stabiliteit. Dit betekent dat de prijs van tpUSD wordt gehandhaafd op een stabiele wisselkoers van 1 dollar, wat gebruikers vertrouwen geeft in de waarde van hun bezittingen.</p>
<h3 id="h3-V820Uw20project20is20volledig20gebaseerd20op20DAO20en20uw20ambitie20is20echte20democratie20Kunt20u20ons20vertellen20hoe20deze20ontwikkelingen20gentegreerd20zijn20met20uw20gemeenschap690497"><a name="V8: Uw project is volledig gebaseerd op DAO, en uw ambitie is echte democratie. Kunt u ons vertellen hoe deze ontwikkelingen geïntegreerd zijn met uw gemeenschap?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V8: Uw project is volledig gebaseerd op DAO, en uw ambitie is echte democratie. Kunt u ons vertellen hoe deze ontwikkelingen geïntegreerd zijn met uw gemeenschap?</h3><p><img src="https://gimg2.gateimg.com/image/article/16820650646.png" alt=""><br><strong>Dag</strong>: Precies, ten eerste hebben alle houders van tomi-pioniers, onze governance NFT, de mogelijkheid om voorstellen voor te stellen en te stemmen in een DAO om de governance van tomi te veranderen. Ze kunnen teamleden ontslaan als ze dat nodig achten, of financiering krijgen om evenementen te organiseren om tomi te promoten, de mogelijkheden zijn eindeloos. Maar je hoeft eigenlijk geen NFT te hebben om nieuwe voorstellen voor de governance van tomi voor te stellen, het is allemaal een samenwerkingsproces waar iedereen in de gemeenschap aan deelneemt, als ze dat willen. En zolang je een houder van een pionier vindt en met hen samenwerkt, kun je de governance van tomi veranderen zonder een Pioneer NFT te hebben.</p>
<h3 id="h3-V920Wat20betreft20de20gemeenschap20welke20stappen20onderneemt20u20om20de20gemeenschap20te20laten20groeien591017"><a name="V9: Wat betreft de gemeenschap, welke stappen onderneemt u om de gemeenschap te laten groeien?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V9: Wat betreft de gemeenschap, welke stappen onderneemt u om de gemeenschap te laten groeien?</h3><p><strong>Dag</strong>: Eigenlijk was het eerste voorstel dat werd goedgekeurd, dat van de tomiARMY, het platform voor elk gemeenschapslid om lid te worden en tomi-tokens te verdienen door bepaalde taken uit te voeren om het bedrijf te promoten. Het is super leuk en boeiend, dus ik raad jullie allemaal aan om het te bekijken. En het is ook een geweldige manier om gratis tokens te verdienen! We hebben ook net onze Japanse tomi-gemeenschap gelanceerd, dus ze hebben hun eigen Twitter-pagina en natuurlijk hopen we dat dit nog verder zal groeien om meer gemeenschapsleden te verwelkomen die zich in hun moedertaal willen engageren. Onze focus ligt altijd op de gemeenschap en het laten groeien ervan, aangezien uiteindelijk het bestuur van tomi afkomstig is van onze gemeenschapsleden.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen, mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>