def test_cancel_multi_eon_swap(self): 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) buy_lqd_nonce = random.randint(1, 999999) sell_lqd_nonce = random.randint(1, 999999) total_remaining_eons = 5 # make persistent swap buy_lqd = send_swap( # Buy LQD at 0.5 ETH test_case=self, eon_number=2, account=self.testrpc_accounts[1], token=self.eth_token, token_swapped=self.lqd_token, amount=1, amount_swapped=2, nonce=buy_lqd_nonce, eon_count=total_remaining_eons) swap = Transfer.objects.filter( swap=True, wallet__token=self.eth_token).order_by('id')[0] swap_tx_id = swap.tx_id wallet_transfer_context = WalletTransferContext(wallet=swap.wallet, transfer=None) recipient_transfer_context = WalletTransferContext( wallet=swap.recipient, transfer=None) wallet_funds_before = 1 recipient_funds_before = 0 # process swaps confirm_swaps_for_eon(operator_eon_number=2) cancel_finalize_swaps_for_eon(operator_eon_number=2) process_swaps_for_eon(operator_eon_number=2) # skip some eons for i in range(3, 5): # proceed to next eon advance_to_next_eon(test_case=self, eon_number=i - 1) commit_eon(test_case=self, eon_number=i) total_remaining_eons -= 1 # process swaps confirm_swaps_for_eon(operator_eon_number=i) cancel_finalize_swaps_for_eon(operator_eon_number=i) process_swaps_for_eon(operator_eon_number=i) self.assertEqual( wallet_transfer_context.available_funds_at_eon(i, False), wallet_funds_before) self.assertEqual( recipient_transfer_context.available_funds_at_eon(i, False), recipient_funds_before) self.assertEqual( wallet_transfer_context.balance_as_of_eon(i).amount(), wallet_funds_before) swap = Transfer.objects.get(swap=True, tx_id=swap_tx_id, eon_number=4) freeze_swap(test_case=self, swap=swap, account=self.testrpc_accounts[1]) swap = Transfer.objects.get(swap=True, tx_id=swap_tx_id, eon_number=4) cancel_swap(test_case=self, swap=swap, account=self.testrpc_accounts[1], eon_count=total_remaining_eons) self.assertEqual( Transfer.objects.filter(tx_id=swap_tx_id, eon_number__gt=4, swap=True, voided=False).count(), 0) swap = Transfer.objects.filter(swap=True)[0] self.assertTrue(swap.cancelled) self.assertTrue(swap.processed) self.assertTrue(swap.appended) self.assertTrue(swap.sender_cancellation_active_state. operator_signature is not None) # proceed to next eon advance_to_next_eon(test_case=self, eon_number=4) commit_eon(test_case=self, eon_number=5) total_remaining_eons -= 1 # process swaps confirm_swaps_for_eon(operator_eon_number=5) cancel_finalize_swaps_for_eon(operator_eon_number=5) process_swaps_for_eon(operator_eon_number=5) swap = Transfer.objects.filter(swap=True)[0] self.assertTrue(swap.cancelled) self.assertTrue(swap.processed) self.assertTrue(swap.appended) self.assertEqual(swap.eon_number, 4) self.assertEqual( wallet_transfer_context.balance_as_of_eon(5).amount(), wallet_funds_before) self.assertEqual( wallet_transfer_context.available_funds_at_eon(5, False), wallet_funds_before) self.assertEqual( recipient_transfer_context.available_funds_at_eon(5, False), recipient_funds_before) # make opposite swap sell_lqd = send_swap( # Sell LQD at 0.5 ETH test_case=self, eon_number=5, account=self.testrpc_accounts[2], token=self.lqd_token, token_swapped=self.eth_token, amount=2, amount_swapped=1, nonce=sell_lqd_nonce, eon_count=1) # process swaps confirm_swaps_for_eon(operator_eon_number=5) cancel_finalize_swaps_for_eon(operator_eon_number=5) process_swaps_for_eon(operator_eon_number=5) self.assertEqual( wallet_transfer_context.available_funds_at_eon(5, False), wallet_funds_before) self.assertEqual( recipient_transfer_context.available_funds_at_eon(5, False), recipient_funds_before) commit_eon(test_case=self, eon_number=5)
def place_parallel_withdrawals(test_case: RPCTestCase, token, wallet_address, current_eon, dishonest=False): token_commitment = TokenCommitment.objects.get( token=token, root_commitment__eon_number=current_eon - 1) wallet = Wallet.objects.get(token=token, address=remove_0x_prefix(wallet_address)) wallet_transfer_context = WalletTransferContext(wallet=wallet, transfer=None) allotment = wallet_transfer_context.balance_as_of_eon( eon_number=current_eon - 1) passive_checksum, passive_amount, passive_marker = wallet_transfer_context.get_passive_values( eon_number=current_eon - 1) available_balance = wallet_transfer_context.loosely_available_funds_at_eon( eon_number=current_eon, current_eon_number=current_eon, is_checkpoint_created=True, only_appended=True) overdraw = dishonest and available_balance < allotment.amount() if overdraw: total_draw = max(available_balance, allotment.amount()) // 4 else: total_draw = min(available_balance, allotment.amount()) // 4 total_amount = 0 if (total_draw == 0): return (total_amount, [], False) withdrawal_amounts = [total_draw // 4, total_draw // 2, total_draw // 4] for withdrawal_amount in withdrawal_amounts: cyan([ wallet.address, wallet.token.address, withdrawal_amount, available_balance ]) test_case.contract_interface.withdraw( token_address=wallet.token.address, wallet=wallet.address, active_state_checksum=crypto.zfill( allotment.active_state_checksum()), trail=int(allotment.merkle_proof_trail), allotment_chain=[ crypto.zfill(crypto.decode_hex(checksum)) for checksum in long_string_to_list( allotment.merkle_proof_hashes, 64) ], membership_chain=[ crypto.zfill(crypto.decode_hex(checksum)) for checksum in long_string_to_list( token_commitment.membership_hashes, 64) ], values=csf_to_list(allotment.merkle_proof_values, int), exclusive_allotment_interval=[ int(allotment.left), int(allotment.right) ], withdrawal_amount=int(withdrawal_amount), passive_checksum=passive_checksum, passive_amount=passive_amount, passive_marker=passive_marker) total_amount += int(withdrawal_amount) return (total_amount, withdrawal_amounts, overdraw)
def init_swap_challenge(test_case: RPCTestCase, swap: Transfer, eon_number): sender_transfer_context = WalletTransferContext(wallet=swap.wallet, transfer=None) if Transfer.objects.filter(eon_number=swap.eon_number - 1, tx_id=swap.tx_id).exists(): starting_balance = int(swap.sender_starting_balance) else: starting_balance = int( sender_transfer_context.starting_balance_in_eon(eon_number)) transfers_list_nonce_index_map = {} transfers_list = sender_transfer_context.authorized_transfers_list_shorthand( only_appended=True, force_append=False, eon_number=eon_number, last_transfer_is_finalized=True, index_map=transfers_list_nonce_index_map, starting_balance=starting_balance) sender_active_state = sender_transfer_context.last_appended_active_state( eon_number=eon_number) transfer_tree = TransactionMerkleTree(transfers_list) transfer_index = transfers_list_nonce_index_map.get(int(swap.nonce)) transfer_node = transfer_tree.merkle_tree_leaf_map.get(transfer_index) transfer_proof = [ node.get('hash') for node in calculate_merkle_proof(transfer_index, transfer_node) ] test_case.assertEqual(sender_active_state.tx_set_hash, crypto.hex_value(transfer_tree.root_hash())) tx_set_root = crypto.zfill( crypto.decode_hex(sender_active_state.tx_set_hash)) deltas = [ int(sender_active_state.updated_spendings), int(sender_active_state.updated_gains) ] test_case.assertTrue( test_case.contract_interface.check_merkle_membership_proof( trail=int(transfer_index), chain=[crypto.zfill(x) for x in transfer_proof], node=transfer_node.get('hash'), merkle_root=tx_set_root)) token_commitment = TokenCommitment.objects.get( token=swap.wallet.token, root_commitment__eon_number=eon_number + 1) v, r, s = sender_active_state.operator_signature.vrs() # swap_sender_balance = sender_transfer_context.balance_as_of_eon( # eon_number) sender_balance = sender_transfer_context.balance_as_of_eon(eon_number + 1) passive_checksum, passive_amount, passive_marker = sender_transfer_context.get_passive_values( eon_number=eon_number + 1) swap_order = [ int(swap.amount), # sell int(swap.amount_swapped), # buy # int(swap_sender_balance.right - swap_sender_balance.left), starting_balance, # balance int(swap.nonce) ] # nonce chain_transition_checksum = test_case.contract_interface.check_proof_of_transition_agreement( token_address=swap.wallet.token.address, holder=swap.wallet.address, trail_identifier=swap.wallet.trail_identifier, eon_number=eon_number, tx_set_root=tx_set_root, deltas=deltas, attester=settings.HUB_OWNER_ACCOUNT_ADDRESS, r=crypto.uint256(r), s=crypto.uint256(s), v=v) test_case.assertEqual(crypto.hex_value(sender_active_state.checksum()), crypto.hex_value(chain_transition_checksum)) node_hash = merkle_tree.leaf_hash( merkle_tree.wallet_leaf_inner_hash, { 'contract': settings.HUB_LQD_CONTRACT_ADDRESS, 'token': swap.wallet.token.address, 'wallet': swap.wallet.address, 'left': sender_balance.left, 'right': sender_balance.right, 'active_state_checksum': sender_active_state.checksum(), 'passive_checksum': passive_checksum, 'passive_amount': passive_amount, 'passive_marker': passive_marker, }) checkpoint = RootCommitment.objects.get(eon_number=eon_number + 1) test_case.contract_interface.check_exclusive_allotment_proof( allotment_trail=int(sender_balance.merkle_proof_trail), membership_trail=swap.wallet.token.trail, node=node_hash, merkle_root=crypto.decode_hex(checkpoint.merkle_root), allotment_chain=[ crypto.zfill(crypto.decode_hex(v)) for v in long_string_to_list( sender_balance.merkle_proof_hashes, 64) ], membership_chain=[ crypto.zfill(crypto.decode_hex(checksum)) for checksum in long_string_to_list( token_commitment.membership_hashes, 64) ], value=csf_to_list(sender_balance.merkle_proof_values, int), left=int(sender_balance.left), right=int(sender_balance.right)) test_case.contract_interface.issue_swap_challenge( token_pair=[swap.wallet.token.address, swap.recipient.token.address], wallet=swap.wallet.address, swap_order=swap_order, sender_tx_recipient_trails=[ swap.wallet.trail_identifier, int(transfer_index), swap.recipient.trail_identifier ], allotment_chain=[ crypto.zfill(crypto.decode_hex(v)) for v in long_string_to_list( sender_balance.merkle_proof_hashes, 64) ], membership_chain=[ crypto.zfill(crypto.decode_hex(checksum)) for checksum in long_string_to_list( token_commitment.membership_hashes, 64) ], tx_chain=[crypto.zfill(x) for x in transfer_proof], values=csf_to_list(sender_balance.merkle_proof_values, int), l_r=[int(sender_balance.left), int(sender_balance.right)], tx_set_root=tx_set_root, deltas=deltas, passive_checksum=passive_checksum, passive_amount=passive_amount, passive_marker=passive_marker)