R2F0ZS5pbyBBTUEgbWV0IEFtdWxldCAtIEhldCBlZXJzdGUgV2ViMy1wbGF0Zm9ybSBkYXQgYmVsZWdnZW4gZW4gdmVyemVrZXJlbiBjb21iaW5lZXJ0

<p><img src="https://gimg2.gateimg.com/image/article/17066798791.jpeg" alt=""><br><strong>Tijd: 30 januari 2023 om 11:00 uur UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Vraag-Me-Alles) sessie met Jet, Marketing Lead van Amulet in de <a href="https://twitter.com/i/spaces/1lDxLPqNoykxm" rel="nofollow noopener noreferrer" target="_blank">Twitter Space</a>.</strong><br><strong>Officiële website: <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>Volg Amulet op <a href="https://twitter.com/AmuletProtocol" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://discord.com/invite/aP7nKNQ9qC" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/17066800512.jpeg" alt=""><br><strong>Jet - Marketing Lead van Amulet</strong></p>
<h2 id="h2-QampA20van20Gateio34881"><a name="Q&amp;A van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A van Gate.io</h2><h3 id="h3-Q120Kunt20u20uw20ervaringen20delen20en20vertellen20wat20u20doet20bij20het20project904618"><a name="Q1: Kunt u uw ervaringen delen en vertellen wat u doet bij het project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u uw ervaringen delen en vertellen wat u doet bij het project?</h3><p><strong>Jet</strong>: Hallo iedereen, mijn naam is Jet en ik ben de Marketing Lead voor Amulet. Ik ben al een tijdje actief in de technologie- en cryptomarketing en ik ben ontzettend enthousiast om hier te zijn.</p>
<p>Ik kijk ernaar uit om te delen wat Amulet zo speciaal maakt, hoe we de manier veranderen waarop mensen naar hun DeFi-investeringen kijken en nog belangrijker, hoe gebruikers zoals JIJ kunnen profiteren van het gebruik van ons product.</p>
<h3 id="h3-Q220Kun20je20me20in20eenvoudige20bewoordingen20iets20vertellen20over20je20project475206"><a name="Q2: Kun je me in eenvoudige bewoordingen iets vertellen over je project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kun je me in eenvoudige bewoordingen iets vertellen over je project?</h3><p><strong>Jet</strong>: Sta me toe om een beetje van onze geschiedenis te delen.<br>Amulet V1 begon als het eerste en enige DeFi-verzekeringsprotocol op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> begin 2022. We hebben sindsdien on-chain dekking geboden aan Solana-projecten.</p>
<p>Met V1 gingen we een stap verder en dachten we na: wat als we investeringen en verzekeringen konden combineren, om beide gebruikersreizen samen te voegen in één complete ervaring. Zo werd V2 geboren.</p>
<p>Amulet V2 is een multi-chain opbrengstplatform met ingebouwde bescherming, denk aan een platform waarop je rendement kunt verdienen dat automatisch wordt beschermd op het moment dat je geld onze kluis binnenkomt.</p>
<p>Je vraagt je misschien af hoe dit mogelijk is. Het is te wijten aan ons vlaggenschipproduct: AmuShield, een meerlaagse beschermingsoplossing geïntegreerd in elke enkele kluis vermeld in Amulet.</p>
<p>AmuShield:<br>Het maakt gebruik van parametrisch risicobeheer om activa in realtime te bewaken, waarbij beveiligingsincidenten worden gedetecteerd via vergelijkingen van LP-tokenprijzen met vooraf gedefinieerde triggers.<br><img src="https://gimg2.gateimg.com/image/article/17066801093.jpeg" alt=""><br>In g van een beveiligingsincident vergemakkelijkt AmuShield een snelle respons, waarbij gebruikers hun activa snel kunnen ophalen. Als er een vorm van claimuitkering nodig is, staat AmuShield klaar met financiële dekking van het Amulet Safety Fund, ondersteund door aanvankelijk $10 miljoen AMU-tokens, voor activabescherming. AmuVerse (Loyaliteitsprogramma): We erkennen het belang van onze gemeenschap. Daarom hebben we AmuVerse gebouwd, een intern platform voor loyaliteitsprogramma’s. Gebruikers kunnen kristallen verdienen via doorverwijzingen, staking. Deze kristallen komen in aanmerking voor $AMU-token drops en vele andere toepassingen die ik later in de routekaart zal delen.</p>
<h3 id="h3-Q320Wat20is20uw20token20en20het20nut20ervan630299"><a name="Q3: Wat is uw token en het nut ervan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Wat is uw token en het nut ervan?</h3><p><strong>Jet</strong>: $AMU is Amulet’s native en governance token. Het biedt 3 hoofdfuncties:</p>
<ul>
<li>Stemrechten: $AMU stelt houders in staat om actief deel te nemen aan de beslissing<br>maakproces. Door $AMU in veAMU te houden en vast te zetten, krijgen gebruikers stemrecht om upgrades te beïnvloeden, nieuwe productfuncties voor te stellen en meningen te geven over kritieke bestuurskwesties. Het hele proces is transparant, waarbij alle stemmen op de blockchain worden geregistreerd voor publieke controle.</li><li>Stembeloningen: Gebruikers die $AMU inzetten om deel te nemen aan het bestuur, ontvangen $AMU beloningen voor hun deelname</li><li>Stemrecht: Zet $AMU voor langere tijd vast voor meer stemrecht in de vorm van veAMU. Behoud stemrecht en beloningen door continue betrokkenheid.<br>Als houders van langdurige $AMU wordt u ook beloond en gestimuleerd via de volgende kanalen:</li><li>Boerderijbeloningen: Verdien $AMU rechtstreeks door ze in onze kluizen te storten.</li><li>Verhoogde boerderijbeloningen: De introductie van het veAMU- en metersysteem gaat nog een stap verder met prikkels. Gebruikers die hun $AMU voor langere tijd vergrendelen, genieten van verhoogde boerderijbeloningen, wat een extra laag voordelen biedt voor toegewijde belanghebbenden.</li><li>Governance Rewards: Actieve deelname aan governance wordt beloond. Degenen die bijdragen aan het vormgeven van de toekomst van het protocol ontvangen prikkels, waardoor een feedbacklus ontstaat die de betrokkenheid van de gemeenschap aanmoedigt.</li><li>Aanvullende programma’s voor het delen van inkomsten: $AMU erkent de waarde van langdurige en betrokken gebruikers. Als tokenhouder kunt u profiteren van aanvullende programma’s voor het delen van inkomsten, waardoor de algehele waardepropositie verder wordt verbeterd.<br>$AMU staat nu op Gate.io! U kunt het nu direct verhandelen en deelnemen aan de vele campagnes die lucratieve $AMU beloningen bieden.</li></ul>
<h3 id="h3-Q420Wat20is20de20routekaart20voor202024515855"><a name="Q4: Wat is de routekaart voor 2024?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Wat is de routekaart voor 2024?</h3><p><strong>Jet</strong>: We hebben geweldige plannen voor Amulet en we zijn enthousiast om ze met jullie te delen.</p>
<ul>
<li>Uitbreiding naar meer netwerken, integratie van meer opbrengststrategieën, samenwerking met meer projecten. Sterker nog, we hebben onlangs onze <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Vaults gelanceerd op V2, waar gebruikers mSOL, bSOL en JitoSOL kunnen storten. Zo bieden we handige bescherming voor elk project en elke gebruiker in de ruimte.</li><li>Lancering van Governance: Een functie die we aan het bouwen zijn om waarde te bieden aan $AMU-langetermijntokenhouders. We willen dat onze community inspraak heeft in het opbouwen van de toekomst van Amulet.</li><li>Upgraden van AmuVerse: We willen meer functies toevoegen aan AmuVerse, waaronder de Lucky Draw-functie, waarmee we meer gebruiksmogelijkheden bieden voor onze kristallen en gebruikers de kans geven om meer $AMU te winnen.</li></ul>
<h3 id="h3-Q520Wat20is20het20ene20ding20dat20je20wenst20dat20mensen20wisten20dat20je20anders20maakt20dan20de20concurrentie317399"><a name="Q5: Wat is het ene ding dat je wenst dat mensen wisten dat je anders maakt dan de concurrentie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Wat is het ene ding dat je wenst dat mensen wisten dat je anders maakt dan de concurrentie?</h3><p><strong>Straalvliegtuig</strong>: Als er één leerpunt is dat ons onderscheidt van andere projecten, is het dat we gemak en gemoedsrust bieden.<br>Amulet V2 is een opbrengstgericht protocol dat ingebouwde bescherming bevat, waarbij de nadruk ligt op het genereren van gecureerde opbrengsten en vervolgens het benadrukken van solide risicobeheer.<br>Ons doel is dus niet echt om te concurreren met andere projecten om te zeggen wie de betere opbrengst of betere strategie heeft, maar echt om te integreren met een verscheidenheid aan uitzonderlijke en betrouwbare opbrengststrategieën, met hen samen te werken en ingebedde bescherming naar hun voordeur te brengen, zodat hun gebruikers veilige opbrengsten kunnen genieten, ongeacht waar hun fondsen zich bevinden.</p>
<div>Auteur:<strong> Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div>