def gyro_fund_v1(
GyroFundV1,
admin,
balancer_token_router,
gyro_price_oracle_v1,
dummy_price_oracle,
tokens,
pools,
):
fund = admin.deploy(GyroFundV1)
fund.initializeOwner()
init_args = [
scale("0.1"), # portfolio_weight_epsilon
gyro_price_oracle_v1.address,
balancer_token_router.address,
scale("0.999993123563518195"), # memory param
]
fund.initialize(*init_args)
for token in tokens:
is_stable = token.symbol() != "WETH"
fund.addToken(token.address, dummy_price_oracle.address, is_stable)
for i, pool in enumerate(pools):
raw_weight = 100 / len(pools)
weight = math.ceil(raw_weight) if i == 0 else math.floor(raw_weight)
fund.addPool(pool.address, scale(weight, 16))
pool.approve(fund.address, 10**50)
return fund
def create_pool(admin, bfactory, BPool, tokens):
deploy_tx = bfactory.newBPool()
bpool = BPool.at(deploy_tx.events["LOG_NEW_POOL"]["pool"], owner=admin)
for token_info in tokens:
token = token_info["contract"]
token_price = PRICES.get(token.symbol(), 1)
raw_balance = token_info.get("balance", BPOOL_AMOUNT)
balance = scale(raw_balance // token_price, token.decimals())
token.approve(bpool.address, balance)
bpool.bind(token.address, balance, scale(token_info.get("weight", 5)))
bpool.setSwapFee(scale("0.0001"))
bpool.finalize()
return bpool
def test_basic_redeem(gyro_fund_v1, pools, admin):
assert gyro_fund_v1.balanceOf(admin.address) == 0
assert gyro_fund_v1.totalSupply() == 0
mint_amounts = [scale(10)] * len(pools)
tx_mint = gyro_fund_v1.mint(pools, mint_amounts, 0)
minted = tx_mint.events["Mint"]["amount"]
redeem_amounts = [scale(1)] * len(pools)
max_redeemed = minted // 8
tx_redeem = gyro_fund_v1.redeem(pools, redeem_amounts, max_redeemed)
assert len(tx_redeem.events) > 0
redeemed = tx_redeem.events["Redeem"]["amount"]
assert redeemed <= max_redeemed
assert gyro_fund_v1.balanceOf(admin.address) == minted - redeemed
def test_mint(gyrolib, gyro_fund_v1, dai, usdc, admin):
assert gyro_fund_v1.balanceOf(admin) == 0
assert gyro_fund_v1.totalSupply() == 0
dai_amount = scale(100)
usdc_amount = scale(100, 6)
dai_balance = dai.balanceOf(admin)
dai.approve(gyrolib.address, dai_amount)
usdc.approve(gyrolib.address, usdc_amount)
tx = gyrolib.mintFromUnderlyingTokens([dai.address, usdc.address],
[dai_amount, usdc_amount], 0)
new_dai_balance = dai.balanceOf(admin)
assert new_dai_balance == dai_balance - dai_amount
assert len(tx.events) > 0
minted = tx.events["Mint"]["amount"]
assert minted > 0
assert gyro_fund_v1.balanceOf(admin) == minted
def test_redeem(gyrolib, gyro_fund_v1, dai, usdc, admin):
dai_amount = scale(1000)
usdc_amount = scale(1000, 6)
dai.approve(gyrolib.address, dai_amount)
usdc.approve(gyrolib.address, usdc_amount)
mint_tx = gyrolib.mintFromUnderlyingTokens([dai.address, usdc.address],
[dai_amount, usdc_amount], 0)
minted = mint_tx.events["Mint"]["amount"]
dai_out = scale(2)
dai_balance = dai.balanceOf(admin)
max_out = dai_out # no slippage expected
gyro_fund_v1.approve(gyrolib, max_out)
redeem_tx = gyrolib.redeemToUnderlyingTokens([dai], [dai_out], max_out)
redeemed = redeem_tx.events["Redeem"]["amount"]
new_dai_balance = dai.balanceOf(admin)
assert new_dai_balance == dai_balance + dai_out
assert gyro_fund_v1.balanceOf(admin) == minted - redeemed
def test_mul_pow(math_testing):
for decimal in range(2, 19):
value = scale(180, decimal)
base = scale("8.5", decimal)
exponent = scale("0.6", decimal)
getcontext().rounding = ROUND_FLOOR
expected = float(round(180 * Decimal("8.5")**Decimal("0.6"), decimal))
result = math_testing.mulPow(value, base, exponent,
decimal) / 10**decimal
assert result == pytest.approx(expected)
# should compute k correctly
k = scale(1, 18)
balance = scale(50_000, 18)
weight = scale(5, 17)
result = float(math_testing.mulPow(k, balance, weight, 18))
expected = float(scale(50_000**Decimal("0.5")))
assert result == pytest.approx(expected, rel=0.0001)
expected = float(scale(50_000, 18))
result = float(math_testing.mulPow(result, balance, weight, 18))
assert result == pytest.approx(expected, rel=0.0001)
def test_basic_mint(gyro_fund_v1, pools, admin):
assert gyro_fund_v1.balanceOf(admin.address) == 0
assert gyro_fund_v1.totalSupply() == 0
amounts = [scale(10)] * len(pools)
tx = gyro_fund_v1.mint(pools, amounts, 0)
assert len(tx.events) > 0
mint_event = tx.events["Mint"]
assert mint_event["minter"] == admin.address
minted = mint_event["amount"]
assert minted > 0
assert gyro_fund_v1.balanceOf(admin.address) == minted
assert gyro_fund_v1.totalSupply() == minted
def create_token(admin, TokenFaucet, name, symbol, decimals, mint_amount):
token = admin.deploy(TokenFaucet, name, symbol, decimals,
scale(mint_amount))
token.initializeOwner()
token.mintAsOwner(admin, scale(mint_amount * 1_000))
return token