R2F0ZS5pbyBBTUEgY29uIEFtYmlyZSBXYWxsZXQgLSBQZXIgcmVuZGVyZSBsJ2F1dG8tY3VzdG9kaWEgZGVsbGUgY3JpcHRvdmFsdXRlIGZhY2lsZSBlIHNpY3VyYSBwZXIgdHV0dGk=

<p><img src="https://gimg2.gateimg.com/image/article/16807646441.jpg" alt=""><br><strong>Orario: 28 aprile 2022, 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 Georgi Vladimirov, Community Manager di Ambire Wallet in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Web ufficiale: <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>Segui Ambire su <a href="https://discord.com/invite/nMBGJsb" rel="nofollow noopener noreferrer" target="_blank">Discord</a> e <a href="https://t.me/AmbireOfficial" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16807648962.png" alt=""><br><strong>Georgi Vladimirov - responsabile della comunità presso Ambire</strong></p>
<h2 id="h2-QampA20da20Gateio470264"><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-Q120Per20favore20raccontaci20qualche20parola20sullo20scopo20di20Ambire20Wallet20Come2020nata20lidea20a20riguardo604004"><a name="Q1: Per favore, raccontaci qualche parola sullo scopo di Ambire Wallet? Come è nata l’idea a riguardo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Per favore, raccontaci qualche parola sullo scopo di Ambire Wallet? Come è nata l’idea a riguardo?</h3><p><strong>Georgi</strong>: Ambire Wallet è stato lanciato nel dicembre 2021, dallo stesso team che ha creato Ambire AdEx (originariamente AdEx Network) nel 2017.</p>
<p>Naturalmente, nel tempo, dato che tutti nel team sono esperti di criptovaluta, abbiamo iniziato a vedere cose nei portafogli non custoditi là fuori che ci infastidivano e che siamo stati in grado di risolvere con un nuovo prodotto. Quando abbiamo confermato che anche il mercato aveva bisogno di questo, abbiamo deciso di creare Ambire Wallet e risolvere i problemi comuni di UI/UX che gli altri portafogli avevano, aggiungendo ancora più funzionalità eccezionali su tutto ciò.<br><img src="https://gimg2.gateimg.com/image/article/16807649163.png" alt=""><br>E per darti una migliore prospettiva su questo, Ambire Wallet è un portafoglio Smart DeFi completo, open source e non custodiale con autenticazione via email, progettato per chiunque, dal principiante assoluto ai DeFi degens. Porta una serie di funzionalità innovative come la gestione automatica del gas, il pagamento delle commissioni di rete in stablecoin, il supporto per i wallet hardware e la visualizzazione delle informazioni sulla transazione in modo leggibile per aumentare la protezione dell’utente.</p>
<h3 id="h3-Q220Perch20le20persone20dovrebbero20scegliere20Ambire20Wallet20rispetto20agli20altri20portafogli20sul20campo276364"><a name="Q2: Perché le persone dovrebbero scegliere Ambire Wallet rispetto agli altri portafogli sul campo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Perché le persone dovrebbero scegliere Ambire Wallet rispetto agli altri portafogli sul campo?</h3><p><strong>Georgi</strong>: Soprattutto, perché se ami le criptovalute e DeFi, non c’è modo migliore di utilizzare i tuoi beni e ottenere la migliore UI/UX nel farlo. Ma se vogliamo essere più specifici:</p>
<p>-Incentivi User Rewards: li ricevi solo per detenere i tuoi token nell’Ambire Wallet, senza altre restrizioni, il minimo consigliato è di $1000, ma anche con meno sarai parte di esso. Ricevi il tuo airdrop in token WALLET e puoi prelevare i tuoi fondi quando vuoi. Attualmente ha un APY di circa il 12% e ancora una volta, nessun requisito di vincolo.</p>
<ul>
<li>Registrazione rapida e veloce tramite email/password, senza frase di recupero o chiavi private, registrati in pochi secondi in modo sicuro e facile e immergiti nel mondo DeFi.</li></ul>
<p>-Paga le commissioni di transazione di rete in altre criptovalute, non solo in quelle native. Molto utile se hai stablecoin, ad esempio, o se vuoi pagare in token WALLET.</p>
<p>Visualizzazione delle transazioni leggibili dall’essere umano - non fare mai più l’errore di firmare la transazione sbagliata e venire dirottati.</p>
<h3 id="h3-Q320Potresti20presentarci20il20concetto705699"><a name="Q3: Potresti presentarci il concetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Potresti presentarci il concetto?</h3><p><strong>Georgi</strong> Mi piacerebbe davvero! È un grande passo avanti nell’adozione dei portafogli crittografici per tutti.</p>
<p>Ambire implementa l’autenticazione tradizionale con un’email e una password come le app web2 tradizionali. Questa modalità di autenticazione è completamente non custodiale. È un’innovazione assoluta perché offre un ottimo equilibrio tra sicurezza e facilità d’uso.</p>
<p>Funziona sfruttando la tecnologia del portafoglio del contratto intelligente e utilizzando due chiavi separate, una associata all’indirizzo email e l’altra crittografata con la password. In questo modo, se una chiave viene compromessa, sei comunque al sicuro.</p>
<h3 id="h3-Q420Il20token20del20portafoglio20Ambire20si20chiama20WALLET20ed2020stato20recentemente20quotato20su20Gateio20Puoi20dirci20qualche20parola20sul20suo20caso20duso135651"><a name="Q4: Il token del portafoglio Ambire si chiama WALLET ed è stato recentemente quotato su Gate.io. Puoi dirci qualche parola sul suo caso d’uso?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Il token del portafoglio Ambire si chiama WALLET ed è stato recentemente quotato su Gate.io. Puoi dirci qualche parola sul suo caso d’uso?</h3><p><strong>Georgi</strong>: Sì, il token WALLET è già attivo su Gate.io da alcune settimane con una coppia USDT, quindi se qualcuno non ha ancora iniziato a scambiarlo dovrebbe affrettarsi.</p>
<p>WALLET è un’aggiunta unica al nostro ecosistema in quanto è il primo token di governance per un portafoglio di massa-consumatore.<br>Ciò consente molte casistiche uniche:</p>
<p>-Votare per futuri sviluppi e presentare proposte.<br>-Incentivare l’uso: Ricompense per gli utenti che detengono token nel portafoglio Ambire.<br>-Bonus di riferimento, rimborsi per il gas e altri meccanismi di incentivo.</p>
<p>In breve, WALLET è un token di governance, controllerà il WalletDAO e determinerà il futuro del prodotto, ma è anche un ottimo meccanismo di crescita per Ambire.</p>
<h3 id="h3-Q520Cosa20dovremmo20aspettarci20dal20portafoglio20Ambire20entro20la20fine20del202022138182"><a name="Q5: Cosa dovremmo aspettarci dal portafoglio Ambire entro la fine del 2022?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Cosa dovremmo aspettarci dal portafoglio Ambire entro la fine del 2022?</h3><p><strong>Georgi</strong>: Stiamo seguendo rigorosamente la nostra roadmap. Detto questo:<br>-A molto presto l’applicazione mobile per Ambire Wallet sarà disponibile su Google Play e Apple Store e segnerà un altro passo avanti nel rendere la tecnologia smart-wallet accessibile a tutti.</p>
<p>-Abbiamo intenzione di rilasciare la nostra carta di debito quest’anno. I proprietari della carta potranno prelevare fondi dal loro portafoglio presso un bancomat o terminale POS, senza dover passare attraverso un terzo.</p>
<ul>
<li>Il WALLET DAO aggiungerà un altro caso d’uso per il nostro token $WALLET, consentendo la governance per i suoi detentori e altri vantaggi, che annunceremo durante il percorso.</li></ul>
<p>-Altre funzionalità che aiuteranno i nostri utenti a massimizzare i profitti che ottengono dalle loro criptovalute.</p>
<p>E solo per non dimenticare, stiamo per implementare una sorpresa NFT molto bella!<br><img src="https://gimg2.gateimg.com/image/article/16807648084.png" alt=""><br>Puoi seguirci su DIscord e rimanere aggiornato su tutti i progressi che facciamo:<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>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. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>