def test_event_operators():
a = EventTransferSentSuccess(2)
b = EventTransferSentSuccess(2)
c = EventTransferSentSuccess(3)
assert a == b
assert not a != b
assert a != c
assert not a == c
a = EventTransferSentFailed(2, 'BECAUSE')
b = EventTransferSentFailed(2, 'BECAUSE')
c = EventTransferSentFailed(3, 'UNKNOWN')
assert a == b
assert not a != b
assert a != c
assert not a == c
a = EventTransferReceivedSuccess(2, 5, sha3('initiator'))
b = EventTransferReceivedSuccess(2, 5, sha3('initiator'))
c = EventTransferReceivedSuccess(3, 5, sha3('initiator'))
d = EventTransferReceivedSuccess(3, 5, sha3('other initiator'))
assert a == b
assert not a != b
assert a != c
assert not a == c
assert c != d
assert not c == d
def test_event_operators():
a = EventTransferSentSuccess(2, 5, sha3(b'target'))
b = EventTransferSentSuccess(2, 5, sha3(b'target'))
c = EventTransferSentSuccess(3, 4, sha3(b'target'))
d = EventTransferSentSuccess(3, 4, sha3(b'differenttarget'))
# pylint: disable=unneeded-not
assert a == b
assert not a != b
assert a != c
assert not a == c
assert not c == d
a = EventTransferSentFailed(2, 'BECAUSE')
b = EventTransferSentFailed(2, 'BECAUSE')
c = EventTransferSentFailed(3, 'UNKNOWN')
assert a == b
assert not a != b
assert a != c
assert not a == c
a = EventTransferReceivedSuccess(2, 5, sha3(b'initiator'))
b = EventTransferReceivedSuccess(2, 5, sha3(b'initiator'))
c = EventTransferReceivedSuccess(3, 5, sha3(b'initiator'))
d = EventTransferReceivedSuccess(3, 5, sha3(b'other initiator'))
assert a == b
assert not a != b
assert a != c
assert not a == c
assert c != d
assert not c == d
def test_event_operators():
a = EventTransferSentSuccess(2)
b = EventTransferSentSuccess(2)
c = EventTransferSentSuccess(3)
assert a == b
assert not a != b
assert a != c
assert not a == c
a = EventTransferSentFailed(2, 'BECAUSE')
b = EventTransferSentFailed(2, 'BECAUSE')
c = EventTransferSentFailed(3, 'UNKNOWN')
assert a == b
assert not a != b
assert a != c
assert not a == c
a = EventTransferReceivedSuccess(2)
b = EventTransferReceivedSuccess(2)
c = EventTransferReceivedSuccess(3)
assert a == b
assert not a != b
assert a != c
assert not a == c
def handle_unlock(target_state, state_change, channel_state):
""" Handles a ReceiveBalanceProof state change. """
iteration = TransitionResult(target_state, list())
if state_change.balance_proof.sender == target_state.route.node_address:
is_valid, _ = channel.handle_unlock(
channel_state,
state_change,
)
if is_valid:
transfer = target_state.transfer
transfer_success = EventTransferReceivedSuccess(
transfer.identifier,
transfer.lock.amount,
transfer.initiator,
)
unlock_success = EventWithdrawSuccess(
transfer.identifier,
transfer.lock.hashlock,
)
iteration = TransitionResult(None, [transfer_success, unlock_success])
return iteration
def handle_receive_directtransfer(channel_state, direct_transfer):
is_valid, msg = is_valid_directtransfer(
direct_transfer,
channel_state,
channel_state.partner_state,
channel_state.our_state,
)
if is_valid:
_, _, previous_transferred_amount = get_current_balanceproof(
channel_state.partner_state)
new_transferred_amount = direct_transfer.balance_proof.transferred_amount
transfer_amount = new_transferred_amount - previous_transferred_amount
channel_state.partner_state.balance_proof = direct_transfer.balance_proof
event = EventTransferReceivedSuccess(
direct_transfer.transfer_identifier,
transfer_amount,
channel_state.partner_state.address,
)
events = [event]
else:
event = EventTransferReceivedInvalidDirectTransfer(
direct_transfer.transfer_identifier,
reason=msg,
)
events = [event]
return TransitionResult(channel_state, events)
def clear_if_finalized(iteration):
""" Clears the state if the transfer was either completed or failed. """
state = iteration.new_state
if state is None:
return iteration
if state.from_transfer.secret is None and state.block_number > state.from_transfer.expiration:
failed = EventWithdrawFailed(
identifier=state.from_transfer.identifier,
hashlock=state.from_transfer.hashlock,
reason='lock expired',
)
iteration = TransitionResult(None, [failed])
elif state.state == 'balance_proof':
transfer_success = EventTransferReceivedSuccess(
state.from_transfer.identifier,
state.from_transfer.amount,
state.from_transfer.initiator,
)
unlock_success = EventWithdrawSuccess(
state.from_transfer.identifier,
state.from_transfer.hashlock,
)
iteration = TransitionResult(None, [transfer_success, unlock_success])
return iteration
def handle_unlock(target_state, state_change, channel_state):
""" Handles a ReceiveUnlock state change. """
iteration = TransitionResult(target_state, list())
balance_proof_sender = state_change.balance_proof.sender
if balance_proof_sender == target_state.route.node_address:
is_valid, events, _ = channel.handle_unlock(
channel_state,
state_change,
)
if is_valid:
transfer = target_state.transfer
transfer_success = EventTransferReceivedSuccess(
transfer.payment_identifier,
transfer.lock.amount,
transfer.initiator,
)
unlock_success = EventWithdrawSuccess(
transfer.payment_identifier,
transfer.lock.secrethash,
)
send_processed = SendProcessed(
balance_proof_sender,
b'global',
state_change.message_identifier,
)
events.extend([transfer_success, unlock_success, send_processed])
iteration = TransitionResult(None, events)
return iteration
def handle_receive_directtransfer(channel_state, direct_transfer):
is_valid, msg = is_valid_directtransfer(
direct_transfer,
channel_state,
channel_state.partner_state,
channel_state.our_state,
)
if is_valid:
_, _, previous_transferred_amount = get_current_balanceproof(
channel_state.partner_state)
new_transferred_amount = direct_transfer.balance_proof.transferred_amount
transfer_amount = new_transferred_amount - previous_transferred_amount
channel_state.partner_state.balance_proof = direct_transfer.balance_proof
transfer_sucess_event = EventTransferReceivedSuccess(
direct_transfer.payment_identifier,
transfer_amount,
channel_state.partner_state.address,
)
send_processed = SendProcessed(
direct_transfer.balance_proof.sender,
b'global',
direct_transfer.message_identifier,
)
events = [transfer_sucess_event, send_processed]
else:
transfer_invalid_event = EventTransferReceivedInvalidDirectTransfer(
direct_transfer.payment_identifier,
reason=msg,
)
events = [transfer_invalid_event]
return TransitionResult(channel_state, events)
def test_target_log_directransfer_successevent(
raiden_chain,
token_addresses,
deposit):
token_address = token_addresses[0]
amount = int(deposit / 2.)
identifier = 23
app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking
direct_transfer(
app0,
app1,
token_address,
amount,
identifier,
)
app1_state_events = get_all_state_events(app1.raiden.transaction_log)
sucessful_received_transfers = [
event.event_object for event in app1_state_events
if isinstance(event.event_object, EventTransferReceivedSuccess)
]
assert sucessful_received_transfers[0] == EventTransferReceivedSuccess(
identifier,
amount,
app0.raiden.address,
)
def message_directtransfer(self, message):
self.balance_proof(message)
if message.token not in self.raiden.token_to_channelgraph:
raise UnknownTokenAddress('Unknown token address {}'.format(pex(message.token)))
if message.token in self.blocked_tokens:
raise TransferUnwanted()
graph = self.raiden.token_to_channelgraph[message.token]
if not graph.has_channel(self.raiden.address, message.sender):
raise UnknownAddress(
'Direct transfer from node without an existing channel: {}'.format(
pex(message.sender),
)
)
channel = graph.partneraddress_to_channel[message.sender]
if channel.state != CHANNEL_STATE_OPENED:
raise TransferWhenClosed(
'Direct transfer received for a closed channel: {}'.format(
pex(channel.channel_address),
)
)
amount = message.transferred_amount - channel.partner_state.transferred_amount
state_change = ReceiveTransferDirect(
message.identifier,
amount,
message.token,
message.sender,
)
state_change_id = self.raiden.transaction_log.log(state_change)
channel.register_transfer(
self.raiden.get_block_number(),
message,
)
receive_success = EventTransferReceivedSuccess(
message.identifier,
amount,
message.sender,
)
self.raiden.transaction_log.log_events(
state_change_id,
[receive_success],
self.raiden.get_block_number()
)
