R2F0ZS5pbyBBTUEgY29uIEFscGFjYSBGaW5hbmNlIC0gSWwgcHJvdG9jb2xsbyBkaSBwcmVzdGl0byBwacO5IGdyYW5kZSBjaGUgY29uc2VudGUgbCdhZ3JpY29sdHVyYSBhIGxldmEgc3VsbGUgY2hhaW4gQk5CIGUgRmFudG9t

<p><img src="https://gimg2.gateimg.com/image/article/16895809181.jpg" alt=""><br><strong>Ora: 20 novembre 2021, 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 Tonichi, Responsabile Sviluppo Aziendale Regionale di Alpaca Finance in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di Gate.io Exchange</a>.</strong><br><strong>Sito ufficiale: <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>Segui Alpaca Finance su <a href="https://twitter.com/AlpacaFinance" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/alpacafinance" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16895812522.jpg" alt=""><br><strong>Tonichi - Responsabile dello sviluppo commerciale regionale di Alpaca Finance</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio490742"><a name="Domande e risposte da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte da Gate.io</h2><h3 id="h3-Q120Per20informazione20di20tutti20cos20Alpaca20e20quale20obiettivo20si20propone20il20progetto386278"><a name="Q1: Per informazione di tutti, cos’è Alpaca e quale obiettivo si propone il progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Per informazione di tutti, cos’è Alpaca e quale obiettivo si propone il progetto?</h3><p><strong>Tonichi</strong>: Certo ! Quindi permettimi di darti un breve background su ALpaca e poi utilizziamo un esempio per mostrarti come puoi guadagnare al meglio da Alpaca e come si confronta con gli investimenti più tradizionali.</p>
<p>In cambio, Pancake swap ti offre una parte delle commissioni di trading e ti fornisce anche ricompense in token Pancake swap, che vengono investite automaticamente nella sua posizione perché in Alpaca Finance, vogliamo che tu lo faccia. <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Composto</a> il tuo interesse il più possibile, offrendoti i massimi rendimenti assoluti!</p>
<p>E indovina un po’… Julian riceve anche ricompense in Alpaca Token come bonus!</p>
<p>Che poi può richiedere e persino reinvestire nel nostro campo di pascolo (più avanti ne parleremo) e guadagnare i token dei nostri progetti partner come premio con un APY di centinaia di %, a volte anche migliaia se sei tra i primi!</p>
<p>Il problema più grande che Alpaca Finance risolve è l’utilizzo del capitale, quindi questo significa che siamo in grado di mettere in contatto i prestatori che vogliono guadagnare tassi di interesse elevati (commento a margine.. NON PIÙ 3% ALL’ANNO PER FAVORE) con gli agricoltori a leva finanziaria, che utilizzano quei fondi per aumentare i loro guadagni quando coltivano. Quindi davvero… VINCONO TUTTI<br>Questo aiuta sia gli istituti di credito che gli agricoltori, in quanto gli istituti di credito possono guadagnare un tasso di interesse più elevato perché gli agricoltori possono prendere in prestito di più, aumentando il tasso di utilizzo di quel token.</p>
<p>E quando il tasso di utilizzo aumenta, significa che più persone vogliono prendere in prestito.</p>
<p>Poiché sempre più persone vogliono prendere in prestito, il tasso di interesse per il prestatore aumenta anche perché c’è solo una quantità finita di token! Legge della domanda e dell’offerta nella sua forma più semplice!</p>
<p>Inoltre, all’interno di tutto BSC, siamo un progetto blue-chip, uno dei leader in tutti i parametri.</p>
<p>Abbiamo circa $1,4 miliardi di dollari statunitensi in TVL (valore totale bloccato, ossia tutti i fondi in un protocollo in un dato momento), decine di migliaia di portafogli degli utenti e siamo sempre stati tra i primi 5 per volume di trading su tutte le blockchain.</p>
<p>All’ultima settimana di ottobre, abbiamo anche il secondo volume più alto in BSC e il quarto in tutte le catene di DEFI, superando altri protocolli come Compound, 1 Inch e molti altri!</p>
<p>Non male per il nuovo arrivato che ha iniziato solo un paio di mesi fa. ;);) Già battendo i grandi in termini di volume.<br>E perché? Tutto questo perché abbiamo offerto ai nostri utenti un’ottima esperienza utente, una grande sicurezza e rendimenti ancora maggiori!!</p>
<p>Mi dispiace, so che è stato un po’ lungo, ma volevo spiegare completamente cosa facciamo in un modo che sia facile da capire, anche quando la DeFi e le criptovalute in sé lo sono; t la cosa più facile da imparare al mondo.</p>
<h3 id="h3-Q220Un20problema20di20molti20protocolli20DeFi2020la20sicurezza20Abbiamo20visto20problemi20con20liquidazioni20istantanee20manipolazione20di20mercato20e20furto20di20fondi20dal20protocollo20Quanto2020sicuro20Alpaca20in20termini20di20sicurezza433062"><a name="Q2: Un problema di molti protocolli DeFi è la sicurezza. Abbiamo visto problemi con liquidazioni istantanee, manipolazione di mercato e furto di fondi dal protocollo. Quanto è sicuro Alpaca in termini di sicurezza?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Un problema di molti protocolli DeFi è la sicurezza. Abbiamo visto problemi con liquidazioni istantanee, manipolazione di mercato e furto di fondi dal protocollo. Quanto è sicuro Alpaca in termini di sicurezza?</h3><p><strong>Tonichi</strong>: Per aggiungere, vorrei parlarti della nostra protezione interna per alpaca, che ti protegge dai pericoli del mercato.<br>Questo è qualcosa di ESTREMAMENTE unico per gli Alpaca, e lascia che ti dica perché.</p>
<p>Più specificamente, quando il prezzo di un asset nella tua coppia di farming ha il suo prezzo on-chain dallo scambio su cui si trova la coppia, <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a>/waultswap/MDEX) differisce di più del 10% dalla mediana di un lotto di oracoli off-chain che verifichiamo, la Guardia di Alpaca entra in modalità di protezione; Questo consiste nel disabilitare le liquidazioni e nell’apertura/chiusura delle posizioni; il tutto al fine di proteggerti dal trading a prezzi sbagliati e dall’incorrere in una perdita ingiusta.</p>
<p>Quando l’intero mercato ha subito un flash crash qualche mese fa, la guardia Alpaca è entrata in azione, proteggendo molte posizioni degli utenti dalle liquidazioni flash, consentendo loro di negoziare a prezzi molto migliori!</p>
<p>Pensa alla guardia Alpaca come al tuo personale bodyguard ;). Un bodyguard personale per i tuoi fondi!</p>
<p>Purtroppo, altri protocolli non hanno la propria guardia del corpo e questo perché è molto difficile replicare questo tipo di tecnologia.<br>Il nostro team di sviluppatori è estremamente intelligente e li ringraziamo per averci dato la nostra guardia del corpo personale in modo che i nostri utenti si sentano al sicuro nel fare farming in Alpaca :)</p>
<p>Lol dire che ho la mia guardia del corpo mi fa sentire un po’ come un re :)).</p>
<p>Ma è così che ci piace trattare i nostri utenti… come dei veri re…</p>
<h3 id="h3-Q32020bello20sapere20che20la20sicurezza2020una20priorit20Sembra20che20molti20progetti20labbiano20trascurata20Perch20avete20lanciato20Alpaca20Qual2020la20logica20alla20base20di20ci848282"><a name="Q3: È bello sapere che la sicurezza è una priorità. Sembra che molti progetti l’abbiano trascurata! Perché avete lanciato Alpaca? Qual è la logica alla base di ciò?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: È bello sapere che la sicurezza è una priorità. Sembra che molti progetti l’abbiano trascurata! Perché avete lanciato Alpaca? Qual è la logica alla base di ciò?</h3><p><strong>Tonichi</strong>: Gli scambi beneficiano anche perché ora hanno molta più liquidità, consentendo un impatto di prezzo più basso che rende il trading più facile e redditizio. Questo è DeFi potenziato e amplificato.</p>
<p>Tuttavia, ciò può accadere solo con la nostra tecnologia, che è difficile da replicare, mantenere e far crescere, ecco perché abbiamo così pochi concorrenti e perché Alpaca è cresciuta così rapidamente, perché costruiamo più velocemente degli altri.</p>
<p>Quindi, il nostro modello è unico. Alpaca è uno strato di liquidità amplificante per tutto il DeFi, e miriamo a diventare un’opzione irrinunciabile.</p>
<p>Al momento, abbiamo $1.4 miliardi di TVL ma siamo solo su PancakeSwap, Waultswap &amp; MDEX per ora.</p>
<p>Cosa succederà quando integreremo più scambi? E per quanto riguarda più blockchain?</p>
<p>Stiamo pianificando di portare questa tecnologia su più blockchain in modo che i prestatori possano guadagnare più interessi, gli agricoltori possano ottenere un rendimento maggiore, gli scambi decentralizzati possano avere più liquidità, i trader possano avere esperienze di trading molto migliori e UGUALE OPPORTUNITÀ</p>
<p>Ecco perché abbiamo fatto un lancio equo.</p>
<p>Ecco perché il nostro team ha bloccato i loro token per 2 anni.</p>
<p>Le persone come te meritano raccolti migliori, in un modo che sia estremamente sicuro e protetto.</p>
<p>Questa è la ragione fondamentale per cui abbiamo creato Alpaca. Per dare alle persone un’opportunità uguale. POTERE AL POPOLO!! O come mi piace dire… POTERE AGLI ALPACA!!</p>
<h3 id="h3-D420Quindi20ora20puoi20dirci20qual2020lutilit20del20token20ALPACA20Cosa20posso20fare20sulla20piattaforma20con20ALPACA565234"><a name="D4: Quindi, ora, puoi dirci qual è l’utilità del token $ALPACA? Cosa posso fare sulla piattaforma con $ALPACA?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>D4: Quindi, ora, puoi dirci qual è l’utilità del token $ALPACA? Cosa posso fare sulla piattaforma con $ALPACA?</h3><p><strong>Tonichi</strong>: Presto lanceremo una vault di governance che permetterà ai membri della comunità di scommettere i loro token ALPACA; i scommettitori riceveranno xALPACA dove 1 xALPACA = 1 voto, permettendo loro di decidere sulle decisioni chiave di governance.</p>
<p>Crediamo in una società veramente decentralizzata in cui le decisioni chiave sono prese dalla comunità, per la comunità.</p>
<p>Sono passati i tempi in cui un’unica entità controllava ogni decisione, e di solito… per il proprio vantaggio… e a discapito degli altri.</p>
<p>L’alpaca fa l’ESATTO OPPOSTO.</p>
<p>In termini di guadagno, ho già menzionato che come prestatori, è possibile guadagnare interessi sicuri e stabili sulle tue criptovalute.</p>
<p>Ho anche menzionato come gli agricoltori possano guadagnare rendimenti molto più elevati utilizzando prestiti sottocollateralizzati. Vorrei anche parlare del pascolo.</p>
<p>Nel programma Grazing Range, i detentori di ALPACA, o più specificamente i detentori di ibALPACA (pensa a questo come una ricevuta per il prestito del tuo Alpaca), possono scommettere il loro ibAlpaca nelle piscine Grazing Range (Sì, puoi guadagnare ancora più soldi dalla tua ricevuta)</p>
<p>Qui, ricevono ricompense in token da progetti partner come Phala network, division network e molti altri, guadagnando APY fino al centinaio di %, oltre al rendimento dal farming della coppia di token scelta!</p>
<p>E se fai pascolare la tua Alpaca nell’area di pascolo per un certo periodo di tempo, sarai in grado di guadagnare NFT in edizione limitata, che potrai poi vendere sul mercato aperto per guadagnare ancora di più!</p>
<p>Gli NFT di Alpaca sono noti per avere alti valori ​​nel mercato a causa della comunità, del design e del caso d’uso che li sostiene.</p>
<p>So che al momento potresti essere confuso, ma pensaci così.<br>Passaggio 1, tu presti la tua Alpaca.<br>Passaggio 2, ricevi indietro ibalpaca (ricevuta per il prestito)<br>Passaggio 3. Piazzi il tuo ibalpaca (ricevuta) nel nostro pascolo a una moneta a tua scelta.<br>Passaggio 4. Pascoli per 27 giorni e guadagni NFT.<br>Passaggio 5. Puoi vendere questi NFT nel marketplace. Ah, a proposito, stai guadagnando interessi su tutto questo! Sono molti passaggi e molto profitto!</p>
<h3 id="h3-Q520Ho20sentito20dire20che20Alpaca20Finance20ha20appena20concluso20la20vendita20dei20tuoi20NFT20chiamati20Alpies20che20fungeranno20da20personaggi20in20un20gioco20di20guadagno20che20arriver20lanno20prossimo20Puoi20dirci20di20pi20a20riguardo750655"><a name="Q5: Ho sentito dire che Alpaca Finance ha appena concluso la vendita dei tuoi NFT chiamati Alpies, che fungeranno da personaggi in un gioco di guadagno che arriverà l’anno prossimo! Puoi dirci di più a riguardo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Ho sentito dire che Alpaca Finance ha appena concluso la vendita dei tuoi NFT chiamati Alpies, che fungeranno da personaggi in un gioco di guadagno che arriverà l’anno prossimo! Puoi dirci di più a riguardo?</h3><p><strong>Tonichi</strong>: Il gioco è un settore in cui abbiamo pianificato di essere coinvolti da un po’ di tempo. Abbiamo lavorato a un gioco play-to-earn da all’inizio di quest’anno, prima che Axies e play-to-earn diventassero popolari. Ora stiamo uscendo dalla fase di progettazione del gioco e passando alla fase di sviluppo.</p>
<p>I nostri avatar NFT, chiamati Alpies, funzioneranno come personaggi nel nostro gioco play-to-earn a partire da questo Q2. Si tratta di una collezione di 10.000 pezzi NFT, che abbiamo rilasciato in due parti su BSC e poi su ETH.</p>
<p>Gli Alpies sono composti da 5000 NFT a tema scuro chiamati “The Dauntless”, che sono stati venduti su BSC, e 5000 NFT a tema chiaro chiamati “The Dreamers” che sono stati venduti su 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>Leverage massimo aumentato del 50% su Alpaca Finance<br>Future NFT airdrops/giveaways<br>Accesso beta al gioco Alpaca<br>Statistiche di gioco più alte<br>Oggetti di gioco gratuiti esclusivi<br>Allevamento NFT di alta qualità<br>Accesso a Discord esclusivi (Illamanati per Dauntless, Knights Tempaca per Dreamers, e entrambi possono accedere a The Paws That Be)<br>Accesso esclusivo al merch fisico di Alpaca</p>
<p>In conclusione, il gioco restituirà valore ai detentori di ALPACA attraverso la condivisione dei ricavi, e questo sarà il caso per qualsiasi prodotto sotto il marchio ALPACA.</p>
<p>Quindi ancora una volta… VALORE PER I TITOLARI DI ALPACA!!</p>
<p>Per quanto riguarda i proventi delle vendite degli NFT, il 20% andrà ai detentori di ALPACA tramite riacquisti e una combinazione di bruciature e condivisione della distribuzione.</p>
<p>Inoltre, il 5% sarà devoluto a scopi benefici e operazioni di soccorso orientate agli alpaca per aiutare gli alpaca veri che ne hanno bisogno. Come puoi non aiutare questi animali estremamente adorabili e carini!!</p>
<p>Sono anche felice di dire che Alpaca Finance ha avuto un lancio di successo per il nostro gioco NFT e siamo riusciti a raccogliere 6,3 milioni di dollari durante la nostra vendita! Sono molto entusiasta per il nostro gioco e spero che anche voi lo siate.</p>
<div class="blog-details-info"><br><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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentita la ripubblicazione dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>