Visite guidée du contrat Uniswap-v2

Introduction

Uniswap v2 (opens in a new tab) peut créer un marché d'échange entre deux jetons ERC-20, quels qu'ils soient. Dans cet article, nous allons passer en revue le code source des contrats qui implémentent ce protocole et voir pourquoi ils sont écrits comme ils le sont.

Que fait Uniswap ?

Fondamentalement, il existe deux types d'utilisateurs : les fournisseurs de liquidités et les traders.

Les fournisseurs de liquidités fournissent le pool avec les deux jetons qui peuvent être échangés (nous les appellerons Jeton0 et Jeton1). En retour, ils reçoivent un troisième jeton qui représente une propriété partielle du pool, appelé un jeton de liquidité.

Les traders envoient un type de jeton au pool et reçoivent l'autre (par exemple, envoient le Jeton0 et reçoivent le Jeton1) hors du pool fourni par les fournisseurs de liquidités. Le taux de change est déterminé par le nombre relatif de Jeton0 et de Jeton1 que le pool possède. En outre, le pool prélève un petit pourcentage en guise de récompense pour le pool de liquidités.

Lorsque les fournisseurs de liquidités veulent récupérer leurs actifs, ils peuvent brûler les jetons du pool et recevoir en retour leurs jetons, y compris leur part des récompenses.

Cliquez ici pour une description plus complète (opens in a new tab).

Pourquoi v2 ? Pourquoi pas v3 ?

Uniswap v3 (opens in a new tab) est une mise à niveau bien plus compliquée que la v2. Il est plus facile d'apprendre d'abord la v2, puis de passer à la v3.

Contrats de base et contrats périphériques

Uniswap v2 est divisé en deux composants, un noyau et une périphérie. Cette division permet aux contrats de base, qui détiennent les actifs et doivent donc être sécurisés, d'être plus simples et plus faciles à auditer. Toutes les fonctionnalités supplémentaires requises par les traders peuvent alors être fournies par des contrats périphériques.

Flux de données et de contrôle

Voici le flux de données et de contrôle qui se produit lorsque vous effectuez les trois actions principales d'Uniswap :

1. Échanger entre différents jetons
2. Ajouter de la liquidité au marché et être récompensé par des jetons de liquidité ERC-20 d'échange de paires
3. Brûler des jetons de liquidité ERC-20 et récupérer les jetons ERC-20 que l'échange de paires permet aux traders d'échanger

Échange

C'est le flux le plus courant, utilisé par les traders :

Appelant

1. Fournir au compte périphérique une provision pour le montant à échanger.
2. Appeler l'une des nombreuses fonctions d'échange du contrat périphérique (la fonction utilisée dépend de si l'ETH est impliqué ou non, si le trader spécifie le montant de jetons à déposer ou le montant de jetons à récupérer, etc.). Chaque fonction d'échange accepte un path (chemin), un tableau d'échanges à parcourir.

Dans le contrat périphérique (UniswapV2Router02.sol)

3. Identifier les montants qui doivent être échangés sur chaque échange le long du chemin.
4. Itère sur le chemin. Pour chaque échange le long du chemin, il envoie le jeton d'entrée, puis appelle la fonction swap de l'échange. Dans la plupart des cas, l'adresse de destination des jetons est le prochain échange de paires sur le chemin. Pour l'échange final, il s'agit de l'adresse fournie par le trader.

Dans le contrat de base (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2}5. Vérifier que le contrat de base ne fait pas l'objet d'une tricherie et peut maintenir une liquidité suffisante après l'échange.

6. Voir combien de jetons supplémentaires ont été reçus en plus des réserves connues. Ce montant correspond au nombre de jetons d'entrée reçus pour l'échange.
7. Envoyer les jetons de sortie à la destination.
8. Appeler _update pour mettre à jour les montants de la réserve.

Retour dans le contrat périphérique (UniswapV2Router02.sol)

9. Effectuer tout nettoyage nécessaire (par exemple, brûler des jetons WETH pour récupérer des ETH à envoyer au trader).

Ajout de liquidité

Appelant

1. Fournir au compte périphérique une provision pour les montants à ajouter au pool de liquidités.
2. Appeler l'une des fonctions addLiquidity du contrat périphérique.

Dans le contrat périphérique (UniswapV2Router02.sol)

3. Créer un nouvel échange de paires si nécessaire.
4. S'il existe un échange de paires, calculer le montant des jetons à ajouter. La valeur est censée être identique pour les deux jetons, donc le ratio des nouveaux jetons par rapport aux jetons existants doit être le même.
5. Vérifier si les montants sont acceptables (les appelants peuvent spécifier un montant minimum en dessous duquel ils préfèrent ne pas ajouter de liquidité).
6. Appeler le contrat de base.

Dans le contrat de base (UniswapV2Pair.sol)

7. Frapper des jetons de liquidité et les envoyer à l'appelant.
8. Appeler _update pour mettre à jour les montants de la réserve.

Retrait de liquidité

Appelant

1. Fournir au compte périphérique une provision de jetons de liquidité à brûler en échange des jetons sous-jacents.
2. Appeler l'une des fonctions removeLiquidity du contrat périphérique.

Dans le contrat périphérique (UniswapV2Router02.sol)

3. Envoyer les jetons de liquidité à l'échange de paires.

Dans le contrat de base (UniswapV2Pair.sol)

4. Envoyer à l'adresse de destination les jetons sous-jacents en proportion des jetons brûlés. Par exemple, s'il y a 1 000 jetons A dans le pool, 500 jetons B et 90 jetons de liquidité, et que nous recevons 9 jetons à brûler, nous brûlons 10 % des jetons de liquidité, nous renvoyons donc à l'utilisateur 100 jetons A et 50 jetons B.
5. Brûler les jetons de liquidité.
6. Appeler _update pour mettre à jour les montants de la réserve.

Les contrats de base

Ce sont les contrats sécurisés qui détiennent la liquidité.

UniswapV2Pair.sol

Ce contrat (opens in a new tab) met en œuvre le pool réel qui échange les jetons. C'est la fonctionnalité principale d'Uniswap.

1pragma solidity =0.5.16;
2
3import './interfaces/IUniswapV2Pair.sol';
4import './UniswapV2ERC20.sol';
5import './libraries/Math.sol';
6import './libraries/UQ112x112.sol';
7import './interfaces/IERC20.sol';
8import './interfaces/IUniswapV2Factory.sol';
9import './interfaces/IUniswapV2Callee.sol';
Afficher tout
Copier

Ce sont toutes les interfaces que le contrat doit connaître, soit parce que le contrat les implémente (IUniswapV2Pair et UniswapV2ERC20), soit parce qu'il appelle des contrats qui les implémentent.

1contract UniswapV2Pair is IUniswapV2Pair, UniswapV2ERC20 {
Copier

Ce contrat hérite d'UniswapV2ERC20, qui fournit les fonctions ERC-20 pour les jetons de liquidité.

1    using SafeMath  for uint;
Copier

La bibliothèque SafeMath (opens in a new tab) est utilisée pour éviter les dépassements de capacité (overflow) et les sous-dépassements (underflow). Ceci est important car sinon, nous pourrions nous retrouver dans une situation où une valeur devrait être -1, mais est en fait 2^256-1.

1    using UQ112x112 for uint224;
Copier

De nombreux calculs dans le contrat de pool nécessitent des fractions. Cependant, les fractions ne sont pas prises en charge par l'EVM. La solution trouvée par Uniswap est d'utiliser des valeurs de 224 bits, avec 112 bits pour la partie entière et 112 bits pour la fraction. Ainsi, 1,0 est représenté par 2^112, 1,5 est représenté par 2^112 + 2^111, etc.

Plus de détails sur cette bibliothèque sont disponibles plus loin dans le document.

Variables

1    uint public constant MINIMUM_LIQUIDITY = 10**3;
Copier

Pour éviter les cas de division par zéro, il existe toujours un nombre minimum de jetons de liquidité (mais ils sont détenus par le compte zéro). Ce nombre est MINIMUM_LIQUIDITY, soit un millier.

1    bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
Copier

C'est le sélecteur ABI pour la fonction de transfert ERC-20. Il est utilisé pour transférer des jetons ERC-20 sur les deux comptes de jetons.

1    address public factory;
Copier

C'est le contrat d'usine qui a créé ce pool. Chaque pool est un échange entre deux jetons ERC-20, l'usine est le point central qui relie tous ces pools.

1    address public token0;
2    address public token1;
Copier

Ce sont les adresses des contrats pour les deux types de jetons ERC-20 qui peuvent être échangés par ce pool.

1    uint112 private reserve0;           // uses single storage slot, accessible via getReserves
2    uint112 private reserve1;           // uses single storage slot, accessible via getReserves
Copier

La réserve du pool pour chaque type de jeton. Nous supposons que les deux représentent le même montant de valeur, et donc que chaque jeton0 vaut la valeur de jeton1 multipliée par reserve1/reserve0.

1    uint32  private blockTimestampLast; // uses single storage slot, accessible via getReserves
Copier

L'horodatage du dernier bloc dans lequel un échange a eu lieu, utilisé pour suivre les taux de change dans le temps.

L'une des plus grandes dépenses de gaz des contrats Ethereum est le stockage, qui persiste d'un appel de contrat à l'autre. Chaque cellule de stockage fait 256 bits de long. Ainsi, trois variables, reserve0, reserve1 et blockTimestampLast, sont allouées de manière à ce qu'une seule valeur de stockage puisse inclure les trois (112+112+32=256).

1    uint public price0CumulativeLast;
2    uint public price1CumulativeLast;
Copier

Ces variables contiennent les coûts cumulatifs pour chaque jeton (chacun en fonction de l'autre). Elles peuvent être utilisées pour calculer le taux de change moyen sur une période de temps.

1    uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
Copier

Pour décider du taux de change entre jeton0 et jeton1, l'échange de paires maintient le multiple des deux réserves constant pendant les transactions. kLast est cette valeur. Elle change lorsqu'un fournisseur de liquidités dépose ou retire des jetons, et elle augmente légèrement en raison des frais de marché de 0,3 %.

Voici un exemple simple. Notez que par souci de simplicité, le tableau ne comporte que trois chiffres après la virgule, et que nous ignorons les frais de transaction de 0,3 %, de sorte que les chiffres ne sont pas exacts.

Plus les traders fournissent de jetons0, plus la valeur relative du jeton1 augmente, et vice versa, en fonction de l'offre et de la demande.

Verrouillage

1    uint private unlocked = 1;
Copier

Il existe une catégorie de vulnérabilités de sécurité basées sur l'abus de réentrance (opens in a new tab). Uniswap doit transférer des jetons ERC-20 arbitraires, ce qui signifie appeler des contrats ERC-20 qui pourraient tenter d'abuser du marché Uniswap qui les appelle. En intégrant une variable unlocked au contrat, nous pouvons empêcher l'appel de fonctions pendant qu'elles sont en cours d'exécution (dans la même transaction).

1    modifier lock() {
Copier

Cette fonction est un modificateur (opens in a new tab), une fonction qui enveloppe une fonction normale pour en modifier le comportement d'une manière ou d'une autre.

1        require(unlocked == 1, 'UniswapV2: LOCKED');
2        unlocked = 0;
Copier

Si unlocked est égal à un, le définir à zéro. S'il est déjà à zéro, annuler l'appel, le faire échouer.

1        _;
Copier

Dans un modificateur, _; est l'appel de fonction d'origine (avec tous les paramètres). Ici, cela signifie que l'appel de fonction ne se produit que si unlocked valait un lorsqu'il a été appelé, et que pendant son exécution, la valeur de unlocked est nulle.

1        unlocked = 1;
2    }
Copier

Une fois que la fonction principale est retournée, libérer le verrou.

Divers fonctions

1    function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
2        _reserve0 = reserve0;
3        _reserve1 = reserve1;
4        _blockTimestampLast = blockTimestampLast;
5    }
Copier

Cette fonction fournit aux appelants l'état actuel de l'échange. Notez que les fonctions Solidity peuvent retourner plusieurs valeurs (opens in a new tab).

1    function _safeTransfer(address token, address to, uint value) private {
2        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
Copier

Cette fonction interne transfère un montant de jetons ERC20 de l'échange à une autre personne. SELECTOR spécifie que la fonction que nous appelons est transfer(address,uint) (voir la définition ci-dessus).

Pour éviter d'avoir à importer une interface pour la fonction de jeton, nous créons « manuellement » l'appel en utilisant l'une des fonctions ABI (opens in a new tab).

1        require(success && (data.length == 0 || abi.decode(data, (bool))), 'UniswapV2: TRANSFER_FAILED');
2    }
Copier

Un appel de transfert ERC-20 peut signaler un échec de deux manières :

1. Annuler. Si un appel à un contrat externe est annulé, alors la valeur de retour booléenne est false.
2. Se terminer normalement mais signaler un échec. Dans ce cas, le tampon de valeur de retour a une longueur non nulle et, lorsqu'il est décodé en tant que valeur booléenne, il est false.

Si l'une de ces conditions se produit, annuler.

Événements

1    event Mint(address indexed sender, uint amount0, uint amount1);
2    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
Copier

Ces deux événements sont émis lorsqu'un fournisseur de liquidités dépose des liquidités (Mint) ou les retire (Burn). Dans les deux cas, les montants des jetons0 et jetons1 déposés ou retirés font partie de l'événement, tout comme l'identité du compte qui nous a appelés (sender). Dans le cas d'un retrait, l'événement inclut également la cible qui a reçu les jetons (to), qui peut ne pas être la même que l'expéditeur.

1    event Swap(
2        address indexed sender,
3        uint amount0In,
4        uint amount1In,
5        uint amount0Out,
6        uint amount1Out,
7        address indexed to
8    );
Copier

Cet événement est émis lorsqu'un trader échange un jeton contre un autre. Encore une fois, l'expéditeur et le destinataire peuvent ne pas être les mêmes. Chaque jeton peut être soit envoyé à l’échange, soit reçu de celui-ci.

1    event Sync(uint112 reserve0, uint112 reserve1);
Copier

Enfin, Sync est émis chaque fois que des jetons sont ajoutés ou retirés, quelle qu'en soit la raison, pour fournir les dernières informations de réserve (et donc le taux de change).

Fonctions de configuration

Ces fonctions sont censées être appelées une fois, lors de la mise en place du nouvel échange de paires.

1    constructor() public {
2        factory = msg.sender;
3    }
Copier

Le constructeur s'assure que nous garderons une trace de l'adresse de l'usine qui a créé la paire. Ces informations sont requises pour initialize et pour les frais d'usine (s'il y en a).

1    // called once by the factory at time of deployment
2    function initialize(address _token0, address _token1) external {
3        require(msg.sender == factory, 'UniswapV2: FORBIDDEN'); // sufficient check
4        token0 = _token0;
5        token1 = _token1;
6    }
Copier

Cette fonction permet à l'usine (et seulement à l'usine) de spécifier les deux jetons ERC-20 que cette paire échangera.

Fonctions de mise à jour interne

_update

1    // update reserves and, on the first call per block, price accumulators
2    function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
Copier

Cette fonction est appelée chaque fois que des jetons sont déposés ou retirés.

1        require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW');
Copier

Si balance0 ou balance1 (uint256) est supérieur à uint112(-1) (=2^112-1) (donc il déborde et revient à 0 lorsqu'il est converti en uint112), refuser de continuer le _update pour éviter les débordements. Avec un jeton normal qui peut être subdivisé en 10^18 unités, cela signifie que chaque échange est limité à environ 5,1*10^15 de chaque jeton. Jusqu'à présent, cela n'a pas posé de problème.

1        uint32 blockTimestamp = uint32(block.timestamp % 2**32);
2        uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
3        if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
Copier

Si le temps écoulé n'est pas nul, cela signifie que nous sommes la première transaction d'échange sur ce bloc. Dans ce cas, nous devons mettre à jour les accumulateurs de coûts.

1            // * never overflows, and + overflow is desired
2            price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
3            price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
4        }
Copier

Chaque accumulateur de coûts est mis à jour avec le coût le plus récent (réserve de l'autre jeton/réserve de ce jeton) multiplié par le temps écoulé en secondes. Pour obtenir un prix moyen, vous lisez le prix cumulé à deux moments donnés et vous divisez par la différence de temps entre eux. Par exemple, supposons la séquence d'événements suivante :

Disons que nous souhaitons calculer le prix moyen du Jeton0 entre les horodatages 5 030 et 5 150. La différence de la valeur de price0Cumulative est 143,702-29,07=114,632. Il s'agit de la moyenne sur deux minutes (120 secondes). Le prix moyen est donc 114,632/120 = 0,955.

Ce calcul de prix est la raison pour laquelle nous devons connaître les anciennes tailles de réserve.

1        reserve0 = uint112(balance0);
2        reserve1 = uint112(balance1);
3        blockTimestampLast = blockTimestamp;
4        emit Sync(reserve0, reserve1);
5    }
Copier

Enfin, mettre à jour les variables globales et émettre un événement Sync.

_mintFee

1    // if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
2    function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
Copier

Dans Uniswap 2.0, les traders paient des frais de 0,30 % pour utiliser le marché. La plus grande partie de ces frais (0,25 % de la transaction) va toujours aux fournisseurs de liquidités. Les 0,05 % restants peuvent être versés soit aux fournisseurs de liquidités, soit à une adresse spécifiée par l'usine en tant que frais de protocole, qui rémunère Uniswap pour ses efforts de développement.

Pour réduire les calculs (et donc les frais de gaz), ces frais ne sont calculés que lorsque la liquidité est ajoutée ou retirée du pool, plutôt qu'à chaque transaction.

1        address feeTo = IUniswapV2Factory(factory).feeTo();
2        feeOn = feeTo != address(0);
Copier

Lire la destination des frais de l'usine. S'ils sont nuls, alors il n'y a pas de frais de protocole et il n'est pas nécessaire de les calculer.

1        uint _kLast = kLast; // gas savings
Copier

La variable d'état kLast est située dans le stockage, elle aura donc une valeur entre les différents appels au contrat. L'accès au stockage est beaucoup plus cher que l'accès à la mémoire volatile qui est libérée lorsque l'appel de fonction au contrat se termine. Nous utilisons donc une variable interne pour économiser du gaz.

1        if (feeOn) {
2            if (_kLast != 0) {
Copier

Les fournisseurs de liquidités obtiennent leur part simplement par l'appréciation de leurs jetons de liquidité. Mais les frais de protocole nécessitent que de nouveaux jetons de liquidité soient frappés et fournis à l'adresse feeTo.

1                uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
2                uint rootKLast = Math.sqrt(_kLast);
3                if (rootK > rootKLast) {
Copier

S'il y a de nouvelles liquidités sur lesquelles percevoir des frais de protocole. Vous pouvez voir la fonction de racine carrée plus loin dans cet article.

1                    uint numerator = totalSupply.mul(rootK.sub(rootKLast));
2                    uint denominator = rootK.mul(5).add(rootKLast);
3                    uint liquidity = numerator / denominator;
Copier

Ce calcul compliqué des frais est expliqué dans le livre blanc (opens in a new tab) à la page 5. Nous savons qu'entre le moment où kLast a été calculé et le moment présent, aucune liquidité n'a été ajoutée ou supprimée (car nous exécutons ce calcul à chaque fois que la liquidité est ajoutée ou supprimée, avant qu'elle ne change réellement). Par conséquent, tout changement dans reserve0 * reserve1 doit provenir des frais de transaction (sans eux, nous conserverions la constante reserve0 * reserve1).

1                    if (liquidity > 0) _mint(feeTo, liquidity);
2                }
3            }
Copier

Utiliser la fonction UniswapV2ERC20._mint pour créer les jetons de liquidité supplémentaires et les affecter à feeTo.

1        } else if (_kLast != 0) {
2            kLast = 0;
3        }
4    }
Copier

S'il n'y a pas de frais, régler kLast à zéro (si ce n'est pas déjà le cas). Lorsque ce contrat a été rédigé, il existait une fonctionnalité de remboursement de gaz (opens in a new tab) qui encourageait les contrats à réduire la taille globale de l'état d'Ethereum en mettant à zéro le stockage dont ils n'avaient pas besoin. Ce code obtient ce remboursement lorsque c'est possible.

Fonctions accessibles en externe

Notez que bien que toute transaction ou tout contrat puisse appeler ces fonctions, elles sont conçues pour être appelées depuis le contrat périphérique. Si vous les appelez directement, vous ne pourrez pas tricher sur l'échange de paires, mais vous pourriez perdre de la valeur par erreur.

frapper

1    // this low-level function should be called from a contract which performs important safety checks
2    function mint(address to) external lock returns (uint liquidity) {
Copier

Cette fonction est appelée lorsqu'un fournisseur de liquidités ajoute de la liquidité au pool. Elle frappe des jetons de liquidité supplémentaires en guise de récompense. Elle devrait être appelée à partir d'un contrat périphérique qui l'appelle après avoir ajouté la liquidité dans la même transaction (afin que personne d'autre ne puisse soumettre une transaction réclamant la nouvelle liquidité avant le propriétaire légitime).

1        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
Copier

C'est ainsi qu'il faut lire les résultats d'une fonction Solidity qui retourne plusieurs valeurs. Nous ignorons la dernière valeur retournée, l'horodatage du bloc, car nous n'en avons pas besoin.

1        uint balance0 = IERC20(token0).balanceOf(address(this));
2        uint balance1 = IERC20(token1).balanceOf(address(this));
3        uint amount0 = balance0.sub(_reserve0);
4        uint amount1 = balance1.sub(_reserve1);
Copier

Obtenir les soldes actuels et voir combien a été ajouté pour chaque type de jeton.

1        bool feeOn = _mintFee(_reserve0, _reserve1);
Copier

Calculer les frais de protocole à percevoir, le cas échéant, et frapper les jetons de liquidité en conséquence. Étant donné que les paramètres de _mintFee sont les anciennes valeurs de réserve, les frais sont calculés avec précision en se basant uniquement sur les changements de pool dus aux frais.

1        uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
2        if (_totalSupply == 0) {
3            liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
4           _mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
Copier

S'il s'agit du premier dépôt, créer des jetons MINIMUM_LIQUIDITY et les envoyer à l'adresse zéro pour les verrouiller. Ils ne peuvent jamais être rachetés, ce qui signifie que le pool ne sera jamais complètement vidé (cela nous évite une division par zéro à certains endroits). La valeur de MINIMUM_LIQUIDITY est de mille, ce qui, si l'on considère que la plupart des ERC-20 sont subdivisés en unités de 10^-18 d'un jeton, comme l'ETH est divisé en wei, correspond à 10^-15 de la valeur d'un seul jeton. Le coût n'est pas élevé.

Au moment du premier dépôt, nous ne connaissons pas la valeur relative des deux jetons, nous multiplions donc simplement les montants et prenons une racine carrée, en supposant que le dépôt nous fournisse une valeur égale pour les deux jetons.

Nous pouvons nous y fier car il est dans l'intérêt du déposant de fournir une valeur égale pour éviter de perdre de la valeur à cause de l'arbitrage. Imaginons que la valeur des deux jetons est identique, mais que notre déposant ait déposé quatre fois plus de Jeton1 que de Jeton0. Un trader peut utiliser le fait que l'échange de paires pense que le Jeton0 a plus de valeur pour en extraire de la valeur.

Comme vous pouvez le voir, le trader a gagné 8 jetons supplémentaires, qui proviennent d'une réduction de la valeur du pool, ce qui pénalise le déposant qui le possède.

1        } else {
2            liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
Copier

À chaque dépôt ultérieur, nous connaissons déjà le taux de change entre les deux actifs et nous attendons des fournisseurs de liquidités qu'ils fournissent une valeur égale pour les deux. S'ils ne le font pas, nous leur donnons des jetons de liquidité basés sur la valeur inférieure qu'ils ont fournie, en guise de pénalité.

Qu'il s'agisse du dépôt initial ou d'un dépôt ultérieur, le nombre de jetons de liquidité que nous fournissons est égal à la racine carrée de la variation de reserve0*reserve1 et la valeur du jeton de liquidité ne change pas (sauf si nous recevons un dépôt qui n'a pas de valeurs égales pour les deux types, auquel cas l'« amende » est distribuée). Voici un autre exemple avec deux jetons qui ont la même valeur, avec trois bons dépôts et un mauvais (dépôt d'un seul type de jeton, il ne produit donc aucun jeton de liquidité).

1        }
2        require(liquidity > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED');
3        _mint(to, liquidity);
Copier

Utiliser la fonction UniswapV2ERC20._mint pour créer les jetons de liquidité supplémentaires et les donner au bon compte.

1
2        _update(balance0, balance1, _reserve0, _reserve1);
3        if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
4        emit Mint(msg.sender, amount0, amount1);
5    }
Copier

Mettre à jour les variables d'état (reserve0, reserve1 et si nécessaire kLast) et émettre l'événement approprié.

brûler

1    // this low-level function should be called from a contract which performs important safety checks
2    function burn(address to) external lock returns (uint amount0, uint amount1) {
Copier

Cette fonction est appelée lorsque la liquidité est retirée et que les jetons de liquidité appropriés doivent être brûlés. Elle devrait également être appelée depuis un compte périphérique.

1        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
2        address _token0 = token0;                                // gas savings
3        address _token1 = token1;                                // gas savings
4        uint balance0 = IERC20(_token0).balanceOf(address(this));
5        uint balance1 = IERC20(_token1).balanceOf(address(this));
6        uint liquidity = balanceOf[address(this)];
Copier

Le contrat périphérique a transféré la liquidité à brûler vers ce contrat avant l'appel. De cette façon, nous savons combien de liquidités brûler et nous pouvons nous assurer qu'elles sont bien brûlées.

1        bool feeOn = _mintFee(_reserve0, _reserve1);
2        uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
3        amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
4        amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
5        require(amount0 > 0 && amount1 > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED');
Copier

Le fournisseur de liquidités reçoit la même valeur pour les deux jetons. De cette façon, nous ne modifions pas le taux de change.

1        _burn(address(this), liquidity);
2        _safeTransfer(_token0, to, amount0);
3        _safeTransfer(_token1, to, amount1);
4        balance0 = IERC20(_token0).balanceOf(address(this));
5        balance1 = IERC20(_token1).balanceOf(address(this));
6
7        _update(balance0, balance1, _reserve0, _reserve1);
8        if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
9        emit Burn(msg.sender, amount0, amount1, to);
10    }
11
Afficher tout
Copier

Le reste de la fonction burn est l'image miroir de la fonction mint ci-dessus.

échange

1    // this low-level function should be called from a contract which performs important safety checks
2    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
Copier

Cette fonction est également censée être appelée depuis un contrat périphérique.

1        require(amount0Out > 0 || amount1Out > 0, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT');
2        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
3        require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: INSUFFICIENT_LIQUIDITY');
4
5        uint balance0;
6        uint balance1;
7        { // scope for _token{0,1}, avoids stack too deep errors
Copier

Les variables locales peuvent être stockées soit en mémoire, soit, si elles ne sont pas trop nombreuses, directement sur la pile. Si nous pouvons limiter le nombre, nous utiliserons la pile pour consommer moins de gaz. Pour plus de détails, voir le Yellow Paper, les spécifications formelles d'Ethereum (opens in a new tab), p. 26, équation 298.

1            address _token0 = token0;
2            address _token1 = token1;
3            require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO');
4            if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
5            if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
Copier

Ce transfert est optimiste, car nous transférons avant d'être sûrs que toutes les conditions sont remplies. Ceci est acceptable dans Ethereum car si les conditions ne sont pas remplies plus tard lors de l'appel, nous annulons l'opération ainsi que les changements qu'elle a créés.

1            if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
Copier

Informer le destinataire de l'échange si demandé.

1            balance0 = IERC20(_token0).balanceOf(address(this));
2            balance1 = IERC20(_token1).balanceOf(address(this));
3        }
Copier

Obtenir les soldes actuels. Le contrat périphérique nous envoie les jetons avant de nous appeler pour l'échange. Il est ainsi facile pour le contrat de vérifier qu'il n'est pas trompé, une vérification qui doit avoir lieu dans le contrat de base (car nous pouvons être appelés par d'autres entités que notre contrat périphérique).

1        uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
2        uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
3        require(amount0In > 0 || amount1In > 0, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT');
4        { // scope for reserve{0,1}Adjusted, avoids stack too deep errors
5            uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
6            uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
7            require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K');
Copier

Ceci est un contrôle de cohérence pour s'assurer que nous ne perdons rien lors de l'échange. En aucune circonstance un échange ne devrait réduire reserve0*reserve1. C'est également là que nous nous assurons qu'une redevance de 0,3 % est envoyée sur l'échange ; avant de vérifier la valeur de K, nous multiplions les deux soldes par 1 000 et soustrayons les montants multipliés par 3, ce qui signifie que 0,3 % (3/1000 = 0,003 = 0,3 %) est déduit du solde avant de comparer sa valeur K à la valeur K des réserves actuelles.

1        }
2
3        _update(balance0, balance1, _reserve0, _reserve1);
4        emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
5    }
Copier

Mettre à jour reserve0 et reserve1, et si nécessaire les accumulateurs de prix et l'horodatage, et émettre un événement.

Sync ou Skim

Il est possible que les soldes réels se désynchronisent des réserves que l'échange de paires pense avoir. Il n'y a aucun moyen de retirer des jetons sans le consentement du contrat, mais pour les dépôts c'est une autre affaire. Un compte peut transférer des jetons à l'échange sans appeler ni mint ni swap.

Dans ce cas, il y a deux solutions :

• sync, mettre à jour les réserves avec les soldes actuels
• skim, retirer le montant supplémentaire. Notez que tout compte est autorisé à appeler skim car nous ne savons pas qui a déposé les jetons. Cette information est émise dans un événement, mais les événements ne sont pas accessibles depuis la blockchain.

1    // force balances to match reserves
2    function skim(address to) external lock {
3        address _token0 = token0; // gas savings
4        address _token1 = token1; // gas savings
5        _safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
6        _safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
7    }
8
9
10
11    // force reserves to match balances
12    function sync() external lock {
13        _update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
14    }
15}
Afficher tout
Copier

UniswapV2Factory.sol

Ce contrat (opens in a new tab) crée les échanges de paires.

1pragma solidity =0.5.16;
2
3import './interfaces/IUniswapV2Factory.sol';
4import './UniswapV2Pair.sol';
5
6contract UniswapV2Factory is IUniswapV2Factory {
7    address public feeTo;
8    address public feeToSetter;
Copier

Ces variables d'état sont nécessaires pour implémenter les frais de protocole (voir le livre blanc (opens in a new tab), p. 5). L'adresse feeTo accumule les jetons de liquidité pour les frais de protocole, et feeToSetter est l'adresse autorisée à changer feeTo en une adresse différente.

1    mapping(address => mapping(address => address)) public getPair;
2    address[] public allPairs;
Copier

Ces variables gardent une trace des paires, des échanges entre deux types de jetons.

La première, getPair, est un mappage qui identifie un contrat d'échange de paires basé sur les deux jetons ERC-20 qu'il échange. Les jetons ERC-20 sont identifiés par les adresses des contrats qui les implémentent, de sorte que les clés et la valeur sont toutes des adresses. Pour obtenir l'adresse de l'échange de paires qui vous permet de convertir tokenA en tokenB, vous utilisez getPair[<adresse de tokenA>][<adresse de tokenB>] (ou l'inverse).

La seconde variable, allPairs, est un tableau qui inclut toutes les adresses des échanges de paires créés par cette usine. Sur Ethereum, vous ne pouvez pas itérer sur le contenu d'un mapping, ni obtenir une liste de toutes les clés. Cette variable est donc le seul moyen de savoir quels échanges cette usine gère.

Note : La raison pour laquelle vous ne pouvez pas itérer sur toutes les clés d'un mapping est que le stockage des données de contrat est coûteux, donc moins nous en utilisons, et moins nous le modifions, mieux c'est. Vous pouvez créer des mappings qui supportent l'itération (opens in a new tab), mais ils nécessitent un stockage supplémentaire pour une liste de clés. Dans la plupart des applications, vous n'en avez pas besoin.

1    event PairCreated(address indexed token0, address indexed token1, address pair, uint);
Copier

Cet événement est émis lorsqu'un nouvel échange de paires est créé. Il comprend les adresses des jetons, l'adresse de l'échange de paires et le nombre total d'échanges gérés par l'usine.

1    constructor(address _feeToSetter) public {
2        feeToSetter = _feeToSetter;
3    }
Copier

La seule chose que fait le constructeur est de spécifier le feeToSetter. Les usines commencent sans frais, et seul feeSetter peut changer cela.

1    function allPairsLength() external view returns (uint) {
2        return allPairs.length;
3    }
Copier

Cette fonction retourne le nombre de paires d'échange.

1    function createPair(address tokenA, address tokenB) external returns (address pair) {
Copier

C'est la fonction principale de l'usine : créer un échange de paires entre deux jetons ERC-20. Notez que n'importe qui peut appeler cette fonction. Vous n'avez pas besoin d'autorisation d'Uniswap pour créer un nouvel échange de paires.

1        require(tokenA != tokenB, 'UniswapV2: IDENTICAL_ADDRESSES');
2        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
Copier

Nous voulons que l'adresse du nouvel échange soit déterministe, afin qu'elle puisse être calculée à l'avance hors chaîne (cela peut être utile pour les transactions de couche 2). Pour ce faire, nous devons avoir un ordre cohérent des adresses de jetons, quel que soit l'ordre dans lequel nous les avons reçues. Nous les trions donc ici.

1        require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS');
2        require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // single check is sufficient
Copier

Les grands pools de liquidités sont préférables aux petits, car ils ont des prix plus stables. Nous ne voulons pas avoir plus d'un pool de liquidités par paire de jetons. S'il existe déjà un échange, il n'est pas nécessaire d'en créer un autre pour la même paire.

1        bytes memory bytecode = type(UniswapV2Pair).creationCode;
Copier

Pour créer un nouveau contrat, nous avons besoin du code qui le crée (à la fois la fonction constructeur et le code qui écrit en mémoire le bytecode EVM du contrat réel). Normalement, dans Solidity, nous utilisons simplement addr = new <nom du contrat>(<paramètres du constructeur>) et le compilateur s'occupe de tout pour nous, mais pour avoir une adresse de contrat déterministe, nous devons utiliser l'opcode CREATE2 (opens in a new tab). Lorsque ce code a été écrit, cet opcode n'était pas encore pris en charge par Solidity, il était donc nécessaire d'obtenir manuellement le code. Ce n'est plus un problème, car Solidity prend maintenant en charge CREATE2 (opens in a new tab).

1        bytes32 salt = keccak256(abi.encodePacked(token0, token1));
2        assembly {
3            pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
4        }
Copier

Lorsqu'un opcode n'est pas encore pris en charge par Solidity, nous pouvons l'appeler en utilisant l'assembly en ligne (opens in a new tab).

1        IUniswapV2Pair(pair).initialize(token0, token1);
Copier

Appeler la fonction initialize pour indiquer au nouvel échange les deux jetons qu'il échange.

1        getPair[token0][token1] = pair;
2        getPair[token1][token0] = pair; // populate mapping in the reverse direction
3        allPairs.push(pair);
4        emit PairCreated(token0, token1, pair, allPairs.length);
Copier

Enregistrer les informations de la nouvelle paire dans les variables d'état et émettre un événement pour informer le monde du nouvel échange de paires.

1    function setFeeTo(address _feeTo) external {
2        require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
3        feeTo = _feeTo;
4    }
5
6    function setFeeToSetter(address _feeToSetter) external {
7        require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
8        feeToSetter = _feeToSetter;
9    }
10}
Afficher tout
Copier

Ces deux fonctions permettent à feeSetter de contrôler le destinataire des frais (le cas échéant) et de changer feeSetter en une nouvelle adresse.

UniswapV2ERC20.sol

Ce contrat (opens in a new tab) met en œuvre le jeton de liquidité ERC-20. Il est similaire au contrat ERC-20 d'OpenZeppelin, je n'expliquerai donc que la partie qui est différente, la fonctionnalité permit.

Les transactions sur Ethereum coûtent de l'ether (ETH), ce qui équivaut à de l'argent réel. Si vous avez des jetons ERC-20 mais pas d'ETH, vous ne pouvez pas envoyer de transactions, et vous ne pouvez donc rien en faire. Une solution pour éviter ce problème est d'utiliser les méta-transactions (opens in a new tab). Le propriétaire des jetons signe une transaction qui permet à une autre personne de retirer des jetons hors chaîne et l'envoie via Internet au destinataire. Le destinataire, qui possède des ETH, soumet alors le permis au nom du propriétaire.

1    bytes32 public DOMAIN_SEPARATOR;
2    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
3    bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
Copier

Ce hachage est l'identifiant du type de transaction (opens in a new tab). Le seul que nous prenons en charge ici est Permit avec ces paramètres.

1    mapping(address => uint) public nonces;
Copier

Il n'est pas possible pour un destinataire de falsifier une signature numérique. Cependant, il est trivial d'envoyer la même transaction deux fois (c'est une forme d'attaque par rejeu (opens in a new tab)). Pour éviter cela, nous utilisons un nonce (opens in a new tab). Si le nonce d'un nouveau Permit n'est pas supérieur de un au dernier nonce utilisé, nous le considérons comme invalide.

1    constructor() public {
2        uint chainId;
3        assembly {
4            chainId := chainid
5        }
Copier

Ceci est le code pour récupérer l'identifiant de la chaîne (opens in a new tab). Il utilise un dialecte d'assembly EVM appelé Yul (opens in a new tab). Notez que dans la version actuelle de Yul, vous devez utiliser chainid(), et non chainid.

1        DOMAIN_SEPARATOR = keccak256(
2            abi.encode(
3                keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
4                keccak256(bytes(name)),
5                keccak256(bytes('1')),
6                chainId,
7                address(this)
8            )
9        );
10    }
Afficher tout
Copier

Calculer le séparateur de domaine (opens in a new tab) pour EIP-712.

1    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
Copier

C'est la fonction qui implémente les permissions. Elle reçoit comme paramètres les champs pertinents, et les trois valeurs scalaires pour la signature (opens in a new tab) (v, r et s).

1        require(deadline >= block.timestamp, 'UniswapV2: EXPIRED');
Copier

Ne pas accepter les transactions après la date limite.

1        bytes32 digest = keccak256(
2            abi.encodePacked(
3                '\x19\x01',
4                DOMAIN_SEPARATOR,
5                keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))
6            )
7        );
Copier

abi.encodePacked(...) est le message que nous nous attendons à recevoir. Nous savons ce que le nonce devrait être, il n'est donc pas nécessaire de l'obtenir en tant que paramètre.

L'algorithme de signature d'Ethereum attend 256 bits à signer, nous utilisons donc la fonction de hachage keccak256.

1        address recoveredAddress = ecrecover(digest, v, r, s);
Copier

À partir du condensé et de la signature, nous pouvons obtenir l'adresse qui l'a signé en utilisant ecrecover (opens in a new tab).

1        require(recoveredAddress != address(0) && recoveredAddress == owner, 'UniswapV2: INVALID_SIGNATURE');
2        _approve(owner, spender, value);
3    }
4
Copier

Si tout est OK, traiter cela comme une approbation ERC-20 (opens in a new tab).

Les contrats périphériques

Les contrats périphériques sont l'API (interface de programme d'application) d'Uniswap. Ils sont disponibles pour les appels externes, en provenance d'autres contrats ou d'applications décentralisées. Vous pourriez appeler directement les contrats de base, mais c'est plus compliqué et vous pourriez perdre de la valeur si vous faites une erreur. Les contrats de base ne contiennent que des tests pour s'assurer qu'ils ne sont pas trompés, pas de contrôles de cohérence pour qui que ce soit d'autre. Ceux-ci sont dans la périphérie afin de pouvoir être mis à jour au besoin.

UniswapV2Router01.sol

Ce contrat (opens in a new tab) a des problèmes et ne devrait plus être utilisé (opens in a new tab). Heureusement, les contrats périphériques sont apatrides et ne détiennent aucun actif, il est donc facile de le déprécier et de suggérer aux gens d'utiliser le remplacement, UniswapV2Router02, à la place.

UniswapV2Router02.sol

Dans la plupart des cas, vous utiliseriez Uniswap via ce contrat (opens in a new tab). Vous pouvez voir comment l'utiliser ici (opens in a new tab).

1pragma solidity =0.6.6;
2
3import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
4import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
5
6import './interfaces/IUniswapV2Router02.sol';
7import './libraries/UniswapV2Library.sol';
8import './libraries/SafeMath.sol';
9import './interfaces/IERC20.sol';
10import './interfaces/IWETH.sol';
Afficher tout
Copier

La plupart d'entre eux ont déjà été rencontrés ou sont assez évidents. La seule exception est IWETH.sol. Uniswap v2 permet les échanges pour n'importe quelle paire de jetons ERC-20, mais l'ether (ETH) lui-même n'est pas un jeton ERC-20. Il est antérieur à la norme et est transféré par des mécanismes uniques. Pour permettre l'utilisation d'ETH dans les contrats qui s'appliquent aux jetons ERC-20, le contrat wrapped ether (WETH) (opens in a new tab) a été créé. Vous envoyez des ETH à ce contrat, et il frappe un montant équivalent de WETH. Ou vous pouvez brûler du WETH, et récupérer de l'ETH.

1contract UniswapV2Router02 is IUniswapV2Router02 {
2    using SafeMath for uint;
3
4    address public immutable override factory;
5    address public immutable override WETH;
Copier

Le routeur a besoin de savoir quelle usine utiliser et, pour les transactions qui nécessitent des WETH, quel contrat WETH utiliser. Ces valeurs sont immuables (opens in a new tab), ce qui signifie qu'elles ne peuvent être définies que dans le constructeur. Cela donne aux utilisateurs l'assurance que personne ne pourra les modifier pour pointer vers des contrats moins honnêtes.

1    modifier ensure(uint deadline) {
2        require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED');
3        _;
4    }
Copier

Ce modificateur garantit que les transactions limitées dans le temps (« faire X avant l'heure Y si possible ») ne se produisent pas après leur délai imparti.

1    constructor(address _factory, address _WETH) public {
2        factory = _factory;
3        WETH = _WETH;
4    }
Copier

Le constructeur définit simplement les variables d'état immuables.

1    receive() external payable {
2        assert(msg.sender == WETH); // only accept ETH via fallback from the WETH contract
3    }
Copier

Cette fonction est appelée lorsque nous échangeons des jetons du contrat WETH contre des ETH. Seul le contrat WETH que nous utilisons est autorisé à faire cela.

Ajouter de la liquidité

Ces fonctions ajoutent des jetons à l'échange de paires, ce qui augmente le pool de liquidités.

1
2    // **** ADD LIQUIDITY ****
3    function _addLiquidity(
Copier

Cette fonction est utilisée pour calculer le montant des jetons A et B qui doivent être déposés dans l'échange de paires.

1        address tokenA,
2        address tokenB,
Copier

Ce sont les adresses des contrats de jetons ERC-20.

1        uint amountADesired,
2        uint amountBDesired,
Copier

Ce sont les montants que le fournisseur de liquidités souhaite déposer. Ce sont également les montants maximums de A et de B à déposer.

1        uint amountAMin,
2        uint amountBMin
Copier

Ce sont les montants minimums acceptables pour le dépôt. Si la transaction ne peut pas avoir lieu avec ces montants ou plus, l'annuler. Si vous ne souhaitez pas cette fonctionnalité, spécifiez simplement zéro.

Les fournisseurs de liquidités spécifient un minimum, généralement parce qu'ils souhaitent limiter la transaction à un taux de change proche de celui en vigueur. Si le taux de change fluctue trop, cela peut signifier que des nouvelles ont modifié les valeurs sous-jacentes, et ils veulent décider manuellement de la marche à suivre.

Par exemple, imaginons un cas où le taux de change est de un pour un et où le fournisseur de liquidités spécifie ces valeurs :

Tant que le taux de change reste compris entre 0,9 et 1,25, la transaction a lieu. Si le taux de change sort de cette fourchette, la transaction est annulée.

Cette précaution s'explique par le fait que les transactions ne sont pas immédiates, vous les soumettez et un validateur finira par les inclure dans un bloc (à moins que le prix du gaz soit très bas, auquel cas vous devrez soumettre une autre transaction avec le même nonce et un prix du gaz plus élevé pour l'écraser). Vous ne pouvez pas contrôler ce qui se passe pendant l'intervalle entre la soumission et l'inclusion.

1    ) internal virtual returns (uint amountA, uint amountB) {
Copier

La fonction retourne les montants que le fournisseur de liquidités doit déposer pour avoir un ratio égal au ratio actuel entre les réserves.

1        // create the pair if it doesn't exist yet
2        if (IUniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)) {
3            IUniswapV2Factory(factory).createPair(tokenA, tokenB);
4        }
Copier

S'il n'existe pas encore d'échange pour cette paire de jetons, le créer.

1        (uint reserveA, uint reserveB) = UniswapV2Library.getReserves(factory, tokenA, tokenB);
Copier

Obtenir les réserves actuelles de la paire.

1        if (reserveA == 0 && reserveB == 0) {
2            (amountA, amountB) = (amountADesired, amountBDesired);
Copier

Si les réserves actuelles sont vides, alors il s'agit d'un nouvel échange de paires. Les montants à déposer doivent être exactement les mêmes que ceux que le fournisseur de liquidités souhaite fournir.

1        } else {
2            uint amountBOptimal = UniswapV2Library.quote(amountADesired, reserveA, reserveB);
Copier

Si nous devons voir quels seront les montants, nous obtenons le montant optimal en utilisant cette fonction (opens in a new tab). Nous voulons le même ratio que les réserves actuelles.

1            if (amountBOptimal <= amountBDesired) {
2                require(amountBOptimal >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT');
3                (amountA, amountB) = (amountADesired, amountBOptimal);
Copier

Si amountBOptimal est inférieur au montant que le fournisseur de liquidités souhaite déposer, cela signifie que le jeton B a actuellement plus de valeur que ne le pense le déposant, un montant inférieur est donc requis.

1            } else {
2                uint amountAOptimal = UniswapV2Library.quote(amountBDesired, reserveB, reserveA);
3                assert(amountAOptimal <= amountADesired);
4                require(amountAOptimal >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
5                (amountA, amountB) = (amountAOptimal, amountBDesired);
Copier

Si le montant optimal de B est supérieur au montant désiré de B, cela signifie que les jetons B ont actuellement moins de valeur que ne le pense le déposant de liquidités, un montant plus élevé est donc requis. Cependant, le montant souhaité est un maximum, nous ne pouvons donc pas le dépasser. Nous calculons donc le nombre optimal de jetons A pour le montant souhaité de jetons B.

En assemblant tout cela, nous obtenons ce graphique. Supposons que vous essayiez de déposer un millier de jetons A (ligne bleue) et un millier de jetons B (ligne rouge). L'axe des x représente le taux de change, A/B. Si x=1, ils ont la même valeur et vous déposez un millier de chaque. Si x=2, A vaut deux fois la valeur de B (vous obtenez deux jetons B pour chaque jeton A), vous déposez donc un millier de jetons B, mais seulement 500 jetons A. Si x=0,5, la situation est inversée : un millier de jetons A et cinq cents jetons B.

Vous pourriez déposer des liquidités directement dans le contrat de base (en utilisant UniswapV2Pair::mint (opens in a new tab)), mais le contrat de base vérifie uniquement qu'il ne se trompe pas lui-même. Vous risquez donc de perdre de la valeur si le taux de change évolue entre le moment où vous soumettez votre transaction et le moment où elle est exécutée. Si vous utilisez le contrat périphérique, il calcule le montant que vous devez déposer et le dépose immédiatement, de sorte que le taux de change ne change pas et vous ne perdez rien.

1    function addLiquidity(
2        address tokenA,
3        address tokenB,
4        uint amountADesired,
5        uint amountBDesired,
6        uint amountAMin,
7        uint amountBMin,
8        address to,
9        uint deadline
Afficher tout
Copier

Cette fonction peut être appelée par une transaction pour déposer des liquidités. La plupart des paramètres sont les mêmes que dans _addLiquidity ci-dessus, à deux exceptions près :

. to est l'adresse qui reçoit les nouveaux jetons de liquidité frappés pour montrer la part du pool détenue par le fournisseur de liquidités. deadline est une limite de temps pour la transaction.

1    ) external virtual override ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
2        (amountA, amountB) = _addLiquidity(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin);
3        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
Copier

Nous calculons les montants à déposer réellement, puis nous trouvons l'adresse du pool de liquidités. Pour économiser du gaz, nous ne le faisons pas en interrogeant l'usine, mais en utilisant la fonction de bibliothèque pairFor (voir ci-dessous dans les bibliothèques).

1        TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA);
2        TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB);
Copier

Transférer les bons montants de jetons de l'utilisateur vers l'échange de paires.

1        liquidity = IUniswapV2Pair(pair).mint(to);
2    }
Copier

En retour, donner à l'adresse to des jetons de liquidité pour une propriété partielle du pool. La fonction mint du contrat de base voit combien de jetons supplémentaires elle a (par rapport à ce qu'elle avait la dernière fois que la liquidité a changé) et frappe la liquidité en conséquence.

1    function addLiquidityETH(
2        address token,
3        uint amountTokenDesired,
Copier

Lorsqu'un fournisseur de liquidités souhaite fournir de la liquidité à un échange de paires Jeton/ETH, il y a quelques différences. Le contrat gère l'enveloppement de l'ETH pour le fournisseur de liquidités. Il n'est pas nécessaire de spécifier combien d'ETH l'utilisateur souhaite déposer, car il les envoie simplement avec la transaction (le montant est disponible dans msg.value).

1        uint amountTokenMin,
2        uint amountETHMin,
3        address to,
4        uint deadline
5    ) external virtual override payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
6        (amountToken, amountETH) = _addLiquidity(
7            token,
8            WETH,
9            amountTokenDesired,
10            msg.value,
11            amountTokenMin,
12            amountETHMin
13        );
14        address pair = UniswapV2Library.pairFor(factory, token, WETH);
15        TransferHelper.safeTransferFrom(token, msg.sender, pair, amountToken);
16        IWETH(WETH).deposit{value: amountETH}();
17        assert(IWETH(WETH).transfer(pair, amountETH));
Afficher tout
Copier

Pour déposer l'ETH, le contrat l'enveloppe d'abord dans du WETH, puis transfère le WETH dans la paire. Notez que le transfert est enveloppé dans un assert. Cela signifie que si le transfert échoue, cet appel de contrat échoue également, et donc l'enveloppement ne se produit pas réellement.

1        liquidity = IUniswapV2Pair(pair).mint(to);
2        // refund dust eth, if any
3        if (msg.value > amountETH) TransferHelper.safeTransferETH(msg.sender, msg.value - amountETH);
4    }
Copier

L'utilisateur nous a déjà envoyé les ETH. S'il reste un surplus (parce que l'autre jeton a moins de valeur que ne le pensait l'utilisateur), nous devons émettre un remboursement.

Retirer de la liquidité

Ces fonctions supprimeront la liquidité et rembourseront le fournisseur de liquidités.

1    // **** REMOVE LIQUIDITY ****
2    function removeLiquidity(
3        address tokenA,
4        address tokenB,
5        uint liquidity,
6        uint amountAMin,
7        uint amountBMin,
8        address to,
9        uint deadline
10    ) public virtual override ensure(deadline) returns (uint amountA, uint amountB) {
Afficher tout
Copier

Le cas le plus simple de retrait de liquidité. Il y a un montant minimum pour chaque jeton que le fournisseur de liquidités accepte de recevoir, et cela doit avoir lieu avant la date limite.

1        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
2        IUniswapV2Pair(pair).transferFrom(msg.sender, pair, liquidity); // send liquidity to pair
3        (uint amount0, uint amount1) = IUniswapV2Pair(pair).burn(to);
Copier

La fonction burn du contrat de base gère le remboursement des jetons à l'utilisateur.

1        (address token0,) = UniswapV2Library.sortTokens(tokenA, tokenB);
Copier

Lorsqu'une fonction retourne plusieurs valeurs, mais que nous ne sommes intéressés que par certaines d'entre elles, voici comment nous obtenons uniquement ces valeurs. C'est un peu moins cher en termes de gaz que de lire une valeur et de ne jamais l'utiliser.

1        (amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
Copier

Traduire les montants de la façon dont le contrat de base les renvoie (jeton d'adresse inférieure en premier) à la manière dont l'utilisateur les attend (correspondant à tokenA et tokenB).

1        require(amountA >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
2        require(amountB >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT');
3    }
Copier

Il est acceptable d'effectuer le transfert d'abord, puis de vérifier sa légitimité, car si ce n'est pas le cas, nous annulerons tous les changements d'état.

1    function removeLiquidityETH(
2        address token,
3        uint liquidity,
4        uint amountTokenMin,
5        uint amountETHMin,
6        address to,
7        uint deadline
8    ) public virtual override ensure(deadline) returns (uint amountToken, uint amountETH) {
9        (amountToken, amountETH) = removeLiquidity(
10            token,
11            WETH,
12            liquidity,
13            amountTokenMin,
14            amountETHMin,
15            address(this),
16            deadline
17        );
18        TransferHelper.safeTransfer(token, to, amountToken);
19        IWETH(WETH).withdraw(amountETH);
20        TransferHelper.safeTransferETH(to, amountETH);
21    }
Afficher tout
Copier

Le retrait de liquidité pour l'ETH est presque identique, sauf que nous recevons les jetons WETH, puis les échangeons contre de l'ETH pour les restituer au fournisseur de liquidités.

1    function removeLiquidityWithPermit(
2        address tokenA,
3        address tokenB,
4        uint liquidity,
5        uint amountAMin,
6        uint amountBMin,
7        address to,
8        uint deadline,
9        bool approveMax, uint8 v, bytes32 r, bytes32 s
10    ) external virtual override returns (uint amountA, uint amountB) {
11        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
12        uint value = approveMax ? uint(-1) : liquidity;
13        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
14        (amountA, amountB) = removeLiquidity(tokenA, tokenB, liquidity, amountAMin, amountBMin, to, deadline);
15    }
16
17
18    function removeLiquidityETHWithPermit(
19        address token,
20        uint liquidity,
21        uint amountTokenMin,
22        uint amountETHMin,
23        address to,
24        uint deadline,
25        bool approveMax, uint8 v, bytes32 r, bytes32 s
26    ) external virtual override returns (uint amountToken, uint amountETH) {
27        address pair = UniswapV2Library.pairFor(factory, token, WETH);
28        uint value = approveMax ? uint(-1) : liquidity;
29        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
30        (amountToken, amountETH) = removeLiquidityETH(token, liquidity, amountTokenMin, amountETHMin, to, deadline);
31    }
Afficher tout
Copier

Ces fonctions relaient les méta-transactions pour permettre aux utilisateurs sans ether de se retirer du pool, en utilisant le mécanisme de permis.

1    // **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens) ****
2    function removeLiquidityETHSupportingFeeOnTransferTokens(
3        address token,
4        uint liquidity,
5        uint amountTokenMin,
6        uint amountETHMin,
7        address to,
8        uint deadline
9    ) public virtual override ensure(deadline) returns (uint amountETH) {
10        (, amountETH) = removeLiquidity(
11            token,
12            WETH,
13            liquidity,
14            amountTokenMin,
15            amountETHMin,
16            address(this),
17            deadline
18        );
19        TransferHelper.safeTransfer(token, to, IERC20(token).balanceOf(address(this)));
20        IWETH(WETH).withdraw(amountETH);
21        TransferHelper.safeTransferETH(to, amountETH);
22    }
23
Afficher tout
Copier

Cette fonction peut être utilisée pour les jetons qui ont des frais de transfert ou de stockage. Lorsqu'un jeton a de tels frais, nous ne pouvons pas compter sur la fonction removeLiquidity pour nous dire combien de jetons nous récupérons. Nous devons donc d'abord retirer, puis obtenir le solde.

1
2
3    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
4        address token,
5        uint liquidity,
6        uint amountTokenMin,
7        uint amountETHMin,
8        address to,
9        uint deadline,
10        bool approveMax, uint8 v, bytes32 r, bytes32 s
11    ) external virtual override returns (uint amountETH) {
12        address pair = UniswapV2Library.pairFor(factory, token, WETH);
13        uint value = approveMax ? uint(-1) : liquidity;
14        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
15        amountETH = removeLiquidityETHSupportingFeeOnTransferTokens(
16            token, liquidity, amountTokenMin, amountETHMin, to, deadline
17        );
18    }
Afficher tout
Copier