R2F0ZS5pbyBBTUEgbWV0IEFscGFjYSBGaW5hbmNlIC0gSGV0IGdyb290c3RlIHVpdGxlZW5wcm90b2NvbCBkYXQgbGV2ZXJhZ2VkIHlpZWxkIGZhcm1pbmcgb3AgQk5CIENoYWluIGVuIEZhbnRvbSBtb2dlbGlqayBtYWFrdA==

<p><img src="https://gimg2.gateimg.com/image/article/16895809181.jpg" alt=""><br><strong>Tijd: 20 november 2021, 13:00 uur UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Tonichi, Regionaal Business Development Manager van Alpaca Finance 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.alpacafinance.org/" rel="nofollow noopener noreferrer" target="_blank">https://www.alpacafinance.org/</a></strong><br><strong>Twitter: <a href="https://twitter.com/AlpacaFinance" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/AlpacaFinance</a></strong><br><strong>Volg Alpaca Finance op <a href="https://twitter.com/AlpacaFinance" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/alpacafinance" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16895812522.jpg" alt=""><br><strong>Tonichi - Regionaal Business Development Manager van Alpaca Finance</strong></p>
<h2 id="h2-QampA20van20Gateio61315"><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-Q120Voor20de20informatie20van20iedereen20wat20is20Alpaca20en20wat20is20het20doel20van20het20project882934"><a name="Q1: Voor de informatie van iedereen, wat is Alpaca en wat is het doel van het project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Voor de informatie van iedereen, wat is Alpaca en wat is het doel van het project?</h3><p><strong>Tonichi</strong>: Zeker! Laat me je dan een korte achtergrond van Alpaca geven en een voorbeeld geven van hoe je het beste kunt verdienen aan Alpaca en hoe het zich verhoudt tot meer traditionele investeringen.</p>
<p>In ruil daarvoor geeft Pancake swap je een deel van de handelskosten en beloont je ook met Pancake swap token, dat automatisch wordt geïnvesteerd in zijn positie omdat we bij Alpaca Finance willen dat je dat doet. <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Samengesteld</a> uw belang zo veel mogelijk, waardoor u de allerbeste rendementen krijgt!</p>
<p>En raad eens… Julian krijgt ook beloningen in Alpaca Token als bonus!</p>
<p>Wat hij dan kan opeisen en zelfs opnieuw kan investeren in onze Grazing-range (meer daarover later) en onze partnerprojecttokens kan verdienen als beloning met een APY van honderden procenten, soms zelfs duizenden als je er vroeg bij bent!</p>
<p>Het grootste probleem dat Alpaca Finance oplost, is kapitaalbenutting. Dit betekent dat we in staat zijn om geldschieters die hoge rentetarieven willen verdienen (bijvoorbeeld.. GEEN 3% PER JAAR MEER AUB) te verbinden met hefboomrendementboeren, die die fondsen gebruiken om hun winsten te vergroten bij het boeren. Dus eigenlijk… IEDEREEN WINT.<br>Dit helpt zowel geldschieters als boeren, omdat geldschieters een hogere rente kunnen verdienen omdat boeren meer kunnen lenen, waardoor de gebruiksgraad voor die token wordt verhoogd.</p>
<p>En wanneer het gebruikscijfer stijgt, betekent dit dat meer mensen willen lenen.</p>
<p>Aangezien meer mensen willen lenen, stijgt ook de rente voor de geldschieter omdat er slechts een beperkte hoeveelheid tokens is! Het basisprincipe van vraag en aanbod in zijn eenvoudigste vorm!</p>
<p>Bovendien zijn we binnen BSC een blue-chip project, een van de leiders op alle gebieden.</p>
<p>We hebben ongeveer $ 1,4 miljard US dollar aan TVL (totale waarde vergrendeld, wat betekent dat alle fondsen op een bepaald moment in een protocol zijn), tienduizenden gebruikersportefeuilles en zijn altijd in de top 5 geweest in handelsvolume op alle blockchains.</p>
<p>Vanaf de laatste week van oktober hebben we ook het op één na hoogste volume op de BSC en op de vierde plaats op alle chains in DEFI, waarbij andere protocollen zoals Compound, 1 Inch en vele anderen worden verslagen!</p>
<p>Niet slecht voor het nieuwe kind in de buurt dat pas een paar maanden geleden is begonnen. ;);) Slaagt er nu al in om de grote jongens te verslaan qua volume.<br>En waarom is dit? Dit allemaal omdat we onze gebruikers een geweldige gebruikerservaring, geweldige beveiliging en nog grotere opbrengsten bieden!!!</p>
<p>sorry, ik weet dat het een beetje lang was, maar ik wilde volledig uitleggen wat we doen op een manier die gemakkelijk te begrijpen is, zelfs als defi en crypto op zichzelf niet het gemakkelijkste zijn om te leren in de wereld.</p>
<h3 id="h3-Een20probleem20van20veel20DeFiprotocollen20is20veiligheid20We20hebben20problemen20gezien20met20flashliquidaties20marktmanipulatie20en20fondsen20die20van20het20protocol20gestolen20zijn20Hoe20veilig20is20Alpaca20wat20betreft20veiligheid232746"><a name="Een probleem van veel DeFi-protocollen is veiligheid. We hebben problemen gezien met flash-liquidaties, marktmanipulatie en fondsen die van het protocol gestolen zijn. Hoe veilig is Alpaca wat betreft veiligheid?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een probleem van veel DeFi-protocollen is veiligheid. We hebben problemen gezien met flash-liquidaties, marktmanipulatie en fondsen die van het protocol gestolen zijn. Hoe veilig is Alpaca wat betreft veiligheid?</h3><p><strong>Tonichi</strong>: Om toe te voegen, wil ik het met u hebben over onze in-house Alpaca-wacht, die u beschermt tegen gevaren op de markt.<br>Dit is iets dat EXTREEM uniek is voor Alpaca, en laat me u vertellen waarom.</p>
<p>Om precies te zijn, wanneer de prijs van een activum in je farming pair zijn on-chain prijs heeft van de exchange waarop dat pair staat, <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a>/waultswap/MDEX) verschilt meer dan 10% van het gemiddelde van een batch off-chain orakels die we verifiëren, dan treedt de Alpaca Guard in Protection Mode; Dit houdt in dat liquidaties worden uitgeschakeld en posities worden geopend/gesloten, allemaal om u te beschermen tegen handelen tegen slechte prijzen en het lijden van een onrechtvaardig verlies.</p>
<p>Toen de hele markt een paar maanden geleden instortte, ging de Alpaca-wacht in actie, waardoor veel gebruikersposities beschermd werden tegen flash-liquidaties, zodat ze tegen veel betere prijzen konden handelen!</p>
<p>Denk aan de Alpaca bewaker als uw eigen persoonlijke beveiligingsbeambte ;). Een persoonlijke beveiligingsbeambte voor uw fondsen!</p>
<p>Helaas hebben andere protocollen hun eigen beveiliger niet en dat komt omdat het erg moeilijk is om deze technologie te repliceren. Ons team van ontwikkelaars is uiterst intelligent en we danken hen voor het geven van onze eigen persoonlijke bodyguard, zodat onze gebruikers zich veilig voelen bij het boeren in Alpaca :)</p>
<p>Lol zeggen dat ik mijn eigen beveiliger heb, maakt me een beetje het gevoel alsof ik een koning ben :)).</p>
<p>Maar zo behandelen we onze gebruikers graag… als royalty…</p>
<h3 id="h3-Q320Fijn20om20te20horen20dat20beveiliging20een20prioriteit20is20Het20lijkt20erop20dat20veel20projecten20dat20hebben20verwaarloosd20Waarom20hebben20jullie20Alpaca20gelanceerd20Wat20is20de20rationale20erachter545829"><a name="Q3: Fijn om te horen dat beveiliging een prioriteit is. Het lijkt erop dat veel projecten dat hebben verwaarloosd! Waarom hebben jullie Alpaca gelanceerd? Wat is de rationale erachter?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Fijn om te horen dat beveiliging een prioriteit is. Het lijkt erop dat veel projecten dat hebben verwaarloosd! Waarom hebben jullie Alpaca gelanceerd? Wat is de rationale erachter?</h3><p><strong>Tonichi</strong>: Ook de beurzen profiteren hiervan, omdat ze nu veel meer liquiditeit hebben, wat zorgt voor een lagere prijsimpact en het handelen gemakkelijker en winstgevender maakt. Dit wordt versterkt en vergroot door DeFi.</p>
<p>Dit kan echter alleen gebeuren met onze technologie, die moeilijk te repliceren, te onderhouden en te laten groeien is. Daarom hebben we zo weinig concurrenten en groeit Alpaca zo snel - omdat we sneller bouwen dan anderen.</p>
<p>Dus ons model is uniek. Alpaca is een versterkende liquiditeitslaag voor alle DeFi, en ons doel is om een onvervangbare te worden.</p>
<p>Op dit moment hebben we $1.4 miljard TVL, maar we zijn voorlopig alleen op PancakeSwap, Waultswap &amp; MDEX.</p>
<p>Wat gaat er gebeuren wanneer we meer beurzen integreren? En wat dacht je van meer blockchains?</p>
<p>We zijn van plan deze technologie naar meer blockchains te brengen zodat geldschieters meer rente kunnen verdienen, boeren meer opbrengst kunnen verdienen, gedecentraliseerde beurzen meer liquiditeit kunnen hebben, handelaren veel betere handelservaringen kunnen hebben en GELIJKE KANSEN kunnen hebben.</p>
<p>Daarom hebben we een eerlijke lancering gedaan.</p>
<p>Daarom heeft ons team hun tokens 2 jaar vergrendeld.</p>
<p>Mensen zoals jij verdienen betere opbrengsten, op een manier die extreem veilig is.</p>
<p>Dit is de fundamentele reden waarom we Alpaca hebben gemaakt. Om mensen een gelijke kans te geven. MACHT AAN HET VOLK!! Of zoals ik het graag zeg… MACHT AAN DE ALPACA’S!!</p>
<h3 id="h3-Q420Kun20je20ons20nu20vertellen20wat20het20nut20is20van20de20ALPACAtoken20Wat20kan20ik20doen20op20het20platform20met20ALPACA620151"><a name="Q4: Kun je ons nu vertellen wat het nut is van de $ALPACA-token? Wat kan ik doen op het platform met $ALPACA?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Kun je ons nu vertellen wat het nut is van de $ALPACA-token? Wat kan ik doen op het platform met $ALPACA?</h3><p><strong>Tonichi</strong>: We zullen binnenkort een governance-kluis lanceren die gemeenschapsleden in staat zal stellen om hun ALPACA-tokens te staken; stakers zullen xALPACA ontvangen waar 1 xALPACA = 1 stem, waardoor ze kunnen beslissen over belangrijke governancebeslissingen.</p>
<p>We geloven in een werkelijk gedecentraliseerde samenleving waar belangrijke beslissingen worden genomen door de gemeenschap, voor de gemeenschap.</p>
<p>De dagen zijn voorbij dat één enkele entiteit elke beslissing zal controleren, en meestal… voor hun eigen voordeel… en tot nadeel van alle anderen.</p>
<p>Alpaca doet het HELEMAAL ANDERS.</p>
<p>Wat betreft het verdienen, heb ik al genoemd waar u als geldschieter veilige en stabiele rente kunt verdienen op uw crypto.</p>
<p>Ik heb ook vermeld hoe boeren veel hogere opbrengsten kunnen behalen door het gebruik van ondergecollateraliseerde leningen. Ik zou ook graag willen praten over het Graasgebied.</p>
<p>In het Grazing Range Programma kunnen ALPACA-houders, of meer specifiek houders van ibALPACA (denk aan dit als een ontvangstbewijs voor het uitlenen van je Alpaca), hun ibAlpaca inzetten in de Grazing Range pools (Ja, je kunt zelfs nog meer geld verdienen met je ontvangstbewijs).</p>
<p>Hier ontvangen ze tokenbeloningen van partnerprojecten zoals Phala-network, Division Network en nog veel meer, waarbij ze APY’s verdienen tot honderden procenten, naast het rendement van het farmen van je gekozen tokenpaar!</p>
<p>En als je je alpaca een bepaalde periode in het graasgebied laat grazen, kun je ook exclusieve NFT’s verdienen, die je vervolgens in de open markt kunt verkopen voor nog meer winst!</p>
<p>Alpaca NFT’s staan bekend om hun hoge waarden op de markt vanwege de gemeenschap, het ontwerp en het gebruiksscenario erachter.</p>
<p>Ik weet dat je nu misschien in de war bent, maar denk er gewoon zo over na.<br>Stap 1, je leent je Alpaca uit.<br>Stap 2, je krijgt ibalpaca terug (ontvangstbewijs voor lening)<br>Stap 3. Je zet je ibalpaca (ontvangstbewijs) vast in ons graasgebied voor een munt naar keuze.<br>Stap 4. Je graast 27 dagen lang en verdient NFT’s.<br>Stap 5. Je kunt deze NFT’s verkopen op de marktplaats. Oh, en trouwens, je verdient rente op dit alles! Dat zijn veel stappen en veel winst!</p>
<h3 id="h3-Q520Ik20heb20gehoord20dat20Alpaca20Finance20zojuist20de20verkoop20van20jullie20NFTs20genaamd20Alpies20heeft20beindigd20die20volgend20jaar20zullen20fungeren20als20personages20in20een20playtoearnspel20Kun20je20ons20hier20meer20over20vertellen710904"><a name="Q5: Ik heb gehoord dat Alpaca Finance zojuist de verkoop van jullie NFT’s genaamd Alpies heeft beëindigd, die volgend jaar zullen fungeren als personages in een play-to-earn-spel! Kun je ons hier meer over vertellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Ik heb gehoord dat Alpaca Finance zojuist de verkoop van jullie NFT’s genaamd Alpies heeft beëindigd, die volgend jaar zullen fungeren als personages in een play-to-earn-spel! Kun je ons hier meer over vertellen?</h3><p><strong>Tonichi</strong>: Gaming is een domein waar we al een tijdje bij betrokken willen raken. We werken sinds begin dit jaar aan een play-to-earn spel, al voor Axies en play-to-earn populair werden. We gaan nu over van de ontwerpfase naar de ontwikkelingsfase.</p>
<p>Onze NFT Avatars, genaamd Alpies, zullen dienen als personages in ons play-to-earn spel in Q2. Ze bestaan uit een NFT collectie van 10.000 stuks, die we in twee delen hebben uitgebracht op BSC en vervolgens ETH.</p>
<p>Alpies bestaan uit 5000 donker gethematiseerde NFT’s genaamd “The Dauntless”, die werden verkocht op BSC, en 5000 licht gethematiseerde NFT’s genaamd “The Dreamers”, die werden verkocht op Eth.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16895812793.jpg" alt=""><img src="https://gimg2.gateimg.com/image/article/16895812984.jpg" alt=""><br>50% hogere maximale hefboomwerking op Alpaca Finance<br>Toekomstige NFT-luchtdrops/giveaways<br>Beta-toegang tot Alpaca-spel<br>Hogere spelstatistieken<br>Exclusieve gratis spelitems<br>Hoogwaardige NFT-fokkerij<br>Toegang tot exclusieve Discords (Illamanati voor Dauntless, Knights Tempaca voor Dreamers, en beide kunnen toegang krijgen tot The Paws That Be)<br>Exclusieve toegang tot Alpaca fysieke merchandise</p>
<p>Tot slot zal het spel waarde teruggeven aan ALPACA-houders via inkomstendeling, en dit zal het g zijn bij elk product onder het ALPACA-merk.</p>
<p>Dus nogmaals… WAARDE VOOR ALPACA-HOUDERS!!</p>
<p>Wat betreft de verkoopopbrengsten van de NFT’s, zal 20% naar ALPACA HOUDERS gaan via terugkoopacties en een mix van verbranding en distributiedeling.</p>
<p>Bovendien gaat 5% naar Alpaca-georiënteerde goede doelen en reddingsoperaties om echte Alpaca’s in nood te helpen. Hoe kun je deze uiterst schattige en schattige dieren niet helpen!</p>
<p>Ik ben ook blij te kunnen zeggen dat Alpaca Finance een succesvolle NFT-lancering heeft gehad voor ons spel en dat we tijdens onze verkoop $6,3 miljoen hebben opgehaald! Ik ben erg enthousiast over ons spel en ik hoop dat jullie dat ook zijn.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Rio Fu.</strong>, Gate.io Gemeenschap<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 mits Gate.io wordt vermeld. In alle glen zal juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>