Análise detalhada do contrato Uniswap-v2

Introdução

O Uniswap v2 (opens in a new tab) pode criar um mercado de câmbio entre quaisquer dois tokens ERC-20. Neste artigo, vamos analisar o código-fonte dos contratos que implementam esse protocolo e ver por que eles foram escritos dessa forma.

O que o Uniswap faz?

Basicamente, existem dois tipos de usuários: provedores de liquidez e traders.

Os provedores de liquidez fornecem ao pool os dois tokens que podem ser trocados (vamos chamá-los de Token0 e Token1). Em troca, eles recebem um terceiro token que representa a propriedade parcial do pool, chamado de token de liquidez.

Traders enviam um tipo de token para o pool e recebem o outro (por exemplo, enviam Token0 e recebem Token1) do pool fornecido pelos provedores de liquidez. A taxa de câmbio é determinada pelo número relativo de Token0 e Token1 que o pool possui. Além disso, o pool recebe uma pequena porcentagem como recompensa para o pool de liquidez.

Quando os provedores de liquidez querem seus ativos de volta, eles podem queimar os tokens do pool e receber de volta seus tokens, incluindo sua parte das recompensas.

Clique aqui para uma descrição mais completa (opens in a new tab).

Por que v2? Por que não v3?

O Uniswap v3 (opens in a new tab) é uma atualização muito mais complicada do que a v2. É mais fácil aprender primeiro a v2 e depois ir para a v3.

Contratos principais vs. contratos periféricos

O Uniswap v2 é dividido em dois componentes, um principal e um periférico. Essa divisão permite que os contratos principais, que detêm os ativos e, portanto, precisam ser seguros, sejam mais simples e fáceis de auditar. Toda a funcionalidade extra exigida pelos traders pode então ser fornecida pelos contratos periféricos.

Fluxos de dados e controle

Este é o fluxo de dados e controle que ocorre quando você executa as três principais ações do Uniswap:

1. Trocar entre tokens diferentes
2. Adicionar liquidez ao mercado e ser recompensado com tokens de liquidez ERC-20 do par de troca
3. Queimar tokens de liquidez ERC-20 e receber de volta os tokens ERC-20 que o par de troca permite aos traders trocar

Troca

Este é o fluxo mais comum, usado por traders:

Chamador

1. Fornecer à conta periférica uma permissão (allowance) no valor a ser trocado.
2. Chamar uma das muitas funções de troca do contrato periférico (a escolha depende se há ETH envolvido ou não, se o trader especifica a quantidade de tokens a depositar ou a quantidade de tokens a receber, etc.). Toda função de troca aceita um caminho (path), uma matriz de trocas a percorrer.

No contrato periférico (UniswapV2Router02.sol)

3. Identificar as quantias que precisam ser negociadas em cada troca ao longo do caminho.
4. Itera sobre o caminho. Para cada troca ao longo do caminho, ele envia o token de entrada e, em seguida, chama a função swap da troca. Na maioria dos casos, o endereço de destino dos tokens é o próximo par de troca no caminho. Na troca final, é o endereço fornecido pelo trader.

No contrato principal (UniswapV2Pair.sol)

6. Ver quantos tokens extras temos além das reservas conhecidas. Essa quantidade é o número de tokens de entrada que recebemos para a troca.
7. Enviar os tokens de saída para o destino.
8. Chamar _update para atualizar os valores da reserva

De volta ao contrato periférico (UniswapV2Router02.sol)

9. Realizar qualquer limpeza necessária (por exemplo, queimar tokens WETH para obter ETH de volta para enviar ao trader)

Adicionar Liquidez

Chamador

1. Fornecer à conta periférica uma permissão (allowance) nas quantias a serem adicionadas ao pool de liquidez.
2. Chamar uma das funções addLiquidity do contrato periférico.

No contrato periférico (UniswapV2Router02.sol)

3. Criar um novo par de troca, se necessário
4. Se houver um par de troca existente, calcular a quantidade de tokens a adicionar. Este valor deve ser idêntico para ambos os tokens, ou seja, a mesma proporção de novos tokens para tokens existentes.
5. Verificar se as quantias são aceitáveis (os chamadores podem especificar uma quantia mínima abaixo da qual preferem não adicionar liquidez)
6. Chamar o contrato principal.

No contrato principal (UniswapV2Pair.sol)

7. Cunhar tokens de liquidez e enviá-los ao chamador
8. Chamar _update para atualizar os valores da reserva

Remover Liquidez

Chamador

1. Fornecer à conta periférica uma permissão (allowance) de tokens de liquidez a serem queimados em troca dos tokens subjacentes.
2. Chamar uma das funções removeLiquidity do contrato periférico.

No contrato periférico (UniswapV2Router02.sol)

3. Enviar os tokens de liquidez para o par de troca

No contrato principal (UniswapV2Pair.sol)

4. Enviar para o endereço de destino os tokens subjacentes em proporção aos tokens queimados. Por exemplo, se houver 1.000 tokens A no pool, 500 tokens B e 90 tokens de liquidez, e recebermos 9 tokens para queimar, estamos queimando 10% dos tokens de liquidez, então enviamos de volta ao usuário 100 tokens A e 50 tokens B.
5. Queimar os tokens de liquidez
6. Chamar _update para atualizar os valores da reserva

Os Contratos Principais

Esses são os contratos seguros que detêm a liquidez.

UniswapV2Pair.sol

Este contrato (opens in a new tab) implementa o pool real que troca tokens. É a funcionalidade principal do 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';
Exibir tudo
Copiar

Estas são todas as interfaces que o contrato precisa conhecer, seja porque o contrato as implementa (IUniswapV2Pair e UniswapV2ERC20), seja porque ele chama contratos que as implementam.

1contract UniswapV2Pair is IUniswapV2Pair, UniswapV2ERC20 {
Copiar

Este contrato herda de UniswapV2ERC20, que fornece as funções ERC-20 para os tokens de liquidez.

1    using SafeMath  for uint;
Copiar

A biblioteca SafeMath (opens in a new tab) é usada para evitar overflows e underflows. Isso é importante porque, caso contrário, podemos acabar em uma situação em que um valor deveria ser -1, mas em vez disso é 2^256-1.

1    using UQ112x112 for uint224;
Copiar

Muitos cálculos no contrato do pool exigem frações. No entanto, as frações não são suportadas pela EVM. A solução que o Uniswap encontrou foi usar valores de 224 bits, com 112 bits para a parte inteira e 112 bits para a fração. Portanto, 1,0 é representado como 2^112, 1,5 é representado como 2^112 + 2^111, etc.

Mais detalhes sobre esta biblioteca estão disponíveis mais adiante no documento.

Variáveis

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

Para evitar casos de divisão por zero, há um número mínimo de tokens de liquidez que sempre existem (mas são de propriedade da conta zero). Esse número é MINIMUM_LIQUIDITY, mil.

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

Este é o seletor da ABI para a função de transferência do ERC-20. É usado para transferir tokens ERC-20 nas duas contas de token.

1    address public factory;
Copiar

Este é o contrato de fábrica que criou este pool. Cada pool é uma troca entre dois tokens ERC-20; a fábrica é um ponto central que conecta todos esses pools.

1    address public token0;
2    address public token1;
Copiar

Estes são os endereços dos contratos para os dois tipos de tokens ERC-20 que podem ser trocados por este pool.

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

As reservas que o pool possui para cada tipo de token. Assumimos que os dois representam a mesma quantidade de valor e, portanto, cada token0 vale reserve1/reserve0 de token1.

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

O carimbo de data/hora do último bloco em que ocorreu uma troca, usado para rastrear as taxas de câmbio ao longo do tempo.

Uma das maiores despesas de gás dos contratos Ethereum é o armazenamento, que persiste de uma chamada do contrato para a próxima. Cada célula de armazenamento tem 256 bits de comprimento. Assim, três variáveis, reserve0, reserve1 e blockTimestampLast, são alocadas de forma que um único valor de armazenamento possa incluir todas as três (112+112+32=256).

1    uint public price0CumulativeLast;
2    uint public price1CumulativeLast;
Copiar

Essas variáveis mantêm os custos cumulativos para cada token (cada um em termos do outro). Elas podem ser usadas para calcular a taxa de câmbio média durante um período de tempo.

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

A forma como o par de troca decide a taxa de câmbio entre token0 e token1 é manter o múltiplo das duas reservas constante durante as negociações. kLast é esse valor. Ele muda quando um provedor de liquidez deposita ou retira tokens, e aumenta ligeiramente por causa da taxa de mercado de 0,3%.

Aqui está um exemplo simples. Observe que, para simplificar, a tabela tem apenas três dígitos após a vírgula decimal, e ignoramos a taxa de negociação de 0,3%, então os números não são precisos.

À medida que os traders fornecem mais token0, o valor relativo do token1 aumenta, e vice-versa, com base na oferta e na demanda.

Bloqueio

1    uint private unlocked = 1;
Copiar

Existe uma classe de vulnerabilidades de segurança que se baseia em abuso de reentrância (opens in a new tab). O Uniswap precisa transferir tokens ERC-20 arbitrários, o que significa chamar contratos ERC-20 que podem tentar abusar do mercado Uniswap que os chama. Ao ter uma variável unlocked como parte do contrato, podemos impedir que funções sejam chamadas enquanto estão em execução (dentro da mesma transação).

1    modifier lock() {
Copiar

Esta função é um modificador (opens in a new tab), uma função que envolve uma função normal para alterar seu comportamento de alguma forma.

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

Se unlocked for igual a um, defina-o como zero. Se já for zero, reverta a chamada, fazendo-a falhar.

1        _;
Copiar

Em um modificador, _; é a chamada de função original (com todos os parâmetros). Aqui, significa que a chamada de função só acontece se unlocked era um quando foi chamada, e enquanto está em execução, o valor de unlocked é zero.

1        unlocked = 1;
2    }
Copiar

Após o retorno da função principal, libere o bloqueio.

Diversos funções

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

Esta função fornece aos chamadores o estado atual da troca. Observe que as funções do Solidity podem retornar vários valores (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));
Copiar

Esta função interna transfere uma quantidade de tokens ERC20 da troca para outra pessoa. SELECTOR especifica que a função que estamos chamando é transfer(address,uint) (veja a definição acima).

Para evitar ter que importar uma interface para a função do token, criamos "manualmente" a chamada usando uma das funções da ABI (opens in a new tab).

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

Existem duas maneiras pelas quais uma chamada de transferência ERC-20 pode relatar falha:

1. Reverter. Se uma chamada para um contrato externo reverter, então o valor de retorno booleano será false
2. Terminar normalmente, mas relatar uma falha. Nesse caso, o buffer de valor de retorno tem um comprimento diferente de zero e, quando decodificado como um valor booleano, é false

Se qualquer uma dessas condições acontecer, reverta.

Eventos

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

Esses dois eventos são emitidos quando um provedor de liquidez deposita liquidez (Mint) ou a retira (Burn). Em ambos os casos, as quantidades de token0 e token1 que são depositadas ou retiradas fazem parte do evento, assim como a identidade da conta que nos chamou (sender). No caso de uma retirada, o evento também inclui o alvo que recebeu os tokens (to), que pode não ser o mesmo que o remetente.

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

Este evento é emitido quando um trader troca um token pelo outro. Novamente, o remetente e o destino podem não ser os mesmos. Cada token pode ser enviado para a troca ou recebido dela.

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

Finalmente, Sync é emitido toda vez que tokens são adicionados ou retirados, independentemente do motivo, para fornecer as informações de reserva mais recentes (e, portanto, a taxa de câmbio).

Funções de Configuração

Essas funções devem ser chamadas uma vez quando o novo par de troca é configurado.

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

O construtor garante que manteremos o controle do endereço da fábrica que criou o par. Esta informação é necessária para initialize e para a taxa da fábrica (se houver)

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    }
Copiar

Esta função permite que a fábrica (e apenas a fábrica) especifique os dois tokens ERC-20 que este par irá trocar.

Funções de Atualização Internas

_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 {
Copiar

Esta função é chamada toda vez que os tokens são depositados ou retirados.

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

Se balance0 ou balance1 (uint256) for maior que uint112(-1) (=2^112-1) (então ele sofre overflow e volta para 0 quando convertido para uint112), recuse-se a continuar a _update para evitar overflows. Com um token normal que pode ser subdividido em 10^18 unidades, isso significa que cada troca está limitada a cerca de 5.1*10^15 de cada token. Até agora, isso não foi um problema.

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

Se o tempo decorrido não for zero, significa que esta é a primeira transação de troca neste bloco. Nesse caso, precisamos atualizar os acumuladores de custo.

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        }
Copiar

Cada acumulador de custo é atualizado com o custo mais recente (reserva do outro token/reserva deste token) vezes o tempo decorrido em segundos. Para obter um preço médio, você lê o preço cumulativo em dois pontos no tempo e divide pela diferença de tempo entre eles. Por exemplo, suponha esta sequência de eventos:

Digamos que queiramos calcular o preço médio do Token0 entre os carimbos de data/hora 5.030 e 5.150. A diferença no valor de price0Cumulative é 143,702-29,07=114,632. Esta é a média ao longo de dois minutos (120 segundos). Portanto, o preço médio é 114,632/120 = 0,955.

Este cálculo de preço é a razão pela qual precisamos saber os tamanhos de reserva antigos.

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

Finalmente, atualize as variáveis globais e emita um evento 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) {
Copiar

No Uniswap 2.0, os traders pagam uma taxa de 0,30% para usar o mercado. A maior parte dessa taxa (0,25% da negociação) vai sempre para os provedores de liquidez. Os 0,05% restantes podem ir tanto para os provedores de liquidez quanto para um endereço especificado pela fábrica como taxa de protocolo, que paga ao Uniswap por seu esforço de desenvolvimento.

Para reduzir os cálculos (e, portanto, os custos de gás), essa taxa só é calculada quando a liquidez é adicionada ou removida do pool, em vez de a cada transação.

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

Ler o destino da taxa da fábrica. Se for zero, não há taxa de protocolo e não há necessidade de calcular essa taxa.

1        uint _kLast = kLast; // gas savings
Copiar

A variável de estado kLast está localizada no armazenamento, então ela terá um valor entre diferentes chamadas para o contrato. O acesso ao armazenamento é muito mais caro do que o acesso à memória volátil que é liberada quando a chamada de função para o contrato termina, então usamos uma variável interna para economizar gás.

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

Os provedores de liquidez recebem sua parte simplesmente pela valorização de seus tokens de liquidez. Mas a taxa de protocolo exige que novos tokens de liquidez sejam cunhados e fornecidos ao endereço feeTo.

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

Se houver nova liquidez sobre a qual coletar uma taxa de protocolo. Você pode ver a função de raiz quadrada mais adiante neste artigo

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

Este cálculo complicado de taxas é explicado no whitepaper (opens in a new tab) na página 5. Sabemos que entre o momento em que kLast foi calculado e o presente, nenhuma liquidez foi adicionada ou removida (porque executamos esse cálculo toda vez que a liquidez é adicionada ou removida, antes que ela realmente mude), então qualquer mudança em reserve0 * reserve1 tem que vir das taxas de transação (sem elas, manteríamos reserve0 * reserve1 constante).

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

Use a função UniswapV2ERC20._mint para realmente criar os tokens de liquidez adicionais e atribuí-los a feeTo.

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

Se não houver taxa definida, defina kLast como zero (se já não for). Quando este contrato foi escrito, havia um recurso de reembolso de gás (opens in a new tab) que incentivava os contratos a reduzir o tamanho geral do estado do Ethereum, zerando o armazenamento de que não precisavam. Este código obtém esse reembolso quando possível.

Funções Acessíveis Externamente

Observe que, embora qualquer transação ou contrato possa chamar essas funções, elas são projetadas para serem chamadas a partir do contrato periférico. Se você as chamar diretamente, não conseguirá enganar o par de troca, mas poderá perder valor por um erro.

mint

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) {
Copiar

Esta função é chamada quando um provedor de liquidez adiciona liquidez ao pool. Ela cunha tokens de liquidez adicionais como recompensa. Ela deve ser chamada a partir de um contrato periférico que a chama após adicionar a liquidez na mesma transação (para que ninguém mais possa enviar uma transação que reivindique a nova liquidez antes do proprietário legítimo).

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

Esta é a maneira de ler os resultados de uma função do Solidity que retorna vários valores. Descartamos o último valor retornado, o carimbo de data/hora do bloco, porque não precisamos dele.

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);
Copiar

Obtenha os saldos atuais e veja quanto foi adicionado de cada tipo de token.

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

Calcule as taxas de protocolo a serem coletadas, se houver, e cunhe os tokens de liquidez correspondentes. Como os parâmetros para _mintFee são os valores de reserva antigos, a taxa é calculada com precisão com base apenas nas alterações do pool devido às taxas.

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
Copiar

Se este for o primeiro depósito, crie tokens MINIMUM_LIQUIDITY e envie-os para o endereço zero para bloqueá-los. Eles nunca podem ser resgatados, o que significa que o pool nunca será esvaziado completamente (isso nos salva da divisão por zero em alguns lugares). O valor de MINIMUM_LIQUIDITY é mil, o que, considerando que a maioria dos ERC-20 são subdivididos em unidades de 10^-18 de um token, assim como o ETH é dividido em wei, é 10^-15 do valor de um único token. Não é um custo alto.

No momento do primeiro depósito, não sabemos o valor relativo dos dois tokens, então apenas multiplicamos as quantidades e tiramos a raiz quadrada, supondo que o depósito nos forneça um valor igual em ambos os tokens.

Podemos confiar nisso porque é do interesse do depositante fornecer valor igual, para evitar a perda de valor por arbitragem. Digamos que o valor dos dois tokens seja idêntico, mas nosso depositante depositou quatro vezes mais Token1 do que Token0. Um trader pode usar o fato de que o par de troca acha que o Token0 é mais valioso para extrair valor dele.

Como você pode ver, o trader ganhou 8 tokens extras, que vêm de uma redução no valor do pool, prejudicando o depositante que o possui.

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

A cada depósito subsequente, já sabemos a taxa de câmbio entre os dois ativos, e esperamos que os provedores de liquidez forneçam valor igual em ambos. Se não o fizerem, damos a eles tokens de liquidez com base no menor valor que forneceram, como punição.

Seja no depósito inicial ou em um subsequente, o número de tokens de liquidez que fornecemos é igual à raiz quadrada da mudança em reserve0*reserve1 e o valor do token de liquidez não muda (a menos que recebamos um depósito que não tenha valores iguais de ambos os tipos, caso em que a "multa" é distribuída). Aqui está outro exemplo com dois tokens que têm o mesmo valor, com três depósitos bons e um ruim (depósito de apenas um tipo de token, então não produz nenhum token de liquidez).

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

Use a função UniswapV2ERC20._mint para realmente criar os tokens de liquidez adicionais e entregá-los à conta correta.

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    }
Copiar

Atualize as variáveis de estado (reserve0, reserve1, e se necessário kLast) e emita o evento apropriado.

burn

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) {
Copiar

Esta função é chamada quando a liquidez é retirada e os tokens de liquidez apropriados precisam ser queimados. Ela também deve ser chamada a partir de uma conta periférica.

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)];
Copiar

O contrato periférico transferiu a liquidez a ser queimada para este contrato antes da chamada. Dessa forma, sabemos quanta liquidez queimar e podemos garantir que ela seja queimada.

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');
Copiar

O provedor de liquidez recebe um valor igual de ambos os tokens. Dessa forma, não alteramos a taxa de câmbio.

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
Exibir tudo
Copiar

O resto da função burn é a imagem espelhada da função mint acima.

troca

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 {
Copiar

Esta função também deve ser chamada a partir de um contrato periférico.

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
Copiar

As variáveis locais podem ser armazenadas na memória ou, se não houver muitas, diretamente na pilha (stack). Se pudermos limitar o número para usar a pilha, usaremos menos gás. Para mais detalhes, veja o yellow paper, as especificações formais do Ethereum (opens in a new tab), p. 26, equação 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
Copiar

Esta transferência é otimista, porque transferimos antes de ter certeza de que todas as condições foram atendidas. Isso é aceitável no Ethereum porque, se as condições não forem atendidas mais tarde na chamada, reverteremos a chamada e quaisquer alterações que ela tenha criado.

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

Informar o destinatário sobre a troca, se solicitado.

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

Obter os saldos atuais. O contrato periférico nos envia os tokens antes de nos chamar para a troca. Isso facilita para o contrato verificar que não está sendo enganado, uma verificação que tem que acontecer no contrato principal (porque podemos ser chamados por outras entidades além do nosso contrato periférico).

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');
Copiar

Esta é uma verificação de sanidade para garantir que não percamos valor na troca. Não há nenhuma circunstância em que uma troca deva reduzir reserve0*reserve1. É também aqui que garantimos que uma taxa de 0,3% está sendo enviada na troca; antes de verificar a sanidade do valor de K, multiplicamos ambos os saldos por 1000 e subtraímos os valores multiplicados por 3, o que significa que 0,3% (3/1000 = 0,003 = 0,3%) está sendo deduzido do saldo antes de comparar seu valor K com o valor K das reservas atuais.

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

Atualize reserve0 e reserve1, e, se necessário, os acumuladores de preço e o carimbo de data/hora, e emita um evento.

Sync ou Skim

É possível que os saldos reais fiquem fora de sincronia com as reservas que o par de troca pensa que tem. Não há como retirar tokens sem o consentimento do contrato, mas os depósitos são uma questão diferente. Uma conta pode transferir tokens para a troca sem chamar mint ou swap.

Nesse caso, há duas soluções:

• sync, atualizar as reservas para os saldos atuais
• skim, retirar a quantia extra. Observe que qualquer conta pode chamar skim porque não sabemos quem depositou os tokens. Esta informação é emitida em um evento, mas os eventos não são acessíveis a partir da 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}
Exibir tudo
Copiar

UniswapV2Factory.sol

Este contrato (opens in a new tab) cria os pares de troca.

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;
Copiar

Essas variáveis de estado são necessárias para implementar a taxa de protocolo (consulte o whitepaper (opens in a new tab), p. 5). O endereço feeTo acumula os tokens de liquidez para a taxa de protocolo, e feeToSetter é o endereço permitido a alterar feeTo para um endereço diferente.

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

Essas variáveis rastreiam os pares, as trocas entre dois tipos de token.

A primeira, getPair, é um mapeamento que identifica um contrato de par de troca com base nos dois tokens ERC-20 que ele troca. Os tokens ERC-20 são identificados pelos endereços dos contratos que os implementam, então as chaves e o valor são todos endereços. Para obter o endereço do par de troca que permite converter de tokenA para tokenB, você usa getPair[<endereço do tokenA>][<endereço do tokenB>] (ou o contrário).

A segunda variável, allPairs, é uma matriz que inclui todos os endereços de pares de troca criados por esta fábrica. No Ethereum, não é possível iterar sobre o conteúdo de um mapeamento, ou obter uma lista de todas as chaves, então esta variável é a única maneira de saber quais trocas esta fábrica gerencia.

Nota: A razão pela qual não se pode iterar sobre todas as chaves de um mapeamento é que o armazenamento de dados do contrato é caro, então quanto menos usarmos e quanto menos vezes o alterarmos, melhor. Você pode criar mapeamentos que suportam iteração (opens in a new tab), mas eles exigem armazenamento extra para uma lista de chaves. Na maioria das aplicações, você não precisa disso.

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

Este evento é emitido quando um novo par de troca é criado. Ele inclui os endereços dos tokens, o endereço do par de troca e o número total de trocas gerenciadas pela fábrica.

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

A única coisa que o construtor faz é especificar o feeToSetter. As fábricas começam sem taxa, e apenas o feeSetter pode mudar isso.

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

Esta função retorna o número de pares de troca.

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

Esta é a função principal da fábrica, criar um par de troca entre dois tokens ERC-20. Observe que qualquer um pode chamar esta função. Você não precisa de permissão do Uniswap para criar um novo par de troca.

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

Queremos que o endereço da nova troca seja determinístico, para que possa ser calculado antecipadamente off-chain (isso pode ser útil para transações de camada 2). Para fazer isso, precisamos ter uma ordem consistente dos endereços dos tokens, independentemente da ordem em que os recebemos, então os ordenamos aqui.

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

Pools de liquidez grandes são melhores que os pequenos, porque têm preços mais estáveis. Não queremos ter mais de um único pool de liquidez por par de tokens. Se já existe uma troca, não há necessidade de criar outra para o mesmo par.

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

Para criar um novo contrato, precisamos do código que o cria (tanto a função do construtor quanto o código que escreve na memória o bytecode da EVM do contrato real). Normalmente no Solidity, usamos apenas addr = new <nome do contrato>(<parâmetros do construtor>) e o compilador cuida de tudo para nós, mas para ter um endereço de contrato determinístico, precisamos usar o opcode CREATE2 (opens in a new tab). Quando este código foi escrito, esse opcode ainda não era suportado pelo Solidity, então foi necessário obter manualmente o código. Isso não é mais um problema, porque o Solidity agora suporta 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        }
Copiar

Quando um opcode ainda não é suportado pelo Solidity, podemos chamá-lo usando assembly embutido (opens in a new tab).

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

Chame a função initialize para informar à nova troca quais dois tokens ela troca.

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);
5    }
Copiar

Salve as novas informações do par nas variáveis de estado e emita um evento para informar ao mundo sobre o novo par de troca.

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}
Exibir tudo
Copiar

Essas duas funções permitem que o feeSetter controle o destinatário da taxa (se houver) e altere o feeSetter para um novo endereço.

UniswapV2ERC20.sol

Este contrato (opens in a new tab) implementa o token de liquidez ERC-20. É semelhante ao contrato ERC-20 da OpenZeppelin, então explicarei apenas a parte que é diferente, a funcionalidade permit.

As transações no Ethereum custam ether (ETH), o que é equivalente a dinheiro real. Se você tiver tokens ERC-20, mas não ETH, não poderá enviar transações, então não poderá fazer nada com eles. Uma solução para evitar esse problema são as meta-transações (opens in a new tab). O proprietário dos tokens assina uma transação que permite que outra pessoa saque tokens off-chain e a envia pela Internet para o destinatário. O destinatário, que possui ETH, envia a permissão em nome do proprietário.

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;
Copiar

Este hash é o identificador para o tipo de transação (opens in a new tab). O único que suportamos aqui é Permit com esses parâmetros.

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

Não é viável para um destinatário falsificar uma assinatura digital. No entanto, é trivial enviar a mesma transação duas vezes (esta é uma forma de ataque de repetição (opens in a new tab)). Para evitar isso, usamos um nonce (opens in a new tab). Se o nonce de um novo Permit não for um a mais que o último usado, assumimos que ele é inválido.

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

Este é o código para recuperar o identificador da cadeia (opens in a new tab). Ele usa um dialeto de assembly da EVM chamado Yul (opens in a new tab). Observe que na versão atual do Yul, você deve usar chainid(), não 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    }
Exibir tudo
Copiar

Calcular o separador de domínio (opens in a new tab) para o EIP-712.

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

Esta é a função que implementa as permissões. Ela recebe como parâmetros os campos relevantes e os três valores escalares para a assinatura (opens in a new tab) (v, r e s).

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

Não aceite transações após o prazo.

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        );
Copiar

abi.encodePacked(...) é a mensagem que esperamos receber. Sabemos qual deve ser o nonce, então não há necessidade de o recebermos como parâmetro.

O algoritmo de assinatura do Ethereum espera receber 256 bits para assinar, então usamos a função de hash keccak256.

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

A partir do digest e da assinatura, podemos obter o endereço que o assinou usando ecrecover (opens in a new tab).

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

Se tudo estiver OK, trate isso como uma aprovação (approve) do ERC-20 (opens in a new tab).

Os Contratos Periféricos

Os contratos periféricos são a API (interface de programação de aplicações) para o Uniswap. Eles estão disponíveis para chamadas externas, seja de outros contratos ou de aplicativos descentralizados. Você poderia chamar os contratos principais diretamente, mas isso é mais complicado e você pode perder valor se cometer um erro. Os contratos principais contêm apenas testes para garantir que não sejam enganados, não verificações de sanidade para mais ninguém. Esses estão na periferia para que possam ser atualizados conforme necessário.

UniswapV2Router01.sol

Este contrato (opens in a new tab) tem problemas e não deve mais ser usado (opens in a new tab). Felizmente, os contratos periféricos são sem estado (stateless) e não detêm nenhum ativo, por isso é fácil descontinuá-lo e sugerir que as pessoas usem o substituto, UniswapV2Router02.

UniswapV2Router02.sol

Na maioria dos casos, você usaria o Uniswap através deste contrato (opens in a new tab). Você pode ver como usá-lo aqui (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';
Exibir tudo
Copiar

A maioria deles já encontramos antes ou são bastante óbvios. A única exceção é IWETH.sol. O Uniswap v2 permite trocas para qualquer par de tokens ERC-20, mas o próprio ether (ETH) não é um token ERC-20. Ele antecede o padrão e é transferido por mecanismos únicos. Para permitir o uso de ETH em contratos que se aplicam a tokens ERC-20, as pessoas criaram o contrato wrapped ether (WETH) (opens in a new tab). Você envia ETH a este contrato, e ele cunha para você uma quantidade equivalente de WETH. Ou você pode queimar WETH e receber ETH de volta.

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

O roteador precisa saber qual fábrica usar e, para transações que exigem WETH, qual contrato WETH usar. Esses valores são imutáveis (opens in a new tab), o que significa que só podem ser definidos no construtor. Isso dá aos usuários a confiança de que ninguém será capaz de alterá-los para apontar para contratos menos honestos.

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

Este modificador garante que transações com limite de tempo ("faça X antes do tempo Y, se puder") não aconteçam após seu limite de tempo.

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

O construtor apenas define as variáveis de estado imutáveis.

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

Esta função é chamada quando resgatamos tokens do contrato WETH de volta para ETH. Apenas o contrato WETH que usamos está autorizado a fazer isso.

Adicionar Liquidez

Essas funções adicionam tokens ao par de troca, o que aumenta o pool de liquidez.

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

Esta função é usada para calcular a quantidade de tokens A e B que devem ser depositados no par de troca.

1        address tokenA,
2        address tokenB,
Copiar

Estes são os endereços dos contratos de token ERC-20.

1        uint amountADesired,
2        uint amountBDesired,
Copiar

Estas são as quantias que o provedor de liquidez deseja depositar. Elas também são as quantias máximas de A e B a serem depositadas.

1        uint amountAMin,
2        uint amountBMin
Copiar

Estas são as quantias mínimas aceitáveis para depósito. Se a transação não puder ocorrer com essas quantias ou mais, reverta-a. Se você não quiser este recurso, basta especificar zero.

Os provedores de liquidez especificam um mínimo, geralmente, porque querem limitar a transação a uma taxa de câmbio próxima da atual. Se a taxa de câmbio flutuar demais, isso pode significar notícias que alteram os valores subjacentes, e eles querem decidir manualmente o que fazer.

Por exemplo, imagine um caso em que a taxa de câmbio é de um para um e o provedor de liquidez especifica estes valores:

Enquanto a taxa de câmbio permanecer entre 0,9 e 1,25, a transação ocorre. Se a taxa de câmbio sair desse intervalo, a transação é cancelada.

A razão para esta precaução é que as transações não são imediatas; você as envia e, eventualmente, um validador as incluirá em um bloco (a menos que seu preço do gás seja muito baixo, caso em que você precisará enviar outra transação com o mesmo nonce e um preço de gás mais alto para sobrescrevê-la). Você não pode controlar o que acontece durante o intervalo entre o envio e a inclusão.

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

A função retorna as quantias que o provedor de liquidez deve depositar para ter uma proporção igual à proporção atual entre as reservas.

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        }
Copiar

Se ainda não houver uma troca para este par de tokens, crie-a.

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

Obter as reservas atuais no par.

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

Se as reservas atuais estiverem vazias, então este é um novo par de troca. As quantias a serem depositadas devem ser exatamente as mesmas que o provedor de liquidez deseja fornecer.

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

Se precisarmos ver quais serão as quantias, obtemos a quantia ótima usando esta função (opens in a new tab). Queremos a mesma proporção das reservas atuais.

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

Se amountBOptimal for menor que a quantia que o provedor de liquidez deseja depositar, isso significa que o token B está atualmente mais valioso do que o depositante de liquidez pensa, então uma quantia menor é necessária.

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);
Copiar

Se a quantia ótima de B for maior que a quantia desejada de B, isso significa que os tokens B estão atualmente menos valiosos do que o depositante de liquidez pensa, então uma quantia maior é necessária. No entanto, a quantia desejada é um máximo, então não podemos fazer isso. Em vez disso, calculamos o número ótimo de tokens A para a quantia desejada de tokens B.

Juntando tudo, obtemos este gráfico. Suponha que você está tentando depositar mil tokens A (linha azul) e mil tokens B (linha vermelha). O eixo x é a taxa de câmbio, A/B. Se x=1, eles têm valor igual e você deposita mil de cada. Se x=2, A tem o dobro do valor de B (você recebe dois tokens B para cada token A), então você deposita mil tokens B, mas apenas 500 tokens A. Se x=0,5, a situação se inverte, mil tokens A e quinhentos tokens B.

Você poderia depositar liquidez diretamente no contrato principal (usando UniswapV2Pair::mint (opens in a new tab)), mas o contrato principal apenas verifica se ele próprio não está sendo enganado, então você corre o risco de perder valor se a taxa de câmbio mudar entre o momento em que você envia sua transação e o momento em que ela é executada. Se você usar o contrato periférico, ele calcula a quantia que você deve depositar e a deposita imediatamente, para que a taxa de câmbio não mude e você não perca nada.

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
Exibir tudo
Copiar

Esta função pode ser chamada por uma transação para depositar liquidez. A maioria dos parâmetros é a mesma que em _addLiquidity acima, com duas exceções:

. to é o endereço que recebe os novos tokens de liquidez cunhados para mostrar a parte do pool do provedor de liquidez . deadline é um limite de tempo na transação

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);
Copiar

Calculamos as quantias a serem realmente depositadas e, em seguida, encontramos o endereço do pool de liquidez. Para economizar gás, não fazemos isso perguntando à fábrica, mas usando a função de biblioteca pairFor (veja abaixo em bibliotecas)

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

Transfira as quantias corretas de tokens do usuário para o par de troca.

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

Em troca, dê ao endereço to tokens de liquidez pela propriedade parcial do pool. A função mint do contrato principal vê quantos tokens extras ele tem (em comparação com o que tinha da última vez que a liquidez mudou) e cunha a liquidez de acordo.

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

Quando um provedor de liquidez deseja fornecer liquidez a um par de troca Token/ETH, há algumas diferenças. O contrato lida com o encapsulamento do ETH para o provedor de liquidez. Não há necessidade de especificar quantos ETH o usuário deseja depositar, porque o usuário simplesmente os envia com a transação (a quantia está disponível em 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));
Exibir tudo
Copiar

Para depositar o ETH, o contrato primeiro o encapsula em WETH e, em seguida, transfere o WETH para o par. Observe que a transferência está envolvida em um assert. Isso significa que, se a transferência falhar, essa chamada de contrato também falha e, portanto, o encapsulamento não acontece de fato.

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    }
Copiar

O usuário já nos enviou o ETH, então, se houver algum extra sobrando (porque o outro token é menos valioso do que o usuário pensava), precisamos emitir um reembolso.

Remover Liquidez

Essas funções removerão a liquidez e pagarão de volta ao provedor de liquidez.

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) {
Exibir tudo
Copiar

O caso mais simples de remover liquidez. Há uma quantidade mínima de cada token que o provedor de liquidez concorda em aceitar, e isso deve acontecer antes do prazo.

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);
Copiar

A função burn do contrato principal lida com o pagamento de volta dos tokens ao usuário.

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

Quando uma função retorna vários valores, mas estamos interessados apenas em alguns deles, é assim que obtemos apenas esses valores. É um pouco mais barato em termos de gás do que ler um valor e nunca usá-lo.

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

Traduza as quantias da maneira como o contrato principal as retorna (token de endereço mais baixo primeiro) para a maneira como o usuário as espera (correspondendo a tokenA e tokenB).

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

Não há problema em fazer a transferência primeiro e depois verificar se ela é legítima, porque, se não for, reverteremos todas as alterações de estado.

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    }
Exibir tudo
Copiar

Remover liquidez para ETH é quase a mesma coisa, exceto que recebemos os tokens WETH e depois os resgatamos por ETH para devolver ao provedor de liquidez.

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    }
Exibir tudo
Copiar

Essas funções retransmitem meta-transações para permitir que usuários sem ether retirem do pool, usando o mecanismo de permissão.

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

Esta função pode ser usada para tokens que têm taxas de transferência ou armazenamento. Quando um token tem tais taxas, não podemos confiar na função removeLiquidity para nos dizer quanto do token recebemos de volta, então precisamos retirar primeiro e depois obter o saldo.

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    }
Exibir tudo
Copiar