THVjaSBlIG9tYnJlIHN1Z2xpIEF1dG9tYXRlZCBNYXJrZXQgTWFrZXJzIChBTU0p

2023-03-02, 04:11

<p><img src="https://gimg2.gateimg.com/image/article/167773010511.png" alt=""><br>Gli automated market maker (AMM) a prodotto costante sono un tipo di algoritmo di scambio decentralizzato (DEX) che consente agli utenti di scambiare criptovalute senza un libro degli ordini. L’algoritmo imposta il prezzo di una particolare criptovaluta basandosi su una formula matematica che garantisce che il prodotto delle quantità di due diverse criptovalute in un pool di liquidità rimanga costante. L’AMM a prodotto costante utilizza un’equazione matematica fissa per determinare il prezzo di una particolare criptovaluta in base al saldo dei token in un pool di liquidità. L’equazione è:</p>
<p>x * y = k</p>
<p>dove x e y sono le quantità di due token diversi nel pool di liquidità e k è un valore costante che rappresenta il prodotto iniziale dei due saldi dei token nel pool. Quando un trader compra un token, diminuisce l’offerta di quel token nel pool aumentando l’offerta di un altro token e viceversa quando vende.</p>
<p>Le AMM hanno guadagnato popolarità grazie alla loro semplicità e ai bassi costi. Eliminano la necessità di ordini di acquisto, che possono essere complessi da gestire e possono causare problemi di liquidità, soprattutto per i mercati più piccoli. Inoltre, le AMM come <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> e SushiSwap sono senza permessi, il che significa che chiunque può partecipare al pool di liquidità fornendo i propri token e guadagnando commissioni di negoziazione in cambio.</p>
<p>Gli Automated Market Makers sono stati introdotti per la prima volta in un whitepaper del 2017 da un team di ricercatori guidato da Dan Robinson e Vitalik Buterin. Il documento proponeva un nuovo tipo di exchange decentralizzato che utilizzava un approccio formulistico per la determinazione dei prezzi e la fornitura di liquidità, anziché il tradizionale modello del libro degli ordini utilizzato dagli exchange centralizzati.</p>
<p>La prima implementazione di un market maker automatizzato è stata Bancor, lanciata nel 2017. Bancor ha utilizzato un approccio simile alla formula del prodotto costante utilizzata dai moderni AMM, ma con alcune differenze chiave. L’algoritmo di pricing di Bancor utilizzava un parametro di “peso del connettore” che poteva essere regolato per bilanciare l’offerta e la domanda dei token nel pool di liquidità.</p>
<p>Nel 2018, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> è stato lanciato da Hayden Adams, che ha introdotto la formula del prodotto costante come algoritmo di pricing per la sua AMM. Questa innovazione è stata significativa perché ha eliminato la necessità di un parametro regolabile, rendendo l’algoritmo di pricing più semplice e trasparente.</p>
<p>Da allora, sono emerse diverse altre AMM, tra cui SushiSwap, Curve, <a href="/price/balancer-bal" rel="nofollow noopener noreferrer" target="_blank">Balancer</a>, e molto altro. Questi AMM hanno caratteristiche e scelte di progettazione diverse, ma tutti utilizzano una forma di algoritmo di market-making automatizzato per determinare il prezzo e la liquidità dei token nei loro pool di liquidità.</p>
<p>Una delle critiche più grandi degli AMM è la loro suscettibilità alle perdite temporanee, che è la differenza tra il valore previsto e il valore effettivo dei token di un LP nel pool di liquidità a causa dei cambiamenti nel rapporto di prezzo dei token. Quando il rapporto di prezzo dei token nel pool cambia in modo significativo, l’LP può subire una perdita di valore rispetto al semplice possesso dei token al di fuori del pool.</p>
<p>Ad esempio, supponiamo che un pool di liquidità abbia 10 ETH e 1000 token DAI. Il valore del pool (k) è di 10 ETH * 1000 DAI = 10.000 ETH-DAI. Se un trader vuole acquistare 1 ETH, l’algoritmo calcolerà il nuovo prezzo in base alla formula del prodotto costante, quindi:</p>
<p>10 ETH <em> 1000 DAI = 10.000 ETH-DAI<br>(10 + 1) ETH </em> y = 10.000 ETH-DAI<br>y = 1000 / 11 = 90.9 DAI<br>Il trader dovrà scambiare 90.9 DAI per ricevere 1 ETH. Dopo il trade, il nuovo saldo del pool sarà di 11 ETH e 909.1 DAI, mantenendo costante il prodotto (k).</p>
<p>La perdita impermanente è un rischio che i fornitori di liquidità devono considerare quando forniscono token ad un AMM a prodotto costante. Potrebbero subire una perdita impermanente se il prezzo dei token nel pool cambia significativamente, e potrebbero non guadagnare tanto quanto avrebbero semplicemente tenendo i loro token al di fuori del pool.</p>
<p>Lo slippage è un altro fattore da considerare quando si negozia su un market maker automatizzato con un prodotto costante. È la differenza tra il prezzo previsto e il prezzo effettivo di esecuzione di una negoziazione a causa del cambiamento del saldo dei token del pool. Man mano che cambia la liquidità del pool, il prezzo di esecuzione può discostarsi dal prezzo previsto, dando luogo allo slippage.</p>
<p>Ad esempio, se un trader vuole acquistare una grande quantità di un token che ha una piccola quota del pool di liquidità, il prezzo di esecuzione potrebbe essere significativamente più alto rispetto al prezzo di mercato attuale. Questo perché il trade causerà una deviazione maggiore nel saldo del token del pool, con conseguente aumento dello slippage.</p>
<p>Lo slippage può essere mitigato assicurandosi che la piscina di liquidità abbia una profondità sufficiente e utilizzando ordini limitati anziché ordini di mercato. Gli ordini limitati consentono ai trader di impostare un prezzo massimo o minimo che sono disposti a pagare per un token, riducendo il rischio di slippage significativo.</p>
<p>Oltre alla perdita temporanea e allo slippage, ci sono numerosi altri rischi associati ai market maker automatizzati. In particolare:</p>
<ol>
<li><p>Attacchi di prestiti lampo: I prestiti lampo sono un tipo di prestito che può essere ottenuto e restituito nella stessa transazione. Questo può essere utilizzato per manipolare i prezzi dei token in un AMM, con conseguenti guadagni significativi per l’attaccante. Ad esempio, un attacco di prestito lampo potrebbe essere utilizzato per manipolare i prezzi dei token in un pool di liquidità e far sì che l’AMM acquisti i token dell’attaccante a un prezzo artificialmente alto.</p>
</li><li><p>Vulnerabilità dei contratti intelligenti: Le vulnerabilità dei contratti intelligenti possono essere sfruttate per rubare fondi degli utenti o manipolare i prezzi dei token in un AMM. Ad esempio, se c’è una vulnerabilità nel codice del contratto intelligente, un attaccante potrebbe essere in grado di prelevare i fondi degli utenti dal pool di liquidità.</p>
</li><li><p>Rischi di governance: Molti AMM sono governati da organizzazioni autonome decentralizzate (DAO), che possono essere soggette a rischi di governance in caso di mancanza di trasparenza o se un gruppo minoritario di utenti detiene una quantità sproporzionata di potere decisionale. Ad esempio, se un piccolo gruppo di utenti detiene una quantità significativa di potere decisionale, potrebbero influenzare le decisioni di governance dell’AMM a loro vantaggio.</p>
</li></ol>
<p>4.Rischi regolamentari: Poiché il quadro normativo per le criptovalute continua a evolversi, c’è il rischio che le AMM possano affrontare azioni regolamentari o sfide legali. Ad esempio, se una AMM viola le leggi sui titoli, potrebbe subire azioni legali da parte dei regolatori.</p>
<ol>
<li><p>Rischi di liquidità: Nonostante gli AMM siano progettati per fornire liquidità per mercati e asset di dimensioni ridotte, c’è comunque un rischio di bassa liquidità, che può portare a spread tra offerta e domanda più ampi e slippage più elevato. Ad esempio, se c’è una bassa liquidità in un pool di liquidità, un trader potrebbe non essere in grado di eseguire una transazione al prezzo desiderato.</p>
</li><li><p>Rischi di Oracle: gli AMM si basano sui feed di prezzo degli oracoli, che sono fonti esterne di dati sui prezzi. Se l’oracolo viene manipolato o compromesso, potrebbe comportare una valutazione inaccurata sull’AMM. Ad esempio, se un attaccante è in grado di manipolare i dati di prezzo sull’oracolo, potrebbe essere in grado di trarre profitto dalle negoziazioni sull’AMM.</p>
</li><li><p>Rischi di front-running: il front-running è un tipo di transazione che si verifica quando un trader inserisce un ordine di acquisto o vendita di un token davanti all’ordine di un altro trader, approfittando del movimento dei prezzi causato dall’ordine originale. Questo può essere un rischio per gli AMM, poiché la natura aperta e trasparente del libro degli ordini facilita l’identificazione di operazioni redditizie da parte dei front-runner. Ad esempio, un front-runner potrebbe essere in grado di vedere che un grande ordine sta per essere eseguito sull’AMM e inserire il proprio ordine davanti ad esso, ottenendo un profitto per il front-runner.</p>
</li></ol>
<p>In generale, pur avendo molti vantaggi, le AMM presentano ancora diversi rischi associati al loro utilizzo. I trader e i fornitori di liquidità dovrebbero valutare attentamente questi rischi prima di interagire con una AMM e adottare le precauzioni appropriate per mitigarli. Come per qualsiasi applicazione decentralizzata, è importante che gli utenti siano consapevoli dei rischi e adottino le precauzioni appropriate per proteggere i propri fondi.</p>
<p>Le AMM rappresentano uno dei più grandi movimenti innovativi nella criptovaluta che ha alimentato la crescita del trading decentralizzato, fornendo ai trader un modo semplice e accessibile per scambiare diverse criptovalute senza la necessità di un exchange centralizzato o di un libro degli ordini. Mentre i DEX e le AMM hanno il loro posto nell’ecosistema delle criptovalute, non sono ancora un sostituto degli exchange centralizzati per molti partecipanti al mercato.</p>
<p><strong><em>Divulgazione: Questo articolo è stato scritto in collaborazione con DWF Labs, un market maker e cliente istituzionale di Gate.io. Per maggiori informazioni su DWF Labs, visita <a href="www.dwf-labs.com" rel="nofollow noopener noreferrer" target="_blank" title="www.dwf-labs.com">www.dwf-labs.com</a></em></strong></p>
<div class="blog-details-info"><br><div>Autore:<strong> Laboratori DWF.</strong><br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div class="info-tips"><em></em>Nessun contenuto qui costituirà consulenza sugli investimenti e non costituisce alcuna offerta o sollecitazione di offerta o raccomandazione di alcun prodotto o progetto di investimento.<br><div class="info-tips"><em>L'inclusione di prodotti, servizi, entità o contenuti di terze parti non costituisce un'approvazione, una raccomandazione o un'affiliazione da parte di Gate.io. Si prega di condurre una ricerca approfondita e di cercare consigli professionali prima di prendere qualsiasi decisione di investimento.<br></em><div class="info-tips"><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostare dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<p></p><br><br><p></p></div><p></p><br></div></div></div></div></div>