def test_tokens_swap(self):
# given
add_liquidity = self.add_liquidity_tokens()
balance_systemcoin_before_swap = self.systemcoin_usdc_uniswap.get_account_token_balance(
self.token_systemcoin)
balance_usdc_before_swap = self.systemcoin_usdc_uniswap.get_account_token_balance(
self.token_usdc)
# when
swap = self.systemcoin_usdc_uniswap.swap_exact_tokens_for_tokens(
Wad.from_number(.2),
self.token_usdc.unnormalize_amount(Wad.from_number(.01)),
[self.ds_systemcoin.address.address, self.ds_usdc.address.address
]).transact(from_address=self.our_address)
# then
assert swap.successful == True
balance_systemcoin_after_swap = self.systemcoin_usdc_uniswap.get_account_token_balance(
self.token_systemcoin)
balance_usdc_after_swap = self.systemcoin_usdc_uniswap.get_account_token_balance(
self.token_usdc)
assert balance_systemcoin_after_swap < balance_systemcoin_before_swap
assert balance_usdc_before_swap < balance_usdc_after_swap
def test_collateral_removal(self, mocker):
try:
# given a keeper configured to return all collateral upon rebalance
token_balance_before = self.get_collateral_token_balance()
safe_engine_balance_before = self.get_collateral_safe_engine_balance(
)
self.create_keeper(mocker)
time.sleep(6) # wait for keeper to startup
assert self.get_collateral_token_balance() == token_balance_before
assert self.get_collateral_safe_engine_balance(
) == safe_engine_balance_before
# when some ETH was wrapped and joined
wrap_eth(self.geb, self.keeper_address, Wad.from_number(1.53))
token_balance = self.get_collateral_token_balance()
assert token_balance > Wad(0)
self.collateral.adapter.join(self.keeper_address,
token_balance).transact()
assert self.get_collateral_safe_engine_balance(
) == safe_engine_balance_before + token_balance
# then wait to ensure collateral was exited automatically
time.sleep(4)
assert self.get_collateral_safe_engine_balance() == Wad(0)
assert self.get_collateral_token_balance(
) == token_balance_before + Wad.from_number(1.53)
finally:
self.shutdown_keeper()
self.give_away_system_coin()
def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.zrx_token = ERC20Token(web3=self.web3,
address=deploy_contract(
self.web3, 'ZRXToken'))
self.asset_proxy = deploy_contract(self.web3, 'ExchangeV2-ERC20Proxy')
self.exchange = ZrxExchangeV2.deploy(
self.web3,
None) #"0xf47261b0" + self.zrx_token.address.address - unused yet
self.exchange._contract.functions.registerAssetProxy(
self.asset_proxy.address).transact()
token_proxy_abi = json.loads(
pkg_resources.resource_string('pyflex.deployment',
f'abi/ExchangeV2-ERC20Proxy.abi'))
asset_proxy_contract = self.web3.eth.contract(abi=token_proxy_abi)(
address=self.asset_proxy.address)
asset_proxy_contract.functions.addAuthorizedAddress(
self.exchange.address.address).transact()
self.token1 = DSToken.deploy(self.web3, 'AAA', 'AAA')
self.token1.mint(Wad.from_number(100)).transact()
self.token2 = DSToken.deploy(self.web3, 'BBB', 'BBB')
self.token2.mint(Wad.from_number(100)).transact()
def liquidate_safe(cls, web3, geb, c, auction_income_recipient_address, our_address):
safe = geb.safe_engine.safe(c.collateral_type, auction_income_recipient_address)
delta_debt = max_delta_debt(geb, c, auction_income_recipient_address) - Wad.from_number(1)
assert geb.safe_engine.modify_safe_collateralization(c.collateral_type, auction_income_recipient_address, Wad(0), delta_debt).transact(from_address=auction_income_recipient_address)
safe = geb.safe_engine.safe(c.collateral_type, auction_income_recipient_address)
set_collateral_price(geb, c, Wad.from_number(10))
# Ensure the SAFE isn't safe
assert not is_safe_safe(geb.safe_engine.collateral_type(c.collateral_type.name), safe)
# Determine how many liquidations will be required
liquidation_quantity = Wad(geb.liquidation_engine.liquidation_quantity(c.collateral_type))
liquidations_required = math.ceil(safe.generated_debt / liquidation_quantity)
print(f"locked_collateral={safe.locked_collateral} generated_debt={safe.generated_debt} so {liquidations_required} liquidations are required")
c.collateral_auction_house.approve(geb.safe_engine.address, approval_function=approve_safe_modification_directly(from_address=our_address))
# First auction that will be started
first_auction_id = c.collateral_auction_house.auctions_started() + 1
# liquidate and bid on each auction
for _ in range(liquidations_required):
auction_id = liquidate(geb, c, safe)
assert auction_id > 0
auction = c.collateral_auction_house.bids(auction_id)
bid_amount = Wad(auction.amount_to_raise) + Wad(1)
reserve_system_coin(geb, c, our_address, bid_amount)
assert c.collateral_auction_house.increase_bid_size(auction_id, auction.amount_to_sell, auction.amount_to_raise).transact(from_address=our_address)
time_travel_by(web3, c.collateral_auction_house.total_auction_length()+1)
for auction_id in range(first_auction_id, c.collateral_auction_house.auctions_started()+1):
assert c.collateral_auction_house.settle_auction(auction_id).transact()
set_collateral_price(geb, c, Wad.from_number(200))
safe = geb.safe_engine.safe(c.collateral_type, auction_income_recipient_address)
def setup_method(self):
self.web3 = get_web3()
self.our_address = get_our_address(self.web3)
self.keeper_address = get_keeper_address(self.web3)
self.other_address = get_other_address(self.web3)
self.auction_income_recipient_address = get_auction_income_recipient_address(self.web3)
self.geb = get_geb(self.web3)
self.surplus_auction_house = self.geb.surplus_auction_house
self.surplus_auction_house.approve(self.geb.prot.address, directly(from_address=self.other_address))
#self.min_auction = self.geb.surplus_auction_house.auctions_started() + 1
self.keeper = AuctionKeeper(args=args(f"--eth-from {self.keeper_address} "
f"--type surplus "
f"--from-block 1 "
f"--bid-delay 0 "
#f"--min-auction {self.min_auction} "
f"--model ./bogus-model.sh"), web3=self.web3)
self.keeper.approve()
mint_prot(self.geb.prot, self.keeper_address, Wad.from_number(50000))
mint_prot(self.geb.prot, self.other_address, Wad.from_number(50000))
assert isinstance(self.keeper.gas_price, DynamicGasPrice)
# Since no args were assigned, gas strategy should return a GeometricGasPrice starting at the node gas price
self.default_gas_price = get_node_gas_price(self.web3)
def create_surplus(geb: GfDeployment,
surplus_auction_house: PreSettlementSurplusAuctionHouse,
deployment_address: Address):
assert isinstance(geb, GfDeployment)
assert isinstance(surplus_auction_house, PreSettlementSurplusAuctionHouse)
assert isinstance(deployment_address, Address)
surplus = geb.safe_engine.coin_balance(geb.accounting_engine.address)
if surplus < geb.accounting_engine.surplus_buffer(
) + geb.accounting_engine.surplus_auction_amount_to_sell():
# Create a SAFE with surplus
print('Creating a SAFE with surplus')
collateral = geb.collaterals['ETH-B']
assert surplus_auction_house.auctions_started() == 0
wrap_eth(geb, deployment_address, Wad.from_number(10))
collateral.approve(deployment_address)
assert collateral.adapter.join(
deployment_address,
Wad.from_number(10)).transact(from_address=deployment_address)
wrap_modify_safe_collateralization(
geb,
collateral,
deployment_address,
delta_collateral=Wad.from_number(10),
delta_debt=Wad.from_number(300))
assert geb.tax_collector.tax_single(
collateral.collateral_type).transact(
from_address=deployment_address)
surplus = geb.safe_engine.coin_balance(geb.accounting_engine.address)
assert surplus > geb.accounting_engine.surplus_buffer(
) + geb.accounting_engine.surplus_auction_amount_to_sell()
else:
print(f'Surplus of {surplus} already exists; skipping SAFE creation')
def test_equality(self):
# given
transfer1a = Transfer(
token_address=Address(
'0x0000011111222223333344444555556666677777'),
from_address=Address('0x0000000000111111111100000000001111111111'),
to_address=Address('0x1111111111000000000011111111110000000000'),
value=Wad.from_number(20))
transfer1b = Transfer(
token_address=Address(
'0x0000011111222223333344444555556666677777'),
from_address=Address('0x0000000000111111111100000000001111111111'),
to_address=Address('0x1111111111000000000011111111110000000000'),
value=Wad.from_number(20))
transfer2 = Transfer(
token_address=Address(
'0x0000011111222223333344444555556666677777'),
from_address=Address('0x0000000000111111111100000000001111111111'),
to_address=Address('0x1111111111000000000011111111112222222222'),
value=Wad.from_number(20))
# expect
assert transfer1a == transfer1b
assert transfer1b == transfer1a
assert transfer1a != transfer2
assert transfer1b != transfer2
assert transfer2 != transfer1a
assert transfer2 != transfer1b
def liquidate(web3: Web3, geb: GfDeployment, our_address: Address):
collateral = geb.collaterals['ETH-A']
# Add collateral to our SAFE
delta_collateral = Wad.from_number(1)
wrap_eth(geb, our_address, delta_collateral)
assert collateral.collateral.balance_of(our_address) >= delta_collateral
assert collateral.adapter.join(our_address, delta_collateral).transact()
wrap_modify_safe_collateralization(geb, collateral, our_address,
delta_collateral, Wad(0))
# Define required liquidation parameters
to_price = Wad(Web3.toInt(collateral.osm.read())) / Wad.from_number(2)
# Manipulate price to make our SAFE underwater
# Note this will only work on a testchain deployed with fixed prices, where OSM is a DSValue
wrap_modify_safe_collateralization(
geb, collateral, our_address, Wad(0),
max_delta_debt(geb, collateral, our_address))
set_collateral_price(geb, collateral, to_price)
# Liquidate the SAFE
assert geb.liquidation_engine.can_liquidate(collateral.collateral_type,
SAFE(our_address))
assert geb.liquidation_engine.liquidate_safe(collateral.collateral_type,
SAFE(our_address)).transact()
def test_should_overbid_itself_if_model_has_updated_the_price(self, auction_id):
# given
(model, model_factory) = models(self.keeper, auction_id)
amount_to_sell = self.surplus_auction_house.bids(auction_id).amount_to_sell
# when
first_bid = Wad.from_number(0.0000004)
simulate_model_output(model=model, price=first_bid)
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.surplus_auction_house.bids(auction_id).bid_amount == Wad(amount_to_sell * self.geb.oracle_relayer.redemption_price() / Rad(first_bid))
# when
second_bid = Wad.from_number(0.0000003)
simulate_model_output(model=model, price=second_bid)
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.surplus_auction_house.bids(auction_id).bid_amount == Wad(amount_to_sell * self.geb.oracle_relayer.redemption_price() / Rad(second_bid))
# cleanup
time_travel_by(self.web3, self.surplus_auction_house.bid_duration() + 1)
assert self.surplus_auction_house.settle_auction(auction_id).transact()
def test_past_cancel(self):
# given
self.exchange.approve([self.token1, self.token2], directly())
# when
order = self.exchange.create_order(pay_token=self.token1.address,
pay_amount=Wad.from_number(10),
buy_token=self.token2.address,
buy_amount=Wad.from_number(4),
expiration=1763920792)
# and
self.exchange.cancel_order(self.exchange.sign_order(order)).transact()
# then
past_cancel = self.exchange.past_cancel(PAST_BLOCKS)
assert len(past_cancel) == 1
assert past_cancel[0].maker == self.our_address
assert past_cancel[0].fee_recipient == Address(
"0x0000000000000000000000000000000000000000")
assert past_cancel[0].pay_token == self.token1.address
assert past_cancel[0].cancelled_pay_amount == Wad.from_number(10)
assert past_cancel[0].buy_token == self.token2.address
assert past_cancel[0].cancelled_buy_amount == Wad.from_number(4)
assert past_cancel[0].tokens.startswith('0x')
assert past_cancel[0].order_hash == self.exchange.get_order_hash(
self.exchange.sign_order(order))
assert past_cancel[0].raw['blockNumber'] > 0
def test_should_be_hashable(self):
# given
order = Order(
exchange=None,
maker=Address("0x9e56625509c2f60af937f23b7b532600390e8c8b"),
taker=Address("0x0000000000000000000000000000000000000000"),
maker_fee=Wad.from_number(123),
taker_fee=Wad.from_number(456),
pay_token=Address("0x323b5d4c32345ced77393b3530b1eed0f346429d"),
pay_amount=Wad(10000000000000000),
buy_token=Address("0xef7fff64389b814a946f3e92105513705ca6b990"),
buy_amount=Wad(20000000000000000),
salt=
67006738228878699843088602623665307406148487219438534730168799356281242528500,
fee_recipient=Address(
'0x6666666666666666666666666666666666666666'),
expiration=42,
exchange_contract_address=Address(
"0x12459c951127e0c374ff9105dda097662a027093"),
ec_signature_r=
"0xf9f6a3b67b52d40c16387df2cd6283bbdbfc174577743645dd6f4bd828c7dbc3",
ec_signature_s=
"0x15baf69f6c3cc8ac0f62c89264d73accf1ae165cce5d6e2a0b6325c6e4bab964",
ec_signature_v=28)
# expect
assert is_hashable(order)
def test_should_overbid_itself_if_model_has_updated_the_price(
self, auction_id):
# given
(model, model_factory) = models(self.keeper, auction_id)
# when
simulate_model_output(model=model, price=Wad.from_number(100.0))
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert round(
Rad(self.debt_auction_house.bids(auction_id).amount_to_sell),
2) == round(self.debt_auction_bid_size / Rad.from_number(100.0), 2)
# when
simulate_model_output(model=model, price=Wad.from_number(110.0))
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.amount_to_sell_implies_price(auction_id,
Wad.from_number(110.0))
# cleanup
time_travel_by(self.web3, self.debt_auction_house.bid_duration() + 1)
assert self.debt_auction_house.settle_auction(auction_id).transact()
def test_should_replace_pending_transactions_if_model_lowers_bid_and_increases_gas_price(
self, auction_id):
# given
(model, model_factory) = models(self.keeper, auction_id)
# when
simulate_model_output(model=model,
price=Wad.from_number(80.0),
gas_price=10)
# and
self.start_ignoring_transactions()
# and
self.keeper.check_all_auctions()
# and
time.sleep(2)
# and
self.end_ignoring_transactions()
# and
simulate_model_output(model=model,
price=Wad.from_number(70.0),
gas_price=15)
# and
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.amount_to_sell_implies_price(auction_id,
Wad.from_number(70.0))
assert self.web3.eth.getBlock(
'latest', full_transactions=True).transactions[0].gasPrice == 15
# cleanup
time_travel_by(self.web3, self.debt_auction_house.bid_duration() + 1)
assert self.debt_auction_house.settle_auction(auction_id).transact()
def test_should_replace_pending_transactions_if_model_lowers_bid_and_increases_gas_price(self, auction_id):
# given
(model, model_factory) = models(self.keeper, auction_id)
amount_to_sell = self.surplus_auction_house.bids(auction_id).amount_to_sell
# when
simulate_model_output(model=model, price=Wad.from_number(10.0), gas_price=10)
# and
self.start_ignoring_transactions()
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
# and
self.end_ignoring_transactions()
# and
simulate_model_output(model=model, price=Wad.from_number(8.0), gas_price=15)
# and
self.keeper.check_for_bids()
wait_for_other_threads()
# then
assert self.surplus_auction_house.bids(auction_id).bid_amount == Wad(amount_to_sell * self.geb.oracle_relayer.redemption_price()) / Wad.from_number(8.0)
assert self.web3.eth.getBlock('latest', full_transactions=True).transactions[0].gasPrice == 15
# cleanup
time_travel_by(self.web3, self.surplus_auction_house.bid_duration() + 1)
assert self.surplus_auction_house.settle_auction(auction_id).transact()
def test_should_bid_even_if_there_is_already_a_bidder(self, auction_id):
# given
(model, model_factory) = models(self.keeper, auction_id)
prot_before = self.geb.prot.balance_of(self.keeper_address)
# and
amount_to_sell = Wad.from_number(0.000016)
assert self.debt_auction_house.decrease_sold_amount(
auction_id, amount_to_sell, self.debt_auction_bid_size).transact(
from_address=self.other_address)
assert self.debt_auction_house.bids(
auction_id).amount_to_sell == amount_to_sell
# when
simulate_model_output(model=model, price=Wad.from_number(825.0))
# and
self.keeper.check_all_auctions()
self.keeper.check_for_bids()
wait_for_other_threads()
# then
auction = self.debt_auction_house.bids(auction_id)
assert auction.amount_to_sell != amount_to_sell
assert round(
auction.bid_amount * self.geb.oracle_relayer.redemption_price() /
Rad(auction.amount_to_sell), 2) == round(Rad.from_number(825.0), 2)
prot_after = self.geb.prot.balance_of(self.keeper_address)
assert prot_before == prot_after
# cleanup
time_travel_by(self.web3, self.debt_auction_house.bid_duration() + 1)
assert self.debt_auction_house.settle_auction(auction_id).transact()
def create_surplus_auction(geb: GfDeployment, deployment_address: Address,
our_address: Address, collateral: Collateral):
assert isinstance(geb, GfDeployment)
assert isinstance(deployment_address, Address)
assert isinstance(our_address, Address)
surplus_auction_house = geb.surplus_auction_house
create_surplus(geb, surplus_auction_house, deployment_address, collateral)
coin_balance = geb.safe_engine.coin_balance(geb.accounting_engine.address)
assert coin_balance > geb.safe_engine.debt_balance(
geb.accounting_engine.address
) + geb.accounting_engine.surplus_auction_amount_to_sell(
) + geb.accounting_engine.surplus_buffer()
assert (geb.safe_engine.debt_balance(geb.accounting_engine.address) -
geb.accounting_engine.total_queued_debt()
) - geb.accounting_engine.total_on_auction_debt() == Rad(0)
assert geb.accounting_engine.auction_surplus().transact()
mint_prot(geb.prot, our_address, Wad.from_number(10))
surplus_auction_house.approve(geb.prot.address,
directly(from_address=our_address))
bid = Wad.from_number(0.001)
assert geb.prot.balance_of(our_address) > bid
assert surplus_auction_house.increase_bid_size(
surplus_auction_house.auctions_started(),
geb.accounting_engine.surplus_auction_amount_to_sell(),
bid).transact(from_address=our_address)
def test_do_not_empty(self):
# given system_coin and collateral in the safe_engine
keeper = self.create_keeper(False, False)
purchase_system_coin(Wad.from_number(153), self.keeper_address)
assert self.get_system_coin_token_balance() >= Wad.from_number(153)
assert self.geb.system_coin_adapter.join(
self.keeper_address,
Wad.from_number(153)).transact(from_address=self.keeper_address)
wrap_eth(self.geb, self.keeper_address, Wad.from_number(6))
# and balances before
system_coin_token_balance_before = self.get_system_coin_token_balance()
system_coin_safe_engine_balance_before = self.get_system_coin_safe_engine_balance(
)
collateral_token_balance_before = self.get_collateral_token_balance()
collateral_safe_engine_balance_before = self.get_collateral_safe_engine_balance(
)
# when creating and shutting down the keeper
keeper.shutdown()
# then ensure no balances changed
assert system_coin_token_balance_before == self.get_system_coin_token_balance(
)
assert system_coin_safe_engine_balance_before == self.get_system_coin_safe_engine_balance(
)
assert collateral_token_balance_before == self.get_collateral_token_balance(
)
assert collateral_safe_engine_balance_before == self.get_collateral_safe_engine_balance(
)
def test_empty_collateral_only(self):
# given collateral balances before
collateral_token_balance_before = self.get_collateral_token_balance()
collateral_safe_engine_balance_before = self.get_collateral_safe_engine_balance(
)
# when adding system_coin
purchase_system_coin(Wad.from_number(79), self.keeper_address)
assert self.geb.system_coin_adapter.join(
self.keeper_address,
Wad.from_number(79)).transact(from_address=self.keeper_address)
system_coin_token_balance_before = self.get_system_coin_token_balance()
system_coin_safe_engine_balance_before = self.get_system_coin_safe_engine_balance(
)
# and creating and shutting down the keeper
keeper = self.create_keeper(False, True)
keeper.shutdown()
# then ensure system_coin was not emptied
assert self.get_system_coin_token_balance() == Wad(0)
assert system_coin_safe_engine_balance_before < self.get_system_coin_safe_engine_balance(
)
# and collateral was emptied
assert collateral_token_balance_before == collateral_token_balance_before + collateral_safe_engine_balance_before
assert self.get_collateral_safe_engine_balance() == Wad(0)
def test_multiply_by_ray(self):
assert Wad.from_number(2) * Ray.from_number(3) == Wad.from_number(6)
assert Wad.from_number(2) * Ray(3) == Wad(0)
assert Wad(2) * Ray(499999999999999999999999999) == Wad(0)
assert Wad(2) * Ray(500000000000000000000000000) == Wad(1)
assert Wad(2) * Ray(999999999999999999999999999) == Wad(1)
assert Wad(2) * Ray(1000000000000000000000000000) == Wad(2)
def test_round_inequality(self):
# should hold for all x, ndigits
x = Wad.from_number(7654.321)
ndigits = 1
round_difference = x - round(x, ndigits)
round_distance = Wad(abs(round_difference.value))
assert round_distance <= Wad.from_number(0.5 * 10**(-ndigits))
def test_price(self, web3, geb):
collateral = geb.collaterals['ETH-B']
set_collateral_price(geb, collateral, Wad.from_number(200))
# Note this isn't actually an OSM, but we can still read storage slots
osm = OSM(web3, collateral.osm.address)
raw_price = osm.read()
assert isinstance(raw_price, int)
assert Wad.from_number(200) == Wad(raw_price)
def test_divide(self):
assert Wad.from_number(4) / Wad.from_number(2) == Wad.from_number(2)
assert Wad(4) / Wad.from_number(2) == Wad(2)
assert Wad(3) / Wad.from_number(2) == Wad(1)
assert Wad(39) / Wad.from_number(20) == Wad(1)
assert Wad(40) / Wad.from_number(20) == Wad(2)
assert Wad.from_number(0.2) / Wad.from_number(0.1) == Wad.from_number(
2)
def auction_id(web3: Web3, geb: GfDeployment, auction_income_recipient_address,
other_address) -> int:
total_surplus = geb.safe_engine.coin_balance(geb.accounting_engine.address)
unqueued_unauctioned_debt = (
geb.safe_engine.debt_balance(geb.accounting_engine.address) -
geb.accounting_engine.total_queued_debt()
) - geb.accounting_engine.total_on_auction_debt()
print(
f'total_surplus={str(total_surplus)[:6]}, unqueued_unauctioned_debt={str(unqueued_unauctioned_debt)[:6]}'
)
if unqueued_unauctioned_debt < total_surplus or (
unqueued_unauctioned_debt == Rad(0) and total_surplus == Rad(0)):
# Liquidate SAFE
c = geb.collaterals['ETH-B']
critical_safe = create_critical_safe(geb,
c,
Wad.from_number(2),
other_address,
draw_system_coin=False)
collateral_auction_id = liquidate(geb, c, critical_safe)
# Generate some system coin, bid on and win the collateral auction without covering all the debt
reserve_system_coin(geb,
c,
auction_income_recipient_address,
Wad.from_number(100),
extra_collateral=Wad.from_number(1.1))
c.collateral_auction_house.approve(
geb.safe_engine.address,
approval_function=approve_safe_modification_directly(
from_address=auction_income_recipient_address))
current_bid = c.collateral_auction_house.bids(collateral_auction_id)
bid_amount = Rad.from_number(1.9)
assert geb.safe_engine.coin_balance(
auction_income_recipient_address) > bid_amount
#assert c.collateral_auction_house.increase_bid_size(collateral_auction_id, current_bid.amount_to_sell, bid_amount).transact(from_address=auction_income_recipient_address)
#time_travel_by(web3, c.collateral_auction_house.bid_duration()+1)
#assert c.collateral_auction_house.settle_auction(collateral_auction_id).transact()
pop_debt_and_settle_debt(web3,
geb,
past_blocks=1200,
cancel_auctioned_debt=False)
# Start the debt auction
unqueued_unauctioned_debt = (
geb.safe_engine.debt_balance(geb.accounting_engine.address) -
geb.accounting_engine.total_queued_debt()
) - geb.accounting_engine.total_on_auction_debt()
assert geb.accounting_engine.debt_auction_bid_size(
) <= unqueued_unauctioned_debt
assert geb.safe_engine.coin_balance(
geb.accounting_engine.address) == Rad(0)
assert geb.accounting_engine.auction_debt().transact(
from_address=auction_income_recipient_address)
return geb.debt_auction_house.auctions_started()
def create_debt_auction(geb: GfDeployment, deployment_address: Address,
our_address: Address):
assert isinstance(geb, GfDeployment)
assert isinstance(deployment_address, Address)
assert isinstance(our_address, Address)
debt_auction_house = geb.debt_auction_house
print(
f"Before Debt: {geb.safe_engine.debt_balance(geb.accounting_engine.address)}"
)
if geb.accounting_engine.unqueued_unauctioned_debt(
) <= geb.accounting_engine.debt_auction_bid_size():
create_debt(geb.web3, geb, our_address, deployment_address,
geb.collaterals['ETH-A'])
print(
f"After Debt: {geb.safe_engine.debt_balance(geb.accounting_engine.address)}"
)
# start debt auction
auction_id = debt_auction_house.auctions_started()
assert auction_id == 0
assert len(debt_auction_house.active_auctions()) == 0
assert geb.safe_engine.coin_balance(
geb.accounting_engine.address) == Rad(0)
assert geb.accounting_engine.auction_debt().transact()
auction_id = debt_auction_house.auctions_started()
assert auction_id == 1
assert len(debt_auction_house.active_auctions()) == 1
check_active_auctions(debt_auction_house)
current_bid = debt_auction_house.bids(auction_id)
amount_to_sell = Wad.from_number(0.000005)
# current_bid.bid_amount = 0.001
# current_bid.amount_to_sell = 0.0001
debt_auction_house.approve(
geb.safe_engine.address,
approval_function=approve_safe_modification_directly(
from_address=our_address))
assert geb.safe_engine.safe_rights(our_address, debt_auction_house.address)
collateral = geb.collaterals['ETH-A']
wrap_eth(geb, our_address, Wad.from_number(1))
collateral.approve(our_address)
assert collateral.adapter.join(
our_address, Wad.from_number(1)).transact(from_address=our_address)
#web3.eth.defaultAccount = our_address.address
wrap_modify_safe_collateralization(geb,
collateral,
our_address,
delta_collateral=Wad.from_number(1),
delta_debt=Wad.from_number(10))
assert geb.safe_engine.coin_balance(our_address) >= current_bid.bid_amount
decrease_sold_amount(debt_auction_house, auction_id, our_address,
amount_to_sell, current_bid.bid_amount)
current_bid = debt_auction_house.bids(auction_id)
assert current_bid.high_bidder == our_address
def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.other_address = Address(self.web3.eth.accounts[1])
self.tx = TxManager.deploy(self.web3)
self.token1 = DSToken.deploy(self.web3, 'ABC', 'ABC')
self.token1.mint(Wad.from_number(1000000)).transact()
self.token2 = DSToken.deploy(self.web3, 'DEF', 'DEF')
self.token2.mint(Wad.from_number(1000000)).transact()
def test_getting_balances(self):
# given
self.dgx.mint(Wad(17 * 10**9)).transact()
self.dai.mint(Wad.from_number(17)).transact()
# when
balances = self.zrx_api.get_balances(self.pair)
# then
assert balances[0] == Wad.from_number(17)
assert balances[1] == Wad.from_number(17)
def test_prepare_coins_for_redeeming(self, geb, our_address):
assert geb.global_settlement.coin_bag(our_address) == Wad(0)
assert geb.global_settlement.outstanding_coin_supply() > Rad(0)
assert geb.system_coin.approve(
geb.global_settlement.address).transact()
assert geb.safe_engine.coin_balance(our_address) >= Rad.from_number(10)
# FIXME: `prepareCoinsForRedeeming` fails, possibly because we're passing 0 to `safeEngine.transfer_collateral`
assert geb.global_settlement.prepare_coins_for_redeeming(
Wad.from_number(10)).transact()
assert geb.global_settlement.coin_bag(our_address) == Wad.from_number(
10)
def test_eth_transfer(self):
# given
initial_balance = eth_balance(self.web3, self.second_address)
# when
eth_transfer(self.web3, self.second_address,
Wad.from_number(1.5)).transact()
# then
assert eth_balance(
self.web3,
self.second_address) == initial_balance + Wad.from_number(1.5)
def test_join_all(self):
# given system_coin we just exited
token_balance_before = self.get_system_coin_token_balance()
assert token_balance_before == Wad.from_number(237)
# when keeper is started with a token balance
self.create_keeper_join_all()
# then ensure all available tokens were joined
assert self.get_system_coin_token_balance() == Wad(0)
assert self.get_system_coin_safe_engine_balance() == Wad.from_number(
237)
def test_exit_all(self):
# given balances before
assert self.get_system_coin_token_balance() == Wad.from_number(37)
assert self.get_system_coin_safe_engine_balance() == Wad.from_number(
200)
# when rebalancing to 0
self.create_keeper(0.0)
# then ensure all system_coin has been exited
assert self.get_system_coin_token_balance() == Wad.from_number(237)
assert self.get_system_coin_safe_engine_balance() == Wad(0)
