Dataclasses

constraints.txt

@@ -35,8 +35,9 @@ itsdangerous==0.24
 Jinja2==2.10
 lru-dict==1.1.6
 MarkupSafe==1.0
-marshmallow-polyfield==3.2
-marshmallow==2.15.4
+marshmallow-polyfield==5.5
+marshmallow-dataclass==6.0.0c1
+marshmallow==3.0.0rc6
 matrix-client==0.3.2
 miniupnpc==2.0.2
 mirakuru==1.0.0
@@ -69,7 +70,7 @@ toolz==0.9.0
 traitlets==4.3.2
 urllib3==1.23
 web3==4.9.1
-webargs==5.1.3
+webargs==5.3.1
 websockets==6.0
 Werkzeug==0.14.1
 wrapt==1.11.1

raiden/api/python.py

@@ -31,19 +31,14 @@
 from raiden.messages import RequestMonitoring
 from raiden.settings import DEFAULT_RETRY_TIMEOUT, DEVELOPMENT_CONTRACT_VERSION
 from raiden.transfer import architecture, views
+from raiden.transfer.architecture import TransferTask
 from raiden.transfer.events import (
     EventPaymentReceivedSuccess,
     EventPaymentSentFailed,
     EventPaymentSentSuccess,
 )
-from raiden.transfer.state import (
-    BalanceProofSignedState,
-    InitiatorTask,
-    MediatorTask,
-    NettingChannelState,
-    TargetTask,
-    TransferTask,
-)
+from raiden.transfer.mediated_transfer.tasks import InitiatorTask, MediatorTask, TargetTask
+from raiden.transfer.state import BalanceProofSignedState, NettingChannelState
 from raiden.transfer.state_change import ActionChannelClose
 from raiden.utils import pex, typing
 from raiden.utils.gas_reserve import has_enough_gas_reserve

raiden/api/rest.py

@@ -613,7 +613,7 @@ def open(
 
         result = self.channel_schema.dump(channel_state)
 
-        return api_response(result=result.data, status_code=HTTPStatus.CREATED)
+        return api_response(result=result, status_code=HTTPStatus.CREATED)
 
     def connect(
         self,
@@ -656,7 +656,7 @@ def leave(self, registry_address: typing.PaymentNetworkID, token_address: typing
         )
         closed_channels = self.raiden_api.token_network_leave(registry_address, token_address)
         closed_channels = [
-            self.channel_schema.dump(channel_state).data for channel_state in closed_channels
+            self.channel_schema.dump(channel_state) for channel_state in closed_channels
         ]
         return api_response(result=closed_channels)
 
@@ -718,8 +718,7 @@ def get_channel_list(
         )
         assert isinstance(raiden_service_result, list)
         result = [
-            self.channel_schema.dump(channel_schema).data
-            for channel_schema in raiden_service_result
+            self.channel_schema.dump(channel_schema) for channel_schema in raiden_service_result
         ]
         return api_response(result=result)
 
@@ -733,7 +732,7 @@ def get_tokens_list(self, registry_address: typing.PaymentNetworkID):
         assert isinstance(raiden_service_result, list)
         tokens_list = AddressList(raiden_service_result)
         result = self.address_list_schema.dump(tokens_list)
-        return api_response(result=result.data)
+        return api_response(result=result)
 
     def get_token_network_for_token(
         self, registry_address: typing.PaymentNetworkID, token_address: typing.TokenAddress
@@ -839,7 +838,7 @@ def get_raiden_events_payment_history_with_timestamps(
                     unexpected_event=event.wrapped_event,
                 )
 
-            result.append(serialized_event.data)
+            result.append(serialized_event)
         return api_response(result=result)
 
     def get_raiden_internal_events_with_timestamps(self, limit, offset):
@@ -898,7 +897,7 @@ def get_channel(
                 partner_address=partner_address,
             )
             result = self.channel_schema.dump(channel_state)
-            return api_response(result=result.data)
+            return api_response(result=result)
         except ChannelNotFound as e:
             return api_error(errors=str(e), status_code=HTTPStatus.NOT_FOUND)
 
@@ -934,7 +933,7 @@ def get_partners_by_token(
 
         schema_list = PartnersPerTokenList(return_list)
         result = self.partner_per_token_list_schema.dump(schema_list)
-        return api_response(result=result.data)
+        return api_response(result=result)
 
     def initiate_payment(
         self,
@@ -1003,7 +1002,7 @@ def initiate_payment(
             "secret_hash": sha3(secret),
         }
         result = self.payment_schema.dump(payment)
-        return api_response(result=result.data)
+        return api_response(result=result)
 
     def _deposit(
         self,
@@ -1044,7 +1043,7 @@ def _deposit(
         )
 
         result = self.channel_schema.dump(updated_channel_state)
-        return api_response(result=result.data)
+        return api_response(result=result)
 
     def _close(
         self, registry_address: typing.PaymentNetworkID, channel_state: NettingChannelState
@@ -1074,7 +1073,7 @@ def _close(
         )
 
         result = self.channel_schema.dump(updated_channel_state)
-        return api_response(result=result.data)
+        return api_response(result=result)
 
     def patch_channel(
         self,

raiden/api/v1/encoding.py

@@ -150,8 +150,8 @@ class BaseOpts(SchemaOpts):
     This allows for having the Object the Schema encodes to inside of the class Meta
     """
 
-    def __init__(self, meta):
-        SchemaOpts.__init__(self, meta)
+    def __init__(self, meta, ordered):
+        SchemaOpts.__init__(self, meta, ordered=ordered)
         self.decoding_class = getattr(meta, "decoding_class", None)
 
 

raiden/blockchain_events_handler.py

@@ -7,10 +7,18 @@
 from raiden.blockchain.state import get_channel_state
 from raiden.connection_manager import ConnectionManager
 from raiden.network.proxies.utils import get_onchain_locksroots
+from raiden.storage.restore import (
+    get_event_with_balance_proof_by_locksroot,
+    get_state_change_with_balance_proof_by_locksroot,
+)
 from raiden.transfer import views
 from raiden.transfer.architecture import StateChange
 from raiden.transfer.identifiers import CanonicalIdentifier
-from raiden.transfer.state import TokenNetworkState, TransactionChannelNewBalance
+from raiden.transfer.state import (
+    TokenNetworkGraphState,
+    TokenNetworkState,
+    TransactionChannelNewBalance,
+)
 from raiden.transfer.state_change import (
     ContractReceiveChannelBatchUnlock,
     ContractReceiveChannelClosed,
@@ -23,10 +31,6 @@
     ContractReceiveSecretReveal,
     ContractReceiveUpdateTransfer,
 )
-from raiden.transfer.utils import (
-    get_event_with_balance_proof_by_locksroot,
-    get_state_change_with_balance_proof_by_locksroot,
-)
 from raiden.utils import pex, typing
 from raiden_contracts.constants import (
     EVENT_SECRET_REVEALED,
@@ -58,7 +62,12 @@ def handle_tokennetwork_new(raiden: "RaidenService", event: Event):
         from_block=block_number,
     )
 
-    token_network_state = TokenNetworkState(token_network_address, token_address)
+    token_network_graph_state = TokenNetworkGraphState(token_network_address)
+    token_network_state = TokenNetworkState(
+        address=token_network_address,
+        token_address=token_address,
+        network_graph=token_network_graph_state,
+    )
 
     transaction_hash = event.event_data["transaction_hash"]
 
@@ -111,6 +120,7 @@ def handle_channel_new(raiden: "RaidenService", event: Event):
         )
         raiden.handle_and_track_state_change(new_channel)
 
+        # pylint: disable=E1101
         partner_address = channel_state.partner_state.address
 
         if ConnectionManager.BOOTSTRAP_ADDR != partner_address:

raiden/constants.py

@@ -8,9 +8,11 @@
     BalanceHash,
     BlockHash,
     BlockNumber,
+    LockHash,
     Locksroot,
     RaidenProtocolVersion,
     Secret,
+    SecretHash,
     Signature,
     TokenAmount,
 )
@@ -44,11 +46,13 @@
 
 EMPTY_HASH = BlockHash(bytes(32))
 EMPTY_BALANCE_HASH = BalanceHash(bytes(32))
+EMPTY_LOCK_HASH = LockHash(bytes(32))
 EMPTY_MESSAGE_HASH = AdditionalHash(bytes(32))
 EMPTY_HASH_KECCAK = keccak(EMPTY_HASH)
 EMPTY_SIGNATURE = Signature(bytes(65))
 EMPTY_MERKLE_ROOT = Locksroot(bytes(32))
 EMPTY_SECRET = Secret(b"")
+EMPTY_SECRETHASH = SecretHash(bytes(32))
 ZERO_TOKENS = TokenAmount(0)
 
 SECRET_LENGTH = 32

raiden/message_handler.py

@@ -11,12 +11,12 @@
     RevealSecret,
     SecretRequest,
     Unlock,
+    lockedtransfersigned_from_message,
 )
 from raiden.raiden_service import RaidenService
 from raiden.routing import get_best_routes
 from raiden.transfer import views
 from raiden.transfer.architecture import StateChange
-from raiden.transfer.mediated_transfer.state import lockedtransfersigned_from_message
 from raiden.transfer.mediated_transfer.state_change import (
     ReceiveLockExpired,
     ReceiveSecretRequest,
@@ -73,17 +73,17 @@ def on_message(self, raiden: RaidenService, message: Message) -> None:
     @staticmethod
     def handle_message_secretrequest(raiden: RaidenService, message: SecretRequest) -> None:
         secret_request = ReceiveSecretRequest(
-            message.payment_identifier,
-            message.amount,
-            message.expiration,
-            message.secrethash,
-            message.sender,
+            payment_identifier=message.payment_identifier,
+            amount=message.amount,
+            expiration=message.expiration,
+            secrethash=message.secrethash,
+            sender=message.sender,
         )
         raiden.handle_and_track_state_change(secret_request)
 
     @staticmethod
     def handle_message_revealsecret(raiden: RaidenService, message: RevealSecret) -> None:
-        state_change = ReceiveSecretReveal(message.secret, message.sender)
+        state_change = ReceiveSecretReveal(secret=message.secret, sender=message.sender)
         raiden.handle_and_track_state_change(state_change)
 
     @staticmethod
@@ -93,13 +93,15 @@ def handle_message_unlock(raiden: RaidenService, message: Unlock) -> None:
             message_identifier=message.message_identifier,
             secret=message.secret,
             balance_proof=balance_proof,
+            sender=balance_proof.sender,
         )
         raiden.handle_and_track_state_change(state_change)
 
     @staticmethod
     def handle_message_lockexpired(raiden: RaidenService, message: LockExpired) -> None:
         balance_proof = balanceproof_from_envelope(message)
         state_change = ReceiveLockExpired(
+            sender=balance_proof.sender,
             balance_proof=balance_proof,
             secrethash=message.secrethash,
             message_identifier=message.message_identifier,
@@ -140,10 +142,19 @@ def handle_message_refundtransfer(raiden: RaidenService, message: RefundTransfer
 
             secret = random_secret()
             state_change = ReceiveTransferRefundCancelRoute(
-                routes=routes, transfer=from_transfer, secret=secret
+                routes=routes,
+                transfer=from_transfer,
+                balance_proof=from_transfer.balance_proof,
+                sender=from_transfer.balance_proof.sender,  # pylint: disable=no-member
+                secret=secret,
             )
         else:
-            state_change = ReceiveTransferRefund(transfer=from_transfer, routes=routes)
+            state_change = ReceiveTransferRefund(
+                transfer=from_transfer,
+                balance_proof=from_transfer.balance_proof,
+                sender=from_transfer.balance_proof.sender,  # pylint: disable=no-member
+                routes=routes,
+            )
 
         raiden.handle_and_track_state_change(state_change)