R2F0ZS5pbyBBTUEgY29uIEFtdWxldCAtIExhIHByaW1hIHBpYXR0YWZvcm1hIFdlYjMgY2hlIGNvbWJpbmEgaW52ZXN0aW1lbnRpIGUgYXNzaWN1cmF6aW9uaQ==

<p><img src="https://gimg2.gateimg.com/image/article/17066798791.jpeg" alt=""><br><strong>Ora: 30 gennaio 2023 alle 11: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 Jet, responsabile marketing di Amulet nel <a href="https://twitter.com/i/spaces/1lDxLPqNoykxm" rel="nofollow noopener noreferrer" target="_blank">Twitter Space</a>.</strong><br><strong>Sito Web ufficiale: <a href="https://amulet.org/" rel="nofollow noopener noreferrer" target="_blank">https://amulet.org/</a></strong><br><strong>Twitter: <a href="https://twitter.com/AmuletProtocol" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/AmuletProtocol</a></strong><br><strong>Segui Amulet su <a href="https://twitter.com/AmuletProtocol" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://discord.com/invite/aP7nKNQ9qC" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/17066800512.jpeg" alt=""><br><strong>Jet - Responsabile Marketing di Amulet</strong></p>
<h2 id="h2-QampA20da20Gateio489808"><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-Q120Potresti20condividere20la20tua20esperienza20e20cosa20fai20nel20progetto483929"><a name="Q1: Potresti condividere la tua esperienza e cosa fai nel progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti condividere la tua esperienza e cosa fai nel progetto?</h3><p><strong>Jet</strong>: Ciao a tutti, mi chiamo Jet e sono il Responsabile Marketing di Amulet. Sono nel settore del marketing tecnologico e crittografico da un po’ di tempo e sono entusiasta di essere qui.</p>
<p>Non vedo l’ora di condividere ciò che rende Amulet così speciale, come stiamo cambiando il modo in cui le persone vedono i propri investimenti DeFi e, soprattutto, come gli utenti come TE possono trarre vantaggio dall’interagire con il nostro prodotto.</p>
<h3 id="h3-Q220Potresti20parlarmi20del20tuo20progetto20in20termini20semplici876253"><a name="Q2: Potresti parlarmi del tuo progetto in termini semplici?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Potresti parlarmi del tuo progetto in termini semplici?</h3><p><strong>Jet</strong>: Permettimi di condividere un po’ della nostra storia. Amulet V1 è nato come il primo e unico protocollo di assicurazione DeFi su Gate.io. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> all’inizio del 2022. Abbiamo fornito copertura on-chain ai progetti <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> fin da allora.</p>
<p>Portando V1 un passo avanti, ci siamo seduti e abbiamo pensato: e se potessimo combinare investimenti e assicurazioni insieme, per unire entrambi i percorsi degli utenti in un’unica esperienza completa. Così è nato V2.</p>
<p>Amulet V2 è una piattaforma di rendimento multi-chain con protezione integrata, pensala come una piattaforma per guadagnare i tuoi rendimenti che sono automaticamente protetti nel momento in cui i tuoi fondi entrano nella nostra cassaforte.</p>
<p>Potresti chiederti come sia possibile. È grazie al nostro prodotto di punta: AmuShield, una soluzione di protezione a più strati integrata in ogni singola cassaforte elencata in Amulet.</p>
<p>AmuShield:<br>Utilizza la gestione del rischio parametrico per monitorare gli asset in tempo reale, rilevando gli incidenti di sicurezza attraverso confronti di prezzi dei token LP con trigger predefiniti.<br><img src="https://gimg2.gateimg.com/image/article/17066801093.jpeg" alt=""><br>In caso di incidenti di sicurezza, AmuShield facilita una risposta rapida, aiutando gli utenti a recuperare prontamente i loro asset.<br>Se è necessario un qualsiasi tipo di rimborso, AmuShield è pronta con una copertura finanziaria proveniente dal Fondo di Sicurezza Amulet, supportato inizialmente da 10 milioni di token AMU, per la protezione degli asset.<br>AmuVerse (Programma di Fidelizzazione):<br>Riconosciamo l’importanza della nostra community. Ecco perché abbiamo creato AmuVerse, una piattaforma interna di programma di fidelizzazione. Gli utenti possono guadagnare cristalli attraverso raccomandazioni, staking. Questi cristalli sono validi per i drop di token $AMU e molti altri utilizzi che condividerò più avanti nella roadmap.</p>
<h3 id="h3-Q320Qual2020il20tuo20token20e20lutilit20ad20esso20associata367853"><a name="Q3: Qual è il tuo token e l’utilità ad esso associata?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Qual è il tuo token e l’utilità ad esso associata?</h3><p><strong>Jet</strong>: $AMU è il token nativo e di governance di Amulet. Offre 3 funzionalità principali:</p>
<ul>
<li>Diritti di voto: $AMU dà potere ai detentori di partecipare attivamente al processo decisionale. Detenendo e bloccando $AMU in veAMU, gli utenti ottengono il potere di voto per influenzare gli aggiornamenti, proporre nuove funzionalità del prodotto e esprimere opinioni su questioni critiche di governance. L’intero processo è trasparente, con tutti i voti registrati sulla blockchain per la pubblica verifica.</li><li>Ricompense per il voto: Gli utenti che bloccano $AMU per partecipare alla governance riceveranno ricompense in $AMU per la loro partecipazione.</li><li>Potere di voto: Blocca $AMU per periodi più lunghi per ottenere maggiore potere di voto sotto forma di veAMU. Mantieni il potere di voto e le ricompense attraverso un coinvolgimento continuo.<br>Come detentori a lungo termine di $AMU, riceverete anche ricompense e incentivi attraverso i seguenti canali:</li><li>Ricompense del farming: Guadagnare $AMU direttamente depositando nei nostri vault.</li><li>Ricompense del farming potenziate: L’introduzione del sistema veAMU e del gauge porta gli incentivi a un livello superiore. Gli utenti che bloccano il proprio $AMU per periodi prolungati godono di ricompense del farming potenziate, offrendo un ulteriore livello di benefici per gli stakeholder impegnati.</li><li>Ricompense di governance: La partecipazione attiva alla governance è premiata. Coloro che contribuiscono a plasmare il futuro del protocollo ricevono incentivi, creando un circolo vizioso che incoraggia il coinvolgimento della comunità.</li><li>Programmi aggiuntivi di revenue-sharing: $AMU riconosce il valore degli utenti a lungo termine e coinvolti. Come detentore di token, potresti beneficiare di programmi aggiuntivi di revenue-sharing, migliorando ulteriormente la proposta di valore complessiva.<br>$AMU è ora quotato su Gate.io! Puoi scambiarlo subito e partecipare alle molte campagne che offrono ricompense in $AMU.</li></ul>
<h3 id="h3-Q420Qual2020la20tabella20di20marcia20per20il202024501579"><a name="Q4: Qual è la tabella di marcia per il 2024?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Qual è la tabella di marcia per il 2024?</h3><p><strong>Jet</strong>: Abbiamo grandi progetti in programma per Amulet e siamo entusiasti di condividerli con voi.</p>
<ul>
<li>Espansione verso più reti, integrazione di più strategie di rendimento, collaborazione con più progetti. Infatti, abbiamo recentemente lanciato le nostre Solana Vaults su V2, su cui gli utenti possono depositare mSOL, bSOL e JitoSOL. Portando davvero una protezione conveniente a ogni progetto e a ogni utente nello spazio.</li><li>Lancio di Governance: una funzionalità che stiamo sviluppando per dare valore ai detentori a lungo termine del token $AMU. Vogliamo che la nostra comunità abbia voce in capitolo nella costruzione del futuro di Amulet.</li><li>Aggiornamento di AmuVerse: stiamo cercando di introdurre più funzionalità in AmuVerse, tra cui la funzionalità Lucky Draw, portando più casi d’uso ai nostri cristalli e consentendo agli utenti di vincere più $AMU.</li></ul>
<h3 id="h3-Q520Qual2020una20cosa20che20vorresti20che20le20persone20sapessero20che20ti20differenzia20dai20concorrenti615052"><a name="Q5: Qual è una cosa che vorresti che le persone sapessero che ti differenzia dai concorrenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Qual è una cosa che vorresti che le persone sapessero che ti differenzia dai concorrenti?</h3><p><strong>Jet</strong>: Se c’è un punto di forza che ci differenzia dagli altri progetti, è che offriamo comodità e tranquillità.<br>Amulet V2 è un protocollo focalizzato sul rendimento che incorpora protezioni integrate, privilegiando la generazione di rendimenti selezionati mentre successivamente enfatizza una solida gestione del rischio.<br>Quindi il nostro obiettivo non è davvero quello di competere con altri progetti per dire chi ha il miglior rendimento o la migliore strategia ma, davvero, di integrarci con una varietà di strategie di rendimento eccezionali e affidabili, collaborando con loro e portando protezione integrata alla loro porta, affinché i loro utenti possano godere di rendimenti sicuri, ovunque siano i loro fondi.</p>
<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 ri-pubblicare dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div>