diff --git a/contracts/main/CurveCryptoMathOptimized2.vy b/contracts/main/CurveCryptoMathOptimized2.vy index 3947686..431f02f 100644 --- a/contracts/main/CurveCryptoMathOptimized2.vy +++ b/contracts/main/CurveCryptoMathOptimized2.vy @@ -151,7 +151,7 @@ def _newton_y(ANN: uint256, gamma: uint256, x: uint256[N_COINS], D: uint256, i: y: uint256 = D**2 / (x_j * N_COINS**2) K0_i: uint256 = (10**18 * N_COINS) * x_j / D - assert (K0_i >= unsafe_div(10**36, lim_mul)) and (K0_i <= lim_mul) # dev: unsafe values x[i] + assert (K0_i >= unsafe_div(10**36, lim_mul)) and (K0_i <= lim_mul), "unsafe values x[i]" convergence_limit: uint256 = max(max(x_j / 10**14, D / 10**14), 100) @@ -210,16 +210,16 @@ def _newton_y(ANN: uint256, gamma: uint256, x: uint256[N_COINS], D: uint256, i: def newton_y(ANN: uint256, gamma: uint256, x: uint256[N_COINS], D: uint256, i: uint256) -> uint256: # Safety checks - assert ANN > MIN_A - 1 and ANN < MAX_A + 1 # dev: unsafe values A - assert gamma > MIN_GAMMA - 1 and gamma < MAX_GAMMA + 1 # dev: unsafe values gamma - assert D > 10**17 - 1 and D < 10**15 * 10**18 + 1 # dev: unsafe values D + assert ANN > MIN_A - 1 and ANN < MAX_A + 1, "unsafe values A" + assert gamma > MIN_GAMMA - 1 and gamma < MAX_GAMMA + 1, "unsafe values gamma" + assert D > 10**17 - 1 and D < 10**15 * 10**18 + 1, "unsafe values D" lim_mul: uint256 = 100 * 10**18 # 100.0 if gamma > MAX_GAMMA_SMALL: lim_mul = unsafe_div(unsafe_mul(lim_mul, MAX_GAMMA_SMALL), gamma) # smaller than 100.0 y: uint256 = self._newton_y(ANN, gamma, x, D, i, lim_mul) frac: uint256 = y * 10**18 / D - assert (frac >= unsafe_div(10**36 / N_COINS, lim_mul)) and (frac <= unsafe_div(lim_mul, N_COINS)) # dev: unsafe value for y + assert (frac >= unsafe_div(10**36 / N_COINS, lim_mul)) and (frac <= unsafe_div(lim_mul, N_COINS)), "unsafe value for y" return y @@ -235,9 +235,9 @@ def get_y( ) -> uint256[2]: # Safety checks - assert _ANN > MIN_A - 1 and _ANN < MAX_A + 1 # dev: unsafe values A - assert _gamma > MIN_GAMMA - 1 and _gamma < MAX_GAMMA + 1 # dev: unsafe values gamma - assert _D > 10**17 - 1 and _D < 10**15 * 10**18 + 1 # dev: unsafe values D + assert _ANN > MIN_A - 1 and _ANN < MAX_A + 1, "unsafe values A" + assert _gamma > MIN_GAMMA - 1 and _gamma < MAX_GAMMA + 1, "unsafe values gamma" + assert _D > 10**17 - 1 and _D < 10**15 * 10**18 + 1, "unsafe values D" lim_mul: uint256 = 100 * 10**18 # 100.0 if _gamma > MAX_GAMMA_SMALL: lim_mul = unsafe_div(unsafe_mul(lim_mul, MAX_GAMMA_SMALL), _gamma) # smaller than 100.0 @@ -254,7 +254,7 @@ def get_y( # K0_i: int256 = (10**18 * N_COINS) * x_j / D K0_i: int256 = unsafe_div(10**18 * N_COINS * x_j, D) - assert (K0_i >= unsafe_div(10**36, lim_mul_signed)) and (K0_i <= lim_mul_signed) # dev: unsafe values x[i] + assert (K0_i >= unsafe_div(10**36, lim_mul_signed)) and (K0_i <= lim_mul_signed), "unsafe values x[i]" ann_gamma2: int256 = ANN * gamma2 @@ -366,7 +366,7 @@ def get_y( y_out: uint256[2] = [convert(unsafe_div(unsafe_div(unsafe_mul(unsafe_div(D**2, x_j), root), 4), 10**18), uint256), convert(root, uint256)] frac: uint256 = unsafe_div(y_out[0] * 10**18, _D) - assert (frac >= unsafe_div(10**36 / N_COINS, lim_mul)) and (frac <= unsafe_div(lim_mul, N_COINS)) # dev: unsafe value for y + assert (frac >= unsafe_div(10**36 / N_COINS, lim_mul)) and (frac <= unsafe_div(lim_mul, N_COINS)), "unsafe value for y" return y_out @@ -381,16 +381,16 @@ def newton_D(ANN: uint256, gamma: uint256, x_unsorted: uint256[N_COINS], K0_prev """ # Safety checks - assert ANN > MIN_A - 1 and ANN < MAX_A + 1 # dev: unsafe values A - assert gamma > MIN_GAMMA - 1 and gamma < MAX_GAMMA + 1 # dev: unsafe values gamma + assert ANN > MIN_A - 1 and ANN < MAX_A + 1, "unsafe values A" + assert gamma > MIN_GAMMA - 1 and gamma < MAX_GAMMA + 1, "unsafe values gamma" # Initial value of invariant D is that for constant-product invariant x: uint256[N_COINS] = x_unsorted if x[0] < x[1]: x = [x_unsorted[1], x_unsorted[0]] - assert x[0] > 10**9 - 1 and x[0] < 10**15 * 10**18 + 1 # dev: unsafe values x[0] - assert unsafe_div(x[1] * 10**18, x[0]) > 10**14 - 1 # dev: unsafe values x[i] (input) + assert x[0] > 10**9 - 1 and x[0] < 10**15 * 10**18 + 1, "unsafe values x[0]" + assert unsafe_div(x[1] * 10**18, x[0]) > 10**14 - 1, "unsafe values x[i] (input)" S: uint256 = unsafe_add(x[0], x[1]) # can unsafe add here because we checked x[0] bounds @@ -408,7 +408,7 @@ def newton_D(ANN: uint256, gamma: uint256, x_unsorted: uint256[N_COINS], K0_prev for i in range(255): D_prev: uint256 = D - assert D > 0 + assert D > 0, "D==0" # Unsafe division by D and D_prev is now safe # K0: uint256 = 10**18 @@ -454,7 +454,7 @@ def newton_D(ANN: uint256, gamma: uint256, x_unsorted: uint256[N_COINS], K0_prev for _x in x: frac: uint256 = _x * 10**18 / D - assert (frac > 10**16 / N_COINS - 1) and (frac < 10**20 / N_COINS + 1) # dev: unsafe values x[i] + assert (frac > 10**16 / N_COINS - 1) and (frac < 10**20 / N_COINS + 1), "unsafe values x[i]" return D raise "Did not converge" @@ -473,7 +473,7 @@ def get_p( @param _A_gamma Amplification coefficient and gamma. """ - assert _D > 10**17 - 1 and _D < 10**15 * 10**18 + 1 # dev: unsafe D values + assert _D > 10**17 - 1 and _D < 10**15 * 10**18 + 1, "unsafe D values" # K0 = P * N**N / D**N. # K0 is dimensionless and has 10**36 precision: diff --git a/contracts/main/CurveCryptoViews2Optimized.vy b/contracts/main/CurveCryptoViews2Optimized.vy index 1a9feed..913b4db 100644 --- a/contracts/main/CurveCryptoViews2Optimized.vy +++ b/contracts/main/CurveCryptoViews2Optimized.vy @@ -311,8 +311,8 @@ def _calc_withdraw_one_coin( ) -> (uint256, uint256): token_supply: uint256 = Curve(swap).totalSupply() - assert token_amount <= token_supply # dev: token amount more than supply - assert i < N_COINS # dev: coin out of range + assert token_amount <= token_supply, "token amount more than supply" + assert i < N_COINS, "coin out of range" math: Math = Curve(swap).MATH() diff --git a/contracts/main/CurveTwocryptoFactory.vy b/contracts/main/CurveTwocryptoFactory.vy index 6c1f754..01980ad 100644 --- a/contracts/main/CurveTwocryptoFactory.vy +++ b/contracts/main/CurveTwocryptoFactory.vy @@ -101,8 +101,8 @@ def __init__(): @external def initialise_ownership(_fee_receiver: address, _admin: address): - assert msg.sender == self.deployer - assert self.admin == empty(address) + assert msg.sender == self.deployer, "unauthorized" + assert self.admin == empty(address), "already initialized" self.fee_receiver = _fee_receiver self.admin = _admin @@ -158,21 +158,21 @@ def deploy_pool( assert pool_implementation != empty(address), "Pool implementation not set" assert _math_implementation != empty(address), "Math implementation not set" - assert mid_fee < MAX_FEE-1 # mid_fee can be zero - assert out_fee >= mid_fee - assert out_fee < MAX_FEE-1 - assert fee_gamma < 10**18+1 - assert fee_gamma > 0 + assert mid_fee < MAX_FEE-1, "mid>max" # mid_fee can be zero + assert out_fee >= mid_fee, "outmax" + assert fee_gamma < 10**18+1, "fee_gamma>max" + assert fee_gamma > 0, "fee_gamma==0" - assert allowed_extra_profit < 10**18+1 + assert allowed_extra_profit < 10**18+1, "allowed_extra_profit>max" - assert adjustment_step < 10**18+1 - assert adjustment_step > 0 + assert adjustment_step < 10**18+1, "adjustment_step>max" + assert adjustment_step > 0, "adjustment_step==0" - assert ma_exp_time < 872542 # 7 * 24 * 60 * 60 / ln(2) - assert ma_exp_time > 86 # 60 / ln(2) + assert ma_exp_time < 872542, "ma_exp_time>max" # 7 * 24 * 60 * 60 / ln(2) + assert ma_exp_time > 86, "ma_exp_time 10**6 and initial_price < 10**30 # dev: initial price out of bound + assert initial_price > 10**6 and initial_price < 10**30, "initial price out of bound" assert _coins[0] != _coins[1], "Duplicate coins" diff --git a/contracts/main/CurveTwocryptoOptimized.vy b/contracts/main/CurveTwocryptoOptimized.vy index 8495060..4165bf1 100644 --- a/contracts/main/CurveTwocryptoOptimized.vy +++ b/contracts/main/CurveTwocryptoOptimized.vy @@ -234,11 +234,11 @@ def __init__( # --------------- Validate A and gamma parameters here and not in factory. gamma_A: uint256[2] = self._unpack_2(packed_gamma_A) # gamma is at idx 0. - assert gamma_A[0] > MIN_GAMMA-1 - assert gamma_A[0] < MAX_GAMMA+1 + assert gamma_A[0] > MIN_GAMMA-1, "gammaMAX" - assert gamma_A[1] > MIN_A-1 - assert gamma_A[1] < MAX_A+1 + assert gamma_A[1] > MIN_A-1, "AMAX" self.initial_A_gamma = packed_gamma_A self.future_A_gamma = packed_gamma_A @@ -312,7 +312,7 @@ def _transfer_in( # If we checked for received_amounts == dx, an extra transfer without a # call to exchange_received will break the method. dx: uint256 = coin_balance - self.balances[_coin_idx] - assert dx >= _dx # dev: user didn't give us coins + assert dx >= _dx, "user didn't give us coins" # Adjust balances self.balances[_coin_idx] += dx @@ -327,7 +327,7 @@ def _transfer_in( self, _dx, default_return_value=True - ) + ), "transferFrom failed" dx: uint256 = ERC20(coins[_coin_idx]).balanceOf(self) - coin_balance self.balances[_coin_idx] += dx @@ -353,7 +353,7 @@ def _transfer_out(_coin_idx: uint256, _amount: uint256, receiver: address): receiver, _amount, default_return_value=True - ) + ), "transfer failed" # -------------------------- AMM Main Functions ------------------------------ @@ -474,7 +474,7 @@ def add_liquidity( d_token_fee: uint256 = 0 old_D: uint256 = 0 - assert amounts[0] + amounts[1] > 0 # dev: no coins to add + assert amounts[0] + amounts[1] > 0, "no coins to add" # --------------------- Get prices, balances ----------------------------- @@ -529,7 +529,7 @@ def add_liquidity( else: d_token = self.get_xcp(D, price_scale) # <----- Making initial virtual price equal to 1. - assert d_token > 0 # dev: nothing minted + assert d_token > 0, "nothing minted" if old_D > 0: @@ -616,7 +616,7 @@ def remove_liquidity( for i in range(N_COINS): withdraw_amounts[i] = balances[i] * amount / total_supply - assert withdraw_amounts[i] >= min_amounts[i] + assert withdraw_amounts[i] >= min_amounts[i], "slippage" D: uint256 = self.D self.D = D - unsafe_div(D * amount, total_supply) # <----------- Reduce D @@ -749,8 +749,8 @@ def _exchange( min_dy: uint256, ) -> uint256[3]: - assert i != j # dev: coin index out of range - assert dx_received > 0 # dev: do not exchange 0 coins + assert i != j, "same coin" + assert dx_received > 0, "zero dx" A_gamma: uint256[2] = self._A_gamma() xp: uint256[N_COINS] = self.balances @@ -918,7 +918,7 @@ def tweak_price( # else the pool suffers a loss. if self.future_A_gamma_time < block.timestamp: # this usually reverts when withdrawing a very small amount of LP tokens - assert virtual_price > old_virtual_price # dev: virtual price decreased + assert virtual_price > old_virtual_price, "virtual price decreased" self.xcp_profit = xcp_profit @@ -1222,8 +1222,8 @@ def _calc_withdraw_one_coin( ) -> (uint256, uint256, uint256[N_COINS], uint256): token_supply: uint256 = self.totalSupply - assert token_amount <= token_supply # dev: token amount more than supply - assert i < N_COINS # dev: coin out of range + assert token_amount <= token_supply, "token amount more than supply" + assert i < N_COINS, "coin out of range" xx: uint256[N_COINS] = self.balances D0: uint256 = 0 @@ -1294,7 +1294,7 @@ def _approve(_owner: address, _spender: address, _value: uint256): @internal def _transfer(_from: address, _to: address, _value: uint256): - assert _to not in [self, empty(address)] + assert _to not in [self, empty(address)], "invalid receiver" self.balanceOf[_from] -= _value self.balanceOf[_to] += _value @@ -1388,8 +1388,8 @@ def permit( @param _s The second 32 bytes of the ECDSA signature. @return bool Success. """ - assert _owner != empty(address) # dev: invalid owner - assert block.timestamp <= _deadline # dev: permit expired + assert _owner != empty(address), "invalid owner" + assert block.timestamp <= _deadline, "permit expired" nonce: uint256 = self.nonces[_owner] digest: bytes32 = keccak256( @@ -1403,7 +1403,7 @@ def permit( ), ) ) - assert ecrecover(digest, _v, _r, _s) == _owner # dev: invalid signature + assert ecrecover(digest, _v, _r, _s) == _owner, "invalid signature" self.nonces[_owner] = unsafe_add(nonce, 1) # <-- Unsafe add is safe here. self._approve(_owner, _spender, _value) @@ -1776,26 +1776,26 @@ def ramp_A_gamma( @param future_gamma The future gamma value. @param future_time The timestamp at which the ramping will end. """ - assert msg.sender == factory.admin() # dev: only owner - assert block.timestamp > self.future_A_gamma_time # dev: ramp undergoing - assert future_time > block.timestamp + MIN_RAMP_TIME - 1 # dev: insufficient time + assert msg.sender == factory.admin(), "unauthorized ramp" + assert block.timestamp > self.future_A_gamma_time, "ramp ongoing" + assert future_time > block.timestamp + MIN_RAMP_TIME - 1, "ramp time MIN_A - 1 - assert future_A < MAX_A + 1 - assert future_gamma > MIN_GAMMA - 1 - assert future_gamma < MAX_GAMMA + 1 + assert future_A > MIN_A - 1, "Amax" + assert future_gamma > MIN_GAMMA - 1, "gammamax" ratio: uint256 = 10**18 * future_A / A_gamma[0] - assert ratio < 10**18 * MAX_A_CHANGE + 1 # dev: A change too high - assert ratio > 10**18 / MAX_A_CHANGE - 1 # dev: A change too low + assert ratio < 10**18 * MAX_A_CHANGE + 1, "A change too high" + assert ratio > 10**18 / MAX_A_CHANGE - 1, "A change too low" ratio = 10**18 * future_gamma / A_gamma[1] - assert ratio < 10**18 * MAX_A_CHANGE + 1 # dev: gamma change too high - assert ratio > 10**18 / MAX_A_CHANGE - 1 # dev: gamma change too low + assert ratio < 10**18 * MAX_A_CHANGE + 1, "gamma change too high" + assert ratio > 10**18 / MAX_A_CHANGE - 1, "gamma change too low" self.initial_A_gamma = initial_A_gamma self.initial_A_gamma_time = block.timestamp @@ -1821,7 +1821,7 @@ def stop_ramp_A_gamma(): @notice Stop Ramping A and gamma parameters immediately. @dev Only accessible by factory admin. """ - assert msg.sender == factory.admin() # dev: only owner + assert msg.sender == factory.admin(), "only owner" A_gamma: uint256[2] = self._A_gamma() current_A_gamma: uint256 = A_gamma[0] << 128 @@ -1856,7 +1856,7 @@ def apply_new_parameters( @param _new_adjustment_step The new adjustment step. @param _new_ma_time The new ma time. ma_time is time_in_seconds/ln(2). """ - assert msg.sender == factory.admin() # dev: only owner + assert msg.sender == factory.admin(), "only owner" # ----------------------------- Set fee params --------------------------- @@ -1867,16 +1867,16 @@ def apply_new_parameters( current_fee_params: uint256[3] = self._unpack_3(self.packed_fee_params) if new_out_fee < MAX_FEE + 1: - assert new_out_fee > MIN_FEE - 1 # dev: fee is out of range + assert new_out_fee > MIN_FEE - 1, "fee is out of range" else: new_out_fee = current_fee_params[1] if new_mid_fee > MAX_FEE: new_mid_fee = current_fee_params[0] - assert new_mid_fee <= new_out_fee # dev: mid-fee is too high + assert new_mid_fee <= new_out_fee, "mid-fee is too high" if new_fee_gamma < 10**18: - assert new_fee_gamma > 0 # dev: fee_gamma out of range [1 .. 10**18] + assert new_fee_gamma > 0, "fee_gamma out of range [1 .. 10**18]" else: new_fee_gamma = current_fee_params[2] @@ -1897,7 +1897,7 @@ def apply_new_parameters( new_adjustment_step = current_rebalancing_params[1] if new_ma_time < 872542: # <----- Calculated as: 7 * 24 * 60 * 60 / ln(2) - assert new_ma_time > 86 # dev: MA time should be longer than 60/ln(2) + assert new_ma_time > 86, "MA time should be longer than 60/ln(2)" else: new_ma_time = current_rebalancing_params[2]