def setUp(self):
super(SLATests, self).setUp()
self.eth_token = Token.objects.first()
lqd_token_address = deploy_new_test_token(test_case=self)
distribute_token_balance_to_addresses(
test_case=self,
token_address=lqd_token_address,
recipients=testrpc_accounts.accounts)
self.lqd_token = register_token(token_address=lqd_token_address,
name='Liquidity',
short_name='LQD',
register_on_chain=True)
send_queued_transactions()
self.tokens = [self.eth_token, self.lqd_token]
self.registered_accounts = {
self.eth_token: register_testrpc_accounts(self,
token=self.eth_token),
self.lqd_token: register_testrpc_accounts(self,
token=self.lqd_token)
}
def heartbeat_verifier():
# synchronize with contract
synchronize_contract_state()
# respond to challenges
respond_to_challenges()
# confirm withdrawals
confirm_withdrawals()
# broadcast on-chain transactions
send_queued_transactions()
def setUp(self):
super(SwapTestCase, self).setUp()
self.eth_token = Token.objects.first()
lqd_token_address = deploy_new_test_token(test_case=self)
distribute_token_balance_to_addresses(
test_case=self,
token_address=lqd_token_address,
recipients=testrpc_accounts.accounts)
self.lqd_token = register_token(token_address=lqd_token_address,
name='Liquidity',
short_name='LQD',
register_on_chain=True)
send_queued_transactions()
self.tokens = [self.eth_token, self.lqd_token]
TokenPair.objects.create(token_from=self.eth_token,
token_to=self.lqd_token)
TokenPair.objects.create(token_from=self.lqd_token,
token_to=self.eth_token)
self.registered_accounts = {
self.eth_token: register_testrpc_accounts(self,
token=self.eth_token),
self.lqd_token: register_testrpc_accounts(self,
token=self.lqd_token)
}
for token in self.tokens:
self.assertEqual(
self.contract_interface.get_unmanaged_funds(token.address, 1),
0)
self.assertEqual(
self.contract_interface.get_managed_funds(token.address, 1), 0)
for token in self.tokens:
create_deposits(self, testrpc_accounts.accounts, token)
for token in self.tokens:
self.assertEqual(
self.contract_interface.get_unmanaged_funds(token.address, 1),
self.contract_interface.get_total_balance(token.address))
self.assertEqual(
self.contract_interface.get_managed_funds(token.address, 1), 0)
# remove hub account (used to remove extra funds) and last account (top make them even) to make list size 8
self.testrpc_accounts = testrpc_accounts.accounts[1:-1]
def test_make_random_valid_erc20_transactions(self):
eth_token = Token.objects.first()
lqd_token_address = deploy_new_test_token(test_case=self)
distribute_token_balance_to_addresses(
test_case=self,
token_address=lqd_token_address,
recipients=testrpc_accounts.accounts)
lqd_token = register_token(token_address=lqd_token_address,
name='Liquidity',
short_name='LQD',
register_on_chain=True)
send_queued_transactions()
tokens = [eth_token, lqd_token]
registered_accounts = {
eth_token: register_testrpc_accounts(self, token=eth_token),
lqd_token: register_testrpc_accounts(self, token=lqd_token)
}
for token in tokens:
self.assertEqual(
self.contract_interface.get_unmanaged_funds(token.address, 1),
0)
self.assertEqual(
self.contract_interface.get_managed_funds(token.address, 1), 0)
for token in tokens:
make_random_valid_transactions(test_case=self,
eon_number=1,
accounts=registered_accounts[token],
token=token)
for token in tokens:
self.assertEqual(
self.contract_interface.get_unmanaged_funds(token.address, 1),
self.contract_interface.get_total_balance(token.address))
self.assertEqual(
self.contract_interface.get_managed_funds(token.address, 1), 0)
def test_checkpoint_creation(self):
self.eth_token = Token.objects.first()
lqd_token_address = deploy_new_test_token(test_case=self)
distribute_token_balance_to_addresses(
test_case=self,
token_address=lqd_token_address,
recipients=testrpc_accounts.accounts)
self.lqd_token = register_token(token_address=lqd_token_address,
name='Liquidity',
short_name='LQD',
register_on_chain=True)
send_queued_transactions()
self.tokens = [self.eth_token, self.lqd_token]
TokenPair.objects.create(token_from=self.eth_token,
token_to=self.lqd_token)
TokenPair.objects.create(token_from=self.lqd_token,
token_to=self.eth_token)
self.registered_accounts = {
self.eth_token: register_testrpc_accounts(self,
token=self.eth_token),
self.lqd_token: register_testrpc_accounts(self,
token=self.lqd_token)
}
for token in self.tokens:
self.assertEqual(
self.contract_interface.get_unmanaged_funds(token.address, 1),
0)
self.assertEqual(
self.contract_interface.get_managed_funds(token.address, 1), 0)
for token in self.tokens:
create_deposits(self, testrpc_accounts.accounts, token)
for token in self.tokens:
self.assertEqual(
self.contract_interface.get_unmanaged_funds(token.address, 1),
self.contract_interface.get_total_balance(token.address))
self.assertEqual(
self.contract_interface.get_managed_funds(token.address, 1), 0)
for account in testrpc_accounts.accounts[1:5]:
eth_wallet = Wallet.objects.get(address=remove_0x_prefix(
account.get('address')),
token=self.eth_token)
lqd_wallet = Wallet.objects.get(address=remove_0x_prefix(
account.get('address')),
token=self.lqd_token)
eth_wallet_context = WalletTransferContext(wallet=eth_wallet,
transfer=None)
lqd_wallet_context = WalletTransferContext(wallet=lqd_wallet,
transfer=None)
account[
'reduced_eth_balance'] = eth_wallet_context.available_funds_at_eon(
eon_number=1, only_appended=False) - 1
account[
'reduced_lqd_balance'] = lqd_wallet_context.available_funds_at_eon(
eon_number=1, only_appended=False)
send_swap( # Buy LQD at 0.5 ETH
test_case=self,
eon_number=1,
account=account,
token=self.eth_token,
token_swapped=self.lqd_token,
amount=1,
amount_swapped=2,
nonce=random.randint(1, 999999))
for account in testrpc_accounts.accounts[5:9]:
eth_wallet = Wallet.objects.get(address=remove_0x_prefix(
account.get('address')),
token=self.eth_token)
lqd_wallet = Wallet.objects.get(address=remove_0x_prefix(
account.get('address')),
token=self.lqd_token)
eth_wallet_context = WalletTransferContext(wallet=eth_wallet,
transfer=None)
lqd_wallet_context = WalletTransferContext(wallet=lqd_wallet,
transfer=None)
account[
'reduced_eth_balance'] = eth_wallet_context.available_funds_at_eon(
eon_number=1, only_appended=False)
account[
'reduced_lqd_balance'] = lqd_wallet_context.available_funds_at_eon(
eon_number=1, only_appended=False) - 2
send_swap( # Sell LQD at 0.5 ETH
test_case=self,
eon_number=1,
account=account,
token=self.lqd_token,
token_swapped=self.eth_token,
amount=2,
amount_swapped=1,
nonce=random.randint(1, 999999))
confirm_swaps_for_eon(operator_eon_number=1)
cancel_finalize_swaps_for_eon(operator_eon_number=1)
process_swaps_for_eon(operator_eon_number=1)
for account in testrpc_accounts.accounts[1:5]:
finalize_last_swap(test_case=self,
token=self.eth_token,
token_swapped=self.lqd_token,
account=account)
for account in testrpc_accounts.accounts[5:9]:
finalize_last_swap(test_case=self,
token=self.lqd_token,
token_swapped=self.eth_token,
account=account)
confirm_swaps_for_eon(operator_eon_number=1)
cancel_finalize_swaps_for_eon(operator_eon_number=1)
process_swaps_for_eon(operator_eon_number=1)
buyers_sellers = [
testrpc_accounts.accounts[1:5], testrpc_accounts.accounts[5:9]
]
for i in range(0, 2):
for account in buyers_sellers[i]:
eth_wallet = Wallet.objects.get(address=remove_0x_prefix(
account.get('address')),
token=self.eth_token)
lqd_wallet = Wallet.objects.get(address=remove_0x_prefix(
account.get('address')),
token=self.lqd_token)
eth_wallet_context = WalletTransferContext(wallet=eth_wallet,
transfer=None)
lqd_wallet_context = WalletTransferContext(wallet=lqd_wallet,
transfer=None)
eth_out, eth_in = eth_wallet_context.off_chain_actively_sent_received_amounts(
eon_number=1, only_appended=False)
lqd_out, lqd_in = lqd_wallet_context.off_chain_actively_sent_received_amounts(
eon_number=1, only_appended=False)
eth_out -= account['reduced_eth_balance']
lqd_out -= account['reduced_lqd_balance']
if i == 0: # LQD buyers
assert eth_out == 1 and eth_in == 0, '{}/{}'.format(
eth_out, eth_in)
assert lqd_out - 2 == 0 and lqd_in - 2 == 2, '{}/{}'.format(
lqd_out, lqd_in)
else: # LQD sellers
assert lqd_out == 2 and lqd_in == 0, '{}/{}'.format(
lqd_out, lqd_in)
assert eth_out - 1 == 0 and eth_in - 1 == 1, '{}/{}'.format(
eth_out, eth_in)
# Verify transfers were complete
swaps = Transfer.objects.filter(swap=True)
for transfer in swaps:
self.assertTrue(transfer.is_fulfilled_swap())
commit_eon(test_case=self, eon_number=1)
advance_to_next_eon(test_case=self, eon_number=1)
commit_eon(test_case=self, eon_number=2)