VHV0dG8gc3VsbGEgbGlxdWlkaXTDoDogY29tZSBsZSBjcmlwdG8tYm9yc2UgbGF2b3Jhbm8gY29uIGkgbWFya2V0IG1ha2Vy

2023-04-12, 05:54

<p><img src="https://gimg2.gateimg.com/image/1681277935619226796blog.png" alt=""><em>-dal team di 1Token BD</em></p>
<h2 id="h2-Preludio512118"><a name="Preludio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Preludio</h2><p>Gli scambi di criptovalute sono il giocatore principale nel mercato delle criptovalute e degli asset digitali che <a href="https://tokeninsight.com/en/research/miscellaneous/classification-of-exchanges-service-differences-and-reasons" rel="nofollow noopener noreferrer" target="_blank">combina più ruoli nella finanza tradizionale,</a> <a href="https://tokeninsight.com/en/research/miscellaneous/classification-of-exchanges-service-differences-and-reasons" rel="nofollow noopener noreferrer" target="_blank">con la diversificazione per competere tra loro.</a></p>
<p>Come attirano gli scambi di criptovalute più utenti e si distinguono dalla concorrenza? Le competenze possono essere coppie di trading, costo di trading, sicurezza, liquidità, UI/UX, guadagni… Tra questi, la liquidità è un fattore chiave che le istituzioni prenderebbero in considerazione nella scelta dei luoghi di scambio di criptovalute.</p>
<p><strong>Cos’è la liquidità?</strong><br>Per comprendere cos’è la liquidità, la metrica più diretta è lo slippage previsto. Si tratta della differenza tra il prezzo medio di mercato attuale e il prezzo medio dell’esecuzione effettiva. I fattori chiave dietro a questo sono lo spread (la differenza tra il prezzo di domanda e il prezzo di offerta) e la profondità (la quantità di acquirenti e venditori disponibili a varie quotazioni).</p>
<p>Immagina su quale registro ordini preferiresti fare trading di seguito<br><img src="https://gimg2.gateimg.com/image/1681278256157871819ama001.jpeg" alt=""><br>Allo stesso modo, in un exchange di criptovalute, la liquidità significa acquistare e vendere in modo efficiente in termini di tempo e costo. Un exchange di criptovalute altamente liquido avrà molti acquirenti e venditori di ciascuna criptovaluta elencata sulla piattaforma, consentendo ai trader di entrare ed uscire dalle posizioni con una minima slippage di prezzo.</p>
<p>Ad esempio, questi sono i libri degli ordini per <a href="/trade/BTC_USDT" target="_blank" class="blog_inner_link">BTC/USDT</a> su CEX1 e CEX2 allo stesso momento. Possiamo vedere che l’acquisto di 16.982 BTC su CEX1 comporterà approssimativamente uno slippage di 6.055 USDT (0 taker fee su CEX1) <em>) e l’acquisto di 15.897 BTC su CEX2 comporterà uno slippage di 1.528 USDT (commissione taker dello 0.02% su CEX2</em>), il che significa che CEX2 ha una maggiore liquidità in BTC/USDT rispetto a CEX1 in questo preciso momento.</p>
<p><em>Confronto della liquidità BTC/USDT su CEX1 e CEX2</em><br>1.0 commissioni taker coppie di trading spot BTC su CEX1</p>
<ol>
<li>Prendi la tariffa taker spot più bassa su CEX2 (0,020%)</li></ol>
<p>Per gli exchange che vogliono ottenere una maggiore liquidità, una pratica comune è quella di avvalersi dei servizi dei market maker.</p>
<p><strong>Cos’è un market maker</strong>?<br>Un market maker è un ente o un individuo che fornisce liquidità posizionando continuamente ordini limite sia per l’offerta che per la domanda.<br>Nel TradFi (forex, azioni, mercati ETF, ecc.), i market maker sono grandi marchi come Goldman Sachs, Two Sigma, Citadel…<br>Nel mercato delle criptovalute, i market maker delle criptovalute si dividono in due categorie:</p>
<p>● Le società di trading ad alta frequenza TradFi si stanno espandendo nel mercato delle criptovalute e stanno diventando market maker: Jump Trading, Tower Research, DRW Cumberland.<br>● Le società native delle criptovalute che crescono fino a diventare market maker: B2C2, Wintermute.</p>
<p>Scambi di criptovalute come Gate.io, Bitfinex mostrano pubblicamente classifiche di trading, spot, futures/swap perpetui, opzioni… dove le aziende cripto-native commercializzano attivamente le loro competenze, ad es. <a href="https://www.gate.io/testnet/delivery_ranking/usdt?ranking_id=1" target="_blank">Classifica di Gate.io</a></p>
<p><strong>Come attrarre liquidità gli scambi - Programma Market Maker</strong><br>Gli scambi valutano le prestazioni dei market maker con i seguenti criteri<br>● Spread: Più il prezzo di un market maker (sia bid che ask) è vicino al prezzo di mercato, meglio è.<br>● Profondità: Maggiore è la dimensione del prezzo (sia bid che ask), meglio è.<br>● Uptime: Più lungo è il tempo di quotazione qualificato su entrambi i lati, meglio è.<br>● Ambito di trading: Più coppie di trading sono coperte nell’elenco delle coppie di ‘market maker’, meglio è.</p>
<p>O semplicemente considera il volume di trading del maker, o il tasso di partecipazione al volume del maker dello scambio.</p>
<p>In cambio, gli scambi incentivano i market maker con condizioni migliori in<br>● Connettività: limite di velocità più elevato, punti di latenza bassa<br>● Commissione: tassa maker/taker<br>● Finanziamento: prestito a tasso zero/basso (o linea di credito)</p>
<p>Alcuni scambi concedono persino equità di scambio o opzioni ai market maker.</p>
<p><strong>Valutazione del tipo di programma di market making</strong><br>Ci sono diversi modi in cui gli scambi vengono valutati.<br>1.Semplice: orientato ai risultati<br>2.Come maker, il volume è un modo semplice e diretto di misurazione.<br>Gli scambi valutano i market maker sul volume del maker, sia per valore assoluto, percentuale dello scambio, o classifica di tutti i trader.<br>3.Medio - scheda punteggio semplice<br>4.Gli scambi valutano i market maker con una scheda punteggio, per incentivare determinati comportamenti preferiti dagli scambi, ad esempio, fare mercato per coppie di trading specifiche con pesi diversi (il peso sarà regolato strategicamente di volta in volta), ad esempio, <a href="https://www.gate.io/gis_mm" target="_blank">Programma di incentivi per i Market Maker di Gate.io</a></p>
<ol>
<li>Complesso - sistema di punteggio</li><li>I market maker saranno incentivati secondo una formula.<br>Ad esempio, la formula introdotta da un DEX nel 2021, è stata fenomenale al suo lancio e è stata immediatamente copiata da diverse borse.<br><img src="https://gimg2.gateimg.com/image/168127895824761296ama003.png" alt=""><br><strong><em>Divulgazione: Questo articolo proviene da 1Token, fornitore di tecnologia cripto-nativa dal 2015.</em></strong><br><strong><em>1Token è un fornitore di software per istituzioni cripto-finanziarie, che offre una soluzione tecnologica completa. Per ulteriori informazioni su 1Token, visita il sito <a href="https://1token.tech/" rel="nofollow noopener noreferrer" target="_blank">https://1token.tech/</a></em></strong></li></ol>
<div class="blog-details-info"><br><div>Autore: <strong>1Token</strong>, Ricercatore di 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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno adottate azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>