R2F0ZS5pbyBBTUEgbWV0IEFtYmlyZSBXYWxsZXQgLSBPbSBDcnlwdG8gU2VsZi1DdXN0b2R5IG1ha2tlbGlqayBlbiB2ZWlsaWcgdGUgbWFrZW4gdm9vciBpZWRlcmVlbg==

<p><img src="https://gimg2.gateimg.com/image/article/16807646441.jpg" alt=""><br><strong>Tijd: 28 april 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> georganiseerd een AMA (Vraag-mij-alles) sessie met Georgi Vladimirov, Community Manager van Ambire Wallet 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://www.ambire.com/" rel="nofollow noopener noreferrer" target="_blank">https://www.ambire.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/AmbireWallet" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/AmbireWallet</a></strong><br><strong>Volg Ambire op <a href="https://discord.com/invite/nMBGJsb" rel="nofollow noopener noreferrer" target="_blank">Discord</a> en <a href="https://t.me/AmbireOfficial" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16807648962.png" alt=""><br><strong>Georgi Vladimirov - Gemeenschapsmanager bij Ambire</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio119110"><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-Q120Vertel20ons20alstublieft20in20een20paar20woorden20over20het20doel20van20Ambire20Wallet20Hoe20kwam20u20op20het20idee20ervoor967559"><a name="Q1: Vertel ons alstublieft in een paar woorden over het doel van Ambire Wallet? Hoe kwam u op het idee ervoor?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Vertel ons alstublieft in een paar woorden over het doel van Ambire Wallet? Hoe kwam u op het idee ervoor?</h3><p><strong>Georgi</strong>: Ambire Wallet werd gelanceerd in december 2021 door hetzelfde team dat Ambire AdEx (oorspronkelijk AdEx Network) in 2017 heeft gecreëerd.</p>
<p>Natuurlijk, na verloop van tijd, aangezien iedereen in het team bekend is met crypto, begonnen we dingen te zien in de niet-custodiale portefeuilles die ons dwarszaten en die we konden oplossen met een nieuw product. Toen we valideerden dat de markt hetzelfde nodig heeft, besloten we Ambire Wallet te creëren en de gebruikelijke UI/UX pijnpunten op te lossen die de andere portefeuilles hadden, met nog meer geweldige functionaliteit daar bovenop.<br><img src="https://gimg2.gateimg.com/image/article/16807649163.png" alt=""><br>Om u een beter perspectief te geven, is Ambire Wallet een volledig uitgeruste open source en niet-custodial Smart DeFi-portemonnee met e-mailverificatie, ontworpen voor iedereen van absolute beginner tot DeFi-degens. Het brengt een aantal innovatieve functies met zich mee, zoals automatisch gasbeheer, betaling van netwerkkosten in stablecoins, ondersteuning van hardware-portemonnees en weergave van transactiegegevens op een menselijk leesbare manier voor verhoogde gebruikersbescherming.</p>
<h3 id="h3-Q220Waarom20zouden20mensen20Ambire20Wallet20moeten20kiezen20boven20de20andere20wallets20op20het20veld286478"><a name="Q2: Waarom zouden mensen Ambire Wallet moeten kiezen boven de andere wallets op het veld?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Waarom zouden mensen Ambire Wallet moeten kiezen boven de andere wallets op het veld?</h3><p><strong>Georgi</strong>: Vooral omdat als je van crypto en DeFi houdt, er geen betere manier is om je bezittingen te gebruiken en de beste UI/UX te krijgen terwijl je dat doet. Maar als we specifieker moeten zijn:</p>
<p>-Gebruikersbeloningsstimulans - u krijgt dit alleen voor het behouden van uw tokens in de Ambire Wallet, geen andere vereisten, de aanbevolen minimum is $1000, maar zelfs met minder maakt u er deel van uit. U krijgt uw airdrop in WALLET-tokens en u kunt uw fondsen op elk gewenst moment opnemen. Momenteel rond de 12% APY en opnieuw, geen bindingseisen.</p>
<ul>
<li><p>Snelle en snelle e-mail/wachtwoordregistratie, geen seed-zinnen of privésleutels, registreer in een paar seconden veilig en gemakkelijk en spring in de DeFi-wereld.</p>
</li><li><p>Betaal de netwerktransactiekosten in andere tokens, niet alleen inheemse tokens. Super handig als je stabiele munten vasthoudt, bijvoorbeeld, of als je wilt betalen met WALLET-tokens.</p>
</li></ul>
<p>-Visuele weergave van transacties die leesbaar is voor mensen - maak nooit meer de fout om de verkeerde transactie te ondertekenen en gekaapt te worden.</p>
<h3 id="h3-Q320Kunt20u20ons20het20concept20introduceren583189"><a name="Q3: Kunt u ons het concept introduceren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Kunt u ons het concept introduceren?</h3><p><strong>Georgi</strong> Graag zou ik dat echt willen! Het is een grote stap voorwaarts in het adopteren van cryptowallets voor iedereen.</p>
<p>Ambire implementeert traditionele authenticatie met een e-mail en een wachtwoord zoals traditionele web2-apps. Deze authenticatiemodus is volledig niet-bewaarder. Het is een absolute innovatie omdat het een geweldige balans biedt tussen beveiliging en gebruiksgemak.</p>
<p>Het werkt door gebruik te maken van slimme contract wallet technologie en het gebruik van twee aparte sleutels, één gekoppeld aan het e-mailadres en de andere versleuteld met het wachtwoord. Op deze manier, als één sleutel wordt aangetast, ben je nog steeds veilig.</p>
<h3 id="h3-Q420Ambire20Wallets20token20heet20WALLET20en20is20onlangs20genoteerd20op20Gateio20Kun20je20ons20een20paar20woorden20vertellen20over20het20gebruik20ervan242936"><a name="Q4: Ambire Wallet’s token heet WALLET en is onlangs genoteerd op Gate.io. Kun je ons een paar woorden vertellen over het gebruik ervan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Ambire Wallet’s token heet WALLET en is onlangs genoteerd op Gate.io. Kun je ons een paar woorden vertellen over het gebruik ervan?</h3><p><strong>Georgi</strong>: Ja, de WALLET-token is al een paar weken live op Gate.io met een USDT-paar, dus als iemand er nog niet in heeft gehandeld, moeten ze zich haasten.</p>
<p>WALLET is een unieke toevoeging aan ons ecosysteem, aangezien het de eerste governance token is voor een portemonnee voor massaconsumenten.<br>Dit maakt vele unieke gebruiksmogelijkheden mogelijk:</p>
<ul>
<li>Stemmen voor toekomstige ontwikkelingen en voorstellen indienen.</li><li>Stimuleren van gebruik: Gebruikersbeloningen voor het vasthouden van tokens in Ambire Wallet.</li><li>Verwijsbonussen, gasrestituties en andere stimuleringsmechanismen.</li></ul>
<p>Kort gezegd is WALLET een governance-token, het zal WalletDAO controleren en de toekomst van het product bepalen, maar ook een geweldig groeimechanisme voor Ambire.</p>
<h3 id="h3-Q520Wat20kunnen20we20verwachten20van20de20Ambire20Wallet20tegen20het20einde20van202022546708"><a name="Q5: Wat kunnen we verwachten van de Ambire Wallet tegen het einde van 2022?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Wat kunnen we verwachten van de Ambire Wallet tegen het einde van 2022?</h3><p><strong>Georgi</strong>: We volgen strikt ons routekaart. Dit gezegd zijnde:<br>-Zeer binnenkort zal de mobiele applicatie voor Ambire Wallet beschikbaar zijn in de Google Play Store en de Apple Store en zal dit weer een stap zijn in het dichterbij brengen van de smart-wallet technologie voor iedereen.</p>
<p>We zijn van plan om dit jaar onze debitcard uit te brengen. De kaarthouders kunnen geld opnemen vanuit hun portemonnee bij een geldautomaat of POS-terminal, zonder dat ze door een derde partij hoeven te gaan.</p>
<ul>
<li>The WALLET DAO zal nog een use case toevoegen voor onze $WALLET token, waardoor governance mogelijk is voor de houders en andere voordelen, die we tijdens het proces zullen aankondigen.</li></ul>
<p>-Meer functies die onze gebruikers zullen helpen om de winsten die ze maken uit hun cryptovaluta te maximaliseren.</p>
<p>En alleen maar zodat ik het niet vergeet, implementeren we binnenkort ook een hele leuke NFT-verrassing!<br><img src="https://gimg2.gateimg.com/image/article/16807648084.png" alt=""><br>Je kunt ons volgen in DIscord en op de hoogte blijven van alle vooruitgang die we boeken:<br><a href="https://discord.gg/erA5Z3PU" rel="nofollow noopener noreferrer" target="_blank">https://discord.gg/erA5Z3PU</a></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 visie van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan, mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>