uniswap 0.0.1

data/lib/uniswap/UniswapV2Pair.rb

@@ -0,0 +1,274 @@
+
+# import 'UniswapV2Callee'
+# import 'UniswapV2ERC20'
+
+## add for now too
+# import 'UnsafeNoApprovalERC20'
+# import 'PublicMintERC20'
+
+
+# contract :IUniswapV2Factory, abstract: true do
+#   function :feeTo, {}, :external, :view, returns: :address do
+#   end
+# end
+
+class UniswapV2Pair < UniswapV2ERC20
+
+  event :Mint, sender:  Address, 
+               amount0: UInt, 
+               amount1: UInt 
+  event :Burn, sender:  Address, 
+               amount0: UInt, 
+               amount1: UInt, 
+               to:      Address 
+  event :Swap, sender:     Address, 
+               amount0In:  UInt, 
+               amount1In:  UInt, 
+               amount0Out: UInt, 
+               amount1Out: UInt, 
+               to:         Address 
+  event :Sync, reserve0:  UInt,  # :uint112, 
+               reserve1:  UInt  # :uint112 
+  event :PreSwapReserves, reserve0: UInt, # :uint112, 
+                          reserve1: UInt  # :uint112 
+
+
+  MINIMUM_LIQUIDITY =  10 ** 3     #=> 1000
+
+  storage factory:   Address,
+          token0:    Address, 
+          token1:    Address,
+          _reserve0: UInt,   # uint112 ??
+          _reserve1: UInt,   # uint112 ??
+          _blockTimestampLast:  Timestamp,  # uint32 - why?  
+          price0CumulativeLast: UInt,
+          price1CumulativeLast: UInt,
+          kLast:                UInt,
+          _unlocked:            UInt  ## use bool or is counter more than 0/1 e.g. 0/1/2?
+ 
+
+  sig []
+  def constructor
+    super
+    @factory  = msg.sender
+    @unlocked = uint256( 1 )
+  end
+        
+  # note: can't name method initialize because of ruby
+  sig [Address, Address], :external
+  def init( token0:, token1: )
+    assert msg.sender == @factory, 'ScribeSwap: FORBIDDEN'
+
+    @token0 = token0
+    @token1 = token1    
+  end
+  
+  sig [], :view, returns: [UInt, UInt, Timestamp]        
+  def getReserves
+    return [@_reserve0,
+            @_reserve1,
+            @_blockTimestampLast]
+  end
+  
+  sig [Address, Address, UInt]
+  def _safeTransfer( token:, to:, value:)
+    result = ERC20.at( token ).transfer(to: to, amount: value)
+    
+    assert result, "ScribeSwap: TRANSFER_FAILED"
+  end
+  
+end  # class UniswapV2Pair
+
+__END__
+
+  
+  function :_update, {
+    balance0: :uint256,
+    balance1: :uint256,
+    _reserve0: :uint112,
+    _reserve1: :uint112
+  }, :private do
+    require(balance0 <= (2 ** 112 - 1) && balance1 <= (2 ** 112 - 1), 'ScribeSwap: OVERFLOW')
+    
+    # blockTimestamp = uint32(block.timestamp % 2 ** 32)
+    blockTimestamp = block.timestamp 
+    timeElapsed = blockTimestamp - s.blockTimestampLast # overflow is desired
+    
+    if timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0
+      # * never overflows, and + overflow is desired
+      s.price0CumulativeLast += uint256(uqdiv(encode(_reserve1), _reserve0)) * timeElapsed
+      s.price1CumulativeLast += uint256(uqdiv(encode(_reserve0), _reserve1)) * timeElapsed
+    end
+    
+    emit :PreSwapReserves, reserve0: s.reserve0, reserve1: s.reserve1
+    
+    s.reserve0 = uint112(balance0)
+    s.reserve1 = uint112(balance1)
+    
+    s.blockTimestampLast = blockTimestamp
+    emit :Sync, reserve0: s.reserve0, reserve1: s.reserve1
+  end
+  
+  function :encode, { y: :uint112 }, :internal, :pure, returns: :uint224 do
+    return uint224(y) * (2 ** 112)
+  end
+
+  function :uqdiv, { x: :uint224, y: :uint112 }, :internal, :pure, returns: :uint224 do
+    return x / uint224(y)
+  end
+  
+  function :_mintFee, { _reserve0: :uint112, _reserve1: :uint112 }, :private, returns: :bool do
+    feeTo = UniswapV2Factory.at( s.factory ).feeTo
+    feeOn = feeTo != address(0)
+    _kLast = s.kLast
+    
+
+    if feeOn
+      if _kLast != 0
+        ## note: sqrt NOT built-in - double check
+        rootK = Integer.sqrt(_reserve0 * _reserve1)
+        rootKLast = Integer.sqrt(_kLast)
+        if rootK > rootKLast
+          numerator = totalSupply * (rootK - rootKLast)
+          denominator = rootK * 5 + rootKLast
+          liquidity = numerator.div(denominator)
+          _mint(feeTo, liquidity)   if liquidity > 0
+        end
+      end
+    elsif _kLast != 0
+      s.kLast = 0
+    end
+    feeOn
+  end
+  
+  function :mint, { to: :address }, :public, returns: :uint256 do
+    require(s.unlocked == 1, 'ScribeSwap: LOCKED')
+    
+    _reserve0, _reserve1, _ = getReserves
+    
+    balance0 = ERC20.at(s.token0).balanceOf( __address__ ) ## address(this)
+    balance1 = ERC20.at(s.token1).balanceOf( __address__ ) ## address(this)
+ 
+    amount0 = balance0 - _reserve0
+    amount1 = balance1 - _reserve1
+    
+    feeOn = _mintFee(_reserve0, _reserve1)
+    _totalSupply = s.totalSupply
+
+ 
+
+    if _totalSupply == 0
+      ## note: sqrt NOT built-in - double check
+      liquidity = uint256( Integer.sqrt(amount0 * amount1)) - s.MINIMUM_LIQUIDITY
+      _mint(address(0), s.MINIMUM_LIQUIDITY)
+    else
+      liquidity = [
+        (amount0 * _totalSupply).div(_reserve0),
+        (amount1 * _totalSupply).div(_reserve1)
+      ].min
+    end
+
+    require(liquidity > 0, 'ScribeSwap: INSUFFICIENT_LIQUIDITY_MINTED')
+    _mint(to, liquidity)
+ 
+  
+    _update(balance0, balance1, _reserve0, _reserve1)
+    s.kLast = s.reserve0 * s.reserve1   if feeOn
+    
+    emit :Mint, sender: msg.sender, amount0: amount0, amount1: amount1
+    
+    return liquidity
+  end
+  
+  function :burn, { to: :address }, :external, :lock, returns: { amount0: :uint256, amount1: :uint256 } do
+    require(s.unlocked == 1, 'ScribeSwap: LOCKED')
+
+    _reserve0, _reserve1, _ = getReserves
+    _token0 = s.token0
+    _token1 = s.token1
+    balance0 = ERC20.at(_token0).balanceOf( __address__ )  ## address(this)
+    balance1 = ERC20.at(_token1).balanceOf( __address__ )
+    liquidity = s.balanceOf[ __address__ ]
+  
+    feeOn = _mintFee(_reserve0, _reserve1)
+    _totalSupply = s.totalSupply
+    amount0 = (liquidity * balance0).div(_totalSupply)
+    amount1 = (liquidity * balance1).div(_totalSupply)
+    
+    require(amount0 > 0 && amount1 > 0, 'ScribeSwap: INSUFFICIENT_LIQUIDITY_BURNED')
+    _burn( __address__, liquidity)
+    _safeTransfer(_token0, to, amount0)
+    _safeTransfer(_token1, to, amount1)
+    balance0 = ERC20.at(_token0).balanceOf( __address__ )
+    balance1 = ERC20.at(_token1).balanceOf( __address__ )
+  
+    _update(balance0, balance1, _reserve0, _reserve1)
+    s.kLast = s.reserve0 * s.reserve1   if feeOn
+    
+    emit :Burn, sender: msg.sender, amount0: amount0, amount1: amount1, to: to
+    
+    ## return { amount0: amount0, amount1: amount1 }
+    return [amount0, amount1]
+  end
+  
+
+  function :swap, { amount0Out: :uint256, amount1Out: :uint256, to: :address, data: :bytes }, :external do
+    require(s.unlocked == 1, 'ScribeSwap: LOCKED')
+    
+    require(amount0Out > 0 || amount1Out > 0, 'ScribeSwap: INSUFFICIENT_OUTPUT_AMOUNT')
+    _reserve0, _reserve1, _ = getReserves
+    require(amount0Out < _reserve0 && amount1Out < _reserve1, 'ScribeSwap: INSUFFICIENT_LIQUIDITY')
+  
+    balance0 = 0
+    balance1 = 0
+    _token0 = s.token0
+    _token1 = s.token1
+    
+    require(to != _token0 && to != _token1, 'ScribeSwap: INVALID_TO')
+    
+    _safeTransfer(_token0, to, amount0Out) if amount0Out > 0 # optimistically transfer tokens
+    _safeTransfer(_token1, to, amount1Out) if amount1Out > 0 # optimistically transfer tokens
+    
+    UniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data) if data.length > 0
+    
+    balance0 = ERC20(_token0).balanceOf(address(this))
+    balance1 = ERC20(_token1).balanceOf(address(this))
+
+    amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0
+    amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0
+
+    require(amount0In > 0 || amount1In > 0, 'ScribeSwap: INSUFFICIENT_INPUT_AMOUNT')
+  
+    balance0Adjusted = balance0 * 1000 - amount0In * 3
+    balance1Adjusted = balance1 * 1000 - amount1In * 3
+    
+    require(
+      balance0Adjusted * balance1Adjusted >= uint256(_reserve0) * _reserve1 * (1000 ** 2),
+      'ScribeSwap: K'
+    )
+  
+    _update(balance0, balance1, _reserve0, _reserve1)
+    emit :Swap, sender: msg.sender, amount0In: amount0In, amount1In: amount1In, amount0Out: amount0Out, amount1Out: amount1Out, to: to
+  end
+  
+  function :skim, { to: :address }, :external do
+    require(s.unlocked == 1, 'ScribeSwap: LOCKED')
+    
+    _token0 = s.token0
+    _token1 = s.token1
+    
+    _safeTransfer(_token0, to, ERC20(_token0).balanceOf(address(this)) - s.reserve0)
+    _safeTransfer(_token1, to, ERC20(_token1).balanceOf(address(this)) - s.reserve1)
+  end
+  
+  function :sync, {}, :external do
+    require(s.unlocked == 1, 'ScribeSwap: LOCKED')
+    
+    _update(
+      ERC20(s.token0).balanceOf(address(this)),
+      ERC20(s.token1).balanceOf(address(this)),
+      s.reserve0,
+      s.reserve1
+    )
+  end
+end

data/lib/uniswap/UniswapV2Router.rb

@@ -0,0 +1,323 @@
+pragma :rubidity, "1.0.0"
+
+import 'UniswapV2Factory'
+
+contract :UniswapV2Router do
+  address :public, :factory
+  address :public, :WETH
+  
+  constructor(_factory: :address, _WETH: :address) {
+    s.factory = _factory
+    s.WETH = _WETH
+  }
+  
+  function :_addLiquidity, {
+    tokenA: :address,
+    tokenB: :address,
+    amountADesired: :uint256,
+    amountBDesired: :uint256,
+    amountAMin: :uint256,
+    amountBMin: :uint256
+  }, :internal, :virtual, returns: { amountA: :uint256, amountB: :uint256 } do
+    if UniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)
+      UniswapV2Factory(factory).createPair(tokenA, tokenB)
+    end
+    
+    reserveA, reserveB = getReserves(s.factory, tokenA, tokenB)
+    
+    if reserveA == 0 && reserveB == 0
+      return { amountA: amountADesired, amountB: amountBDesired }
+    else
+      amountBOptimal = quote(amountADesired, reserveA, reserveB)
+      
+      if amountBOptimal <= amountBDesired
+        require(amountBOptimal >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT')
+        
+        return { amountA: amountADesired, amountB: amountBOptimal }
+      else
+        amountAOptimal = quote(amountBDesired, reserveB, reserveA)
+        
+        require(amountAOptimal <= amountADesired, "ASSERT")
+        
+        require(amountAOptimal >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT')
+        
+        return { amountA: amountAOptimal, amountB: amountBDesired }
+      end
+    end
+  end
+  
+  function :addLiquidity, {
+    tokenA: :address,
+    tokenB: :address,
+    amountADesired: :uint256,
+    amountBDesired: :uint256,
+    amountAMin: :uint256,
+    amountBMin: :uint256,
+    to: :address,
+    deadline: :uint256
+  }, :public, :virtual, returns: { amountA: :uint256, amountB: :uint256, liquidity: :uint256 } do
+    require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED');
+    
+    amountA, amountB = _addLiquidity(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin)
+    
+    pair = pairFor(s.factory, tokenA, tokenB)
+    
+    _safeTransferFrom(token: tokenA, from: msg.sender, to: pair, value: amountA)
+    _safeTransferFrom(token: tokenB, from: msg.sender, to: pair, value: amountB)
+    
+    liquidity = UniswapV2Pair(pair).mint(to: to)
+    
+    return { amountA: amountA, amountB: amountB, liquidity: liquidity }
+  end
+  
+  function :removeLiquidity, {
+    tokenA: :address,
+    tokenB: :address,
+    liquidity: :uint256,
+    amountAMin: :uint256,
+    amountBMin: :uint256,
+    to: :address,
+    deadline: :uint256
+  }, :public, :virtual, returns: { amountA: :uint256, amountB: :uint256 } do
+    require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED');
+    
+    pair = pairFor(s.factory, tokenA, tokenB)
+    UniswapV2Pair(pair).transferFrom(msg.sender, pair, liquidity)
+    
+    amount0, amount1 = UniswapV2Pair(pair).burn(to)
+    
+    token0, _ = sortTokens(tokenA, tokenB)
+
+    (amountA, amountB) = tokenA == token0 ? [amount0, amount1] : [amount1, amount0]
+    
+    require(amountA >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT')
+    require(amountB >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT')
+    
+    return { amountA: amountA, amountB: amountB }
+  end
+  
+  function :swapExactTokensForTokens, { 
+    amountIn: :uint256, 
+    amountOutMin: :uint256, 
+    path: [:address],
+    to: :address, 
+    deadline: :uint256 
+  }, :public, :virtual, returns: [:uint256] do
+    require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED');
+
+    amounts = getAmountsOut(factory, amountIn, path)
+    
+    require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT')
+    
+    _safeTransferFrom(
+      path[0], msg.sender, pairFor(factory, path[0], path[1]), amounts[0]
+    )
+    
+    _swap(amounts, path, to)
+    
+    return amounts
+  end
+  
+  function :swapTokensForExactTokens, {
+    amountOut: :uint256,
+    amountInMax: :uint256,
+    path: [:address],
+    to: :address,
+    deadline: :uint256
+  }, :public, :virtual, returns: [:uint256] do
+    require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED');
+    
+    amounts = getAmountsIn(factory, amountOut, path)
+    require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT')
+  
+    _safeTransferFrom(
+      path[0], msg.sender, pairFor(factory, path[0], path[1]), amounts[0]
+    )
+  
+    _swap(amounts, path, to)
+  
+    return amounts
+  end
+  
+  function :_swap, {
+    amounts: [:uint256],
+    path: [:address],
+    _to: :address
+  }, :internal, :virtual do
+    # TODO: how bad can this loop get?
+    
+    for i in 0...(path.length - 1)
+      input, output = path[i], path[i + 1]
+      token0, _ = sortTokens(input, output)
+      amountOut = amounts[i + 1]
+      amount0Out, amount1Out = input == token0 ? [0, amountOut] : [amountOut, 0]
+      to = i < path.length - 2 ? pairFor(factory, output, path[i + 2]) : _to
+
+      UniswapV2Pair(pairFor(factory, input, output)).swap(amount0Out, amount1Out, to, "")
+    end
+    
+    return nil
+  end
+  
+  function :_safeTransferFrom, { token: :address, from: :address, to: :address, value: :uint256 }, :private do
+    result = ERC20(token).transferFrom(from: from, to: to, amount: value)
+    
+    require(result, "ScribeSwap: TRANSFER_FAILED")
+  end
+  
+  function :getAmountsOut, {
+    factory: :address,
+    amountIn: :uint256,
+    path: [:address]
+  }, :public, :view, returns: [:uint256] do
+    require(path.length >= 2, 'UniswapV2Library: INVALID_PATH')
+    
+    amounts = array(:uint256, path.length)
+    amounts[0] = amountIn
+    
+    for i in 0...(path.length - 1)
+      reserveIn, reserveOut = getReserves(factory, path[i], path[i + 1])
+      amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut)
+    end
+    
+    return amounts
+  end
+  
+  function :getAmountOut, {
+    amountIn: :uint256,
+    reserveIn: :uint256,
+    reserveOut: :uint256
+  }, :public, :view, returns: :uint256 do
+    require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
+    require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
+    
+    amountInWithFee = amountIn * 997;
+    numerator = amountInWithFee * reserveOut
+    denominator = reserveIn * 1000 + amountInWithFee
+    amountOut = numerator.div(denominator)
+    
+    return amountOut
+  end
+  
+  function :getAmountsIn, {
+    factory: :address,
+    amountOut: :uint256,
+    path: [:address]
+  }, :public, :view, returns: [:uint256] do
+    require(path.length >= 2, 'UniswapV2Library: INVALID_PATH')
+  
+    amounts = array(:uint256, path.length)
+    amounts[amounts.length - 1] = amountOut
+    
+    for i in (path.length - 1).downto(1)
+      reserveIn, reserveOut = getReserves(factory, path[i - 1], path[i])
+      amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut)
+    end
+  
+    return amounts
+  end
+  
+  function :getAmountIn, {
+    amountOut: :uint256,
+    reserveIn: :uint256,
+    reserveOut: :uint256
+  }, :public, :view, returns: :uint256 do
+    require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT')
+    require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY')
+  
+    numerator = reserveIn * amountOut * 1000
+    denominator = (reserveOut - amountOut) * 997
+    amountIn = (numerator.div(denominator)) + 1
+  
+    return amountIn
+  end
+  
+  function :quote, {
+    amountA: :uint256,
+    reserveA: :uint256,
+    reserveB: :uint256
+  }, :public, :pure, returns: :uint256 do
+    require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');
+    require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
+    
+    return (amountA * reserveB).div(reserveA);
+  end
+  
+  function :getReserves, {
+    factory: :address,
+    tokenA: :address,
+    tokenB: :address
+  }, :public, :view, returns: { reserveA: :uint256, reserveB: :uint256 } do
+    token0, _ = sortTokens(tokenA, tokenB)
+    
+    reserve0, reserve1, _ = UniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();
+    
+    (reserveA, reserveB) = tokenA == token0 ? [reserve0, reserve1] : [reserve1, reserve0]
+    
+    return {
+      reserveA: reserveA,
+      reserveB: reserveB
+    }
+  end
+  
+  function :pairFor, {
+    factory: :address,
+    tokenA: :address,
+    tokenB: :address
+  }, :internal, :pure, returns: :address do
+    token0, token1 = sortTokens(tokenA, tokenB)
+    
+    return create2_address(
+      salt: keccak256(abi.encodePacked(token0, token1)),
+      deployer: factory,
+      contract_type: "UniswapV2Pair"
+    )
+  end
+  
+  function :sortTokens, { tokenA: :address, tokenB: :address }, :internal, :pure, returns: { token0: :address, token1: :address } do
+    require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES')
+    
+    token0, token1 = tokenA.cast(:uint256) < tokenB.cast(:uint256) ? [tokenA, tokenB] : [tokenB, tokenA]
+    
+    require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS')
+    
+    return { token0: token0, token1: token1 }
+  end
+  
+  function :userStats, {
+    user: :address,
+    tokenA: :address,
+    tokenB: :address,
+  }, :public, :view, returns: {
+    userTokenABalance: :uint256,
+    userTokenBBalance: :uint256,
+    tokenAName: :string,
+    tokenBName: :string,
+    tokenAReserves: :uint256,
+    tokenBReserves: :uint256,
+    userLPBalance: :uint256,
+    pairAddress: :address
+  } do
+    tokenAReserves = 0
+    tokenBReserves = 0
+    userLPBalance = 0
+    
+    if UniswapV2Factory(s.factory).getPair(tokenA, tokenB) != address(0)
+      tokenAReserves, tokenBReserves = getReserves(s.factory, tokenA, tokenB)
+      
+      pair = UniswapV2Factory(s.factory).getPair(tokenA, tokenB)
+      userLPBalance = UniswapV2ERC20(pair).balanceOf(user)
+    end
+    
+    return {
+      userTokenABalance: ERC20(tokenA).balanceOf(user),
+      userTokenBBalance: ERC20(tokenB).balanceOf(user),
+      tokenAName: ERC20(tokenA).name(),
+      tokenBName: ERC20(tokenB).name(),
+      tokenAReserves: tokenAReserves,
+      tokenBReserves: tokenBReserves,
+      userLPBalance: userLPBalance,
+      pairAddress: pair
+    }
+  end
+end