def main():
admin = accounts[0]
alice = accounts[1]
bob = accounts[2]
renbtc = interface.IERC20Ex('0xeb4c2781e4eba804ce9a9803c67d0893436bb27d')
wbtc = interface.IERC20Ex('0x2260fac5e5542a773aa44fbcfedf7c193bc2c599')
eurs = interface.IERC20Ex('0xdB25f211AB05b1c97D595516F45794528a807ad8')
seur = interface.IERC20Ex('0xD71eCFF9342A5Ced620049e616c5035F1dB98620')
lp = interface.IERC20Ex('0x49849C98ae39Fff122806C06791Fa73784FB3675')
pool = interface.ICurvePool('0x93054188d876f558f4a66B2EF1d97d16eDf0895B')
lp_eurs = interface.IERC20Ex('0x194eBd173F6cDacE046C53eACcE9B953F28411d1')
pool_eurs = interface.ICurvePool(
'0x0Ce6a5fF5217e38315f87032CF90686C96627CAA')
registry = interface.ICurveRegistry(
'0x7d86446ddb609ed0f5f8684acf30380a356b2b4c')
crrenbtc = MockCErc20.deploy(renbtc, {'from': admin})
crwbtc = MockCErc20.deploy(wbtc, {'from': admin})
creurs = MockCErc20.deploy(eurs, {'from': admin})
crseur = MockCErc20.deploy(seur, {'from': admin})
gauge = accounts.at('0xB1F2cdeC61db658F091671F5f199635aEF202CAC',
force=True)
wgauge = WLiquidityGauge.deploy(
registry, '0xD533a949740bb3306d119CC777fa900bA034cd52',
{'from': admin})
crv = interface.IERC20Ex(wgauge.crv())
werc20 = WERC20.deploy({'from': admin})
simple_oracle = SimpleOracle.deploy({'from': admin})
simple_oracle.setETHPx(
[renbtc, wbtc, eurs, seur],
[2**112 * 30, 2**112 * 30, 2**112 // 700, 2**112 // 700])
curve_oracle = CurveOracle.deploy(simple_oracle, registry, {'from': admin})
curve_oracle.registerPool(lp) # update pool info
curve_oracle.registerPool(lp_eurs) # update pool info
core_oracle = CoreOracle.deploy({'from': admin})
oracle = ProxyOracle.deploy(core_oracle, {'from': admin})
oracle.setWhitelistERC1155([werc20, wgauge], True, {'from': admin})
core_oracle.setRoute(
[renbtc, wbtc, lp, eurs, seur, lp_eurs],
[
simple_oracle, simple_oracle, curve_oracle, simple_oracle,
simple_oracle, curve_oracle
],
{'from': admin},
)
oracle.setOracles(
[renbtc, wbtc, lp, eurs, seur, lp_eurs],
[
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
],
{'from': admin},
)
# initialize
homora = HomoraBank.deploy({'from': admin})
homora.initialize(oracle, 1000, {'from': admin}) # 10% fee
setup_bank_hack(homora)
# add bank
homora.addBank(renbtc, crrenbtc, {'from': admin})
homora.addBank(wbtc, crwbtc, {'from': admin})
homora.addBank(eurs, creurs, {'from': admin})
homora.addBank(seur, crseur, {'from': admin})
# setup initial funds to alice
mint_tokens(renbtc, alice)
mint_tokens(wbtc, alice)
mint_tokens(eurs, alice)
mint_tokens(seur, alice)
mint_tokens(wbtc, crwbtc)
# check alice's funds
print(f'Alice renbtc balance {renbtc.balanceOf(alice)}')
print(f'Alice wbtc balance {wbtc.balanceOf(alice)}')
print(f'Alice eurs balance {eurs.balanceOf(alice)}')
print(f'Alice seur balance {seur.balanceOf(alice)}')
# steal some LP from the staking pool
mint_tokens(lp, alice)
mint_tokens(lp, bob)
mint_tokens(lp_eurs, alice)
# set approval
renbtc.approve(homora, 2**256 - 1, {'from': alice})
renbtc.approve(crrenbtc, 2**256 - 1, {'from': alice})
wbtc.approve(homora, 2**256 - 1, {'from': alice})
wbtc.approve(crwbtc, 2**256 - 1, {'from': alice})
eurs.approve(homora, 2**256 - 1, {'from': alice})
eurs.approve(creurs, 2**256 - 1, {'from': alice})
seur.approve(homora, 2**256 - 1, {'from': alice})
seur.approve(crseur, 2**256 - 1, {'from': alice})
lp.approve(homora, 2**256 - 1, {'from': alice})
lp.approve(gauge, 2**256 - 1, {'from': bob})
lp_eurs.approve(homora, 2**256 - 1, {'from': alice})
curve_spell = CurveSpellV1.deploy(
homora, werc20, '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', wgauge,
{'from': admin})
# register gauge
wgauge.registerGauge(9, 0)
wgauge.registerGauge(23, 0)
# set up pools
curve_spell.getPool(lp)
curve_spell.getPool(lp_eurs)
# first time call to reduce gas
curve_spell.ensureApproveN(lp, 2, {'from': admin})
curve_spell.ensureApproveN(lp_eurs, 2, {'from': admin})
# whitelist spell in bank
homora.setWhitelistSpells([curve_spell], [True], {'from': admin})
# whitelist lp in spell
curve_spell.setWhitelistLPTokens([lp, lp_eurs], [True, True],
{'from': admin})
#####################################################################################
print(
'========================================================================='
)
print('Case 1.')
prevABal = renbtc.balanceOf(alice)
prevBBal = wbtc.balanceOf(alice)
prevLPBal = lp.balanceOf(alice)
prevLPBal_bank = lp.balanceOf(homora)
prevLPBal_gauge = lp.balanceOf(gauge)
renbtc_amt = 1 * 10**7
wbtc_amt = 1 * 10**7
lp_amt = 10**13
borrow_renbtc_amt = 0
borrow_wbtc_amt = 0
borrow_lp_amt = 0
minLPMint = 0
pid = 9
gid = 0
tx = homora.execute(
0,
curve_spell,
curve_spell.addLiquidity2.encode_input(
lp, # LP
[renbtc_amt, wbtc_amt], # supply tokens
lp_amt, # supply LP
[borrow_renbtc_amt, borrow_wbtc_amt], # borrow tokens
borrow_lp_amt, # borrow LP
minLPMint, # min LP mint
pid,
gid),
{'from': alice})
curABal = renbtc.balanceOf(alice)
curBBal = wbtc.balanceOf(alice)
curLPBal = lp.balanceOf(alice)
curLPBal_bank = lp.balanceOf(homora)
curLPBal_gauge = lp.balanceOf(gauge)
print('spell lp balance', lp.balanceOf(curve_spell))
print('Alice delta A balance', curABal - prevABal)
print('Alice delta B balance', curBBal - prevBBal)
print('add liquidity gas', tx.gas_used)
print('bank lp balance', curLPBal_bank)
_, _, _, renbtcDebt, renbtcDebtShare = homora.getBankInfo(renbtc)
_, _, _, wbtcDebt, wbtcDebtShare = homora.getBankInfo(wbtc)
print('bank renbtc totalDebt', renbtcDebt)
print('bank renbtc totalShare', renbtcDebtShare)
print('bank wbtc totalDebt', wbtcDebt)
print('bank wbtc totalShare', wbtcDebtShare)
print('bank prev LP balance', prevLPBal_bank)
print('bank cur LP balance', curLPBal_bank)
print('gauge prev LP balance', prevLPBal_gauge)
print('gauge cur LP balance', curLPBal_gauge)
# alice
assert almostEqual(curABal - prevABal, -renbtc_amt), 'incorrect renbtc amt'
assert almostEqual(curBBal - prevBBal, -wbtc_amt), 'incorrect wbtc amt'
assert almostEqual(curLPBal - prevLPBal, -lp_amt), 'incorrect LP amt'
# spell
assert renbtc.balanceOf(curve_spell) == 0, 'non-zero spell renbtc balance'
assert wbtc.balanceOf(curve_spell) == 0, 'non-zero spell wbtc balance'
assert lp.balanceOf(curve_spell) == 0, 'non-zero spell LP balance'
# debt
assert renbtcDebt == borrow_renbtc_amt
assert wbtcDebt == borrow_wbtc_amt
_, _, collId, collSize = homora.getPositionInfo(1)
print('collSize', collSize)
# staking directly
prevCrv = crv.balanceOf(bob)
print('bob lp balance', interface.IERC20Ex(lp).balanceOf(bob))
pid, gid = 9, 0
gauge, _ = wgauge.gauges(pid, gid)
print('gauge address', gauge)
tx = interface.ILiquidityGauge(gauge).deposit(collSize, {'from': bob})
chain.sleep(20000)
prevAliceCrvBalance = crv.balanceOf(alice)
print('Alice crv balance', prevAliceCrvBalance)
# #####################################################################################
print(
'========================================================================='
)
print('Case 2. add liquidity (failed tx desired)')
eurs_amt = 1 * 10**3
seur_amt = 1 * 10**3
lp_amt = 0
borrow_eurs_amt = 0
borrow_seur_amt = 0
borrow_lp_amt = 0
minLPMint = 0
pid = 9
gid = 0
try:
tx = homora.execute(
1,
curve_spell,
curve_spell.addLiquidity2.encode_input(
lp_eurs, # lp_eurs
[eurs_amt, seur_amt], # supply tokens
lp_amt, # supply LP
[borrow_eurs_amt, borrow_seur_amt], # borrow tokens
borrow_lp_amt, # borrow LP
minLPMint, # min LP mint
pid,
gid),
{'from': alice})
assert False, 'tx should fail'
except VirtualMachineError:
pass
# #####################################################################################
print(
'========================================================================='
)
print('Case 3. add liquidity (failed tx desired)')
eurs_amt = 1 * 10**3
seur_amt = 1 * 10**3
lp_amt = 0
borrow_eurs_amt = 0
borrow_seur_amt = 0
borrow_lp_amt = 0
minLPMint = 0
pid = 23
gid = 0
try:
tx = homora.execute(
1,
curve_spell,
curve_spell.addLiquidity2.encode_input(
lp_eurs, # lp_eurs
[eurs_amt, seur_amt], # supply tokens
lp_amt, # supply LP
[borrow_eurs_amt, borrow_seur_amt], # borrow tokens
borrow_lp_amt, # borrow LP
minLPMint, # min LP mint
pid,
gid),
{'from': alice})
assert False, 'tx should fail'
except VirtualMachineError:
pass
# #####################################################################################
print(
'========================================================================='
)
print('Case 4. remove liquidity (failed tx desired)')
lp_take_amt = 2**256 - 1 # max
lp_want = 1 * 10**17
eurs_repay = 2**256 - 1 # max
seur_repay = 2**256 - 1 # max
lp_repay = 0
try:
tx = homora.execute(
1,
curve_spell,
curve_spell.removeLiquidity2.encode_input(
lp_eurs, # lp_eurs token
lp_take_amt, # LP amount to take out
lp_want, # LP amount to withdraw to wallet
[eurs_repay, seur_repay], # repay amounts
lp_repay, # repay LP amount
[0, 0] # min amounts
),
{'from': alice})
assert False, 'tx should revert'
except VirtualMachineError:
pass
# #####################################################################################
print(
'========================================================================='
)
print('Case 5. remove liquidity')
# remove liquidity from the same position
prevABal = renbtc.balanceOf(alice)
prevBBal = wbtc.balanceOf(alice)
prevLPBal = lp.balanceOf(alice)
prevLPBal_bank = lp.balanceOf(homora)
prevLPBal_gauge = lp.balanceOf(gauge)
_, _, _, collSize = homora.getPositionInfo(1)
lp_take_amt = 2**256 - 1 # max
lp_want = 1 * 10**12
renbtc_repay = 2**256 - 1 # max
wbtc_repay = 2**256 - 1 # max
lp_repay = 0
tx = homora.execute(
1,
curve_spell,
curve_spell.removeLiquidity2.encode_input(
lp, # LP token
lp_take_amt, # LP amount to take out
lp_want, # LP amount to withdraw to wallet
[renbtc_repay, wbtc_repay], # repay amounts
lp_repay, # repay LP amount
[0, 0] # min amounts
),
{'from': alice})
curABal = renbtc.balanceOf(alice)
curBBal = wbtc.balanceOf(alice)
curLPBal = lp.balanceOf(alice)
curLPBal_bank = lp.balanceOf(homora)
curLPBal_gauge = lp.balanceOf(gauge)
print('spell lp balance', lp.balanceOf(curve_spell))
print('spell renbtc balance', renbtc.balanceOf(curve_spell))
print('spell wbtc balance', wbtc.balanceOf(curve_spell))
print('Alice delta A balance', curABal - prevABal)
print('Alice delta B balance', curBBal - prevBBal)
print('Alice delta LP balance', curLPBal - prevLPBal)
print('remove liquidity gas', tx.gas_used)
print('bank delta lp balance', curLPBal_bank - prevLPBal_bank)
print('bank total lp balance', curLPBal_bank)
_, _, _, renbtcDebt, renbtcDebtShare = homora.getBankInfo(renbtc)
_, _, _, wbtcDebt, wbtcDebtShare = homora.getBankInfo(wbtc)
print('bank renbtc totalDebt', renbtcDebt)
print('bank renbtc totalDebt', renbtcDebt)
print('bank wbtc totalShare', wbtcDebtShare)
print('bank wbtc totalShare', wbtcDebtShare)
print('LP want', lp_want)
print('bank delta LP amount', curLPBal_bank - prevLPBal_bank)
print('LP take amount', lp_take_amt)
print('prev gauge LP balance', prevLPBal_gauge)
print('cur gauge LP balance', curLPBal_gauge)
print('coll size', collSize)
# alice
assert almostEqual(curLPBal - prevLPBal, lp_want), 'incorrect LP amt'
# gauge
assert almostEqual(curLPBal_gauge - prevLPBal_gauge,
-collSize), 'incorrect gauge LP amt'
# spell
assert renbtc.balanceOf(curve_spell) == 0, 'non-zero spell renbtc balance'
assert wbtc.balanceOf(curve_spell) == 0, 'non-zero spell wbtc balance'
assert lp.balanceOf(curve_spell) == 0, 'non-zero spell LP balance'
# debt
assert wbtcDebt == 0, 'wbtcDebt should be 0'
assert renbtcDebt == 0, 'renbtcDebt should be 0'
curAliceCrvBalance = crv.balanceOf(alice)
print('Alice crv balance', curAliceCrvBalance)
receivedCrv = curAliceCrvBalance - prevAliceCrvBalance
print('received crv', receivedCrv)
# check with staking directly
minter = interface.ILiquidityGaugeMinter(
interface.ILiquidityGauge(gauge).minter())
print('minter', minter)
tx = minter.mint(gauge, {'from': bob})
print('tx status', tx.status)
tx = interface.ILiquidityGauge(gauge).withdraw(collSize, {'from': bob})
receivedCrvFromGauge = crv.balanceOf(bob) - prevCrv
print('receivedCrvFromGauge', receivedCrvFromGauge)
assert almostEqual(receivedCrv, receivedCrvFromGauge)
return tx
def main():
admin = accounts[0]
alice = accounts[1]
dai = interface.IERC20Ex('0x6B175474E89094C44Da98b954EedeAC495271d0F')
usdc = interface.IERC20Ex('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48')
usdt = interface.IERC20Ex('0xdAC17F958D2ee523a2206206994597C13D831ec7')
lp = interface.IERC20Ex('0x6c3f90f043a72fa612cbac8115ee7e52bde6e490')
pool = interface.ICurvePool('0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7')
registry = interface.ICurveRegistry(
'0x7d86446ddb609ed0f5f8684acf30380a356b2b4c')
crdai = interface.ICErc20('0x92B767185fB3B04F881e3aC8e5B0662a027A1D9f')
crusdc = interface.ICErc20('0x44fbebd2f576670a6c33f6fc0b00aa8c5753b322')
crusdt = interface.ICErc20('0x797AAB1ce7c01eB727ab980762bA88e7133d2157')
werc20 = WERC20.deploy({'from': admin})
simple_oracle = SimpleOracle.deploy({'from': admin})
simple_oracle.setETHPx([dai, usdt, usdc], [
9060553589188986552095106856227,
9002288773315920458132820329673073223442669,
9011535487953795006625883219171279625142296
])
curve_oracle = CurveOracle.deploy(simple_oracle, registry, {'from': admin})
curve_oracle.registerPool(lp) # update pool info
oracle = ProxyOracle.deploy({'from': admin})
oracle.setWhitelistERC1155([werc20], True, {'from': admin})
oracle.setOracles(
[
'0x6B175474E89094C44Da98b954EedeAC495271d0F', # DAI
'0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', # USDC
'0xdAC17F958D2ee523a2206206994597C13D831ec7', # USDT
'0x6c3f90f043a72fa612cbac8115ee7e52bde6e490', # lp
],
[
[simple_oracle, 10000, 10000, 10000],
[simple_oracle, 10000, 10000, 10000],
[simple_oracle, 10000, 10000, 10000],
[curve_oracle, 10000, 10000, 10000],
],
{'from': admin},
)
#####################################################################################
print(
'========================================================================='
)
print('Case 1.')
print('pool virtual price', pool.get_virtual_price())
lp_price = curve_oracle.getETHPx(lp)
dai_price = simple_oracle.getETHPx(dai)
usdt_price = simple_oracle.getETHPx(usdt)
usdc_price = simple_oracle.getETHPx(usdc)
print('lp price', lp_price)
print('dai price', dai_price)
print('usdt price', usdt_price)
print('usdc price', usdc_price)
# min price is from USDT
assert almostEqual(
9002288773315920458132820329673073223442669 *
pool.get_virtual_price() * 10**6 // 10**18 // 10**18, lp_price)
def main():
admin = accounts[0]
alice = accounts[1]
bob = accounts[2]
dai = interface.IERC20Ex('0x6B175474E89094C44Da98b954EedeAC495271d0F')
usdc = interface.IERC20Ex('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48')
usdt = interface.IERC20Ex('0xdAC17F958D2ee523a2206206994597C13D831ec7')
susd = interface.IERC20Ex('0x57ab1ec28d129707052df4df418d58a2d46d5f51')
ydai = interface.IERC20Ex('0xC2cB1040220768554cf699b0d863A3cd4324ce32')
yusdc = interface.IERC20Ex('0x26EA744E5B887E5205727f55dFBE8685e3b21951')
yusdt = interface.IERC20Ex('0xE6354ed5bC4b393a5Aad09f21c46E101e692d447')
ybusd = interface.IERC20Ex('0x04bC0Ab673d88aE9dbC9DA2380cB6B79C4BCa9aE')
lp = interface.IERC20Ex('0xC25a3A3b969415c80451098fa907EC722572917F')
pool = interface.ICurvePool('0xA5407eAE9Ba41422680e2e00537571bcC53efBfD')
lp_busd = interface.IERC20Ex('0x3B3Ac5386837Dc563660FB6a0937DFAa5924333B')
pool_busd = interface.ICurvePool(
'0x79a8C46DeA5aDa233ABaFFD40F3A0A2B1e5A4F27')
registry = interface.ICurveRegistry(
'0x7d86446ddb609ed0f5f8684acf30380a356b2b4c')
crdai = interface.ICErc20('0x92B767185fB3B04F881e3aC8e5B0662a027A1D9f')
crusdc = interface.ICErc20('0x44fbebd2f576670a6c33f6fc0b00aa8c5753b322')
crusdt = interface.ICErc20('0x797AAB1ce7c01eB727ab980762bA88e7133d2157')
crsusd = MockCErc20.deploy(susd, {'from': admin})
crydai = MockCErc20.deploy(ydai, {'from': admin})
cryusdc = MockCErc20.deploy(yusdc, {'from': admin})
cryusdt = MockCErc20.deploy(yusdt, {'from': admin})
crybusd = MockCErc20.deploy(ybusd, {'from': admin})
gauge = accounts.at('0xA90996896660DEcC6E997655E065b23788857849',
force=True)
wgauge = WLiquidityGauge.deploy(
registry, '0xD533a949740bb3306d119CC777fa900bA034cd52',
{'from': admin})
crv = interface.IERC20Ex(wgauge.crv())
werc20 = WERC20.deploy({'from': admin})
simple_oracle = SimpleOracle.deploy({'from': admin})
simple_oracle.setETHPx(
[dai, usdt, usdc, susd, ydai, yusdc, yusdt, ybusd], [
2**112 // 700, 2**112 * 10**12 // 700, 2**112 * 10**12 // 700,
2**112 // 700, 2**112 // 700, 2**112 * 10**12 // 700,
2**112 * 10**12 // 700, 2**112 // 700
])
curve_oracle = CurveOracle.deploy(simple_oracle, registry, {'from': admin})
curve_oracle.registerPool(lp) # update pool info
curve_oracle.registerPool(lp_busd) # update pool info
core_oracle = CoreOracle.deploy({'from': admin})
oracle = ProxyOracle.deploy(core_oracle, {'from': admin})
oracle.setWhitelistERC1155([werc20, wgauge], True, {'from': admin})
core_oracle.setRoute(
[
dai,
usdc,
usdt,
susd,
lp,
ydai,
yusdc,
yusdt,
ybusd,
lp_busd,
],
[
simple_oracle, simple_oracle, simple_oracle, simple_oracle,
curve_oracle, simple_oracle, simple_oracle, simple_oracle,
simple_oracle, curve_oracle
],
{'from': admin},
)
oracle.setOracles(
[dai, usdc, usdt, susd, lp, ydai, yusdc, yusdt, ybusd, lp_busd],
[
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
],
{'from': admin},
)
# initialize
homora = HomoraBank.deploy({'from': admin})
print('donator ether', accounts[5].balance())
homora.initialize(oracle, 1000, {'from': admin}) # 10% fee
setup_bank_hack(homora)
# add bank
homora.addBank(dai, crdai, {'from': admin})
homora.addBank(usdc, crusdc, {'from': admin})
homora.addBank(usdt, crusdt, {'from': admin})
homora.addBank(susd, crsusd, {'from': admin})
homora.addBank(ydai, crydai, {'from': admin})
homora.addBank(yusdc, cryusdc, {'from': admin})
homora.addBank(yusdt, cryusdt, {'from': admin})
homora.addBank(ybusd, crybusd, {'from': admin})
# setup initial funds to alice
mint_tokens(
dai,
alice,
)
mint_tokens(usdc, alice)
mint_tokens(usdt, alice)
mint_tokens(susd, alice)
mint_tokens(ydai, alice)
mint_tokens(yusdc, alice)
mint_tokens(yusdt, alice)
mint_tokens(ybusd, alice)
# check alice's funds
print(f'Alice dai balance {dai.balanceOf(alice)}')
print(f'Alice usdc balance {usdc.balanceOf(alice)}')
print(f'Alice usdt balance {usdt.balanceOf(alice)}')
print(f'Alice susd balance {susd.balanceOf(alice)}')
print(f'Alice ydai balance {ydai.balanceOf(alice)}')
print(f'Alice yusdc balance {yusdc.balanceOf(alice)}')
print(f'Alice yusdt balance {yusdt.balanceOf(alice)}')
print(f'Alice ybusd balance {ybusd.balanceOf(alice)}')
# steal some LP from the staking pool
mint_tokens(lp, alice)
mint_tokens(lp, bob)
mint_tokens(lp_busd, alice)
# set approval
dai.approve(homora, 2**256 - 1, {'from': alice})
dai.approve(crdai, 2**256 - 1, {'from': alice})
usdc.approve(homora, 2**256 - 1, {'from': alice})
usdc.approve(crusdc, 2**256 - 1, {'from': alice})
usdt.approve(homora, 2**256 - 1, {'from': alice})
usdt.approve(crusdt, 2**256 - 1, {'from': alice})
susd.approve(homora, 2**256 - 1, {'from': alice})
susd.approve(crsusd, 2**256 - 1, {'from': alice})
ydai.approve(homora, 2**256 - 1, {'from': alice})
ydai.approve(crydai, 2**256 - 1, {'from': alice})
yusdc.approve(homora, 2**256 - 1, {'from': alice})
yusdc.approve(cryusdc, 2**256 - 1, {'from': alice})
yusdt.approve(homora, 2**256 - 1, {'from': alice})
yusdt.approve(cryusdt, 2**256 - 1, {'from': alice})
ybusd.approve(homora, 2**256 - 1, {'from': alice})
ybusd.approve(crybusd, 2**256 - 1, {'from': alice})
lp.approve(homora, 2**256 - 1, {'from': alice})
lp.approve(gauge, 2**256 - 1, {'from': bob})
lp_busd.approve(homora, 2**256 - 1, {'from': alice})
curve_spell = CurveSpellV1.deploy(
homora, werc20, '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', wgauge,
{'from': admin})
# register gauge
wgauge.registerGauge(12, 0)
wgauge.registerGauge(1, 0)
# set up pools
curve_spell.getPool(lp)
curve_spell.getPool(lp_busd)
# first time call to reduce gas
curve_spell.ensureApproveN(lp, 4, {'from': admin})
curve_spell.ensureApproveN(lp_busd, 4, {'from': admin})
# whitelist spell in bank
homora.setWhitelistSpells([curve_spell], [True], {'from': admin})
# whitelist token in bank
homora.setWhitelistTokens([dai, usdt, usdc, susd],
[True, True, True, True], {'from': admin})
# whitelist lp in spell
curve_spell.setWhitelistLPTokens([lp], [True], {'from': admin})
#####################################################################################
print(
'========================================================================='
)
print('Case 1.')
prevABal = dai.balanceOf(alice)
prevBBal = usdc.balanceOf(alice)
prevCBal = usdt.balanceOf(alice)
prevDBal = susd.balanceOf(alice)
prevLPBal = lp.balanceOf(alice)
prevLPBal_bank = lp.balanceOf(homora)
prevLPBal_gauge = lp.balanceOf(gauge)
dai_amt = 200 * 10**18
usdc_amt = 1000 * 10**6
usdt_amt = 1000 * 10**6
susd_amt = 1000 * 10**18
lp_amt = 0
borrow_dai_amt = 10 * 10**18
borrow_usdc_amt = 10**6
borrow_usdt_amt = 0
borrow_susd_amt = 0
borrow_lp_amt = 0
minLPMint = 0
pid = 12
gid = 0
tx = homora.execute(
0,
curve_spell,
curve_spell.addLiquidity4.encode_input(
lp, # LP
[dai_amt, usdc_amt, usdt_amt, susd_amt], # supply tokens
lp_amt, # supply LP
[
borrow_dai_amt, borrow_usdc_amt, borrow_usdt_amt,
borrow_susd_amt
], # borrow tokens
borrow_lp_amt, # borrow LP
minLPMint, # min LP mint
pid,
gid),
{'from': alice})
curABal = dai.balanceOf(alice)
curBBal = usdc.balanceOf(alice)
curCBal = usdt.balanceOf(alice)
curDBal = susd.balanceOf(alice)
curLPBal = lp.balanceOf(alice)
curLPBal_bank = lp.balanceOf(homora)
curLPBal_gauge = lp.balanceOf(gauge)
print('spell lp balance', lp.balanceOf(curve_spell))
print('Alice delta A balance', curABal - prevABal)
print('Alice delta B balance', curBBal - prevBBal)
print('Alice delta C balance', curCBal - prevCBal)
print('add liquidity gas', tx.gas_used)
print('bank lp balance', curLPBal_bank)
_, _, _, daiDebt, daiDebtShare = homora.getBankInfo(dai)
_, _, _, usdcDebt, usdcDebtShare = homora.getBankInfo(usdc)
_, _, _, usdtDebt, usdtDebtShare = homora.getBankInfo(usdt)
_, _, _, susdDebt, susdDebtShare = homora.getBankInfo(susd)
print('bank dai totalDebt', daiDebt)
print('bank dai totalShare', daiDebtShare)
print('bank usdt totalDebt', usdtDebt)
print('bank usdt totalShare', usdtDebtShare)
print('bank usdc totalDebt', usdcDebt)
print('bank usdc totalShare', usdcDebtShare)
print('bank susd totalDebt', susdDebt)
print('bank susd totalShare', susdDebtShare)
print('bank prev LP balance', prevLPBal_bank)
print('bank cur LP balance', curLPBal_bank)
print('gauge prev LP balance', prevLPBal_gauge)
print('gauge cur LP balance', curLPBal_gauge)
# alice
assert almostEqual(curABal - prevABal, -dai_amt), 'incorrect DAI amt'
assert almostEqual(curBBal - prevBBal, -usdc_amt), 'incorrect USDC amt'
assert almostEqual(curCBal - prevCBal, -usdt_amt), 'incorrect USDT amt'
assert almostEqual(curDBal - prevDBal, -susd_amt), 'incorrect SUSD amt'
assert almostEqual(curLPBal - prevLPBal, -lp_amt), 'incorrect LP amt'
# spell
assert dai.balanceOf(curve_spell) == 0, 'non-zero spell DAI balance'
assert usdc.balanceOf(curve_spell) == 0, 'non-zero spell USDC balance'
assert usdt.balanceOf(curve_spell) == 0, 'non-zero spell USDT balance'
assert susd.balanceOf(curve_spell) == 0, 'non-zero spell SUSD balance'
assert lp.balanceOf(curve_spell) == 0, 'non-zero spell LP balance'
# debt
assert daiDebt == borrow_dai_amt
assert usdcDebt == borrow_usdc_amt
assert usdtDebt == borrow_usdt_amt
assert susdDebt == borrow_susd_amt
# #####################################################################################
print(
'========================================================================='
)
print('Case 2. harvest first time')
prevCRVBalance = crv.balanceOf(alice)
print('Alice CRV balance before harvest', prevCRVBalance)
_, _, collId, collSize = homora.getPositionInfo(1)
print('collSize', collSize)
# staking directly
prevCrv = crv.balanceOf(bob)
print('bob lp balance', interface.IERC20Ex(lp).balanceOf(bob))
pid, gid = 12, 0
gauge, _ = wgauge.gauges(pid, gid)
tx = interface.ILiquidityGauge(gauge).deposit(collSize, {'from': bob})
chain.sleep(20000)
tx = homora.execute(1, curve_spell, curve_spell.harvest.encode_input(),
{'from': alice})
print('tx gas used', tx.gas_used)
curCRVBalance = crv.balanceOf(alice)
print('Alice CRV balance after harvest', curCRVBalance)
receivedCrv = curCRVBalance - prevCRVBalance
# check with staking directly
minter = interface.ILiquidityGaugeMinter(
interface.ILiquidityGauge(gauge).minter())
print('minter', minter)
tx = minter.mint(gauge, {'from': bob})
print('tx status', tx.status)
tx = interface.ILiquidityGauge(gauge).withdraw(collSize, {'from': bob})
receivedCrvFromGauge = crv.balanceOf(bob) - prevCrv
print('receivedCrvFromGauge', receivedCrvFromGauge)
assert almostEqual(receivedCrv, receivedCrvFromGauge)
# #####################################################################################
print(
'========================================================================='
)
print('Case 3. harvest second time')
prevCRVBalance = crv.balanceOf(alice)
print('Alice CRV balance before harvest', prevCRVBalance)
_, _, collId, collSize = homora.getPositionInfo(1)
print('collSize', collSize)
# staking directly
prevCrv = crv.balanceOf(bob)
print('bob lp balance', interface.IERC20Ex(lp).balanceOf(bob))
pid, gid = 12, 0
gauge, _ = wgauge.gauges(pid, gid)
tx = interface.ILiquidityGauge(gauge).deposit(collSize, {'from': bob})
chain.sleep(20000)
tx = homora.execute(1, curve_spell, curve_spell.harvest.encode_input(),
{'from': alice})
print('tx gas used', tx.gas_used)
curCRVBalance = crv.balanceOf(alice)
print('Alice CRV balance after harvest', curCRVBalance)
receivedCrv = curCRVBalance - prevCRVBalance
# check with staking directly
minter = interface.ILiquidityGaugeMinter(
interface.ILiquidityGauge(gauge).minter())
print('minter', minter)
tx = minter.mint(gauge, {'from': bob})
print('tx status', tx.status)
tx = interface.ILiquidityGauge(gauge).withdraw(collSize, {'from': bob})
receivedCrvFromGauge = crv.balanceOf(bob) - prevCrv
print('receivedCrvFromGauge', receivedCrvFromGauge)
assert almostEqual(receivedCrv, receivedCrvFromGauge)
return tx
def main():
admin = accounts[0]
alice = accounts[1]
bob = accounts[2]
dai = interface.IERC20Ex('0x6B175474E89094C44Da98b954EedeAC495271d0F')
usdc = interface.IERC20Ex('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48')
usdt = interface.IERC20Ex('0xdAC17F958D2ee523a2206206994597C13D831ec7')
adai = interface.IERC20Ex('0x028171bCA77440897B824Ca71D1c56caC55b68A3')
ausdc = interface.IERC20Ex('0xBcca60bB61934080951369a648Fb03DF4F96263C')
ausdt = interface.IERC20Ex('0x3Ed3B47Dd13EC9a98b44e6204A523E766B225811')
lp = interface.IERC20Ex('0x6c3f90f043a72fa612cbac8115ee7e52bde6e490')
pool = interface.ICurvePool('0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7')
lp_aave = interface.IERC20Ex('0xFd2a8fA60Abd58Efe3EeE34dd494cD491dC14900')
pool_aave = interface.ICurvePool(
'0xDeBF20617708857ebe4F679508E7b7863a8A8EeE')
registry = interface.ICurveRegistry(
'0x7d86446ddb609ed0f5f8684acf30380a356b2b4c')
crdai = interface.ICErc20('0x92B767185fB3B04F881e3aC8e5B0662a027A1D9f')
crusdc = interface.ICErc20('0x44fbebd2f576670a6c33f6fc0b00aa8c5753b322')
crusdt = interface.ICErc20('0x797AAB1ce7c01eB727ab980762bA88e7133d2157')
cradai = MockCErc20.deploy(adai, {'from': admin})
crausdc = MockCErc20.deploy(ausdc, {'from': admin})
crausdt = MockCErc20.deploy(ausdt, {'from': admin})
gauge = accounts.at('0xbFcF63294aD7105dEa65aA58F8AE5BE2D9d0952A',
force=True)
wgauge = WLiquidityGauge.deploy(
registry, '0xD533a949740bb3306d119CC777fa900bA034cd52',
{'from': admin})
crv = interface.IERC20Ex(wgauge.crv())
werc20 = WERC20.deploy({'from': admin})
simple_oracle = SimpleOracle.deploy({'from': admin})
simple_oracle.setETHPx([dai, usdt, usdc, adai, ausdc, ausdt], [
2**112 // 700, 2**112 // 700, 2**112 // 700, 2**112 // 700,
2**112 // 700, 2**112 // 700
])
curve_oracle = CurveOracle.deploy(simple_oracle, registry, {'from': admin})
curve_oracle.registerPool(lp) # update pool info
curve_oracle.registerPool(lp_aave) # update pool info
core_oracle = CoreOracle.deploy({'from': admin})
oracle = ProxyOracle.deploy(core_oracle, {'from': admin})
oracle.setWhitelistERC1155([werc20, wgauge], True, {'from': admin})
core_oracle.setRoute(
[dai, usdc, usdt, lp, adai, ausdc, ausdt, lp_aave],
[
simple_oracle, simple_oracle, simple_oracle, curve_oracle,
simple_oracle, simple_oracle, simple_oracle, curve_oracle
],
{'from': admin},
)
oracle.setOracles(
[dai, usdc, usdt, lp, adai, ausdc, ausdt, lp_aave],
[
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
[10000, 10000, 10000],
],
{'from': admin},
)
# initialize
homora = HomoraBank.deploy({'from': admin})
print('donator ether', accounts[5].balance())
homora.initialize(oracle, 1000, {'from': admin}) # 10% fee
setup_bank_hack(homora)
# add bank
homora.addBank(dai, crdai, {'from': admin})
homora.addBank(usdc, crusdc, {'from': admin})
homora.addBank(usdt, crusdt, {'from': admin})
homora.addBank(adai, cradai, {'from': admin})
homora.addBank(ausdc, crausdc, {'from': admin})
homora.addBank(ausdt, crausdt, {'from': admin})
# setup initial funds 10^6 USDT + 10^6 USDC + 10^6 DAI to alice
mint_tokens(
dai,
alice,
)
mint_tokens(usdc, alice)
mint_tokens(usdt, alice)
mint_tokens(adai, alice)
mint_tokens(ausdc, alice)
mint_tokens(ausdt, alice)
# check alice's funds
print(f'Alice dai balance {dai.balanceOf(alice)}')
print(f'Alice usdc balance {usdc.balanceOf(alice)}')
print(f'Alice usdt balance {usdt.balanceOf(alice)}')
print(f'Alice adai balance {adai.balanceOf(alice)}')
print(f'Alice ausdc balance {ausdc.balanceOf(alice)}')
print(f'Alice ausdt balance {ausdt.balanceOf(alice)}')
# steal some LP from the staking pool
mint_tokens(lp, alice)
mint_tokens(lp, bob)
mint_tokens(lp_aave, alice)
# set approval
dai.approve(homora, 2**256 - 1, {'from': alice})
dai.approve(crdai, 2**256 - 1, {'from': alice})
usdc.approve(homora, 2**256 - 1, {'from': alice})
usdc.approve(crusdc, 2**256 - 1, {'from': alice})
usdt.approve(homora, 2**256 - 1, {'from': alice})
usdt.approve(crusdt, 2**256 - 1, {'from': alice})
adai.approve(homora, 2**256 - 1, {'from': alice})
adai.approve(cradai, 2**256 - 1, {'from': alice})
ausdc.approve(homora, 2**256 - 1, {'from': alice})
ausdc.approve(crausdc, 2**256 - 1, {'from': alice})
ausdt.approve(homora, 2**256 - 1, {'from': alice})
ausdt.approve(crausdt, 2**256 - 1, {'from': alice})
lp.approve(homora, 2**256 - 1, {'from': alice})
lp.approve(gauge, 2**256 - 1, {'from': bob})
lp_aave.approve(homora, 2**256 - 1, {'from': alice})
curve_spell = CurveSpellV1.deploy(
homora, werc20, '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', wgauge,
{'from': admin})
# register gauge
wgauge.registerGauge(0, 0)
wgauge.registerGauge(25, 0)
# set up pools
curve_spell.getPool(lp)
curve_spell.getPool(lp_aave)
# first time call to reduce gas
curve_spell.ensureApproveN(lp, 3, {'from': admin})
curve_spell.ensureApproveN(lp_aave, 3, {'from': admin})
#####################################################################################
print(
'========================================================================='
)
print('Case 1.')
prevABal = dai.balanceOf(alice)
prevBBal = usdc.balanceOf(alice)
prevCBal = usdt.balanceOf(alice)
prevLPBal = lp.balanceOf(alice)
prevLPBal_bank = lp.balanceOf(homora)
prevLPBal_gauge = lp.balanceOf(gauge)
dai_amt = 200 * 10**18
usdc_amt = 500 * 10**6
usdt_amt = 400 * 10**6
lp_amt = 1 * 10**18
borrow_dai_amt = 0
borrow_usdc_amt = 20 * 10**6
borrow_usdt_amt = 0
borrow_lp_amt = 0
minLPMint = 0
pid = 0
gid = 0
tx = homora.execute(
0,
curve_spell,
curve_spell.addLiquidity3.encode_input(
lp, # LP
[dai_amt, usdc_amt, usdt_amt], # supply tokens
lp_amt, # supply LP
[borrow_dai_amt, borrow_usdc_amt, borrow_usdt_amt
], # borrow tokens
borrow_lp_amt, # borrow LP
minLPMint, # min LP mint
pid,
gid),
{'from': alice})
curABal = dai.balanceOf(alice)
curBBal = usdc.balanceOf(alice)
curCBal = usdt.balanceOf(alice)
curLPBal = lp.balanceOf(alice)
curLPBal_bank = lp.balanceOf(homora)
curLPBal_gauge = lp.balanceOf(gauge)
print('spell lp balance', lp.balanceOf(curve_spell))
print('Alice delta A balance', curABal - prevABal)
print('Alice delta B balance', curBBal - prevBBal)
print('Alice delta C balance', curCBal - prevCBal)
print('add liquidity gas', tx.gas_used)
print('bank lp balance', curLPBal_bank)
_, _, _, daiDebt, daiDebtShare = homora.getBankInfo(dai)
_, _, _, usdcDebt, usdcDebtShare = homora.getBankInfo(usdc)
_, _, _, usdtDebt, usdtDebtShare = homora.getBankInfo(usdt)
_, _, _, lpDebt, usdcDebtShare = homora.getBankInfo(usdc)
print('bank dai totalDebt', daiDebt)
print('bank dai totalShare', daiDebtShare)
print('bank usdt totalDebt', usdtDebt)
print('bank usdt totalShare', usdtDebtShare)
print('bank usdc totalDebt', usdcDebt)
print('bank usdc totalShare', usdcDebtShare)
print('bank prev LP balance', prevLPBal_bank)
print('bank cur LP balance', curLPBal_bank)
print('gauge prev LP balance', prevLPBal_gauge)
print('gauge cur LP balance', curLPBal_gauge)
# alice
assert almostEqual(curABal - prevABal, -dai_amt), 'incorrect DAI amt'
assert almostEqual(curBBal - prevBBal, -usdc_amt), 'incorrect USDC amt'
assert almostEqual(curCBal - prevCBal, -usdt_amt), 'incorrect USDT amt'
assert almostEqual(curLPBal - prevLPBal, -lp_amt), 'incorrect LP amt'
# spell
assert dai.balanceOf(curve_spell) == 0, 'non-zero spell DAI balance'
assert usdc.balanceOf(curve_spell) == 0, 'non-zero spell USDC balance'
assert usdt.balanceOf(curve_spell) == 0, 'non-zero spell USDT balance'
assert lp.balanceOf(curve_spell) == 0, 'non-zero spell LP balance'
# debt
assert daiDebt == borrow_dai_amt
assert usdcDebt == borrow_usdc_amt
assert usdtDebt == borrow_usdt_amt
_, _, collId, collSize = homora.getPositionInfo(1)
print('collSize', collSize)
# staking directly
prevCrv = crv.balanceOf(bob)
print('bob lp balance', interface.IERC20Ex(lp).balanceOf(bob))
pid, gid = 0, 0
gauge, _ = wgauge.gauges(pid, gid)
tx = interface.ILiquidityGauge(gauge).deposit(collSize, {'from': bob})
chain.sleep(20000)
prevAliceCrvBalance = crv.balanceOf(alice)
print('Alice crv balance', prevAliceCrvBalance)
# #####################################################################################
print(
'========================================================================='
)
print('Case 2. add liquidity (failed tx desired)')
adai_amt = 200 * 10**18
ausdc_amt = 500 * 10**6
ausdt_amt = 400 * 10**6
lp_amt = 0
borrow_adai_amt = 0
borrow_ausdc_amt = 0
borrow_ausdt_amt = 0
borrow_lp_amt = 0
minLPMint = 0
pid = 0
gid = 0
try:
tx = homora.execute(
1,
curve_spell,
curve_spell.addLiquidity3.encode_input(
lp_aave, # LP_aave
[adai_amt, ausdc_amt, ausdt_amt], # supply tokens
lp_amt, # supply LP
[borrow_adai_amt, borrow_ausdc_amt, borrow_ausdt_amt
], # borrow tokens
borrow_lp_amt, # borrow LP
minLPMint, # min LP mint
pid,
gid),
{'from': alice})
assert False, 'tx should fail'
except VirtualMachineError:
pass
# #####################################################################################
print(
'========================================================================='
)
print('Case 3. add liquidity (failed tx desired)')
adai_amt = 200 * 10**18
ausdc_amt = 500 * 10**6
ausdt_amt = 400 * 10**6
lp_amt = 0
borrow_adai_amt = 0
borrow_ausdc_amt = 0
borrow_ausdt_amt = 0
borrow_lp_amt = 0
minLPMint = 0
pid = 25
gid = 0
try:
tx = homora.execute(
1,
curve_spell,
curve_spell.addLiquidity3.encode_input(
lp_aave, # LP_aave
[adai_amt, ausdc_amt, ausdt_amt], # supply tokens
lp_amt, # supply LP
[borrow_adai_amt, borrow_ausdc_amt, borrow_ausdt_amt
], # borrow tokens
borrow_lp_amt, # borrow LP
minLPMint, # min LP mint
pid,
gid),
{'from': alice})
assert False, 'tx should fail'
except VirtualMachineError:
pass
# #####################################################################################
print(
'========================================================================='
)
print('Case 4. remove liquidity (failed tx desired)')
lp_take_amt = 2**256 - 1 # max
lp_want = 1 * 10**17
adai_repay = 2**256 - 1 # max
ausdc_repay = 2**256 - 1 # max
ausdt_repay = 2**256 - 1 # max
lp_repay = 0
try:
tx = homora.execute(
1,
curve_spell,
curve_spell.removeLiquidity3.encode_input(
lp_aave, # LP_aave token
lp_take_amt, # LP amount to take out
lp_want, # LP amount to withdraw to wallet
[adai_repay, ausdc_repay, ausdt_repay], # repay amounts
lp_repay, # repay LP amount
[0, 0, 0] # min amounts
),
{'from': alice})
assert False, 'tx should revert'
except VirtualMachineError:
pass
# #####################################################################################
print(
'========================================================================='
)
print('Case 5. remove liqudiity')
# remove liquidity from the same position
prevABal = dai.balanceOf(alice)
prevBBal = usdc.balanceOf(alice)
prevCBal = usdt.balanceOf(alice)
prevLPBal = lp.balanceOf(alice)
prevLPBal_bank = lp.balanceOf(homora)
prevLPBal_gauge = lp.balanceOf(gauge)
_, _, _, collSize = homora.getPositionInfo(1)
lp_take_amt = 2**256 - 1 # max
lp_want = 1 * 10**17
dai_repay = 2**256 - 1 # max
usdc_repay = 2**256 - 1 # max
usdt_repay = 2**256 - 1 # max
lp_repay = 0
tx = homora.execute(
1,
curve_spell,
curve_spell.removeLiquidity3.encode_input(
lp, # LP token
lp_take_amt, # LP amount to take out
lp_want, # LP amount to withdraw to wallet
[dai_repay, usdc_repay, usdt_repay], # repay amounts
lp_repay, # repay LP amount
[0, 0, 0] # min amounts
),
{'from': alice})
curABal = dai.balanceOf(alice)
curBBal = usdc.balanceOf(alice)
curCBal = usdt.balanceOf(alice)
curLPBal = lp.balanceOf(alice)
curLPBal_bank = lp.balanceOf(homora)
curLPBal_gauge = lp.balanceOf(gauge)
print('spell lp balance', lp.balanceOf(curve_spell))
print('spell dai balance', dai.balanceOf(curve_spell))
print('spell usdc balance', usdc.balanceOf(curve_spell))
print('spell usdt balance', usdt.balanceOf(curve_spell))
print('Alice delta A balance', curABal - prevABal)
print('Alice delta B balance', curBBal - prevBBal)
print('Alice delta C balance', curCBal - prevCBal)
print('Alice delta LP balance', curLPBal - prevLPBal)
print('remove liquidity gas', tx.gas_used)
print('bank delta lp balance', curLPBal_bank - prevLPBal_bank)
print('bank total lp balance', curLPBal_bank)
_, _, _, daiDebt, daiDebtShare = homora.getBankInfo(dai)
_, _, _, usdcDebt, usdcDebtShare = homora.getBankInfo(usdc)
_, _, _, usdtDebt, usdtDebtShare = homora.getBankInfo(usdt)
print('bank dai totalDebt', daiDebt)
print('bank dai totalDebt', daiDebt)
print('bank usdc totalShare', usdcDebtShare)
print('bank usdc totalShare', usdcDebtShare)
print('bank usdt totalDebt', usdtDebt)
print('bank usdt totalShare', usdtDebtShare)
print('LP want', lp_want)
print('bank delta LP amount', curLPBal_bank - prevLPBal_bank)
print('LP take amount', lp_take_amt)
print('prev gauge LP balance', prevLPBal_gauge)
print('cur gauge LP balance', curLPBal_gauge)
print('coll size', collSize)
# alice
assert almostEqual(curLPBal - prevLPBal, lp_want), 'incorrect LP amt'
# gauge
assert almostEqual(curLPBal_gauge - prevLPBal_gauge,
-collSize), 'incorrect gauge LP amt'
# spell
assert dai.balanceOf(curve_spell) == 0, 'non-zero spell DAI balance'
assert usdc.balanceOf(curve_spell) == 0, 'non-zero spell USDC balance'
assert usdt.balanceOf(curve_spell) == 0, 'non-zero spell USDT balance'
assert lp.balanceOf(curve_spell) == 0, 'non-zero spell LP balance'
# debt
assert usdcDebt == 0, 'usdcDebt should be 0'
assert daiDebt == 0, 'daiDebt should be 0'
assert usdtDebt == 0, 'usdtDebt should be 0'
curAliceCrvBalance = crv.balanceOf(alice)
print('Alice crv balance', curAliceCrvBalance)
receivedCrv = curAliceCrvBalance - prevAliceCrvBalance
print('received crv', receivedCrv)
# check with staking directly
minter = interface.ILiquidityGaugeMinter(
interface.ILiquidityGauge(gauge).minter())
print('minter', minter)
tx = minter.mint(gauge, {'from': bob})
print('tx status', tx.status)
tx = interface.ILiquidityGauge(gauge).withdraw(collSize, {'from': bob})
receivedCrvFromGauge = crv.balanceOf(bob) - prevCrv
print('receivedCrvFromGauge', receivedCrvFromGauge)
assert almostEqual(receivedCrv, receivedCrvFromGauge)
return tx
def mint_tokens(token, to, amount=None):
if amount is None:
# default is 1M tokens
amount = 10**12 * 10**token.decimals()
if token == USDT:
owner = token.owner()
token.issue(amount, {'from': owner})
token.transfer(to, amount, {'from': owner})
elif token == USDC:
master_minter = token.masterMinter()
token.configureMinter(master_minter, 2**256 - 1,
{'from': master_minter})
token.mint(to, amount, {'from': master_minter})
elif token == DAI:
auth = '0x9759a6ac90977b93b58547b4a71c78317f391a28'
token.mint(to, amount, {'from': auth})
elif token == AUSDT:
pool = '0x7d2768de32b0b80b7a3454c06bdac94a69ddc7a9'
token.mint(to, amount, 10**18, {'from': pool})
elif token == AUSDC:
pool = '0x7d2768de32b0b80b7a3454c06bdac94a69ddc7a9'
token.mint(to, amount, 10**18, {'from': pool})
elif token == ADAI:
pool = '0x7d2768de32b0b80b7a3454c06bdac94a69ddc7a9'
token.mint(to, amount, 10**18, {'from': pool})
elif token == WETH:
token.deposit({'from': to, 'value': amount})
elif token == SUSD:
target = interface.IERC20Ex(token.target())
contract_issuer = target.resolverAddressesRequired()[2]
resolver = interface.IERC20Ex(target.resolver())
resolver_target = interface.IERC20Ex(resolver.target())
issuer = resolver_target.repository(contract_issuer)
target.issue(to, amount, {'from': issuer})
elif token == HUSD:
issuer = '0xc2fbf9b9084e92f9649ca4cec9043daac9092539'
token.issue(to, amount, {'from': issuer})
elif token == BUSD:
supply_controller = token.supplyController()
token.increaseSupply(amount, {'from': supply_controller})
token.transfer(to, amount, {'from': supply_controller})
elif token == YDAI:
mint_tokens(interface.IERC20Ex(DAI), to, amount)
interface.IERC20Ex(DAI).approve(token, 0, {'from': to})
interface.IERC20Ex(DAI).approve(token, 2**256 - 1, {'from': to})
token.deposit(amount, {'from': to})
elif token == YUSDT:
mint_tokens(interface.IERC20Ex(USDT), to, amount)
interface.IERC20Ex(USDT).approve(token, 0, {'from': to})
interface.IERC20Ex(USDT).approve(token, 2**256 - 1, {'from': to})
token.deposit(amount, {'from': to})
elif token == YBUSD:
mint_tokens(interface.IERC20Ex(BUSD), to, amount)
interface.IERC20Ex(BUSD).approve(token, 0, {'from': to})
interface.IERC20Ex(BUSD).approve(token, 2**256 - 1, {'from': to})
token.deposit(amount, {'from': to})
elif token == YUSDC:
mint_tokens(interface.IERC20Ex(USDC), to, amount)
interface.IERC20Ex(USDC).approve(token, 0, {'from': to})
interface.IERC20Ex(USDC).approve(token, 2**256 - 1, {'from': to})
token.deposit(amount, {'from': to})
elif token == DPI:
module = token.getModules()[0]
token.mint(to, amount, {'from': module})
elif token == WBTC:
owner = token.owner()
token.mint(to, amount, {'from': owner})
elif token == RENBTC:
owner = token.owner()
token.mint(to, amount, {'from': owner})
elif token == PERP:
owner = token.owner()
token.addMinter(owner, {'from': owner})
token.mint(to, amount, {'from': owner})
elif token == DFD:
gov = token.governance()
token.mint(to, amount, {'from': gov})
elif token == DUSD:
core = token.core()
token.mint(to, amount, {'from': core})
elif token == EURS:
owner = '0x2EbBbc541E8f8F24386FA319c79CedA0579f1Efb'
token.createTokens(amount, {'from': owner})
token.transfer(to, amount, {'from': owner})
elif token == SEUR:
target = interface.IERC20Ex(token.target())
contract_issuer = target.resolverAddressesRequired()[2]
resolver = interface.IERC20Ex(target.resolver())
resolver_target = interface.IERC20Ex(resolver.target())
issuer = resolver_target.repository(contract_issuer)
target.issue(to, amount, {'from': issuer})
elif token == YFI:
governor = token.governance()
token.addMinter(to, {'from': governor})
token.mint(to, amount, {'from': to})
elif is_uni_lp(token):
router = interface.IUniswapV2Router02(
'0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D')
# Uniswap LP token
token0 = interface.IERC20Ex(token.token0())
token1 = interface.IERC20Ex(token.token1())
# mint underlying
amount0 = 10**12 * 10**token0.decimals()
amount1 = 10**12 * 10**token1.decimals()
mint_tokens(token0, to, amount0)
mint_tokens(token1, to, amount1)
# approve router
token0.approve(router, 0, {'from': to})
token0.approve(router, 2**256 - 1, {'from': to})
token1.approve(router, 0, {'from': to})
token1.approve(router, 2**256 - 1, {'from': to})
# add liquidity
interface.IUniswapV2Router02(router).addLiquidity(
token0, token1, amount0, amount1, 0, 0, to,
chain.time() + 1200, {'from': to})
elif is_sushi_lp(token):
router = interface.IUniswapV2Router02(
'0xd9e1ce17f2641f24ae83637ab66a2cca9c378b9f')
# Sushiswap LP token
token0 = interface.IERC20Ex(token.token0())
token1 = interface.IERC20Ex(token.token1())
# mint underlying
amount0 = 10**12 * 10**token0.decimals()
amount1 = 10**12 * 10**token1.decimals()
mint_tokens(token0, to, amount0)
mint_tokens(token1, to, amount1)
# approve router
token0.approve(router, 0, {'from': to})
token0.approve(router, 2**256 - 1, {'from': to})
token1.approve(router, 0, {'from': to})
token1.approve(router, 2**256 - 1, {'from': to})
# add liquidity
interface.IUniswapV2Router02(router).addLiquidity(
token0, token1, amount0, amount1, 0, 0, to,
chain.time() + 1200, {'from': to})
elif is_bal_lp(token):
# Balancer LP token
tokens = token.getFinalTokens()
max_amts = []
amt_desired = 10**100
for _token in tokens:
_token = interface.IERC20Ex(_token)
amt = 10**12 * 10**_token.decimals()
mint_tokens(_token, to, amt)
_token.approve(token, 0, {'from': to})
_token.approve(token, 2**256 - 1, {'from': to})
max_amts.append(amt)
amt_desired = min(
amt_desired,
amt * token.totalSupply() // token.getBalance(_token))
token.joinPool(amt_desired * 9 // 10, max_amts, {'from': to})
elif is_crv_lp(token):
# Curve LP token
registry = interface.ICurveRegistry(
'0x7d86446ddb609ed0f5f8684acf30380a356b2b4c')
pool = registry.get_pool_from_lp_token(token)
tokens = registry.get_coins(pool)
amts = []
for _token in tokens:
if _token == '0x0000000000000000000000000000000000000000':
continue
_token = interface.IERC20Ex(_token)
amt = 10**6 * 10**_token.decimals()
prevBal = _token.balanceOf(to)
mint_tokens(_token, to, amt)
curBal = _token.balanceOf(to)
amts.append(curBal - prevBal)
interface.IERC20Ex(_token).approve(pool, 0, {'from': to})
interface.IERC20Ex(_token).approve(pool, 2**256 - 1, {'from': to})
desc = f'uint[{len(amts)}],uint'
print('adding liquidity to curve')
print(amts)
interface.ICurvePool(pool).add_liquidity[desc](amts, 0, {'from': to})
else:
raise Exception('unsupported token')
from brownie import interface
crv_registry = interface.ICurveRegistry(
'0x7d86446ddb609ed0f5f8684acf30380a356b2b4c')
class Tokens:
ETH = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'
WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'
AAVE = '0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9'
BAND = '0xba11d00c5f74255f56a5e366f4f77f5a186d7f55'
COMP = '0xc00e94cb662c3520282e6f5717214004a7f26888'
CRV = '0xD533a949740bb3306d119CC777fa900bA034cd52'
DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F'
DPI = '0x1494CA1F11D487c2bBe4543E90080AeBa4BA3C2b'
INDEX = '0x0954906da0Bf32d5479e25f46056d22f08464cab'
LINK = '0x514910771af9ca656af840dff83e8264ecf986ca'
MKR = '0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2'
PERP = '0xbC396689893D065F41bc2C6EcbeE5e0085233447'
REN = '0x408e41876cccdc0f92210600ef50372656052a38'
RENBTC = '0xeb4c2781e4eba804ce9a9803c67d0893436bb27d'
SNX = '0xC011a73ee8576Fb46F5E1c5751cA3B9Fe0af2a6F'
SUSD = '0x57Ab1ec28D129707052df4dF418D58a2D46d5f51'
SUSHI = '0x6B3595068778DD592e39A122f4f5a5cF09C90fE2'
UMA = '0x04Fa0d235C4abf4BcF4787aF4CF447DE572eF828'
UNI = '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984'
USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
USDT = '0xdAC17F958D2ee523a2206206994597C13D831ec7'
WBTC = '0x2260fac5e5542a773aa44fbcfedf7c193bc2c599'
YFI = '0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e'
UNI_YFI_WETH = '0x2fDbAdf3C4D5A8666Bc06645B8358ab803996E28'
def main():
admin = accounts[0]
alice = accounts[1]
bob = accounts[2]
dai = interface.IERC20Ex('0x6B175474E89094C44Da98b954EedeAC495271d0F')
usdc = interface.IERC20Ex('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48')
usdt = interface.IERC20Ex('0xdAC17F958D2ee523a2206206994597C13D831ec7')
wbtc = interface.IERC20Ex('0x2260fac5e5542a773aa44fbcfedf7c193bc2c599')
renbtc = interface.IERC20Ex('0xeb4c2781e4eba804ce9a9803c67d0893436bb27d')
crv = interface.IERC20Ex('0xD533a949740bb3306d119CC777fa900bA034cd52')
lp_3pool = interface.IERC20Ex('0x6c3f90f043a72fa612cbac8115ee7e52bde6e490')
lp_btc = interface.IERC20Ex('0x49849c98ae39fff122806c06791fa73784fb3675')
pool_3pool = interface.ICurvePool(
'0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7')
pool_btc = interface.ICurvePool(
'0x93054188d876f558f4a66B2EF1d97d16eDf0895B')
registry = interface.ICurveRegistry(
'0x7d86446ddb609ed0f5f8684acf30380a356b2b4c')
gauge = accounts.at('0xbFcF63294aD7105dEa65aA58F8AE5BE2D9d0952A',
force=True)
wgauge = WLiquidityGauge.deploy(
registry, '0xD533a949740bb3306d119CC777fa900bA034cd52',
{'from': admin})
# set approval
dai.approve(wgauge, 2**256 - 1, {'from': alice})
usdc.approve(wgauge, 2**256 - 1, {'from': alice})
usdt.approve(wgauge, 2**256 - 1, {'from': alice})
renbtc.approve(wgauge, 2**256 - 1, {'from': alice})
wbtc.approve(wgauge, 2**256 - 1, {'from': alice})
lp_3pool.approve(wgauge, 2**256 - 1, {'from': alice})
lp_3pool.approve(gauge, 2**256 - 1, {'from': alice})
lp_btc.approve(wgauge, 2**256 - 1, {'from': alice})
lp_btc.approve(gauge, 2**256 - 1, {'from': alice})
dai.approve(wgauge, 2**256 - 1, {'from': bob})
usdc.approve(wgauge, 2**256 - 1, {'from': bob})
usdt.approve(wgauge, 2**256 - 1, {'from': bob})
renbtc.approve(wgauge, 2**256 - 1, {'from': bob})
wbtc.approve(wgauge, 2**256 - 1, {'from': bob})
lp_3pool.approve(wgauge, 2**256 - 1, {'from': bob})
lp_3pool.approve(gauge, 2**256 - 1, {'from': bob})
lp_btc.approve(wgauge, 2**256 - 1, {'from': bob})
lp_btc.approve(gauge, 2**256 - 1, {'from': bob})
# setup initial funds to alice
mint_tokens(dai, alice)
mint_tokens(usdc, alice)
mint_tokens(usdt, alice)
mint_tokens(renbtc, alice)
mint_tokens(wbtc, alice)
mint_tokens(dai, bob)
mint_tokens(usdc, bob)
mint_tokens(usdt, bob)
mint_tokens(renbtc, bob)
mint_tokens(wbtc, bob)
# steal some LP from the staking pool
mint_tokens(lp_3pool, alice)
mint_tokens(lp_btc, alice)
mint_tokens(lp_3pool, bob)
mint_tokens(lp_btc, bob)
# register gauges
wgauge.registerGauge(0, 0, {'from': admin})
wgauge.registerGauge(9, 0, {'from': admin})
######################################################################
# Check encoding and decoding ids
print(
'######################################################################'
)
print('Case 1.')
# check 3pool
pid = 0
gid = 0
crvPerShare = 210
encoded_id = wgauge.encodeId(pid, gid, crvPerShare)
print('encoded id', encoded_id)
assert (encoded_id >> 248) == pid
assert (encoded_id >> 240) & ((1 << 8) - 1) == gid
assert (encoded_id & ((1 << 240) - 1)) == crvPerShare
d_pid, d_gid, d_crvPerShare = wgauge.decodeId(encoded_id)
print('decoded pid', d_pid)
print('decoded gid', d_gid)
print('decoded crvPerShare', d_crvPerShare)
assert d_pid == pid
assert d_gid == gid
assert d_crvPerShare == crvPerShare
# check renbtc pool
pid = 9
gid = 0
crvPerShare = 100
encoded_id = wgauge.encodeId(pid, gid, crvPerShare)
print('encoded id', encoded_id)
assert (encoded_id >> 248) == pid
assert (encoded_id >> 240) & ((1 << 8) - 1) == gid
assert (encoded_id & ((1 << 240) - 1)) == crvPerShare
d_pid, d_gid, d_crvPerShare = wgauge.decodeId(encoded_id)
print('decoded pid', d_pid)
print('decoded gid', d_gid)
print('decoded crvPerShare', d_crvPerShare)
assert d_pid == pid
assert d_gid == gid
assert d_crvPerShare == crvPerShare
######################################################################
# check getUnderlyingToken
pid = 0
gid = 0
crvPerShare = 200
id_num = wgauge.encodeId(pid, gid, crvPerShare)
lpToken = wgauge.getUnderlyingToken(id_num)
print('lpToken', lpToken)
assert lpToken == lp_3pool
pid = 9
gid = 0
crvPerShare = 100
id_num = wgauge.encodeId(pid, gid, crvPerShare)
lpToken = wgauge.getUnderlyingToken(id_num)
print('lpToken', lpToken)
assert lpToken == lp_btc
######################################################################
# check mint & burn
print(
'######################################################################'
)
print('Case 2.')
pid = 0
gid = 0
amt = 10**18
print('alice lp 3pool balance', lp_3pool.balanceOf(alice))
# mint
tx = wgauge.mint(pid, gid, amt, {'from': alice})
encoded_id = tx.return_value
print('tx status', tx.status)
print('encoded id', encoded_id)
gauge, prevAccCrvPerShare = wgauge.gauges(pid, gid)
print('gauge', gauge)
print('prevAccCrvPerShare', prevAccCrvPerShare)
print('alice wlp_3pool balance', wgauge.balanceOf(alice, encoded_id))
assert tx.status == 1
assert wgauge.balanceOf(alice, encoded_id) == amt
chain.sleep(20000)
# burn exact
prevCrvBalance = crv.balanceOf(alice)
tx = wgauge.burn(encoded_id, amt, {'from': alice})
print('tx status', tx.status)
print('alice wlp_3pool balance', wgauge.balanceOf(alice, encoded_id))
print('alice crv balance', crv.balanceOf(alice))
receivedCrv = crv.balanceOf(alice) - prevCrvBalance
assert tx.status == 1
assert tx.return_value == pid
assert wgauge.balanceOf(alice, encoded_id) == 0 # remove all
# check reward same as staking directly
prevCrv = crv.balanceOf(alice)
print('alice lp_3pool balance',
interface.IERC20Ex(lp_3pool).balanceOf(alice))
gauge, _ = wgauge.gauges(pid, gid)
tx = interface.ILiquidityGauge(gauge).deposit(amt, {'from': alice})
chain.sleep(20000)
minter = interface.ILiquidityGaugeMinter(
interface.ILiquidityGauge(gauge).minter())
print('minter', minter)
tx = minter.mint(gauge, {'from': alice})
print('tx status', tx.status)
tx = interface.ILiquidityGauge(gauge).withdraw(amt, {'from': alice})
receivedCrvFromGauge = crv.balanceOf(alice) - prevCrv
print('receivedCrvFromGauge', receivedCrvFromGauge)
assert almostEqual(receivedCrv, receivedCrvFromGauge)
######################################################################
# check mint & burn max_int
print(
'######################################################################'
)
print('Case 3.')
pid = 0
gid = 0
amt = 10**18
print('alice lp 3pool balance', lp_3pool.balanceOf(alice))
# mint alice
tx = wgauge.mint(pid, gid, amt, {'from': alice})
encoded_id = tx.return_value
print('tx status', tx.status)
print('encoded id', encoded_id)
gauge, prevAccCrvPerShare = wgauge.gauges(pid, gid)
print('gauge', gauge)
print('prevAccCrvPerShare', prevAccCrvPerShare)
print('alice wlp_3pool balance', wgauge.balanceOf(alice, encoded_id))
assert tx.status == 1
assert wgauge.balanceOf(alice, encoded_id) == amt
# mint bob
prevCrvBob = crv.balanceOf(bob)
print('bob lp_3pool balance', interface.IERC20Ex(lp_3pool).balanceOf(bob))
gauge, _ = wgauge.gauges(pid, gid)
tx = interface.ILiquidityGauge(gauge).deposit(amt, {'from': bob})
chain.sleep(10000)
# burn max_int alice
prevCrvBalance = crv.balanceOf(alice)
tx = wgauge.burn(encoded_id, 2**256 - 1, {'from': alice})
print('tx status', tx.status)
print('alice wlp_3pool balance', wgauge.balanceOf(alice, encoded_id))
print('alice crv balance', crv.balanceOf(alice))
receivedCrv = crv.balanceOf(alice) - prevCrvBalance
assert tx.status == 1
assert tx.return_value == pid
assert wgauge.balanceOf(alice, encoded_id) == 0 # remove all
# burn all bob
minter = interface.ILiquidityGaugeMinter(
interface.ILiquidityGauge(gauge).minter())
print('minter', minter)
tx = minter.mint(gauge, {'from': bob})
print('tx status', tx.status)
tx = interface.ILiquidityGauge(gauge).withdraw(amt, {'from': bob})
receivedCrvFromGauge = crv.balanceOf(bob) - prevCrvBob
print('receivedCrv', receivedCrv)
print('receivedCrvFromGauge', receivedCrvFromGauge)
assert almostEqual(receivedCrv, receivedCrvFromGauge)
######################################################################
# check mint & burn (try more than available--revert, half, then remaining)
print(
'######################################################################'
)
print('Case 4.')
pid = 0
gid = 0
amt = 10**18
print('alice lp 3pool balance', lp_3pool.balanceOf(alice))
# mint alice
tx = wgauge.mint(pid, gid, amt, {'from': alice})
encoded_id = tx.return_value
print('tx status', tx.status)
print('encoded id', encoded_id)
gauge, prevAccCrvPerShare = wgauge.gauges(pid, gid)
print('gauge', gauge)
print('prevAccCrvPerShare', prevAccCrvPerShare)
print('alice wlp_3pool balance', wgauge.balanceOf(alice, encoded_id))
assert tx.status == 1
assert wgauge.balanceOf(alice, encoded_id) == amt
# mint bob
prevCrvBob = crv.balanceOf(bob)
print('bob lp_3pool balance', interface.IERC20Ex(lp_3pool).balanceOf(bob))
gauge, _ = wgauge.gauges(pid, gid)
tx = interface.ILiquidityGauge(gauge).deposit(amt, {'from': bob})
chain.sleep(10000)
# burn too much (expected failed)
prevCrvBalance = crv.balanceOf(alice)
try:
tx = wgauge.burn(encoded_id, amt + 1, {'from': alice})
assert tx.status == 0
except:
pass
print('alice wlpusdt balance', wgauge.balanceOf(alice, encoded_id))
print('alice crv balance', crv.balanceOf(alice))
assert prevCrvBalance == crv.balanceOf(alice)
assert wgauge.balanceOf(alice, encoded_id) == amt
# burn half alice
prevCrvBalance = crv.balanceOf(alice)
tx = wgauge.burn(encoded_id, amt // 2, {'from': alice})
print('tx status', tx.status)
print('alice wlp_3pool balance', wgauge.balanceOf(alice, encoded_id))
print('amt - amt//2', amt - amt // 2)
print('alice crv balance', crv.balanceOf(alice))
assert tx.status == 1
assert tx.return_value == pid
assert wgauge.balanceOf(alice, encoded_id) == amt - amt // 2 # remove half
# burn half bob
minter = interface.ILiquidityGaugeMinter(
interface.ILiquidityGauge(gauge).minter())
print('minter', minter)
tx = minter.mint(gauge, {'from': bob})
print('tx status', tx.status)
tx = interface.ILiquidityGauge(gauge).withdraw(amt // 2, {'from': bob})
chain.sleep(10000)
# burn remaining alice
tx = wgauge.burn(encoded_id, 2**256 - 1, {'from': alice})
print('tx status', tx.status)
print('alice wlp_3pool balance', wgauge.balanceOf(alice, encoded_id))
print('alice crv balance', crv.balanceOf(alice))
receivedCrv = crv.balanceOf(alice) - prevCrvBalance
assert tx.status == 1
assert tx.return_value == pid
# burn remaining bob
tx = minter.mint(gauge, {'from': bob})
print('tx status', tx.status)
tx = interface.ILiquidityGauge(gauge).withdraw(amt - amt // 2,
{'from': bob})
receivedCrvFromGauge = crv.balanceOf(bob) - prevCrvBob
print('receivedCrv alice', receivedCrv)
print('receivedCrvFromGauge bob', receivedCrvFromGauge)
assert wgauge.balanceOf(alice, encoded_id) == 0 # remove all
# check reward same as staking directly
assert almostEqual(receivedCrv, receivedCrvFromGauge)
def main():
admin = accounts[0]
alice = accounts[1]
dai = interface.IERC20Ex('0x6B175474E89094C44Da98b954EedeAC495271d0F')
usdc = interface.IERC20Ex('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48')
usdt = interface.IERC20Ex('0xdAC17F958D2ee523a2206206994597C13D831ec7')
lp = interface.IERC20Ex('0x6c3f90f043a72fa612cbac8115ee7e52bde6e490')
pool = interface.ICurvePool('0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7')
registry = interface.ICurveRegistry(
'0x7d86446ddb609ed0f5f8684acf30380a356b2b4c')
crdai = interface.ICErc20('0x92B767185fB3B04F881e3aC8e5B0662a027A1D9f')
crusdc = interface.ICErc20('0x44fbebd2f576670a6c33f6fc0b00aa8c5753b322')
crusdt = interface.ICErc20('0x797AAB1ce7c01eB727ab980762bA88e7133d2157')
werc20 = WERC20.deploy({'from': admin})
simple_oracle = SimpleOracle.deploy({'from': admin})
simple_oracle.setETHPx([dai, usdt, usdc, lp], [
9060553589188986552095106856227,
9002288773315920458132820329673073223442669,
9011535487953795006625883219171279625142296,
9002288773315920458132820329673
])
oracle = ProxyOracle.deploy({'from': admin})
oracle.setWhitelistERC1155([werc20], True, {'from': admin})
oracle.setOracles(
[
'0x6B175474E89094C44Da98b954EedeAC495271d0F', # DAI
'0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', # USDC
'0xdAC17F958D2ee523a2206206994597C13D831ec7', # USDT
'0x6c3f90f043a72fa612cbac8115ee7e52bde6e490', # lp
],
[
[simple_oracle, 10000, 10000, 10000],
[simple_oracle, 10000, 10000, 10000],
[simple_oracle, 10000, 10000, 10000],
[simple_oracle, 10000, 10000, 10000],
],
{'from': admin},
)
# initialize
homora = HomoraBank.deploy({'from': admin})
homora.initialize(oracle, 1000, {'from': admin}) # 10% fee
setup_bank_hack(homora)
# add bank
homora.addBank(dai, crdai, {'from': admin})
homora.addBank(usdc, crusdc, {'from': admin})
homora.addBank(usdt, crusdt, {'from': admin})
# setup initial funds 10^6 USDT + 10^6 USDC + 10^6 DAI to alice
setup_transfer(
dai,
accounts.at('0xc3d03e4f041fd4cd388c549ee2a29a9e5075882f', force=True),
alice, 10**6 * 10**18)
setup_transfer(
usdc,
accounts.at('0xa191e578a6736167326d05c119ce0c90849e84b7', force=True),
alice, 10**6 * 10**6)
setup_transfer(
usdt,
accounts.at('0xbe0eb53f46cd790cd13851d5eff43d12404d33e8', force=True),
alice, 10**6 * 10**6)
# setup initial funds 10^6 USDT + 10^6 USDC + 10^6 DAI to homora bank
setup_transfer(
dai,
accounts.at('0xc3d03e4f041fd4cd388c549ee2a29a9e5075882f', force=True),
homora, 10**6 * 10**18)
setup_transfer(
usdc,
accounts.at('0x397ff1542f962076d0bfe58ea045ffa2d347aca0', force=True),
homora, 10**6 * 10**6)
setup_transfer(
usdt,
accounts.at('0xbe0eb53f46cd790cd13851d5eff43d12404d33e8', force=True),
homora, 10**6 * 10**6)
# check alice's funds
print(f'Alice dai balance {dai.balanceOf(alice)}')
print(f'Alice usdc balance {usdc.balanceOf(alice)}')
print(f'Alice usdt balance {usdt.balanceOf(alice)}')
# steal some LP from the staking pool
lp.transfer(
alice, 10**6 * 10**18, {
'from':
accounts.at('0x8038c01a0390a8c547446a0b2c18fc9aefecc10c',
force=True)
})
# set approval
dai.approve(homora, 2**256 - 1, {'from': alice})
dai.approve(crdai, 2**256 - 1, {'from': alice})
usdc.approve(homora, 2**256 - 1, {'from': alice})
usdc.approve(crusdc, 2**256 - 1, {'from': alice})
usdt.approve(homora, 2**256 - 1, {'from': alice})
usdt.approve(crusdt, 2**256 - 1, {'from': alice})
lp.approve(homora, 2**256 - 1, {'from': alice})
curve_spell = CurveSpellV1.deploy(homora, werc20, registry,
{'from': admin})
# set up pools
curve_spell.registerPool(lp)
# first time call to reduce gas
curve_spell.ensureApprove3(lp, {'from': admin})
#####################################################################################
# TODO: Test borrow 3 assets simultaneously
print(
'========================================================================='
)
print('Case 1.')
prevABal = dai.balanceOf(alice)
prevBBal = usdc.balanceOf(alice)
prevCBal = usdt.balanceOf(alice)
prevLPBal = lp.balanceOf(alice)
prevLPBal_bank = lp.balanceOf(homora)
prevLPBal_werc20 = lp.balanceOf(werc20)
dai_amt = 20000 * 10**18 # 20000 DAI
usdc_amt = 50000 * 10**6 # 50000 USDC
usdt_amt = 40000 * 10**6 # 40000 USDT
lp_amt = 1 * 10**18
borrow_dai_amt = 2000 * 10**18 # 2000 DAI
borrow_usdc_amt = 200 * 10**6 # 200 USDC
borrow_usdt_amt = 0 # 1000 * 10**6 # 1000 USDT
borrow_lp_amt = 0
minLPMint = 0
tx = homora.execute(
0,
curve_spell,
curve_spell.addLiquidity3.encode_input(
lp, # LP
[dai_amt, usdc_amt, usdt_amt], # supply tokens
lp_amt, # supply LP
[borrow_dai_amt, borrow_usdc_amt, borrow_usdt_amt
], # borrow tokens
borrow_lp_amt, # borrow LP
minLPMint # min LP mint
),
{'from': alice})
position_id = tx.return_value
print('position_id', position_id)
print('tx gas used', tx.gas_used)
curABal = dai.balanceOf(alice)
curBBal = usdc.balanceOf(alice)
curCBal = usdt.balanceOf(alice)
curLPBal = lp.balanceOf(alice)
curLPBal_bank = lp.balanceOf(homora)
curLPBal_werc20 = lp.balanceOf(werc20)
print('spell lp balance', lp.balanceOf(curve_spell))
print('Alice delta A balance', curABal - prevABal)
print('Alice delta B balance', curBBal - prevBBal)
print('Alice delta C balance', curCBal - prevCBal)
print('add liquidity gas', tx.gas_used)
print('bank lp balance', curLPBal_bank)
_, _, _, daiDebt, daiDebtShare = homora.getBankInfo(dai)
_, _, _, usdcDebt, usdcDebtShare = homora.getBankInfo(usdc)
_, _, _, usdtDebt, usdtDebtShare = homora.getBankInfo(usdt)
_, _, _, lpDebt, usdcDebtShare = homora.getBankInfo(usdc)
print('bank dai totalDebt', daiDebt)
print('bank dai totalShare', daiDebtShare)
print('bank usdt totalDebt', usdtDebt)
print('bank usdt totalShare', usdtDebtShare)
print('bank usdc totalDebt', usdcDebt)
print('bank usdc totalShare', usdcDebtShare)
print('bank prev LP balance', prevLPBal_bank)
print('bank cur LP balance', curLPBal_bank)
print('werc20 prev LP balance', prevLPBal_werc20)
print('werc20 cur LP balance', curLPBal_werc20)
# alice
assert almostEqual(curABal - prevABal, -dai_amt), 'incorrect DAI amt'
assert almostEqual(curBBal - prevBBal, -usdc_amt), 'incorrect USDC amt'
assert almostEqual(curCBal - prevCBal, -usdt_amt), 'incorrect USDT amt'
assert almostEqual(curLPBal - prevLPBal, -lp_amt), 'incorrect LP amt'
# spell
assert dai.balanceOf(curve_spell) == 0, 'non-zero spell DAI balance'
assert usdc.balanceOf(curve_spell) == 0, 'non-zero spell USDC balance'
assert usdt.balanceOf(curve_spell) == 0, 'non-zero spell USDT balance'
assert lp.balanceOf(curve_spell) == 0, 'non-zero spell LP balance'
# debt
assert daiDebt == borrow_dai_amt
assert usdcDebt == borrow_usdc_amt
assert usdtDebt == borrow_usdt_amt
# #####################################################################################
print(
'========================================================================='
)
print('Case 2.')
# remove liquidity from the same position
prevABal = dai.balanceOf(alice)
prevBBal = usdc.balanceOf(alice)
prevCBal = usdt.balanceOf(alice)
prevLPBal = lp.balanceOf(alice)
prevLPBal_bank = lp.balanceOf(homora)
prevLPBal_werc20 = lp.balanceOf(werc20)
_, _, _, collSize = homora.getPositionInfo(position_id)
lp_take_amt = 2**256 - 1 # max
lp_want = 1 * 10**17
dai_repay = 2**256 - 1 # max
usdc_repay = 2**256 - 1 # max
usdt_repay = 2**256 - 1 # max
lp_repay = 0
tx = homora.execute(
position_id,
curve_spell,
curve_spell.removeLiquidity3.encode_input(
lp, # LP token
lp_take_amt, # LP amount to take out
lp_want, # LP amount to withdraw to wallet
[dai_repay, usdc_repay, usdt_repay], # repay amounts
lp_repay, # repay LP amount
[0, 0, 0] # min amounts
),
{'from': alice})
position_id = tx.return_value
print('position_id', position_id)
print('tx gas used', tx.gas_used)
curABal = dai.balanceOf(alice)
curBBal = usdc.balanceOf(alice)
curCBal = usdt.balanceOf(alice)
curLPBal = lp.balanceOf(alice)
curLPBal_bank = lp.balanceOf(homora)
curLPBal_werc20 = lp.balanceOf(werc20)
print('spell lp balance', lp.balanceOf(curve_spell))
print('spell dai balance', dai.balanceOf(curve_spell))
print('spell usdc balance', usdc.balanceOf(curve_spell))
print('spell usdt balance', usdt.balanceOf(curve_spell))
print('Alice delta A balance', curABal - prevABal)
print('Alice delta B balance', curBBal - prevBBal)
print('Alice delta C balance', curCBal - prevCBal)
print('Alice delta LP balance', curLPBal - prevLPBal)
print('remove liquidity gas', tx.gas_used)
print('bank delta lp balance', curLPBal_bank - prevLPBal_bank)
print('bank total lp balance', curLPBal_bank)
_, _, _, daiDebt, daiDebtShare = homora.getBankInfo(dai)
_, _, _, usdcDebt, usdcDebtShare = homora.getBankInfo(usdc)
_, _, _, usdtDebt, usdtDebtShare = homora.getBankInfo(usdt)
print('bank dai totalDebt', daiDebt)
print('bank dai totalDebt', daiDebt)
print('bank usdc totalShare', usdcDebtShare)
print('bank usdc totalShare', usdcDebtShare)
print('bank usdt totalDebt', usdtDebt)
print('bank usdt totalShare', usdtDebtShare)
print('LP want', lp_want)
print('bank delta LP amount', curLPBal_bank - prevLPBal_bank)
print('LP take amount', lp_take_amt)
print('prev werc20 LP balance', prevLPBal_werc20)
print('cur werc20 LP balance', curLPBal_werc20)
print('coll size', collSize)
# alice
assert almostEqual(curLPBal - prevLPBal, lp_want), 'incorrect LP amt'
# werc20
assert almostEqual(curLPBal_werc20 - prevLPBal_werc20,
-collSize), 'incorrect werc20 LP amt'
# spell
assert dai.balanceOf(curve_spell) == 0, 'non-zero spell DAI balance'
assert usdc.balanceOf(curve_spell) == 0, 'non-zero spell USDC balance'
assert usdt.balanceOf(curve_spell) == 0, 'non-zero spell USDT balance'
assert lp.balanceOf(curve_spell) == 0, 'non-zero spell LP balance'
# debt
assert usdcDebt == 0, 'usdcDebt should be 0'
assert daiDebt == 0, 'daiDebt should be 0'
assert usdtDebt == 0, 'usdtDebt should be 0'
return tx
