uniswap.fe

contract ERC20:
    pub def balanceOf(account: address) -> u256:
        return 0

    pub def transfer(recipient: address, amount: u256) -> bool:
        return false

contract UniswapV2Pair:
    # TODO: const support (https://github.com/ethereum/fe/issues/192)
    # const MINIMUM_LIQUIDITY: u256 = 1000

    balances: map<address, u256>
    allowances: map<address, map<address, u256>>
    total_supply: u256

    nonces: map<address, u256>

    factory: address
    token0: address
    token1: address

    reserve0: u256
    reserve1: u256
    block_timestamp_last: u256

    price0_cumulative_last: u256
    price1_cumulative_last: u256
    k_last: u256

    event Approval:
        idx owner: address
        idx spender: address
        value: u256

    event Transfer:
        idx from: address
        idx to: address
        value: u256

    event Mint:
        idx sender: address
        amount0: u256
        amount1: u256

    event Burn:
        idx sender: address
        amount0: u256
        amount1: u256
        idx to: address

    event Swap:
        idx sender: address
        amount0_in: u256
        amount1_in: u256
        amount0_out: u256
        amount1_out: u256
        idx to: address

    event Sync:
        reserve0: u256
        reserve1: u256

    pub def __init__():
        self.factory = msg.sender

    pub def factory() -> address:
        return self.factory

    pub def token0() -> address:
        return self.token0

    pub def token1() -> address:
        return self.token1

    def _mint(to: address, value: u256):
        self.total_supply = self.total_supply + value
        self.balances[to] = self.balances[to] + value
        emit Transfer(address(0), to, value)

    def _burn(from: address, value: u256):
        self.balances[from] = self.balances[from] - value
        self.total_supply = self.total_supply - value
        emit Transfer(from, address(0), value)

    def _approve(owner: address, spender: address, value: u256):
        self.allowances[owner][spender] = value
        emit Approval(owner, spender, value)

    def _transfer(from: address, to: address, value: u256):
        self.balances[from] = self.balances[from] - value
        self.balances[to] = self.balances[to] + value
        emit Transfer(from, to, value)

    pub def approve(spender: address, value: u256) -> bool:
        self._approve(msg.sender, spender, value)
        return true

    pub def transfer(to: address, value: u256) -> bool:
        self._transfer(msg.sender, to, value)
        return true

    pub def transferFrom(from: address, to: address, value: u256) -> bool:
        assert self.allowances[from][msg.sender] >= value

        self.allowances[from][msg.sender] = self.allowances[from][msg.sender] - value
        self._transfer(from, to, value)
        return true

    pub def balanceOf(account: address) -> u256:
        return self.balances[account]

    pub def get_reserves() -> (u256, u256, u256):
        return (self.reserve0, self.reserve1, self.block_timestamp_last)

    # called once by the factory at time of deployment
    pub def initialize(token0: address, token1: address):
        # TODO: we should not be ignoring the revert messages (https://github.com/ethereum/fe/issues/288)
        assert msg.sender == self.factory, "UniswapV2: FORBIDDEN"
        self.token0 = token0
        self.token1 = token1

    # update reserves and, on the first call per block, price accumulators
    def _update(balance0: u256, balance1: u256, reserve0: u256, reserve1: u256):
        # changed from u32s
        block_timestamp: u256 = block.timestamp % 2**32
        # TODO: reproduce desired overflow (https://github.com/ethereum/fe/issues/286)
        time_elapsed: u256 = block_timestamp - self.block_timestamp_last # overflow is desired
        if time_elapsed > 0 and reserve0 != 0 and reserve1 != 0:
            # `*` never overflows, and + overflow is desired
            self.price0_cumulative_last = self.price0_cumulative_last + (reserve1 / reserve0) * time_elapsed
            self.price1_cumulative_last = self.price1_cumulative_last + (reserve0 / reserve1) * time_elapsed

        self.reserve0 = balance0
        self.reserve1 = balance1
        self.block_timestamp_last = block_timestamp
        emit Sync(self.reserve0, self.reserve1)

    # if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
    def _mint_fee(reserve0: u256, reserve1: u256) -> bool:
        fee_to: address = UniswapV2Factory(self.factory).fee_to()
        fee_on: bool = fee_to != address(0)
        k_last: u256 = self.k_last # gas savings
        if fee_on:
            if k_last != 0:
                root_k: u256 = self.sqrt(reserve0 * reserve1)
                root_k_last: u256 = self.sqrt(k_last)
                if root_k > root_k_last:
                    numerator: u256 = self.total_supply * root_k - root_k_last
                    denominator: u256 = root_k * 5 + root_k_last
                    liquidity: u256 = numerator / denominator
                    if liquidity > 0:
                        self._mint(fee_to, liquidity)
        elif k_last != 0:
            self.k_last = 0

        return fee_on

    # this low-level function should be called from a contract which performs important safety checks
    pub def mint(to: address) -> u256:
        MINIMUM_LIQUIDITY: u256 = 1000
        reserve0: u256 = self.reserve0
        reserve1: u256 = self.reserve1
        balance0: u256 = ERC20(self.token0).balanceOf(self.address)
        balance1: u256 = ERC20(self.token1).balanceOf(self.address)
        amount0: u256 = balance0 - self.reserve0
        amount1: u256 = balance1 - self.reserve1

        fee_on: bool = self._mint_fee(reserve0, reserve1)
        total_supply: u256 = self.total_supply # gas savings, must be defined here since totalSupply can update in _mintFee
        liquidity: u256 = 0
        if total_supply == 0:
            liquidity = self.sqrt(amount0 * amount1) - MINIMUM_LIQUIDITY
            self._mint(address(0), MINIMUM_LIQUIDITY) # permanently lock the first MINIMUM_LIQUIDITY tokens
        else:
            liquidity = self.min((amount0 * total_supply) / reserve0, (amount1 * total_supply) / reserve1)

        assert liquidity > 0, "UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED"

        self._mint(to, liquidity)
        self._update(balance0, balance1, reserve0, reserve1)

        if fee_on:
            self.k_last = reserve0 * reserve1 # reserve0 and reserve1 are up-to-date

        emit Mint(msg.sender, amount0, amount1)
        return liquidity

    # this low-level function should be called from a contract which performs important safety checks
    pub def burn(to: address) -> (u256, u256):
        reserve0: u256 = self.reserve0
        reserve1: u256 = self.reserve1
        token0: ERC20 = ERC20(self.token0)
        token1: ERC20 = ERC20(self.token1)
        balance0: u256 = token0.balanceOf(self.address)
        balance1: u256 = token1.balanceOf(self.address)
        liquidity: u256 = self.balances[self.address]

        fee_on: bool = self._mint_fee(reserve0, reserve1)
        total_supply: u256 = self.total_supply # gas savings, must be defined here since total_supply can update in _mintFee
        amount0: u256 = (liquidity * balance0) / total_supply # using balances ensures pro-rata distribution
        amount1: u256 = (liquidity * balance1) / total_supply # using balances ensures pro-rata distribution
        assert amount0 > 0 and amount1 > 0, "UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED"
        self._burn(self.address, liquidity)
        token0.transfer(to, amount0)
        token1.transfer(to, amount1)
        balance0 = token0.balanceOf(self.address)
        balance1 = token1.balanceOf(self.address)

        self._update(balance0, balance1, reserve0, reserve1)

        if fee_on:
            self.k_last = reserve0 * reserve1 # reserve0 and reserve1 are up-to-date

        emit Burn(msg.sender, amount0, amount1, to)
        return (amount0, amount1)

    # this low-level function should be called from a contract which performs important safety checks
    # TODO: add support for the bytes type (https://github.com/ethereum/fe/issues/280)
    # pub def swap(amount0_out: u256, amount1_out: u256, to: address, data: bytes):
    pub def swap(amount0_out: u256, amount1_out: u256, to: address):
        assert amount0_out > 0 or amount1_out > 0, "UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT"
        reserve0: u256 = self.reserve0
        reserve1: u256 = self.reserve1
        assert amount0_out < reserve0 and amount1_out < reserve1, "UniswapV2: INSUFFICIENT_LIQUIDITY"

        token0: ERC20 = ERC20(self.token0)
        token1: ERC20 = ERC20(self.token1)

        # TODO: we should be using `token0.address` (https://github.com/ethereum/fe/issues/287)
        assert to != address(token0) and to != address(token1), "UniswapV2: INVALID_TO"

        if amount0_out > 0:
            token0.transfer(to, amount0_out) # optimistically transfer tokens
        if amount1_out > 0:
            token1.transfer(to, amount1_out) # optimistically transfer tokens
        # TODO: bytes support
#        if data.length > 0:
#            IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0_out, amount1_out, data)

        balance0: u256 = token0.balanceOf(self.address)
        balance1: u256 = token1.balanceOf(self.address)

        amount0_in: u256 = balance0 - (reserve0 - amount0_out) if balance0 > reserve0 - amount0_out else 0
        amount1_in: u256 = balance1 - (reserve1 - amount1_out) if balance1 > reserve1 - amount1_out else 0

        assert amount0_in > 0 or amount1_in > 0, "UniswapV2: INSUFFICIENT_INPUT_AMOUNT"

        balance0_adjusted: u256 = balance0 * 1000 - amount0_in * 3
        balance1_adjusted: u256 = balance1 * 1000 - amount1_in * 3

        assert balance0_adjusted * balance1_adjusted >= reserve0 * reserve1 * 1000000, "UniswapV2: K"

        self._update(balance0, balance1, reserve0, reserve1)
        emit Swap(msg.sender, amount0_in, amount1_in, amount0_out, amount1_out, to)

    # force balances to match reserves
    pub def skim(to: address):
        token0: ERC20 = ERC20(self.token0) # gas savings
        token1: ERC20 = ERC20(self.token1) # gas savings

        token0.transfer(to, token0.balanceOf(self.address) - self.reserve0)
        token1.transfer(to, token1.balanceOf(self.address) - self.reserve1)

    # force reserves to match balances
    pub def sync():
        token0: ERC20 = ERC20(self.token0)
        token1: ERC20 = ERC20(self.token1)
        self._update(token0.balanceOf(self.address), token1.balanceOf(self.address), self.reserve0, self.reserve1)

    def sqrt(val: u256) -> u256:
        z: u256
        if (val > 3):
            z = val
            x: u256 = val / 2 + 1
            while (x < z):
                z = x
                x = (val / x + x) / 2
        elif (val != 0):
            z = 1
        return z

    def min(x: u256, y: u256) -> u256:
        return x if x < y else y

contract UniswapV2Factory:
    fee_to: address
    fee_to_setter: address

    pairs: map<address, map<address, address>>

    all_pairs: address[100]
    pair_counter: u256

    event PairCreated:
        idx token0: address
        idx token1: address
        pair: address
        index: u256

    pub def __init__(fee_to_setter: address):
       self.fee_to_setter = fee_to_setter

    pub def fee_to() -> address:
        return self.fee_to

    pub def fee_to_setter() -> address:
        return self.fee_to_setter

    pub def all_pairs_length() -> u256:
        return self.pair_counter

    pub def create_pair(token_a: address, token_b: address) -> address:
        assert token_a != token_b, "UniswapV2: IDENTICAL_ADDRESSES"

        token0: address = token_a if token_a < token_b else token_b
        token1: address = token_a if token_a > token_b else token_b
        assert token0 != address(0), "UniswapV2: ZERO_ADDRESS"
        assert self.pairs[token0][token1] == address(0), "UniswapV2: PAIR_EXISTS"

        salt: u256 = keccak256((token0, token1).abi_encode())
        pair: UniswapV2Pair = UniswapV2Pair.create2(0, salt)
        pair.initialize(token0, token1)

        self.pairs[token0][token1] = address(pair)
        self.pairs[token1][token0] = address(pair)
        self.all_pairs[self.pair_counter] = address(pair)
        self.pair_counter = self.pair_counter + 1

        emit PairCreated(token0, token1, address(pair), self.pair_counter)
        return address(pair)

    pub def set_fee_to(fee_to: address):
        assert msg.sender == self.fee_to_setter, "UniswapV2: FORBIDDEN"
        self.fee_to = fee_to

    pub def set_fee_to_setter(fee_to_setter: address):
        assert msg.sender == fee_to_setter, "UniswapV2: FORBIDDEN"
        self.fee_to_setter = fee_to_setter