QWxsZXMgb3ZlciBMaXF1aWRpdGVpdDogSG9lIENyeXB0byBCZXVyemVuIFNhbWVud2Vya2VuIG1ldCBNYXJrZXQgTWFrZXJz

2023-04-12, 05:54

<p><img src="https://gimg2.gateimg.com/image/1681277935619226796blog.png" alt=""><em>-door 1Token BD Team</em></p>
<h2 id="h2-Prelude519121"><a name="Prelude" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prelude</h2><p>Cryptobeurzen zijn de belangrijkste spelers op de markt voor cryptocurrency en digitale activa. <a href="https://tokeninsight.com/en/research/miscellaneous/classification-of-exchanges-service-differences-and-reasons" rel="nofollow noopener noreferrer" target="_blank">combineert meerdere rollen in traditionele financiën,</a> <a href="https://tokeninsight.com/en/research/miscellaneous/classification-of-exchanges-service-differences-and-reasons" rel="nofollow noopener noreferrer" target="_blank">met diversificatie om met elkaar te concurreren.</a></p>
<p>Hoe trekken crypto-beurzen meer gebruikers aan en excelleren ze boven de concurrentie? De competenties kunnen handelsparen, handelskosten, beveiliging, liquiditeit, UI/UX, verdienen … Onder welke liquiditeit een belangrijke factor is die instellingen zouden overwegen bij het kiezen van cryptohandel locaties.</p>
<p><strong>Wat is liquiditeit?</strong><br>Om te begrijpen wat liquiditeit is, is de meest voor de hand liggende maatstaf de verwachte slippage. Dit is het verschil tussen de huidige marktmiddenprijs en de gemiddelde prijs van daadwerkelijke uitvoering. De belangrijkste factoren hierachter zijn de spread (het verschil tussen de bied- en laatprijs) en de diepte (de hoeveelheid kopers en verkopers die beschikbaar zijn tegen verschillende prijzen).</p>
<p>Stel je voor op welke orderboek hieronder je liever zou handelen<br><img src="https://gimg2.gateimg.com/image/1681278256157871819ama001.jpeg" alt=""><br>Op dezelfde manier betekent liquiditeit in een cryptocurrency exchange efficiënt kopen en verkopen in termen van tijd en kosten. Een zeer liquide cryptocurrency exchange zal veel kopers en verkopers hebben van elke cryptocurrency die op het platform is vermeld, waardoor handelaren posities kunnen openen en sluiten met minimale prijsafwijkingen.</p>
<p>Bijvoorbeeld, dit zijn de orderboeken voor <a href="/trade/BTC_USDT" target="_blank" class="blog_inner_link">BTC/USDT</a> op CEX1 en CEX2 op hetzelfde moment. We kunnen zien dat het kopen van 16.982 BTC op CEX1 zal leiden tot een slippage van ongeveer 6.055 USDT (0 taker fee op CEX1). <em>) en het kopen van 15.897 BTC op CEX2 zal leiden tot een slippage van 1.528 USDT (0,02% taker fee op CEX2</em>), wat betekent dat CEX2 op dit specifieke moment een hogere liquiditeit in BTC/USDT heeft dan CEX1.</p>
<p><em>Vergelijking van BTC/USDT-liquiditeit op CEX1 en CEX2</em><br>1.0 takerkosten BTC spot-handelsparen op CEX1<br>2.Neem de laagste spot taker fee op CEX2 (0.020%)</p>
<p>Voor beurzen die een hogere liquiditeit willen bereiken, is een veelvoorkomende praktijk om gebruik te maken van market makers.</p>
<p><strong>Wat is een market maker</strong>?<br>Een market maker is een entiteit of een persoon die liquiditeit verschaft door continu limietorders te plaatsen op zowel bied- als laatprijs.<br>In TradFi (forex, aandelen, ETF-markten, enz.) zijn market makers die grote merken zoals Goldman Sachs, Two Sigma, Citadel…<br>Op de cryptomarkt vallen cryptomarktmakers in twee categorieën:</p>
<p>● TradFi high-frequency trading firms die uitbreiden naar de cryptocurrency-markt en marktmakers worden: Jump Trading, Tower Research, DRW Cumberland.<br>● Crypto-native bedrijven die uitgroeien tot marktmakers: B2C2, Wintermute.</p>
<p>Crypto exchanges zoals Gate.io, Bitfinex tonen openlijk handelsleiderborden, spot, futures/perpetual swap, opties… waar cryptogerichte bedrijven actief hun competentie promoten, bijv. <a href="https://www.gate.io/testnet/delivery_ranking/usdt?ranking_id=1" target="_blank">Gate.io Leaderboard</a></p>
<p><strong>Hoe trekken beurzen liquiditeit aan - Market maker Programma</strong><br>Beurzen beoordelen de prestaties van market makers aan de hand van de onderstaande criteria<br>● Spread: Hoe dichter een citaat van een market maker bij de mid-market ligt, hoe beter.<br>● Diepte: Hoe groter de omvang van het citaat (zowel bieden als vragen), hoe beter.<br>● Uptime: Hoe langer de gekwalificeerde quoteringstijd aan beide zijden, hoe beter.<br>● Handelsbereik: Hoe meer handelsparen worden gedekt in de ‘market maker Pair List’, hoe beter.</p>
<p>Of gewoonweg rekening houden met de handelsvolume van de maker, of de participatiegraad van de maker in het volume van de beurs.</p>
<p>In ruil daarvoor stimuleren beurzen marktmakers met betere voorwaarden in<br>● Connectiviteit: hogere tarieflimiet, endpoints met lage latentie<br>● Commissie: maker/taker fee<br>● Financiering: nul/laag-renteloze lening (of kredietlijn)</p>
<p>Sommige beurzen verlenen zelfs beursaandelen of opties aan market makers.</p>
<p><strong>uatietype voor marktmakingsprogramma</strong><br>Er zijn verschillende manieren waarop uitwisselingen ueren.<br>1.Eenvoudig: resultaatgericht<br>2.As maker is volume een eenvoudige en directe manier van meten.<br>Beurzen beoordelen market makers op makervolume, hetzij op basis van absolute waarde, percentage van de beurs of rangschikking van alle handelaren.<br>3.Medium - eenvoudige scorekaart</p>
<ol>
<li>Beurzen ueren market makers met een scorekaart, om bepaald gedrag te stimuleren dat de voorkeur heeft van de beurzen, bijvoorbeeld om markt te maken voor specifieke handelsparen met verschillende gewichten (het gewicht zal van tijd tot tijd strategisch worden aangepast), bijv. <a href="https://www.gate.io/gis_mm" target="_blank">Gate.io Market Maker Incentive Program</a><br>5.Complex - scorensysteem<br>6.Market makers zullen worden gestimuleerd volgens een formule.<br>Bijvoorbeeld, de formule die in 2021 werd geïntroduceerd door een DEX, was fenomenaal bij de lancering en werd onmiddellijk gekopieerd door verschillende beurzen.<br><img src="https://gimg2.gateimg.com/image/168127895824761296ama003.png" alt=""><br><strong><em>Openbaarmaking: Dit artikel is afkomstig van 1Token, een in crypto gespecialiseerde technologieaanbieder sinds 2015.</em></strong><br><strong><em>1Token is een softwareaanbieder voor crypto-financiële instellingen en biedt een alles-in-één technologische oplossing. Voor meer informatie over 1Token, ga naar <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>Auteur: <strong>1Teken</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>