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 __init__(self): super().__init__() self.offchain = self.arguments.offchain self.order_age = self.arguments.order_age self.max_eth_amount = Wad.from_number(self.arguments.max_eth_amount) self.min_eth_amount = Wad.from_number(self.arguments.min_eth_amount) self.max_sai_amount = Wad.from_number(self.arguments.max_sai_amount) self.min_sai_amount = Wad.from_number(self.arguments.min_sai_amount) self.eth_reserve = Wad.from_number(self.arguments.eth_reserve) self.min_margin = self.arguments.min_margin self.avg_margin = self.arguments.avg_margin self.max_margin = self.arguments.max_margin self.etherdelta_address = Address( self.config.get_config()["etherDelta"]["contract"]) self.etherdelta_api_server = self.config.get_config()["etherDelta"]["apiServer"][1] \ if "apiServer" in self.config.get_config()["etherDelta"] \ else None self.etherdelta = EtherDelta(web3=self.web3, address=self.etherdelta_address, api_server=self.etherdelta_api_server) if self.offchain and not self.etherdelta.supports_offchain_orders(): raise Exception( "Off-chain EtherDelta orders not supported on this chain")
def test_should_identify_multi_step_opportunities(self, token1, token2, token3, token4): # given conversion1 = Conversion(token1, token2, Ray.from_number(1.02), Wad.from_number(10000), 'met1') conversion2 = Conversion(token2, token3, Ray.from_number(1.03), Wad.from_number(10000), 'met2') conversion3 = Conversion(token3, token4, Ray.from_number(1.05), Wad.from_number(10000), 'met3') conversion4 = Conversion(token4, token1, Ray.from_number(1.07), Wad.from_number(10000), 'met4') conversions = [conversion1, conversion2, conversion3, conversion4] base_token = token1 # when opportunities = OpportunityFinder(conversions).find_opportunities( base_token, Wad.from_number(100)) # then assert len(opportunities) == 1 assert len(opportunities[0].steps) == 4 assert opportunities[0].steps[0].method == "met1" assert opportunities[0].steps[1].method == "met2" assert opportunities[0].steps[2].method == "met3" assert opportunities[0].steps[3].method == "met4"
def test_tag(self, sai: SaiDeployment): # when DSValue(web3=sai.web3, address=sai.tub.pip()).poke_with_int( Wad.from_number(250.45).value) # then assert sai.tub.tag() == Wad.from_number(250.45)
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 __init__(self): super().__init__() self.base_token = ERC20Token(web3=self.web3, address=ERC20Token.token_address_by_name( self.arguments.base_token)) self.min_profit = Wad.from_number(self.arguments.min_profit) self.max_engagement = Wad.from_number(self.arguments.max_engagement) if len(self.arguments.excluded_makers) > 0: self.excluded_makers = set( map(lambda maker: Address(maker), self.arguments.excluded_makers.split(','))) else: self.excluded_makers = set() self.max_errors = self.arguments.max_errors self.errors = 0 if self.arguments.tx_manager: self.tx_manager_address = Address(self.arguments.tx_manager) self.tx_manager = TxManager(web3=self.web3, address=self.tx_manager_address) if self.tx_manager.owner() != self.our_address: logging.info( f"The TxManager has to be owned by the address the keeper is operating from." ) exit(-1) else: self.tx_manager_address = None self.tx_manager = None
def test_cork_and_hat(self, sai: SaiDeployment): # given assert sai.tub.hat() == Wad(0) # when sai.tub.cork(Wad.from_number(150000)) # then assert sai.tub.hat() == Wad.from_number(150000)
def test_jump_and_gap(self, sai: SaiDeployment): # given assert sai.tap.gap() == Wad.from_number(1) # when sai.tap.jump(Wad.from_number(1.05)) # then assert sai.tap.gap() == Wad.from_number(1.05)
def __init__(self): super().__init__() self.max_weth_amount = Wad.from_number(self.arguments.max_weth_amount) self.min_weth_amount = Wad.from_number(self.arguments.min_weth_amount) self.max_sai_amount = Wad.from_number(self.arguments.max_sai_amount) self.min_sai_amount = Wad.from_number(self.arguments.min_sai_amount) self.min_margin = self.arguments.min_margin self.avg_margin = self.arguments.avg_margin self.max_margin = self.arguments.max_margin
def test_nicely_convert_to_string_with_amounts(token1, token2): # given conversion = Conversion(token1, token2, Ray.from_number(1.01), Wad.from_number(1000), 'met()') conversion.source_amount = Wad.from_number(50) conversion.target_amount = Wad.from_number(50.5) # expect assert str(conversion) == "[50.000000000000000000 TK1 -> 50.500000000000000000 TK2 @1.010000000000000000000000000" \ " by met() (max=1000.000000000000000000 TK1)]"
def test_should_format_net_balances(token1, our_address, some_address): # given transfer1 = Transfer(token1, our_address, some_address, Wad.from_number(15)) transfer2 = Transfer(token1, some_address, our_address, Wad.from_number(17)) # expect assert TransferFormatter().format_net([transfer1, transfer2], our_address) \ == "2.000000000000000000 TK1"
def prepare_balances(self): recipient = Address('0x002ca7F9b416B2304cDd20c26882d1EF5c53F611') if self.sai.balance_of(self.our_address) > Wad(0): self.sai.transfer(recipient, self.sai.balance_of(self.our_address)) if self.skr.balance_of(self.our_address) > Wad(0): self.skr.transfer(recipient, self.skr.balance_of(self.our_address)) if self.gem.balance_of(self.our_address) > Wad.from_number(0.5): self.gem.transfer( recipient, self.gem.balance_of(self.our_address) - Wad.from_number(0.5))
def test_s2s_and_bid_and_ask(self, sai: SaiDeployment): # when DSValue(web3=sai.web3, address=sai.tub.pip()).poke_with_int( Wad.from_number(500).value) sai.tap.jump(Wad.from_number(1.05)) # then assert sai.tap.bid() == Wad.from_number(475) assert sai.tap.s2s() == Wad.from_number(500) assert sai.tap.ask() == Wad.from_number(525)
def test_should_format_two_different_tokens(token1, token2, some_address): # given transfer1 = Transfer(token1, some_address, some_address, Wad.from_number(105)) transfer2 = Transfer(token2, some_address, some_address, Wad.from_number(17)) # expect assert TransferFormatter().format([transfer1, transfer2]) \ == "105.000000000000000000 TK1 and 17.000000000000000000 TK2"
def bustable_amount_in_sai(self, tap: Tap): #TODO we always try to bust 10 SAI less than what the Tub reports #in order to discount the growth of `joy()` that might've have happened since the last drip #of course this is not the right solution and it won't even work properly if the last #drip happened enough time ago bustable_woe = tap.woe() - tap.joy() - Wad.from_number(10) # we deduct 0.000001 in order to avoid rounding errors bustable_fog = tap.fog() * tap.ask() - Wad.from_number(0.000001) return Wad.max(bustable_woe, bustable_fog, Wad.from_number(0))
def test_should_format_net_balances_excluding_transfers_between_us( token1, our_address, some_address): # given transfer1 = Transfer(token1, some_address, our_address, Wad.from_number(4)) transfer2 = Transfer(token1, our_address, some_address, Wad.from_number(1.5)) transfer3 = Transfer(token1, our_address, our_address, Wad.from_number(50)) # expect assert TransferFormatter().format_net([transfer1, transfer2, transfer3], our_address) \ == "2.500000000000000000 TK1"
def test_should_calculate_total_rate(self, token1, token2): # given step1 = Conversion(token1, token2, Ray.from_number(1.01), Wad.from_number(1000), 'met1') step2 = Conversion(token2, token1, Ray.from_number(1.02), Wad.from_number(1000), 'met2') # when sequence = Sequence([step1, step2]) # then assert sequence.total_rate() == Ray.from_number(1.0302)
def test_should_format_net_balances_if_multiple_transfers( token1, our_address, some_address): # given transfer1 = Transfer(token1, our_address, some_address, Wad.from_number(15)) transfer2 = Transfer(token1, some_address, our_address, Wad.from_number(17)) transfer3 = Transfer(token1, some_address, our_address, Wad.from_number(3.5)) # expect assert TransferFormatter().format_net([transfer1, transfer2, transfer3], our_address) \ == "5.500000000000000000 TK1"
def test_should_format_net_balances_for_more_than_one_token( token1, token2, our_address, some_address): # given transfer1 = Transfer(token1, our_address, some_address, Wad.from_number(15)) transfer2 = Transfer(token1, some_address, our_address, Wad.from_number(17)) transfer3 = Transfer(token2, our_address, some_address, Wad.from_number(2.5)) transfer4 = Transfer(token2, some_address, our_address, Wad.from_number(100)) # expect assert TransferFormatter().format_net([transfer1, transfer2, transfer3, transfer4], our_address) \ == "2.000000000000000000 TK1 and 97.500000000000000000 TK2"
def test_should_not_include_zeros_in_net_balances(token1, token2, our_address, some_address): # given transfer1 = Transfer(token1, our_address, some_address, Wad.from_number(15)) transfer2 = Transfer(token1, some_address, our_address, Wad.from_number(17)) transfer3 = Transfer(token2, our_address, some_address, Wad.from_number(22.5)) transfer4 = Transfer(token2, some_address, our_address, Wad.from_number(22.5)) # expect assert TransferFormatter().format_net([transfer1, transfer2, transfer3, transfer4], our_address) \ == "2.000000000000000000 TK1"
def test_should_recognize_if_there_are_no_opportunities( self, token1, token2, token3): # given conversion1 = Conversion(token1, token2, Ray.from_number(1.02), Wad.from_number(10000), 'met1') conversion2 = Conversion(token2, token3, Ray.from_number(1.03), Wad.from_number(10000), 'met2') conversions = [conversion1, conversion2] base_token = token1 # when opportunities = OpportunityFinder(conversions).find_opportunities( base_token, Wad.from_number(100)) # then assert len(opportunities) == 0
def __init__(self, tub: Tub): self.tub = tub super().__init__(source_token=self.tub.skr(), target_token=self.tub.gem(), rate=tub.jar_bid(), max_source_amount=Wad.from_number(1000000), #1 mio SKR = infinity ;) method="tub.exit()")
def __init__(self, tub: Tub): self.tub = tub super().__init__(source_token=self.tub.gem(), target_token=self.tub.skr(), rate=(Ray.from_number(1) / tub.jar_ask()), max_source_amount=Wad.from_number(1000000), #1 mio ETH = infinity ;) method="tub.join()")
def close_position(self): cup_id = 8 # (1) Exchange our ETH to SAI as we want to repay our SAI debt our_entire_gem = self.gem.balance_of(self.our_address) conversion = self.gem_to_sai_conversion() sequence = Sequence([conversion]) if our_entire_gem > Wad.from_number(0.0001): sequence.set_amounts(our_entire_gem) receipt = sequence.steps[0].execute() if receipt: logging.info(receipt.transfers) self.print_balances() our_debt = self.tub.tab(cup_id) print(our_debt) our_sai_balanace = self.sai.balance_of(self.our_address) if our_sai_balanace < our_debt: logging.info("NOT ENOUGH SAI TO REPAY OUR DEBT!") exit(-1) # (2) Repay the debt and get back our SKR # some surplus of SAI will be left, this is the profit we made # self.tub.wipe(cup_id, Wad.from_number(1)) logging.info(self.tub.shut(cup_id)) self.print_balances() # (3) Exchange SKR back to ETH if self.skr.balance_of(self.our_address) > Wad(0): logging.info(self.tub.exit(self.skr.balance_of(self.our_address))) self.print_balances()
def test_should_format_single_transfer(token1, some_address): # given transfer = Transfer(token1, some_address, some_address, Wad.from_number(105)) # expect assert TransferFormatter().format([transfer ]) == "105.000000000000000000 TK1"
def test_lock_and_free(self, sai: SaiDeployment): # given sai.tub.open() sai.tub.join(Wad.from_number(10)) # when print(sai.tub.cupi()) sai.tub.lock(1, Wad.from_number(5)) # then assert sai.tub.ink(1) == Wad.from_number(5) # when sai.tub.free(1, Wad.from_number(3)) # then assert sai.tub.ink(1) == Wad.from_number(2)
def test_support_iterators(token1, some_address): # given transfer = Transfer(token1, some_address, some_address, Wad.from_number(11.5)) # expect assert TransferFormatter().format(iter([transfer ])) == "11.500000000000000000 TK1"
def test_nicely_convert_to_string_without_amounts(token1, token2): # given conversion = Conversion(token1, token2, Ray.from_number(1.01), Wad.from_number(1000), 'met()') # expect assert str( conversion ) == "[TK1 -> TK2 @1.010000000000000000000000000 by met() (max=1000.000000000000000000 TK1)]"
def test_should_identify_opportunity(self, token1, token2): # given conversion1 = Conversion(token1, token2, Ray.from_number(1.02), Wad.from_number(10000), 'met1') conversion2 = Conversion(token2, token1, Ray.from_number(1.03), Wad.from_number(10000), 'met2') conversions = [conversion1, conversion2] base_token = token1 # when opportunities = OpportunityFinder(conversions).find_opportunities( base_token, Wad.from_number(100)) # then assert len(opportunities) == 1 assert len(opportunities[0].steps) == 2 assert opportunities[0].steps[0].method == "met1" assert opportunities[0].steps[1].method == "met2"
def test_should_calculate_tx_costs(self, token1): # expect the tx_costs to be non negative and to increase with the number of steps steps = [] prev_tx_costs = Wad.from_number(0) for i in range(10): steps.append(Conversion(token1, token1, Ray(0), Wad(0), 'met')) opportunity = Sequence(steps) tx_costs = opportunity.tx_costs() assert (tx_costs > prev_tx_costs) prev_tx_costs = tx_costs