def test_on_take(self):
# given
on_take_mock = Mock()
self.otc.on_take(on_take_mock)
# when
self.otc.approve([self.token1], directly())
self.otc.make(have_token=self.token1.address,
have_amount=Wad.from_number(1),
want_token=self.token2.address,
want_amount=Wad.from_number(2)).transact()
# and
self.otc.approve([self.token2], directly())
self.otc.take(1, Wad.from_number(0.5)).transact()
# then
on_take = wait_until_mock_called(on_take_mock)[0]
assert on_take.id == 1
assert on_take.maker == self.our_address
assert on_take.taker == self.our_address
assert on_take.have_token == self.token1.address
assert on_take.take_amount == Wad.from_number(0.5)
assert on_take.want_token == self.token2.address
assert on_take.give_amount == Wad.from_number(1)
assert on_take.timestamp != 0
def test_direct_approval_should_raise_exception_if_approval_fails():
# given
global web3, our_address, second_address, token
token.approve = MagicMock(return_value=FailingTransact())
# expect
with pytest.raises(Exception):
directly()(token, second_address, "some-name")
def test_direct_approval():
# given
global web3, our_address, second_address, token
# when
directly()(token, second_address, "some-name")
# then
assert token.allowance_of(our_address, second_address) == Wad(2**256-1)
def test_direct_approval_should_not_approve_if_already_approved():
# given
global web3, our_address, second_address, token
token.approve(second_address, Wad(2**248+17)).transact()
# when
directly()(token, second_address, "some-name")
# then
assert token.allowance_of(our_address, second_address) == Wad(2**248+17)
def test_approve_and_make_and_getters(self):
# given
assert self.otc.get_last_offer_id() == 0
# when
self.otc.approve([self.token1], directly())
self.otc.make(have_token=self.token1.address,
have_amount=Wad.from_number(1),
want_token=self.token2.address,
want_amount=Wad.from_number(2)).transact()
# then
assert self.otc.get_last_offer_id() == 1
# and
assert self.otc.get_offer(1).offer_id == 1
assert self.otc.get_offer(1).sell_which_token == self.token1.address
assert self.otc.get_offer(1).sell_how_much == Wad.from_number(1)
assert self.otc.get_offer(1).buy_which_token == self.token2.address
assert self.otc.get_offer(1).buy_how_much == Wad.from_number(2)
assert self.otc.get_offer(1).owner == self.our_address
assert self.otc.get_offer(1).timestamp != 0
# and
assert self.otc.active_offers() == [self.otc.get_offer(1)]
def test_onchain_order_happy_path(self):
# given
self.etherdelta.approve([self.token1, self.token2], directly())
self.etherdelta.deposit_token(self.token1.address, Wad.from_number(10)).transact()
self.etherdelta.deposit_token(self.token2.address, Wad.from_number(10)).transact()
# when
self.etherdelta.place_order_onchain(token_get=self.token2.address, amount_get=Wad.from_number(4),
token_give=self.token1.address, amount_give=Wad.from_number(2),
expires=100000000).transact()
# then
assert len(self.etherdelta.active_onchain_orders()) == 1
# and
order = self.etherdelta.active_onchain_orders()[0]
assert order.token_get == self.token2.address
assert order.amount_get == Wad.from_number(4)
assert order.token_give == self.token1.address
assert order.amount_give == Wad.from_number(2)
assert order.expires == 100000000
assert order.user == self.our_address
# and
assert self.etherdelta.amount_available(order) == Wad.from_number(4)
assert self.etherdelta.amount_filled(order) == Wad.from_number(0)
# and
assert self.etherdelta.can_trade(order, Wad.from_number(1.5))
assert not self.etherdelta.can_trade(order, Wad.from_number(5.5))
def test_take_complete(self):
# given
self.otc.approve([self.token1], directly())
self.otc.make(have_token=self.token1.address,
have_amount=Wad.from_number(1),
want_token=self.token2.address,
want_amount=Wad.from_number(2)).transact()
# when
self.otc.approve([self.token2], directly())
self.otc.take(1, Wad.from_number(1)).transact()
# then
assert self.otc.get_offer(1) is None
assert self.otc.active_offers() == []
assert self.otc.get_last_offer_id() == 1
def test_take_partial(self):
# given
self.otc.approve([self.token1], directly())
self.otc.make(have_token=self.token1.address,
have_amount=Wad.from_number(1),
want_token=self.token2.address,
want_amount=Wad.from_number(2)).transact()
# when
self.otc.approve([self.token2], directly())
self.otc.take(1, Wad.from_number(0.25)).transact()
# then
assert self.otc.get_offer(1).sell_how_much == Wad.from_number(0.75)
assert self.otc.get_offer(1).buy_how_much == Wad.from_number(1.5)
assert self.otc.active_offers() == [self.otc.get_offer(1)]
assert self.otc.get_last_offer_id() == 1
def test_execute(self):
# given
self.tx.approve([self.token1], directly())
# when
self.tx.execute([self.token1.address],
[self.token1.transfer(self.other_address, Wad.from_number(500)).invocation()]).transact()
# then
assert self.token1.balance_of(self.our_address) == Wad.from_number(999500)
assert self.token1.balance_of(self.other_address) == Wad.from_number(500)
def test_approve(self):
# given
assert self.token1.allowance_of(self.our_address, self.tx.address) == Wad(0)
assert self.token2.allowance_of(self.our_address, self.tx.address) == Wad(0)
# when
self.tx.approve([self.token1, self.token2], directly())
# then
assert self.token1.allowance_of(self.our_address, self.tx.address) == Wad(2**256-1)
assert self.token2.allowance_of(self.our_address, self.tx.address) == Wad(2**256-1)
def test_past_take(self):
# when
self.otc.approve([self.token1], directly())
self.otc.make(have_token=self.token1.address,
have_amount=Wad.from_number(1),
want_token=self.token2.address,
want_amount=Wad.from_number(2)).transact()
# and
self.otc.approve([self.token2], directly())
self.otc.take(1, Wad.from_number(0.5)).transact()
# then
past_take = self.otc.past_take(PAST_BLOCKS)
assert len(past_take) == 1
assert past_take[0].id == 1
assert past_take[0].maker == self.our_address
assert past_take[0].taker == self.our_address
assert past_take[0].have_token == self.token1.address
assert past_take[0].take_amount == Wad.from_number(0.5)
assert past_take[0].want_token == self.token2.address
assert past_take[0].give_amount == Wad.from_number(1)
assert past_take[0].timestamp != 0
def test_deposit_and_withdraw_token(self):
# given
self.etherdelta.approve([self.token1], directly())
# when
self.etherdelta.deposit_token(self.token1.address, Wad.from_number(1.5)).transact()
# then
assert self.etherdelta.balance_of_token(self.token1.address, self.our_address) == Wad.from_number(1.5)
# when
self.etherdelta.withdraw_token(self.token1.address, Wad.from_number(0.2)).transact()
# then
assert self.etherdelta.balance_of_token(self.token1.address, self.our_address) == Wad.from_number(1.3)
def new_sai() -> SaiDeployment:
def deploy(web3, contract_name, args=None):
contract_factory = web3.eth.contract(
abi=json.loads(
pkg_resources.resource_string('keeper.api.feed',
f'abi/{contract_name}.abi')),
bytecode=pkg_resources.resource_string('keeper.api.feed',
f'abi/{contract_name}.bin'))
tx_hash = contract_factory.deploy(args=args)
receipt = web3.eth.getTransactionReceipt(tx_hash)
return receipt['contractAddress']
web3 = Web3(EthereumTesterProvider())
web3.eth.defaultAccount = web3.eth.accounts[0]
our_address = Address(web3.eth.defaultAccount)
sai = DSToken.deploy(web3, 'SAI')
sin = DSToken.deploy(web3, 'SIN')
gem = DSToken.deploy(web3, 'ETH')
pip = DSValue.deploy(web3)
skr = DSToken.deploy(web3, 'SKR')
pot = DSVault.deploy(web3)
pit = DSVault.deploy(web3)
tip = deploy(web3, 'Tip')
dad = DSGuard.deploy(web3)
jug = deploy(web3, 'SaiJug', [sai.address.address, sin.address.address])
jar = deploy(
web3, 'SaiJar',
[skr.address.address, gem.address.address, pip.address.address])
tub = Tub.deploy(web3, Address(jar), Address(jug), pot.address,
pit.address, Address(tip))
tap = Tap.deploy(web3, tub.address, pit.address)
top = Top.deploy(web3, tub.address, tap.address)
# set permissions
dad.permit(DSGuard.ANY, DSGuard.ANY, DSGuard.ANY).transact()
tub.set_authority(dad.address)
for auth in [sai, sin, skr, pot, pit, tap, top]:
auth.set_authority(dad.address).transact()
# approve, mint some GEMs
tub.approve(directly())
gem.mint(Wad.from_number(1000000)).transact()
web3.currentProvider.rpc_methods.evm_snapshot()
return SaiDeployment(web3, our_address, gem, sai, sin, skr, tub, tap, top)
def test_offer_comparison(self):
# when
self.otc.approve([self.token1], directly())
self.otc.make(have_token=self.token1.address,
have_amount=Wad.from_number(1),
want_token=self.token2.address,
want_amount=Wad.from_number(2)).transact()
# and
self.otc.make(have_token=self.token1.address,
have_amount=Wad.from_number(3),
want_token=self.token2.address,
want_amount=Wad.from_number(4)).transact()
# then
assert self.otc.get_last_offer_id() == 2
assert self.otc.get_offer(1) == self.otc.get_offer(1)
assert self.otc.get_offer(1) != self.otc.get_offer(2)
def approve(self):
"""Approve EtherDelta to access our SAI, so we can deposit it with the exchange"""
self.etherdelta.approve([self.sai], directly())
def approve(self):
"""Approve OasisDEX to access our balances, so we can place orders."""
self.otc.approve([self.gem, self.sai], directly())
def approve(self):
self.tub.approve(directly())
