def to_representation(self, transfer: Transfer): if not transfer.is_swap(): return None matched_out, matched_in = transfer.matched_amounts(all_eons=True) return {'matched_in': str(matched_in), 'matched_out': str(matched_out)}
def test_wallet_funds(self): hub_mba = MinimumAvailableBalanceMarker(wallet=self.hub_wallet, amount=1, eon_number=3) mba_checksum = hub_mba.checksum() sign = Signature(wallet=self.hub_wallet, checksum=crypto.hex_value(mba_checksum), value=crypto.encode_signature( crypto.sign_message( mba_checksum, self.hub_private.to_string()))) sign.save() hub_mba.signature = sign hub_mba.save() hub_state = ActiveState(wallet=self.hub_wallet, eon_number=3, updated_spendings=4, updated_gains=76, tx_set_hash=uuid.uuid4().hex, tx_set_index=2) state_checksum = hub_state.checksum() sign = Signature( wallet=self.hub_wallet, checksum=crypto.hex_value(state_checksum), value=crypto.encode_signature( crypto.sign_message(state_checksum, self.hub_private.to_string()))) sign.save() hub_state.wallet_signature = sign hub_state.save() transfer = Transfer( wallet=self.hub_wallet, sender_balance_marker=hub_mba, amount=100000, eon_number=NOCUSTContractInterface().get_current_eon_number(), recipient=self.wallet, nonce=random.randint(1, 1000), sender_active_state=hub_state, passive=True) transfer.save() response = self.client.post(self.url, data=self.payload).json() self.assertEqual(response, "Ok")
def freeze_swap(test_case: RPCTestCase, swap: Transfer, account, expected_status=status.HTTP_200_OK): freeze_authorization = sign_message( swap.swap_cancellation_message_checksum(), account.get('pk')) # Make API Request url = reverse('freeze-swap-endpoint', kwargs={'pk': swap.id}) data = { 'freezing_signature': { 'value': encode_signature(freeze_authorization) } } # Send tx to server x = datetime.now() response = test_case.client.put(url, data, format='json') y = datetime.now() delta = y - x # Ensure the transaction was recorded test_case.assertEqual(response.status_code, expected_status, response.content) print('FREEZE Time: {}s'.format(delta)) # Log time delta return delta
def appropriate_transfer_active_state( transfer: Transfer, is_outgoing: bool) -> Union[ActiveState, None]: if transfer is None: return None elif transfer.is_swap(): if transfer.processed: if is_outgoing: return transfer.sender_cancellation_active_state if transfer.cancelled \ else transfer.sender_active_state else: if transfer.recipient_finalization_active_state is not None: return transfer.recipient_finalization_active_state elif transfer.cancelled: return transfer.recipient_cancellation_active_state elif transfer.complete: return transfer.recipient_fulfillment_active_state return transfer.recipient_active_state else: if is_outgoing: return transfer.sender_active_state else: if transfer.complete: return transfer.recipient_fulfillment_active_state return transfer.recipient_active_state else: if is_outgoing: # TODO return passive outgoing finalization active state update return transfer.sender_cancellation_active_state if transfer.cancelled \ else transfer.sender_active_state elif not transfer.passive: return transfer.recipient_cancellation_active_state if transfer.cancelled \ else transfer.recipient_active_state else: return None
def match_limit_to_limit(left_order: Transfer, right_order: Transfer): assert(left_order.wallet.token == right_order.recipient.token) assert(left_order.recipient.token == right_order.wallet.token) assert (left_order.amount_swapped * right_order.amount_swapped <= right_order.amount * left_order.amount) # fetch all past matches left_matched_out, left_matched_in = left_order.matched_amounts( all_eons=True) right_matched_out, right_matched_in = right_order.matched_amounts( all_eons=True) left_remaining_out = left_order.amount - left_matched_out left_remaining_in = left_order.amount_swapped - left_matched_in right_remaining_out = right_order.amount - right_matched_out right_remaining_in = right_order.amount_swapped - right_matched_in if left_order.sell_order: max_left_order_incoming_token_volume = int( left_remaining_out * right_order.amount) // right_order.amount_swapped max_left_order_outgoing_token_volume = left_remaining_out else: max_left_order_incoming_token_volume = left_remaining_in max_left_order_outgoing_token_volume = int( left_remaining_in * right_order.amount_swapped) // right_order.amount if right_order.sell_order: max_right_order_incoming_token_volume = int( right_remaining_out * right_order.amount_swapped) // right_order.amount max_right_order_outgoing_token_volume = right_remaining_out else: max_right_order_incoming_token_volume = right_remaining_in max_right_order_outgoing_token_volume = int( right_remaining_in * right_order.amount) // right_order.amount_swapped left_to_right_token_volume_traded = max_left_order_outgoing_token_volume right_to_left_token_volume_traded = max_left_order_incoming_token_volume # If the left order can give more than the right can take, or takes more than the right can give if left_to_right_token_volume_traded > max_right_order_incoming_token_volume or right_to_left_token_volume_traded > max_right_order_outgoing_token_volume: # Downsize the volume to the maximum that can be offered by the right order left_to_right_token_volume_traded = max_right_order_incoming_token_volume right_to_left_token_volume_traded = max_right_order_outgoing_token_volume logger.info('max_left_order_incoming_token_volume: {}'.format( max_left_order_incoming_token_volume)) logger.info('max_left_order_outgoing_token_volume: {}'.format( max_left_order_outgoing_token_volume)) logger.info('max_right_order_incoming_token_volume: {}'.format( max_right_order_incoming_token_volume)) logger.info('max_right_order_outgoing_token_volume: {}'.format( max_right_order_outgoing_token_volume)) logger.info('left_to_right_token_volume_traded: {}'.format( left_to_right_token_volume_traded)) logger.info('right_to_left_token_volume_traded: {}'.format( right_to_left_token_volume_traded)) # Calculate the new values after enacting the traded volumes new_left_matched_out = left_matched_out + left_to_right_token_volume_traded new_left_matched_in = left_matched_in + right_to_left_token_volume_traded new_right_matched_out = right_matched_out + right_to_left_token_volume_traded new_right_matched_in = right_matched_in + left_to_right_token_volume_traded # if this matching is at a price fractionally lower than what the seller is selling for # if new_left_matched_in / new_left_matched_out < left_order.amount_swapped / left_order.amount: if int(new_left_matched_in * left_order.amount) // 100 < int(left_order.amount_swapped * new_left_matched_out) // 100: logger.error( 'Matching tips price fractionally lower than seller limit price.') logger.error((new_left_matched_in, new_left_matched_out,)) logger.error((left_order.amount_swapped, left_order.amount,)) return False # if this matching is at a price fractionally higher than what the buyer is buying for # if new_right_matched_in / new_right_matched_out < right_order.amount_swapped / right_order.amount: if int(new_right_matched_in * right_order.amount) // 100 < int(right_order.amount_swapped * new_right_matched_out) // 100: logger.error( 'Matching tips price fractionally higher than buyer limit price.') logger.error((new_right_matched_in, new_right_matched_out,)) logger.error((right_order.amount_swapped, right_order.amount,)) return False if new_left_matched_out > left_order.amount: logger.error('Matching overspends seller limit.') return False if new_right_matched_out > right_order.amount: logger.error('Matching overspends buyer limit.') return False try: with transaction.atomic(): Matching.objects.create( eon_number=left_order.eon_number, left_order_tx_id=left_order.tx_id, right_order_tx_id=right_order.tx_id, left_deducted_right_granted_amount=left_to_right_token_volume_traded, right_deducted_left_granted_amount=right_to_left_token_volume_traded, left_token=left_order.wallet.token, right_token=right_order.wallet.token) logger.info('Match {}-{}: {}/{}'.format( left_order.tx_id, right_order.tx_id, left_to_right_token_volume_traded, right_to_left_token_volume_traded)) if new_left_matched_out == left_order.amount: assert(new_left_matched_in >= left_order.amount_swapped) logger.info('L-Order {} complete. (+{})'.format(left_order.id, new_left_matched_in - left_order.amount_swapped)) logger.info('L-Sell-Order {} complete. (+{})'.format(left_order.id, new_left_matched_in - left_order.amount_swapped)) left_order.change_state(complete=True, appended=True) elif (not left_order.sell_order) and new_left_matched_in == left_order.amount_swapped: assert(new_left_matched_out <= left_order.amount) logger.info('L-Buy-Order {} complete. (+{})'.format(left_order.id, left_order.amount - new_left_matched_out)) left_order.change_state(complete=True, appended=True) elif not left_order.sell_order: assert(new_left_matched_in < left_order.amount_swapped) if new_right_matched_out == right_order.amount: assert(new_right_matched_in >= right_order.amount_swapped) logger.info('R-Order {} complete. (+{})'.format(right_order.id, new_right_matched_in - right_order.amount_swapped)) logger.info('R-Sell-Order {} complete. (+{})'.format(right_order.id, new_right_matched_in - right_order.amount_swapped)) right_order.change_state(complete=True, appended=True) elif (not right_order.sell_order) and new_right_matched_in == right_order.amount_swapped: assert(new_right_matched_out <= right_order.amount) logger.info('R-Buy-Order {} complete. (+{})'.format(right_order.id, right_order.amount - new_right_matched_out)) right_order.change_state(complete=True, appended=True) elif not right_order.sell_order: assert(new_right_matched_in < right_order.amount_swapped) except IntegrityError: return False return True
def create(self, validated_data): active_state_signature_data = validated_data.pop('debit_signature') wallet = validated_data.pop('wallet') recipient = validated_data.pop('recipient') # get current eon current_eon = LocalViewInterface.latest().eon_number() # transfer eon should be the current eon number if validated_data.pop('eon_number') != current_eon: raise serializers.ValidationError( detail='', code=ErrorCode.EON_NUMBER_OUT_OF_SYNC) # TODO refactor this such that the recipient is only locked after the sender's details are verified wallets = sorted([wallet, recipient], key=lambda w: w.trail_identifier) with RootCommitment.read_write_lock( suffix=current_eon, auto_renewal=False), wallets[0].lock( auto_renewal=False), wallets[1].lock(auto_renewal=False): if RootCommitment.objects.filter(eon_number=current_eon + 1).exists(): raise serializers.ValidationError( detail='', code=ErrorCode.EON_NUMBER_OUT_OF_SYNC) transfer = Transfer(wallet=wallet, amount=validated_data.pop('amount'), eon_number=current_eon, recipient=recipient, nonce=validated_data.pop('nonce'), passive=True) wallet_view_context = WalletTransferContext(wallet=wallet, transfer=transfer) recipient_view_context = WalletTransferContext(wallet=recipient, transfer=transfer) # Minimal SLA if not wallet.is_sla_exempt() and not recipient.is_sla_exempt(): if not wallet.has_valid_sla(): sender_transfers_list = wallet_view_context.authorized_transfers_list( only_appended=False, force_append=True) if len(sender_transfers_list) > settings.SLA_THRESHOLD: raise serializers.ValidationError( detail='', code=ErrorCode.DEBIT_WALLET_EXCEEDED_SLA) elif not recipient.has_valid_sla(): recipient_transfers_list = recipient_view_context.authorized_transfers_list( only_appended=False, force_append=True) if len(recipient_transfers_list) > settings.SLA_THRESHOLD: raise serializers.ValidationError( detail='', code=ErrorCode.CREDIT_WALLET_EXCEEDED_SLA) # Ensure sender log consistency can_append_to_sender_log = wallet_view_context.can_schedule_transfer( ) if can_append_to_sender_log is not True: raise serializers.ValidationError( detail='Sender: {}'.format(can_append_to_sender_log), code=ErrorCode.DEBIT_WALLET_CANNOT_ADD_TRANSACTION) # Ensure recipient log consistency can_append_to_recipient_log = recipient_view_context.can_schedule_transfer( ) if can_append_to_recipient_log is not True: raise serializers.ValidationError( detail='Recipient: {}'.format(can_append_to_recipient_log), code=ErrorCode.CREDIT_WALLET_CANNOT_ADD_TRANSACTION) # Ensure transfer consistency can_spend, currently_available_funds = wallet_view_context.can_send_transfer( current_eon_number=current_eon, using_only_appended_funds=False) if can_spend is not True: raise serializers.ValidationError( detail=can_spend, code=ErrorCode.DEBIT_WALLET_OVERSPENDING) # Validate data concise_balance_marker_signature_data = validated_data.pop( 'debit_balance_signature') concise_balance_marker_amount = validated_data.pop('debit_balance') if concise_balance_marker_amount > currently_available_funds - transfer.amount: raise serializers.ValidationError( detail='', code=ErrorCode.DEBIT_WALLET_BALANCE_MARKER_EXCEED_BALANCE) concise_balance_marker = MinimumAvailableBalanceMarker( wallet=wallet, eon_number=transfer.eon_number, amount=concise_balance_marker_amount) concise_balance_marker_checksum = hex_value( concise_balance_marker.checksum()) concise_balance_marker_signature = Signature( wallet=transfer.wallet, checksum=concise_balance_marker_checksum, value=concise_balance_marker_signature_data.get('value')) if not concise_balance_marker_signature.is_valid(): raise serializers.ValidationError( detail='', code=ErrorCode.INVALID_DEBIT_BALANCE_SIGNATURE) tx_set_tree = wallet_view_context.optimized_authorized_transfers_tree( ) tx_set_hash = hex_value(tx_set_tree.root_hash()) transfer_index = tx_set_tree.merkle_tree_nonce_map.get( transfer.nonce) transfer_proof = tx_set_tree.proof(transfer_index) highest_spendings, highest_gains = wallet_view_context.off_chain_actively_sent_received_amounts( eon_number=transfer.eon_number, only_appended=False) active_state = ActiveState(wallet=wallet, updated_spendings=highest_spendings + transfer.amount, updated_gains=highest_gains, tx_set_hash=tx_set_hash, tx_set_proof_hashes=transfer_proof, tx_set_index=transfer_index, eon_number=transfer.eon_number) checksum = hex_value(active_state.checksum()) active_state_signature = Signature( wallet=transfer.wallet, checksum=checksum, value=active_state_signature_data.get('value')) if not active_state_signature.is_valid(): raise serializers.ValidationError( detail='', code=ErrorCode.INVALID_DEBIT_SIGNATURE) transfer.position = recipient_view_context.off_chain_passively_received_amount( eon_number=transfer.eon_number, only_appended=False) # locking context covers saving the state as well to make sure checkpoint creation is consistent with transaction.atomic(): Signature.objects.bulk_create( [concise_balance_marker_signature, active_state_signature]) concise_balance_marker.signature = concise_balance_marker_signature concise_balance_marker.save() active_state.wallet_signature = active_state_signature active_state.operator_signature = active_state.sign_active_state( settings.HUB_OWNER_ACCOUNT_ADDRESS, settings.HUB_OWNER_ACCOUNT_KEY) active_state.save() transfer.sender_active_state = active_state transfer.sender_balance_marker = concise_balance_marker # cache transfer index in sender active set transfer.sender_merkle_index = transfer_index # transfer.sender_merkle_root_cache = tx_set_hash # cache active set merkle mountains height array and hash array for recipient active set transfer.sender_merkle_hash_cache, transfer.sender_merkle_height_cache = tx_set_tree.merkle_cache_stacks( ) transfer.complete = True transfer.appended = True transfer.processed = True transfer.save() if transfer.appended: operator_celery.send_task('auditor.tasks.on_transfer_confirmation', args=[transfer.id]) return transfer
def should_void_swap(swap: Transfer, wallet_view_context: WalletTransferContext, recipient_view_context: WalletTransferContext, operator_eon_number: int, is_checkpoint_created: bool): if not settings.SWAPS_ENABLED: logger.error('Swaps disabled. Voiding {}'.format(swap.id)) return True if swap.amount < 1: logger.error('Swap {} has less than 1 amount'.format(swap.id)) return True if swap.amount_swapped < 1: logger.error('Swap {} has less than 1 amount swapped'.format(swap.id)) return True # Unauthorized transfer if swap.sender_active_state is None: logger.error('Swap {} no authorization'.format(swap.id)) return True # Invalid signature by sender if not swap.sender_active_state.wallet_signature.is_valid(): logger.error('Swap {} invalid sender signature.'.format(swap.id)) return True # Unreceived transaction if swap.recipient_active_state is None: logger.error('Swap receipt for {} not provided.'.format(swap.id)) return True # Invalid signature by recipient if not swap.recipient_active_state.wallet_signature.is_valid(): logger.error('Swap {} invalid receipt signature.'.format(swap.id)) return True # Ensure log consistency can_append_to_sender_log = wallet_view_context.can_append_transfer() if can_append_to_sender_log is not True: logger.error('Sender: {}'.format(can_append_to_sender_log)) return True can_append_to_recipient_log = recipient_view_context.can_append_transfer() if can_append_to_recipient_log is not True: logger.error('Recipient: {}'.format(can_append_to_recipient_log)) return True # Skip consistency checks since they were done at least once before. if swap.appended: return False # Overspending sender_funds_remaining = wallet_view_context.loosely_available_funds_at_eon( eon_number=swap.eon_number, current_eon_number=operator_eon_number, is_checkpoint_created=is_checkpoint_created, only_appended=True) # sender remaining funds should be more than remaining amount in order matched_out, matched_in = swap.matched_amounts(all_eons=True) if sender_funds_remaining < swap.amount - matched_out: logger.error('Swap {} overspending.'.format(swap.id)) return True # Prevent future overdrawing # if swap.sender_balance_marker.amount > sender_funds_remaining - swap.amount: if swap.sender_balance_marker.amount != 0: logger.error('Swap {} invalid concise marker balance.'.format(swap.id)) return True concise_balance_marker = MinimumAvailableBalanceMarker( wallet=swap.wallet, eon_number=swap.eon_number, amount=swap.sender_balance_marker.amount) concise_balance_marker_checksum = crypto.hex_value( concise_balance_marker.checksum()) if swap.sender_balance_marker.signature.checksum != concise_balance_marker_checksum: logger.error('Swap {} invalid concise marker checksum for {}.'.format( swap.id, swap.sender_balance_marker.amount)) return True highest_spendings, highest_gains = wallet_view_context.off_chain_actively_sent_received_amounts( eon_number=swap.eon_number, only_appended=True) # if this is a multi eon swap if Transfer.objects.filter(eon_number=swap.eon_number - 1, tx_id=swap.tx_id).exists(): # set balances to initial fixed balances stored in transfer eon state sender_starting_balance = swap.sender_starting_balance recipient_starting_balance = swap.recipient_starting_balance # make sure this eon's starting balance is exactly the initial stored balance # when matched amount is taken into consideration for both sender and receiver if wallet_view_context.starting_balance_in_eon( swap.eon_number) != sender_starting_balance - matched_out: logger.error( 'Swap {} invalid sender starting balance of future state {} != {} - {}.' .format( swap.id, wallet_view_context.starting_balance_in_eon( swap.eon_number), sender_starting_balance, matched_out)) if recipient_view_context.starting_balance_in_eon( swap.eon_number) != recipient_starting_balance + matched_in: logger.error( 'Swap {} invalid recipient starting balance of future state {} != {} + {}.' .format( swap.id, recipient_view_context.starting_balance_in_eon( swap.eon_number), recipient_starting_balance, matched_out)) assert (wallet_view_context.starting_balance_in_eon( swap.eon_number) == sender_starting_balance - matched_out) assert (recipient_view_context.starting_balance_in_eon( swap.eon_number) == recipient_starting_balance + matched_in) else: sender_starting_balance = int( wallet_view_context.starting_balance_in_eon(swap.eon_number)) recipient_starting_balance = int( recipient_view_context.starting_balance_in_eon(swap.eon_number)) # Debit Authorization tx_set_tree = wallet_view_context.optimized_authorized_transfers_tree( only_appended=True, starting_balance=sender_starting_balance) tx_set_hash = crypto.hex_value(tx_set_tree.root_hash()) transfer_index = tx_set_tree.merkle_tree_nonce_map.get(swap.nonce) transfer_proof = tx_set_tree.proof(transfer_index) highest_spendings, highest_gains = wallet_view_context.off_chain_actively_sent_received_amounts( eon_number=swap.eon_number, only_appended=True) debiting_active_state = ActiveState(wallet=swap.wallet, updated_spendings=highest_spendings + swap.amount, updated_gains=highest_gains, tx_set_hash=tx_set_hash, tx_set_proof_hashes=transfer_proof, tx_set_index=transfer_index, eon_number=swap.eon_number) debiting_active_state_checksum = crypto.hex_value( debiting_active_state.checksum()) if swap.sender_active_state.wallet_signature.checksum != debiting_active_state_checksum: logger.error('Swap {} invalid debit active state checksum.'.format( swap.id)) return True # Credit Authorization tx_set_tree = recipient_view_context.optimized_authorized_transfers_tree( only_appended=True, starting_balance=recipient_starting_balance) tx_set_hash = crypto.hex_value(tx_set_tree.root_hash()) transfer_index = tx_set_tree.merkle_tree_nonce_map.get(swap.nonce) transfer_proof = tx_set_tree.proof(transfer_index) highest_spendings, highest_gains = recipient_view_context.off_chain_actively_sent_received_amounts( eon_number=swap.eon_number, only_appended=True) crediting_active_state = ActiveState(wallet=swap.recipient, updated_spendings=highest_spendings, updated_gains=highest_gains, tx_set_hash=tx_set_hash, tx_set_proof_hashes=transfer_proof, tx_set_index=transfer_index, eon_number=swap.eon_number) crediting_active_state_checksum = crypto.hex_value( crediting_active_state.checksum()) if swap.recipient_active_state.wallet_signature.checksum != crediting_active_state_checksum: logger.error('Swap {} invalid credit active state checksum.'.format( swap.id)) return True # Finality Authorization swap.complete = True tx_set_tree = recipient_view_context.optimized_authorized_transfers_tree( only_appended=True, starting_balance=recipient_starting_balance) swap.complete = False tx_set_hash = crypto.hex_value(tx_set_tree.root_hash()) transfer_index = tx_set_tree.merkle_tree_nonce_map.get(swap.nonce) transfer_proof = tx_set_tree.proof(transfer_index) recipient_fulfillment_active_state = ActiveState( wallet=swap.recipient, updated_spendings=highest_spendings, updated_gains=highest_gains + swap.amount_swapped, tx_set_hash=tx_set_hash, tx_set_proof_hashes=transfer_proof, tx_set_index=transfer_index, eon_number=swap.eon_number) recipient_fulfillment_active_state_checksum = crypto.hex_value( recipient_fulfillment_active_state.checksum()) if swap.recipient_fulfillment_active_state.wallet_signature.checksum != recipient_fulfillment_active_state_checksum: logger.error( 'Swap {} invalid finalization active state checksum.'.format( swap.id)) return True return False
def cancel_swap(test_case: RPCTestCase, swap: Transfer, account, expected_status=status.HTTP_200_OK, eon_count=1): sender_cancellation_authorizations = [] recipient_cancellation_authorizations = [] sender_view_context = WalletTransferContext(wallet=swap.wallet, transfer=swap) tx_set_tree = sender_view_context.authorized_transfers_tree( only_appended=False, force_append=False, assume_active_state_exists=True) tx_set_hash = crypto.hex_value(tx_set_tree.root_hash()) transfer_index = tx_set_tree.merkle_tree_nonce_map.get(swap.nonce) transfer_proof = tx_set_tree.proof(transfer_index) sender_highest_spendings, sender_highest_gains = sender_view_context.off_chain_actively_sent_received_amounts( eon_number=swap.eon_number, only_appended=False) matched_out, _ = swap.matched_amounts() sender_highest_gains += swap.amount - matched_out sender_cancellation_active_state = ActiveState( wallet=swap.wallet, updated_spendings=sender_highest_spendings, updated_gains=sender_highest_gains, tx_set_hash=tx_set_hash, tx_set_proof_hashes=transfer_proof, tx_set_index=transfer_index, eon_number=swap.eon_number) recipient_view_context = WalletTransferContext(wallet=swap.recipient, transfer=swap) tx_set_tree = recipient_view_context.authorized_transfers_tree( only_appended=False, force_append=False, assume_active_state_exists=True) tx_set_hash = crypto.hex_value(tx_set_tree.root_hash()) transfer_index = tx_set_tree.merkle_tree_nonce_map.get(swap.nonce) transfer_proof = tx_set_tree.proof(transfer_index) recipient_highest_spendings, recipient_highest_gains = recipient_view_context.off_chain_actively_sent_received_amounts( eon_number=swap.eon_number, only_appended=False) recipient_cancellation_active_state = ActiveState( wallet=swap.recipient, updated_spendings=recipient_highest_spendings + swap.amount_swapped, updated_gains=recipient_highest_gains + swap.amount_swapped, tx_set_hash=tx_set_hash, tx_set_proof_hashes=transfer_proof, tx_set_index=transfer_index, eon_number=swap.eon_number) sender_cancellation_authorizations.append({ 'value': encode_signature( sign_message(sender_cancellation_active_state.checksum(), account.get('pk'))) }) recipient_cancellation_authorizations.append({ 'value': encode_signature( sign_message(recipient_cancellation_active_state.checksum(), account.get('pk'))) }) for i in range(1, eon_count): empty_tx_set_hash = crypto.hex_value(NODE_CACHE[0]['hash']) sender_future_spent_gained = max(sender_highest_spendings, sender_highest_gains) + 1 recipient_future_spent_gained = max( recipient_highest_spendings, recipient_highest_gains) + swap.amount_swapped + 1 sender_cancellation_active_state = ActiveState( wallet=swap.wallet, updated_spendings=sender_future_spent_gained, updated_gains=sender_future_spent_gained, tx_set_hash=empty_tx_set_hash, # any dummy value tx_set_proof_hashes='', # any dummy value tx_set_index=0, eon_number=swap.eon_number + i) recipient_cancellation_active_state = ActiveState( wallet=swap.recipient, updated_spendings=recipient_future_spent_gained, updated_gains=recipient_future_spent_gained, tx_set_hash=empty_tx_set_hash, # any dummy value tx_set_proof_hashes='', # any dummy value tx_set_index=0, eon_number=swap.eon_number + i) sender_cancellation_authorizations.append({ 'value': encode_signature( sign_message(sender_cancellation_active_state.checksum(), account.get('pk'))) }) recipient_cancellation_authorizations.append({ 'value': encode_signature( sign_message(recipient_cancellation_active_state.checksum(), account.get('pk'))) }) # Make API Request url = reverse('cancel-swap-endpoint', kwargs={'pk': swap.id}) data = { 'sender_cancellation_signature': sender_cancellation_authorizations, 'recipient_cancellation_signature': recipient_cancellation_authorizations } # Send tx to server x = datetime.now() response = test_case.client.put(url, data, format='json') y = datetime.now() delta = y - x # Ensure the transaction was recorded test_case.assertEqual(response.status_code, expected_status, response.content) print('CANCEL Time: {}s'.format(delta)) # Log time delta return delta
def send_swap(test_case: RPCTestCase, eon_number, account, token, token_swapped, amount, amount_swapped, nonce, expected_status=status.HTTP_201_CREATED, eon_count=1, sell_order=True): # Sender account sender_wallet = Wallet.objects.get(address=remove_0x_prefix( account.get('address')), token=token) # Recipient account recipient_wallet = Wallet.objects.get(address=remove_0x_prefix( account.get('address')), token=token_swapped) sender_wallet_context = WalletTransferContext(wallet=sender_wallet, transfer=None) recipient_wallet_context = WalletTransferContext(wallet=recipient_wallet, transfer=None) initial_sender_balance = sender_wallet_context.available_funds_at_eon( eon_number=eon_number, only_appended=False) initial_recipient_balance = recipient_wallet_context.available_funds_at_eon( eon_number=eon_number, only_appended=False) if initial_sender_balance < amount: send_transaction(test_case=test_case, eon_number=eon_number, sender=testrpc_accounts.accounts[0], recipient=account, amount=amount - initial_sender_balance, nonce=random.randint(1, 999999), token=token) if initial_sender_balance > amount: # clear sender account send_transaction(test_case=test_case, eon_number=eon_number, sender=account, recipient=testrpc_accounts.accounts[0], amount=initial_sender_balance - amount, nonce=random.randint(1, 999999), token=token) if initial_recipient_balance > 0: # clear recipient account send_transaction(test_case=test_case, eon_number=eon_number, sender=account, recipient=testrpc_accounts.accounts[0], amount=initial_recipient_balance, nonce=random.randint(1, 999999), token=token_swapped) sender_balance = sender_wallet_context.available_funds_at_eon( eon_number=eon_number, only_appended=False) recipient_balance = recipient_wallet_context.available_funds_at_eon( eon_number=eon_number, only_appended=False) test_case.assertEqual(sender_balance, amount) test_case.assertEqual(recipient_balance, 0) debit_balance_signatures = [] debit_signatures = [] credit_balance_signatures = [] credit_signatures = [] fulfillment_signatures = [] for i in range(eon_count): swap = Transfer(wallet=sender_wallet, amount=amount, eon_number=eon_number + i, recipient=recipient_wallet, amount_swapped=amount_swapped, nonce=nonce, processed=False, complete=False, swap=True) sender_wallet_context = WalletTransferContext(wallet=sender_wallet, transfer=swap) recipient_wallet_context = WalletTransferContext( wallet=recipient_wallet, transfer=swap) sender_highest_spent, sender_highest_gained = sender_wallet_context.off_chain_actively_sent_received_amounts( eon_number=eon_number + i, only_appended=False) if i == 0: tx_set_tree = sender_wallet_context.authorized_transfers_tree( only_appended=False, force_append=True) else: tx_set_tree = WalletTransferContext.authorized_transfers_tree_from_list( [ swap.shorthand(sender_wallet_context, is_last_transfer=True, starting_balance=sender_balance) ]) tx_set_hash = hex_value(tx_set_tree.root_hash()) debiting_active_state = ActiveState( wallet=sender_wallet, updated_spendings=sender_highest_spent + amount, updated_gains=sender_highest_gained, eon_number=eon_number + i, tx_set_hash=tx_set_hash) debiting_active_state_authorization = sign_message( debiting_active_state.checksum(), account.get('pk')) debiting_active_state_signature = Signature( wallet=sender_wallet, checksum=hex_value(debiting_active_state.checksum()), value=encode_signature(debiting_active_state_authorization)) test_case.assertTrue(debiting_active_state_signature.is_valid()) debit_concise_balance_marker = MinimumAvailableBalanceMarker( wallet=sender_wallet, eon_number=eon_number + i, amount=0) debit_concise_balance_marker_authorization = sign_message( debit_concise_balance_marker.checksum(), account.get('pk')) debit_concise_balance_marker_signature = Signature( wallet=sender_wallet, checksum=hex_value(debit_concise_balance_marker.checksum()), value=encode_signature(debit_concise_balance_marker_authorization)) test_case.assertTrue(debit_concise_balance_marker_signature.is_valid()) recipient_highest_spent, recipient_highest_gained = recipient_wallet_context.off_chain_actively_sent_received_amounts( eon_number=eon_number + i, only_appended=False) if i == 0: tx_set_tree = recipient_wallet_context.authorized_transfers_tree( only_appended=False, force_append=True) else: tx_set_tree = WalletTransferContext.authorized_transfers_tree_from_list( [ swap.shorthand(recipient_wallet_context, is_last_transfer=True, starting_balance=recipient_balance) ]) tx_set_hash = hex_value(tx_set_tree.root_hash()) crediting_active_state = ActiveState( wallet=recipient_wallet, updated_spendings=recipient_highest_spent, updated_gains=recipient_highest_gained, eon_number=eon_number + i, tx_set_hash=tx_set_hash) crediting_active_state_authorization = sign_message( crediting_active_state.checksum(), account.get('pk')) crediting_active_state_signature = Signature( wallet=recipient_wallet, checksum=hex_value(crediting_active_state.checksum()), value=encode_signature(crediting_active_state_authorization)) test_case.assertTrue(crediting_active_state_signature.is_valid()) credit_concise_balance_marker = MinimumAvailableBalanceMarker( wallet=recipient_wallet, eon_number=eon_number + i, amount=0) credit_concise_balance_marker_authorization = sign_message( credit_concise_balance_marker.checksum(), account.get('pk')) credit_concise_balance_marker_signature = Signature( wallet=recipient_wallet, checksum=hex_value(credit_concise_balance_marker.checksum()), value=encode_signature( credit_concise_balance_marker_authorization)) test_case.assertTrue( credit_concise_balance_marker_signature.is_valid()) swap.processed, swap.complete = True, True if i == 0: tx_set_tree = recipient_wallet_context.authorized_transfers_tree( only_appended=False, force_append=True) else: tx_set_tree = WalletTransferContext.authorized_transfers_tree_from_list( [ swap.shorthand(recipient_wallet_context, is_last_transfer=True, starting_balance=0) ]) tx_set_hash = hex_value(tx_set_tree.root_hash()) recipient_fulfillment_active_state = ActiveState( wallet=recipient_wallet, updated_spendings=recipient_highest_spent, updated_gains=recipient_highest_gained + amount_swapped, eon_number=eon_number + i, tx_set_hash=tx_set_hash) recipient_fulfillment_active_state_authorization = sign_message( recipient_fulfillment_active_state.checksum(), account.get('pk')) swap.processed, swap.complete = False, False recipient_fulfillment_active_state_signature = Signature( wallet=recipient_wallet, checksum=hex_value(recipient_fulfillment_active_state.checksum()), value=encode_signature( recipient_fulfillment_active_state_authorization)) test_case.assertTrue( recipient_fulfillment_active_state_signature.is_valid()) debit_balance_signatures.append({ 'value': encode_signature(debit_concise_balance_marker_authorization) }) debit_signatures.append( {'value': encode_signature(debiting_active_state_authorization)}) credit_balance_signatures.append({ 'value': encode_signature(credit_concise_balance_marker_authorization) }) credit_signatures.append( {'value': encode_signature(crediting_active_state_authorization)}) fulfillment_signatures.append({ 'value': encode_signature(recipient_fulfillment_active_state_authorization) }) # Make API Request url = reverse('swap-endpoint') data = { 'debit_signature': debit_signatures, 'debit_balance_signature': debit_balance_signatures, 'credit_signature': credit_signatures, 'credit_balance_signature': credit_balance_signatures, 'credit_fulfillment_signature': fulfillment_signatures, 'eon_number': eon_number, 'amount': amount, 'amount_swapped': amount_swapped, 'nonce': nonce, 'wallet': { 'address': sender_wallet.address, 'token': sender_wallet.token.address, }, 'recipient': { 'address': recipient_wallet.address, 'token': recipient_wallet.token.address, }, 'sell_order': sell_order } # Send tx to server x = datetime.now() response = test_case.client.post(url, data, format='json') y = datetime.now() delta = y - x # Ensure the transaction was recorded test_case.assertEqual(response.status_code, expected_status, response.content) print('SWAP Time: {}s for {}/{}'.format(delta, amount, amount_swapped)) # assert that swap created for current eon is confirmed tx = json.loads(response.content) swap = Transfer.objects.get(id=tx['id']) test_case.assertEqual(swap.eon_number, eon_number) test_case.assertTrue(swap.is_signed_by_operator()) # Log time delta return delta
def create(self, validated_data): wallet = validated_data.pop('wallet') recipient = validated_data.pop('recipient') if not TokenPair.objects.filter(token_from=wallet.token, token_to=recipient.token).exists(): raise serializers.ValidationError( detail='', code=ErrorCode.TOKEN_PAIR_BLOCKED) # swap data valid_eons = validated_data.pop('valid_eons') swap_amount = validated_data.pop('amount') swap_nonce = validated_data.pop('nonce') sell_order = validated_data.pop('sell_order', True) swap_amount_swapped = validated_data.pop('amount_swapped') debit_signatures = validated_data.pop('debit_signature') debit_balance_signatures = validated_data.pop( 'debit_balance_signature') credit_balance_signatures = validated_data.pop( 'credit_balance_signature') credit_signatures = validated_data.pop('credit_signature') recipient_fulfillment_signatures = validated_data.pop( 'credit_fulfillment_signature') # common transaction id tx_id = uuid.uuid4() tx_time = timezone.now() # cached items to be used later sender_available_balance = 0 recipient_available_balance = 0 swap_set = [] debit_tx_set_index = [] credit_tx_set_index = [] # recipient_fulfillment_tx_set_index = [] debit_tx_set_cache = [] credit_tx_set_cache = [] # recipient_fulfillment_tx_set_cache = [] debit_balance_signature_records = [] credit_balance_signature_records = [] debit_signature_records = [] credit_signature_records = [] recipient_fulfillment_signature_records = [] debit_balance_records = [] credit_balance_records = [] debit_active_state_records = [] credit_active_state_records = [] recipient_fulfillment_active_state_records = [] initial_swap_confirmed = False # get current eon current_eon = LocalViewInterface.latest().eon_number() # initial swap eon should be the current eon number if validated_data.pop('eon_number') != current_eon: raise serializers.ValidationError( detail='', code=ErrorCode.EON_NUMBER_OUT_OF_SYNC) wallets = sorted([wallet, recipient], key=lambda w: w.token.id) with RootCommitment.read_write_lock( suffix=current_eon, auto_renewal=False), wallets[0].lock( auto_renewal=False), wallets[1].lock(auto_renewal=False): if RootCommitment.objects.filter(eon_number=current_eon + 1).exists(): raise serializers.ValidationError( detail='Checkpoint was already created for this eon.', code=ErrorCode.EON_NUMBER_OUT_OF_SYNC) for eon_number in range(current_eon, current_eon + valid_eons): swap = Transfer(tx_id=tx_id, wallet=wallet, amount=swap_amount, eon_number=eon_number, recipient=recipient, nonce=swap_nonce, amount_swapped=swap_amount_swapped, swap=True, sell_order=sell_order, time=tx_time) wallet_view_context = WalletTransferContext(wallet=wallet, transfer=swap) recipient_view_context = WalletTransferContext( wallet=recipient, transfer=swap) if eon_number == current_eon: # Ensure sender log consistency can_append_to_sender_log = wallet_view_context.can_schedule_transfer( ) if can_append_to_sender_log is not True: raise serializers.ValidationError( detail='Sender: {}'.format( can_append_to_sender_log), code=ErrorCode.DEBIT_WALLET_CANNOT_ADD_TRANSACTION) # Ensure recipient log consistency can_append_to_recipient_log = recipient_view_context.can_schedule_transfer( ) if can_append_to_recipient_log is not True: raise serializers.ValidationError( detail='Recipient: {}'.format( can_append_to_recipient_log), code=ErrorCode.CREDIT_WALLET_CANNOT_ADD_TRANSACTION ) # Ensure swap consistency can_spend, sender_available_balance = wallet_view_context.can_send_transfer( current_eon_number=current_eon, using_only_appended_funds=False) if can_spend is not True: raise serializers.ValidationError( detail=can_spend, code=ErrorCode.DEBIT_WALLET_OVERSPENDING) # Ensure that sender balance is exactly equal to total outgoing amount if sender_available_balance != swap.amount: raise serializers.ValidationError( detail= 'Sender balance should be exactly equal to outgoing swap amount, {} != {}.' .format(sender_available_balance, swap.amount), code=ErrorCode.DEBIT_WALLET_BALANCE_AMOUNT_MISMATCH ) # Ensure that recipient balance is zero recipient_available_balance = recipient_view_context.available_funds_at_eon( eon_number=eon_number, only_appended=False) if recipient_available_balance != 0: raise serializers.ValidationError( detail='Recipient balance should be exactly zero.', code=ErrorCode.CREDIT_WALLET_BALANCE_NOT_ZERO) current_eon_swap = swap sender_highest_spendings, sender_highest_gains = wallet_view_context.off_chain_actively_sent_received_amounts( eon_number=swap.eon_number, only_appended=False) recipient_highest_spendings, recipient_highest_gains = recipient_view_context.off_chain_actively_sent_received_amounts( eon_number=swap.eon_number, only_appended=False) else: sender_highest_spendings, sender_highest_gains = 0, 0 recipient_highest_spendings, recipient_highest_gains = 0, 0 # Minimum Debit Balance Marker debit_balance_marker_signature_data = debit_balance_signatures[ eon_number - current_eon] debit_balance_marker = MinimumAvailableBalanceMarker( wallet=wallet, eon_number=eon_number, amount=0) debit_balance_marker_checksum = crypto.hex_value( debit_balance_marker.checksum()) debit_balance_marker_signature = Signature( wallet=wallet, checksum=debit_balance_marker_checksum, value=debit_balance_marker_signature_data.get('value')) if not debit_balance_marker_signature.is_valid(): raise serializers.ValidationError( detail='', code=ErrorCode.INVALID_DEBIT_BALANCE_SIGNATURE) # Minimum Credit Balance Marker credit_balance_marker_signature_data = credit_balance_signatures[ eon_number - current_eon] credit_balance_marker = MinimumAvailableBalanceMarker( wallet=recipient, eon_number=eon_number, amount=0) credit_balance_marker_checksum = crypto.hex_value( credit_balance_marker.checksum()) credit_balance_marker_signature = Signature( wallet=recipient, checksum=credit_balance_marker_checksum, value=credit_balance_marker_signature_data.get('value')) if not credit_balance_marker_signature.is_valid(): raise serializers.ValidationError( detail='', code=ErrorCode.INVALID_CREDIT_BALANCE_SIGNATURE) assert (sender_available_balance == swap.amount) # Debit Authorization debit_active_state_signature_data = debit_signatures[ eon_number - current_eon] debit_active_state, \ debit_active_state_signature, \ debit_transfer_index, \ debit_transfer_cache = check_active_state_signature( swap, wallet, debit_active_state_signature_data, eon_number > current_eon, sender_available_balance, sender_highest_spendings, sender_highest_gains, signature_type=SignatureType.DEBIT) # Credit Authorization credit_active_state_signature_data = credit_signatures[ eon_number - current_eon] credit_active_state, \ credit_active_state_signature, \ credit_transfer_index, \ credit_transfer_cache = check_active_state_signature( swap, recipient, credit_active_state_signature_data, eon_number > current_eon, recipient_available_balance, recipient_highest_spendings, recipient_highest_gains, signature_type=SignatureType.CREDIT) # Finality Authorization recipient_fulfillment_active_state_signature_data = recipient_fulfillment_signatures[ eon_number - current_eon] recipient_fulfillment_active_state, \ recipient_fulfillment_active_state_signature, \ recipient_fulfillment_transfer_index, \ recipient_fulfillment_transfer_cache = check_active_state_signature( swap, recipient, recipient_fulfillment_active_state_signature_data, eon_number > current_eon, recipient_available_balance, recipient_highest_spendings, recipient_highest_gains, signature_type=SignatureType.FULFILLMENT) # accumulate records to be saved debit_balance_signature_records.append( debit_balance_marker_signature) credit_balance_signature_records.append( credit_balance_marker_signature) debit_signature_records.append(debit_active_state_signature) credit_signature_records.append(credit_active_state_signature) recipient_fulfillment_signature_records.append( recipient_fulfillment_active_state_signature) debit_balance_records.append(debit_balance_marker) credit_balance_records.append(credit_balance_marker) debit_active_state_records.append(debit_active_state) credit_active_state_records.append(credit_active_state) recipient_fulfillment_active_state_records.append( recipient_fulfillment_active_state) debit_tx_set_index.append(debit_transfer_index) credit_tx_set_index.append(credit_transfer_index) # recipient_fulfillment_tx_set_index.append(recipient_fulfillment_transfer_index) debit_tx_set_cache.append(debit_transfer_cache) credit_tx_set_cache.append(credit_transfer_cache) # recipient_fulfillment_tx_set_cache.append(recipient_fulfillment_transfer_cache) swap_set.append(swap) assert (swap_set[0] is not None and swap_set[0].eon_number == current_eon) assert (len(swap_set) == valid_eons) # locking context covers saving the state as well to make sure checkpoint creation is consistent with transaction.atomic(): Signature.objects.bulk_create( debit_balance_signature_records + credit_balance_signature_records + debit_signature_records + credit_signature_records + recipient_fulfillment_signature_records) for index in range(valid_eons): debit_balance_records[ index].signature = debit_balance_signature_records[ index] credit_balance_records[ index].signature = credit_balance_signature_records[ index] debit_active_state_records[ index].wallet_signature = debit_signature_records[ index] credit_active_state_records[ index].wallet_signature = credit_signature_records[ index] recipient_fulfillment_active_state_records[ index].wallet_signature = recipient_fulfillment_signature_records[ index] ActiveState.objects.bulk_create( debit_active_state_records + credit_active_state_records + recipient_fulfillment_active_state_records) MinimumAvailableBalanceMarker.objects.bulk_create( debit_balance_records + credit_balance_records) for index in range(valid_eons): swap_set[ index].sender_active_state = debit_active_state_records[ index] swap_set[ index].recipient_active_state = credit_active_state_records[ index] swap_set[ index].recipient_fulfillment_active_state = recipient_fulfillment_active_state_records[ index] swap_set[ index].sender_balance_marker = debit_balance_records[ index] swap_set[ index].sender_starting_balance = sender_available_balance swap_set[ index].recipient_starting_balance = recipient_available_balance # cache swap index in sender active set swap_set[index].sender_merkle_index = debit_tx_set_index[ index] # cache swap index in recipient active set swap_set[ index].recipient_merkle_index = credit_tx_set_index[ index] # cache active set merkle mountains height array and hash array for sender active set swap_set[index].sender_merkle_hash_cache, swap_set[ index].sender_merkle_height_cache = debit_tx_set_cache[ index] # cache active set merkle mountains height array and hash array for recipient active set swap_set[index].recipient_merkle_hash_cache, swap_set[ index].recipient_merkle_height_cache = debit_tx_set_cache[ index] Transfer.objects.bulk_create(swap_set) swap_set[0].sign_swap(settings.HUB_OWNER_ACCOUNT_ADDRESS, settings.HUB_OWNER_ACCOUNT_KEY) initial_swap_confirmed = True if initial_swap_confirmed: operator_celery.send_task('auditor.tasks.on_swap_confirmation', args=[swap_set[0].id]) return swap_set[0]
def send_transaction(test_case, eon_number, sender, recipient, amount, nonce, token, expected_status=status.HTTP_201_CREATED): # Sender account sender_wallet = Wallet.objects.get(address=remove_0x_prefix( sender.get('address')), token=token) # Recipient account recipient_wallet = Wallet.objects.get(address=remove_0x_prefix( recipient.get('address')), token=token) transfer = Transfer(wallet=sender_wallet, amount=amount, eon_number=eon_number, recipient=recipient_wallet, nonce=nonce, passive=True) sender_view_context = WalletTransferContext(wallet=sender_wallet, transfer=transfer) sender_highest_spent, sender_highest_gained = sender_view_context.off_chain_actively_sent_received_amounts( eon_number=eon_number, only_appended=False) updated_spendings = sender_highest_spent + amount # Authorize transaction transfer_set_root = hex_value( sender_view_context.authorized_transfers_tree_root(only_appended=False, force_append=True)) active_state = ActiveState(wallet=sender_wallet, updated_spendings=updated_spendings, updated_gains=sender_highest_gained, eon_number=eon_number, tx_set_hash=transfer_set_root) sender_active_state_authorization = sign_message(active_state.checksum(), sender.get('pk')) sender_active_state_signature = Signature( wallet=sender_wallet, checksum=hex_value(active_state.checksum()), value=encode_signature(sender_active_state_authorization)) test_case.assertTrue(sender_active_state_signature.is_valid()) _, available_balance = sender_view_context.can_send_transfer( current_eon_number=eon_number, using_only_appended_funds=False) new_balance = available_balance - transfer.amount concise_balance_marker = MinimumAvailableBalanceMarker( wallet=sender_wallet, eon_number=eon_number, amount=new_balance) sender_concise_balance_marker_authorization = sign_message( concise_balance_marker.checksum(), sender.get('pk')) concise_balance_marker_signature = Signature( wallet=sender_wallet, checksum=hex_value(concise_balance_marker.checksum()), value=encode_signature(sender_concise_balance_marker_authorization)) test_case.assertTrue(concise_balance_marker_signature.is_valid()) print("Sender view:") print("available_balance:", available_balance) print("transfer_set_root:", transfer_set_root) print("active_state.updated_spendings:", active_state.updated_spendings) print("active_state.updated_gains:", active_state.updated_gains) # Make API Request url = reverse('transfer-endpoint') data = { 'debit_signature': { 'value': encode_signature(sender_active_state_authorization), }, 'debit_balance_signature': { 'value': encode_signature(sender_concise_balance_marker_authorization), }, 'debit_balance': new_balance, 'eon_number': eon_number, 'amount': amount, 'nonce': nonce, 'wallet': { 'address': sender_wallet.address, 'token': sender_wallet.token.address, }, 'recipient': { 'address': recipient_wallet.address, 'token': recipient_wallet.token.address, }, } # Send tx to server x = datetime.datetime.now() response = test_case.client.post(url, data, format='json') y = datetime.datetime.now() delta = y - x # Ensure the transaction was recorded test_case.assertEqual(response.status_code, expected_status, '\n'.join([url, str(data), str(response.content)])) print('TX Time: {}s for {}'.format(delta, amount)) # fo rpassive transfer assert that transaction is confirmed tx = json.loads(response.content) transfer = Transfer.objects.get(id=tx['id']) test_case.assertTrue(transfer.complete) test_case.assertTrue(transfer.appended) test_case.assertNotEqual(transfer.sender_active_state.operator_signature, None) # Log time delta return delta