Z2F0ZUxpdmUgQU1BIFJlY2FwLUFhcms=

2024-06-21, 06:08

<p><img src="https://gimg2.gateimg.com/image/article/1718949716aark.png" alt=""></p>
<h2 id="h2-Q120Che20cos20Aark815004"><a name="Q1. Che cos’è Aark?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1. Che cos’è Aark?</h2><p>Aark è l’unico DEX Perp 1000x, alimentato dalla liquidità LST/LRT. Aark è progettato per offrire trading ad alto leverage con commissioni minime e un’esperienza utente senza soluzione di continuità attraverso il suo modello Reflective Market Maker (RMM), che riflette la profondità della liquidità dell’ordinebook CEX per garantire liquidità abbondante per i trader.</p>
<p>In aggiunta a ciò, Aark ha una struttura LP unica che consente LP a un solo lato per un rendimento delta neutro e diverse scelte di asset da RWAs a LRTs. Fondamentalmente, abbiamo progettato in questo modo per consentire ai nostri utenti di guadagnare multi-rewards depositando PT-eETH (l’asset LRT che produce rendimento), eETH nell’LP di Aark.</p>
<p>Infine, siamo sostenuti dai migliori, tra cui Delphi Digital, HashKey Digital, OKX Ventures, Arrington, Morningstar e altri.</p>
<h2 id="h2-Q220Quali20tipi20di20caratteristiche20e20strutture20uniche20offre20Aark20ai20trader145639"><a name="Q2. Quali tipi di caratteristiche e strutture uniche offre Aark ai trader?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2. Quali tipi di caratteristiche e strutture uniche offre Aark ai trader?</h2><p>-1000x leverage è la chiave!<br>Aark offre un’leverage massima fino a 1000x che non è mai vista nell’industria,/ un 1000x! Se ti senti fortunato e vuoi testare la tua fortuna, Aark è il tuo Vegas./ Passa per massima efficienza di capitale./ Potresti chiederti se questo vale solo per certe coppie?/ Gli utenti di Aark possono aprire posizioni con leva 1000x su monete di tendenza e persino monete meme./ Offre anche la commissioni di trading più basse dell’industria, che è dello 0,01%.</p>
<p>La liquidità basata su CEX basata su RMM (Reflective Market Maker) utilizza oracoli per recuperare i dati del libro degli ordini dai CEX. Ad esempio, RMM recupera i dati sulla quantità di liquidità nel mercato ARB-PERP di Binance e simula la stessa liquidità sul pool di Aark. Di conseguenza, i trader possono sperimentare un impatto di prezzo/scivolamento uguale a quello del trading su Binance.</p>
<p>-Interesse aperto illimitato e scalabile<br>Aark sfrutta un meccanismo unico chiamato ‘Skewness Cap’ per proteggere gli LP e consentire al protocollo di scalare oltre gli altri DEX perps.</p>
<p>Implementare un limite di asimmetria anziché sul volume degli interessi aperti (OI), che è una mossa strategica che aumenta significativamente la scalabilità degli OI, mantenendo allo stesso tempo lo stesso basso rischio per il pool. Ad esempio, un DEX perpl con un limite di OI ETH di $10 milioni senza alcun meccanismo di asimmetria potrebbe facilmente avere un bilanciamento degli OI sbilanciato verso il lato long dell’80:20, esponendo il pool a una posizione short di $6 milioni. Tuttavia, con un limite di asimmetria di $6 milioni, il protocollo può aumentare gli OI fino a $100 milioni, dove l’asimmetria è di $6 milioni ($53 milioni long - $47 milioni short). Anche se il pool è esposto a una posizione short di $6 milioni in entrambi i casi, nel secondo caso viene esposta solo il 6% (6m/100m) degli OI, rispetto al 60% del caso iniziale.</p>
<p>Implementando un limite di asimmetria, il protocollo non solo diminuisce sostanzialmente il rischio direzionale assunto dal pool, ma aumenta anche la scalabilità di oltre 10 volte. Questa scalabilità è cruciale per il futuro, dove ci si aspetta che il volume DEX perp corrisponda o superi perp CEX.</p>
<p>-Ampie opzioni di garanzia<br>Gli utenti di Aark possono aprire le loro posizioni con qualsiasi asset in whitelist. Con una vasta scelta di asset di garanzia, i trader possono attuare diverse strategie. Ad esempio, se aprono posizioni corte su ETH utilizzando stETH (stakedETH) come garanzia, ciò consente loro di guadagnare stabilmente premi da Lido tenendo stETH, mentre si proteggono contro la volatilità del prezzo di ETH.</p>
<h2 id="h2-Q320Come20peertopool20Perp20DEX20quali20tipi20di20distinzione20ha20Aark20Liquidity20Pool25249"><a name="Q3. Come peer-to-pool Perp DEX, quali tipi di distinzione ha Aark Liquidity Pool?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3. Come peer-to-pool Perp DEX, quali tipi di distinzione ha Aark Liquidity Pool?</h2><p>Il Pool LP di Aark presenta numerose distinzioni rispetto ad altri Perp DEX:<br>·Rendimento a un solo lato<br>·LP con leva fino a 5x<br>·Collateral iper diversificato</p>
<p>Lasciatemi approfondire un po’ questi:<br>-LP a un solo lato<br>Aark consente agli utenti di depositare qualsiasi singolo asset che desiderano in AALP per guadagnare rendimenti. Gli utenti possono anche optare per più asset, in qualsiasi rapporto desiderino.<br>Nonostante segmenti utente diversificati, i DEX perp legacy consentono solo LP sotto forma di cesti o di un pugno di stablecoin. Nel caso dei cesti, non solo gli utenti sono costretti all’esposizione ad asset indesiderati, ma hanno anche scelte limitate a causa dell’incapacità del cesto di comprendere troppa diversità.<br>Attualmente, LP a un solo lato è limitato a Vertex, Gains (limitato a DAI) e Hyperliquid (limitato a USDC). Gains è l’unico pool-DEX che ha questa differenziazione ma è limitato a DAI. Aark è l’unico LP a un solo lato con iper-diversità.</p>
<p>-LP leva<br>Con l’LP a leva 5x, gli LP possono guadagnare un APR 5x più alto. L’aumento dell’importo dell’LP a sua volta fornisce una maggiore profondità per i trader. Inoltre, l’LP leva è esente da commissioni.</p>
<p>I protocolli tradizionali di yield farming con leva, che prendono in prestito dai pool di prestito, hanno visto aumentare vertiginosamente i tassi di prestito. Il design di Aark rimuove l’incertezza dal costo.</p>
<p>Leveraged LP può essere inteso come una versione LP dei perpetuals:<br>· le posizioni perpetue non prendono in prestito;<br>· nessuna commissione di prestito o interesse;<br>· le posizioni vengono liquidate quando scendono al di sotto del MMR.</p>
<p>In tal senso, si può dire quanto segue riguardo gli LP con leva:<br>· Le posizioni LP non prendono in prestito capitale;<br>· Nessuna commissione o interesse di prestito;<br>· Liquidate quando le posizioni superano il MMR.</p>
<p>-Collaterale iper diversificato<br>Aark consente una vasta gamma di asset per la fornitura di liquidità. A partire da asset di base come ETH, ARB, stablecoins, Aark è il primo DEX perp che consente LST e RWA per LP, consentendo rendimenti doppi. Questi rappresentano circa la metà dell’intero DeFi TVL.</p>
<p>L’innovazione non si ferma qui: Aark-itecture ha la capacità di ampliare i suoi orizzonti per includere i token LP. <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> i token LP v2, le posizioni NFT di <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> v3, i token del pool Curve USDC-USDT o qualsiasi altro asset negoziabile con liquidità possono essere aggiunti al pool di Aark per generare rendimenti. Ciò include i token aUSD e <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> Token pool USDC, che gli utenti ricevono in prestito ad Aave. Queste categorie costituiscono circa la metà dello spazio DeFi.</p>
<p>Questa funzione può anche abilitare il token AARK-ETH Uniswap v2 LP come garanzia, incentivando fortemente gli utenti a fornire liquidità per AARK su DEX senza incentivi separati per il token.</p>
<h2 id="h2-Q420Quali20sono20gli20eventi20in20corso20su20Aark20a20cui20gli20utenti20devono20partecipare20per20guadagnare20ricompense296070"><a name="Q4. Quali sono gli eventi in corso su Aark a cui gli utenti devono partecipare per guadagnare ricompense?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4. Quali sono gli eventi in corso su Aark a cui gli utenti devono partecipare per guadagnare ricompense?</h2><p>Ci sono 2 eventi principali in corso:<br>· Programma di incentivazione $ARB<br>· Mining di token</p>
<p>$ARB Incentive Program:<br>Progettato sia per i trader che per i fornitori di liquidità, questo programma offre incentivi a coloro che commerciano o aggiungono liquidità alla piattaforma Aark. Proviene dai 900k $ARB di sovvenzione ricevuti da LTIPP. Questi sono eventi a tempo limitato per soli altri 10 settimane.</p>
<ul>
<li>Se sei un trader attivo, fai trading su Aark in modalità Classica. Puoi guadagnare $ARB ogni settimana in base al tuo volume di trading settimanale. Ci sono 37.500 $ARB in palio e il fondo aumenta ogni settimana. FYI, la modalità Classica è una modalità di trading regolare che offre fino a 50x di leva.</li><li>Se preferisci un reddito stabile, fornisci liquidità utilizzando i tuoi asset LST/LRT. Puoi guadagnare $ARB in base al tuo ammontare di garanzia settimanale. L’allocazione settimanale è di 10.500 $ARB.</li><li>Stiamo anche assegnando 54.000 $ARB a campagne su Galxe, Intract, QuestN e TaskOn per i nuovi utenti. Se non hai mai fatto trading su Aark prima, questa è un’ottima occasione per conoscere Aark e guadagnare ricompense in $ARB.</li></ul>
<p>Token Mining:<br>Il Token Mining di Aark è un evento ‘Trade to Earn’. Puoi guadagnare esAARK in base alla tua quota di volume di trading in Modalità Classica e Modalità Luna ogni settimana. esAARK può essere utilizzato in due modi. Il primo è che può essere scommesso per guadagnare ricompense su base 1:1 con lo standard $AARK. Il secondo è che può essere vincolato per $AARK. Durante questo periodo, esAARK verrà convertito in $AARK pro-rata sulla base di ogni blocco. esAARK non è trasferibile.</p>
<h2 id="h2-Q520Qual2020lutilit20di20AARK20e20quali20sono20i20vantaggi20di20possederlo824653"><a name="Q5. Qual è l’utilità di AARK e quali sono i vantaggi di possederlo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5. Qual è l’utilità di AARK e quali sono i vantaggi di possederlo?</h2><p>$AARK è il token di governance e utilità di Aark. L’offerta totale di $AARK è di 1.000.000.000. I detentori di $AARK hanno diritto a 3 grandi benefici all’interno dell’ecosistema Aark.</p>
<p>Governance:<br>I titolari di token AARK hanno diritti di voto sulle decisioni chiave del protocollo, che danno loro una voce nello sviluppo futuro della piattaforma. Ad esempio, possono votare per influenzare su come gestire il protocollo. Ciò include quanto segue:</p>
<ul>
<li>Costruzione, distribuzione e aggiornamento dei protocolli centrali Aark.</li><li>Ottimizzazione dei parametri, inclusi la soglia di liquidazione, l’allocazione dell’ecosistema, le ricompense, la struttura delle commissioni, le verifiche e altri per le prestazioni.</li><li>Applicazione di nuovi prodotti, inclusi opzioni, NFT, liste, spot e RWA, nonché funzionalità, tra cui multichain e order book.</li><li>Approvazione di incentivi per singoli ed entità che contribuiscono alla crescita e allo sviluppo di Aark.</li></ul>
<p>Premi di staking:<br>-I titolari di AARK possono effettuare lo staking dei token AARK per guadagnare 3 premi:<br>-Più $AARK.<br>-Più esAARK possono essere scommessi per guadagnare più premi di staking o possono essere scommessi per diventare veri AARK nel corso di un anno. Tuttavia, a seconda dell’importo scommesso, il periodo di blocco può essere abbreviato. Riceverai anche punti moltiplicatori (MP) ad un tasso fisso di 100% APR nel corso di un anno. Ad esempio, se scommetti 1000 AARK per un anno, guadagnerai 1000 MP. I punti moltiplicatori possono essere scommessi per guadagnare premi di staking allo stesso tasso di un token AARK normale. Quando togli lo staking di AARK, una quantità proporzionale di MP verrà bruciata. Ad esempio, se hai scommesso 1000 AARK e guadagnato 500 MP, togliere lo staking di 200 AARK comporterà la distruzione di 100 MP (200 / 1000 * 500). La distruzione si applicherà all’importo totale di MP, compresi sia i MP scommessi che quelli non scommessi.</p>
<p>Sconti sul trading: gli utenti possono bloccare i token AARK per ridurre le commissioni di negoziazione, rendendo ancora più conveniente per i trader attivi.</p>
<div class="blog-details-info"><br><div>Autore: <strong>GateLive</strong>, Team 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 ripubblicare l'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>