Derivations

Deposit

Key Formulas

flFeeVol = flAmountVol * flRate

flFeeStable = getAmountsIn(flFeeVol)

flAmountVol = (depositAmountStable - flFeeStable) / volPrice

protocolFeeStable = (depositAmountStable - flFeeStable) * protocolFeeRate

flAmountVol = (w - (Maths.sqrt((w - (4 * t) * (z / w))) * Maths.sqrt(w))) / (2 * t) (definition of w, t, & z below)

We can figure out exactly how much of a given deposit amount will be used for fees and how much left over will be used to actually LP with. Or how much we need to deposit to result in a specific LP amount. Using linear equations, these define the system (fl is short for flashloan):

Whatever amount of volatile token we borrow in the flashloan, the fee has to be paid in the same token on top (a) flFeeVol = flAmountVol * flRate

The fee needs to be taken from what the user has (stables) and converted into volatile tokens, which incurs a swapping fee and slippage. We need to use the DEX's swapping logic specifically to account for slippage, so for UniswapV2 we use getAmountIn() (we can use getAmountIn instead of getAmountsIn since AutoHedge only uses the pair it's LPing to swap, and therefore only uses a single hop): (b) flFeeStable = getAmountsIn(flFeeVol)

The amount of vol tokens that's flashloaned is the same value of the stables that are left over (c) flAmountVol = (depositAmountStable - flFeeStable) / volPrice

The protocol fee is taken as AHLP tokens when they're minted, which are ultimately valued in terms of stables (d) protocolFeeStable = (depositAmountStable - flFeeStable) * protocolFeeRate

Sub (b) into (c):

(e) flAmountVol = (depositAmountStable - getAmountsIn(flFeeVol)) / volPrice

Sub (a) into (e):

(f) flAmountVol = (depositAmountStable - getAmountsIn(flAmountVol * flRate)) / volPrice

We need to isolate flAmountVol, but it's impossible in its current form, we need to expand getAmountIn. In UniswapV2:

amountIn = getAmountIn(amountOut) = ((reserveIn * amountOut * 1000) / ((reserveOut - amountOut) * 997)) + 1

In our context:

amountIn = flFeeStable

amountOut = flFeeVol

Therefore we can transform (f):

(g) flFeeStable = getAmountIn(flFeeVol) = ((reserveIn * flFeeVol * 1000) / ((reserveOut - flFeeVol) * 997)) + 1

Rearranging this gets pretty gnarly - for brevity, you can check it with Wolfram etc, the result is:

(h) flAmountVol = (w - (Maths.sqrt((w - (4 * t) * (z / w))) * Maths.sqrt(w))) / (2 * t)

Where (it's split up like this because as you can see, some terms are repeated, and it would be very unreadable written out in full):

t = ((reserveStable * FLASH_LOAN_FEE * 997)) / FLASH_LOAN_FEE_PRECISION

w = (amountStableInit * reserveVol * FLASH_LOAN_FEE * 997) / FLASH_LOAN_FEE_PRECISION + reserveStable * reserveVol * 997 + (reserveVol * reserveStable * 1000 * FLASH_LOAN_FEE) / FLASH_LOAN_FEE_PRECISION

z = amountStableInit * reserveVol * reserveVol * 997

I know it's not nice and neat, but hey, that's how linear equations are in real life, and it works without any rounding errors ;)

Withdraw

Rebalance